自己定制一个Springboot-stater

自己开发一个spring boot starter的步骤

新建一个项目，
需要一个配置类，配置类里面需要装备好需要提供出去的类
1）使用@Enable，使用@Import导入需要装配的类
2）/META-INF/spring.factories，在org.springframework.boot.autoconfigure.EnableAutoConfiguration配置需要装备的类。

自己写个demo，写一个springboot-redis-stater项目，整合jedis。
依赖如下：

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>1.5.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

定义一个实体类，为下面在配置文件中配置属性然后自动配置JedisPoolConfig类到spring容器中：

@ConfigurationProperties(prefix="redis.pool")
public class JedisPoolConfigProperties {

    private int maxTotal; //最大连接数

    private int maxIdle; //最大空闲连接数

    private int minIdle; //初始化连接数

    private long maxWait; //最大等待时间

    private boolean testOnBorrow; //对拿到的connection进行validateObject校验

    private boolean testOnReturn; //在进行returnObject对返回的connection进行validateObject校验

    private boolean testWhileIdle; //定时对线程池中空闲的链接进行validateObject校验

    public int getMaxTotal() {
        return maxTotal;
    }

    public void setMaxTotal(int maxTotal) {
        this.maxTotal = maxTotal;
    }

    public int getMaxIdle() {
        return maxIdle;
    }

    public void setMaxIdle(int maxIdle) {
        this.maxIdle = maxIdle;
    }

    public int getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }

    public long getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(long maxWait) {
        this.maxWait = maxWait;
    }

    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }
}

同样的道理，定义一个实体类，为下面在配置文件中配置属性然后将JedisPool纳入到spring容器中。

@ConfigurationProperties(prefix="redis")
public class RedisProperties {
    private String host;
    private Integer port;
    private Integer timeout;
    private String password;
    public String getHost() {
        return host;
    }
    public void setHost(String host) {
        this.host = host;
    }
    public Integer getPort() {
        return port;
    }
    public void setPort(Integer port) {
        this.port = port;
    }

    public Integer getTimeout() {
        return timeout;
    }

    public void setTimeout(Integer timeout) {
        this.timeout = timeout;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

配置相关的JedisPoolConfig和JedisPool，

@Configuration
@ConditionalOnClass(Jedis.class)
@EnableConfigurationProperties(value = {RedisProperties.class,JedisPoolConfigProperties.class})
public class RedisAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public JedisPoolConfig jedisPoolConfig(JedisPoolConfigProperties jedisPoolConfigProperties){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(jedisPoolConfigProperties.getMaxTotal());
        jedisPoolConfig.setMaxIdle(jedisPoolConfigProperties.getMaxIdle());
        jedisPoolConfig.setMaxWaitMillis(jedisPoolConfigProperties.getMaxWait());
        jedisPoolConfig.setTestOnBorrow(jedisPoolConfigProperties.isTestOnBorrow());
        jedisPoolConfig.setTestOnReturn(jedisPoolConfigProperties.isTestOnReturn());
        jedisPoolConfig.setTestWhileIdle(jedisPoolConfigProperties.isTestWhileIdle());
        return jedisPoolConfig;
    }

    @Autowired
    private JedisPoolConfig jedisPoolConfig;

    @Bean
    @ConditionalOnMissingBean
    public JedisPool jedisPool(RedisProperties redisProperties){
        JedisPool jedisPool = new JedisPool(jedisPoolConfig,redisProperties.getHost(),redisProperties.getPort(),
                redisProperties.getTimeout(),redisProperties.getPassword());
        return jedisPool;

    }

}

定义redis的工具类接口，使用Jedis工具类

public interface RedisCacheService {


    //根据缓存key获取值
    Object getCache(Serializable cacheKey);


    //设置缓存数据的key-value，并设置失效时间，单位为秒
    boolean putCache(Serializable cacheKey, Object objValue, int expiration);

    //清除缓存
    void removeCache(Serializable cacheKey);


    //向指定list集合中添加对象，在list尾部添加对象
    boolean putListCache(Serializable cacheKey, Object objValue);


    //向指定list集合中添加对象，并指定位置坐标
    boolean putListCache(Serializable cacheKey, Object objValue,
                                int index);

    /**
     * 根据坐标，返回一段集合
     *
     * @param cacheKey
     * @param start
     *            起始坐标 头部为0
     * @param end
     *            结束坐标 尾部为-1
     * @return
     */
    public List<Object> getListCache(Serializable cacheKey, int start, int end);


    //返回结合
    List<Object> getListCache(Serializable cacheKey);

    /**
     * 裁剪list集合
     *
     * @param cacheKey
     * @param start
     *            起始坐标
     * @param end
     *            结束坐标
     * @return
     */
    boolean trimListCache(Serializable cacheKey, int start, int end);


    //添加map集合
    boolean putMapCache(Serializable cacheKey, Map<Object, Object> map);

    //map中的键值
    boolean deleteMapCache(Serializable cacheKey, Serializable mapKey);


    //获取map中的值
    Object getMapValueCache(Serializable cacheKey, Serializable mapKey);


    //缓存key是否存在
    boolean exists(Serializable cacheKey);


    //设置key的失效时间
    boolean setKeyExpire(String cacheKey, int expiration);
}

实现

@Service("redisCacheService")
public class RedisCacheServiceImpl implements RedisCacheService {

    private static final Logger logger = LoggerFactory.getLogger(RedisCacheServiceImpl.class);

    private static final String JEDIS_SET_RETURN_OK = "OK";

    @Autowired
    protected JedisPool jedisPool;

    /**
     * 同步获取Jedis实例
     * @return Jedis
     */
    public synchronized Jedis getJedis() {
        Jedis jedis = null;
        try {
            if (jedisPool != null) {
                jedis = jedisPool.getResource();
            }
        } catch (Exception e) {
            logger.error("Get jedis from jedisPool,  error : ",e);
        }
        return jedis;
    }

    @Override
    public Object getCache(Serializable cacheKey) {
        Jedis jedis =getJedis();
        Object obj=null;
        try {
            obj= SerializingUtil.deserialize((byte[]) jedis.get(SerializingUtil.serialize(cacheKey)));
        } catch (Exception e) {
            logger.error("getCache,  error cacheKey=: "+cacheKey,e);
        }finally{
            jedis.close();
        }
        return obj;
    }

    @Override
    public boolean putCache(Serializable cacheKey, Object objValue,
                            int expiration) {
        Jedis jedis =getJedis();
        try {
            String result = jedis.setex(SerializingUtil.serialize(cacheKey), expiration, SerializingUtil.serialize(objValue));
            if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) {
                return true;
            }
        } catch (Exception e) {
            logger.error("putCache,  error : cacheKey="+cacheKey+" ,objValue="+objValue+" expiration="+expiration,e);
        }finally{
            jedis.close();
        }
        return false;
    }

    @Override
    public void removeCache(Serializable cacheKey) {
        Jedis jedis =getJedis();
        try {
            jedis.del(SerializingUtil.serialize(cacheKey));
        } catch (Exception e) {
            logger.error("removeCache,  error cacheKey=: "+cacheKey,e);
        }finally{
            jedis.close();
        }
    }

    @Override
    public boolean putListCache(Serializable cacheKey, Object objValue) {
        Jedis jedis =getJedis();
        try {
            Long num = jedis.rpush(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(objValue));
            if (num > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("putListCache,  error : ",e);
        }finally{
            jedis.close();
        }

        return false;
    }

    @Override
    public boolean putListCache(Serializable cacheKey, Object objValue, int index) {
        Jedis jedis =getJedis();
        try {
            String result = jedis.lset(SerializingUtil.serialize(cacheKey), index, SerializingUtil.serialize(objValue));
            if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) {
                return true;
            }
        } catch (Exception e) {
            logger.error("putListCache,  error : ",e);
        }finally{
            jedis.close();
        }
        return false;
    }

    @Override
    public List<Object> getListCache(Serializable cacheKey, int start, int end) {
        Jedis jedis =getJedis();
        try {
            List<byte[]> list = jedis.lrange(SerializingUtil.serialize(cacheKey), start, end);
            if (null != list && list.size() > 0) {
                List<Object> objList = new ArrayList<Object>();
                for (byte[] b : list) {
                    objList.add(SerializingUtil.deserialize(b));
                }
                return objList;
            }
        } catch (Exception e) {
            logger.error("getListCache,  error : ",e);
        }finally{
            jedis.close();
        }
        return null;
    }

    @Override
    public List<Object> getListCache(Serializable cacheKey) {
        return getListCache(cacheKey, 0, -1);
    }

    @Override
    public boolean trimListCache(Serializable cacheKey, int start, int end) {
        Jedis jedis =getJedis();
        try {
            String result = jedis.ltrim(SerializingUtil.serialize(cacheKey), start, end);
            if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) {
                return true;
            }
        } catch (Exception e) {
            logger.error("trimListCache,  error : ",e);
        }finally{
            jedis.close();
        }
        return false;
    }

    @Override
    public boolean putMapCache(Serializable cacheKey, Map<Object, Object> map) {
        Jedis jedis =getJedis();
        try {
            if (null != map && !map.isEmpty()) {
                Map<byte[], byte[]> byteMap = new HashMap<>();
                for (Map.Entry<Object, Object> entry: map.entrySet()) {
                    byteMap.put(SerializingUtil.serialize(entry.getKey()), SerializingUtil.serialize(entry.getValue()));
                }
                String result = jedis.hmset(SerializingUtil.serialize(cacheKey), byteMap);
                if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) {
                    return true;
                }
                return true;
            }
        } catch (Exception e) {
            logger.error("putMapCache,  error : ",e);
        }finally{
            jedis.close();
        }
        return false;
    }

    @Override
    public boolean deleteMapCache(Serializable cacheKey, Serializable mapKey) {
        Jedis jedis =getJedis();
        try {
            Long result = jedis.hdel(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(mapKey));
            if (result > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("deleteMapCache,  error : ",e);
        }finally{
            jedis.close();
        }
        return false;
    }

    @Override
    public Object getMapValueCache(Serializable cacheKey, Serializable mapKey) {
        Jedis jedis =getJedis();
        try {
            List<byte[]> list = jedis.hmget(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(mapKey));
            if (null != list && list.size() > 0) {
                return SerializingUtil.deserialize(list.get(0));
            }
        } catch (Exception e) {
            logger.error("getMapValueCache,  error : ",e);
        }finally{
            jedis.close();
        }
        return null;
    }

    @Override
    public boolean exists(Serializable cacheKey) {
        Jedis jedis =getJedis();
        try {
            return jedis.exists(SerializingUtil.serialize(cacheKey));
        } catch (Exception e) {
            logger.error("exists,  error cacheKey=: "+cacheKey,e);
        }finally{
            jedis.close();
        }
        return false;
    }

    @Override
    public boolean setKeyExpire(String cacheKey, int expiration) {
        Jedis jedis =getJedis();
        try {
            Long result = jedis.expire(SerializingUtil.serialize(cacheKey), expiration);
            if (result > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("setKeyExpire,  error : cacheKey="+cacheKey+" expiration="+expiration,e);
        }finally{
            jedis.close();
        }
        return false;
    }

}

再建一个项目，引入springboot-redis-stater依赖：

    <dependencies>
        <dependency>
            <groupId>com.zhihao.miao</groupId>
            <artifactId>springboot-redis-stater</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

在配置文件配置redis信息：

redis.pool.maxTotal=1024
redis.pool.maxIdle=120
redis.pool.minIdle=10
redis.pool.maxWait=1000
redis.pool.testOnBorrow=true
redis.pool.testOnReturn=true

redis.host=
redis.port=6389
redis.password=
redis.timeout=1000

测试：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class,args);
        RedisCacheService redisCacheService = context.getBean(RedisCacheService.class);
        boolean flag = redisCacheService.putCache("name","miaozhihao00",3000);
        System.out.println(flag);
        Object object = redisCacheService.getCache("name");
        System.out.println(object);
        context.close();
    }
}

最后编辑于：2017.12.09 16:06:02

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,937评论 6赞 478
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,503评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,712评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,668评论 1赞 276
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,677评论 5赞 366
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,601评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,975评论 3赞 396
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,637评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,881评论 1赞 298
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,621评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,710评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,387评论 4赞 319
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,971评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,947评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,189评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 44,805评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,449评论 2赞 342

自己定制一个Springboot-stater

推荐阅读更多精彩内容