Spring Boot教程七：集成redis

骑猪看日落 2021-09-14 11:58 335阅读 0赞

redis在开发中常用于缓存，用户权限管理，消息队列等功能，今天学习一下springboot集成redis的方式，redis的安装启动可以百度到，这里只讲代码的实现方式。  
首先，引入相关依赖：

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-redis</artifactId>
                <version>1.2.8.RELEASE</version>
            </dependency>

将我们之前在读取配置文件中新建的ReadProperties更名为RedisUtil，代码更改如下：

/** * @Package:com.springboot.utils * @ClassName:RedisUtil * @Description:redis工具类 * @Author Shuyu.Wang * @Date 2017-12-07 12:18 **/
    @EnableConfigurationProperties({Redis.class})
    @Component
    public class RedisUtil { 
        @Autowired
        private Redis redis;
    
        public void read(){
            System.out.println(redis.getIp());
        }
    
    
        /** * 非切片链接池 */
        private JedisPool jedisPool;
    
        /** * 非切片连接池初始化 */
        private JedisPool initialPool() {
            // 池基本配置
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(redis.getMaxTotal());
            config.setMaxIdle(redis.getMaxIdle());
            config.setMaxWaitMillis(redis.getMaxActive());
            config.setTestOnBorrow(redis.getTestOnBorrow());
            config.setTestOnReturn(redis.getTestOnReturn());
            jedisPool = new JedisPool(config, redis.getIp(), redis.getPort());
            return jedisPool;
    
        }
    
        /** * 在多线程环境同步初始化 * */
        private synchronized void poolInit() {
    
            if (jedisPool == null) {
    
                initialPool();
    
            }
    
        }
    
        /** * 非切片客户端链接 同步获取非切片Jedis实例 * * @return Jedis * */
        @SuppressWarnings("deprecation")
        public synchronized Jedis getJedis() {
            if (jedisPool == null) {
                poolInit();
            }
            Jedis jedis = null;
            try {
                if (jedisPool != null) {
    
                    jedis = jedisPool.getResource();
                    // jedis.auth(password);
                }
            } catch (Exception e) {
                System.out.println("抛错");
                e.printStackTrace();
                // 释放jedis对象
                jedisPool.returnBrokenResource(jedis);
            } finally {
                // 返还连接池
                if (jedis != null && jedisPool != null) {
                    jedisPool.returnResource(jedis);
    
                }
    
            }
            return jedis;
    
        }
    
    
    }

另外新进一个工具类，实现序列化和反序列化：

/** * 序列化工具类 * @author Shuyu.Wang * */
    public class SerializeUtil { 
        /** * 序列化 * @param value * @return */
        public static byte[] serialize(Object value) {
    
            if (value == null) {
    
                throw new NullPointerException("Can't serialize null");
    
            }
    
            byte[] rv = null;
    
            ByteArrayOutputStream bos = null;
    
            ObjectOutputStream os = null;
    
            try {
    
                bos = new ByteArrayOutputStream();
    
                os = new ObjectOutputStream(bos);
    
                os.writeObject(value);
    
                os.close();
    
                bos.close();
    
                rv = bos.toByteArray();
    
            } catch (IOException e) {
    
                throw new IllegalArgumentException("Non-serializable object", e);
    
            } finally {
    
                try {
    
                    if (os != null)
                        os.close();
    
                    if (bos != null)
                        bos.close();
    
                } catch (Exception e2) {
    
                    e2.printStackTrace();
    
                }
    
            }
    
            return rv;
    
        }
    
        /**反序列化 * @param bytes * @return */
        public static Object unserialize(byte[] bytes) {
    
            Object rv = null;
    
            ByteArrayInputStream bis = null;
    
            ObjectInputStream is = null;
    
            try {
    
                if (bytes != null) {
    
                    bis = new ByteArrayInputStream(bytes);
    
                    is = new ObjectInputStream(bis);
    
                    rv = is.readObject();
    
                    is.close();
    
                    bis.close();
    
                }
            } catch (Exception e) {
    
                e.printStackTrace();
    
            } finally {
    
                try {
    
                    if (is != null)
                        is.close();
    
                    if (bis != null)
                        bis.close();
    
                } catch (Exception e2) {
    
                    e2.printStackTrace();
    
                }
            }
    
            return rv;
    
        }
    
    }

另外新建一个redis的包，新建RedisService接口类，和对应的实现类RedisServiceImpl；  
代码分别如下;

/** * @ClassName: RedisDao * @Description: redis接口 * @author shuyu.wang * @date 2017年11月23日 下午3:55:53 * @version V1.0 */
    public interface RedisService { 
    
        public void setString(String key, int seconds, String value);
    
        public boolean exist(String key);
    
        /** * 存储String * @param key * @param param */
        public <T> boolean setString(String key, String param);
    
        /** * 获取Stringֵ * @param key * @return String */
        public String getString(String key);
    
        /** * 存储实体类 * @param key * @param bean */
        public <T> boolean setBean(String key, Object bean);
    
        /** * 获取实体类 * @param key * @return T */
        public <T> T getBean(String key);
    
        /** * 存储 list * @param key * @param list */
        public <T> boolean setList(String key, List<T> list);
    
        /** * 获取list * @param key * @return list */
        public <T> List<T> getList(String key);
    
        /** * 存储 map * @param key * @param map */
        public <T> boolean setMap(String key, Map<String, T> map);
    
        /** * 获取map * @param key * @return Map */
        public <T> Map<String, T> getMap(String key);
    
        /** * @param key * @return */
        public boolean del(String key);
        /** * @param key * @param num * @return */
        public <T> boolean setInteger(String key, Integer num);
    
        /** * @param key * @return */
        public Integer getSetInteger(String key, Integer num);
    
        /** * @param key * @return */
        public Integer getInteger(String key);
    
    
        /** * 非序列化存储 * @param key * @param map * @return */
        public <T> boolean setHash(String key, Map<String, String> map);
    
        /**获取key中所有的map的key值 * @param key * @return */
        public  Map<String, String> getAllHash(String key);
    
        /**获取key中的Map中的key=fields 的value集合 * @param key * @param fields * @return */
        public List<String> getHashm(String key, String... fields);
    
    
        /** * @Title: login * @Description: TODO * @param userId * @param second * @return String 返回token * @throws */
        public String login(String userId, int second);
    
    
        public Boolean validate(String token);
    
        public void logout(String token);
    
        public String getUserId(String token);
    
    }

/** * @ClassName: RedisDaoImpl * @Description: TODO * @author shuyu.wang * @date 2017年10月19日 下午2:54:39 * @version V1.0 */
    @Service
    public class RedisServiceImpl implements RedisService { 
        private static final String VIRTUAL_COURSE_PREX = "lc_vc_";
        @Autowired
        private RedisUtil redisUtil;
    
        private static final String RETURN_OK="OK";
    
    
        /** * * @param key * @return */
        public String buildKey(String key) {
            return VIRTUAL_COURSE_PREX + key;
        }
    
        /* * (non-Javadoc) * * @see com.shuyu.cache.RedisDao#setString(java.lang.String, int, * java.lang.String) */
        @Override
        public void setString(String key, int seconds, String value) {
            Jedis jedis = redisUtil.getJedis();
            jedis.setex(buildKey(key), seconds, value);
    
        }
    
        /* * (non-Javadoc) * * @see com.shuyu.cache.RedisDao#exist(java.lang.String) */
        @Override
        public boolean exist(String key) {
            Jedis jedis = redisUtil.getJedis();
            String bKey = buildKey(key);
            if (jedis == null || !jedis.exists(bKey)) {
                return false;
            }
            return true;
        }
    
        /** * * @param key * @param param */
        @Override
        public <T> boolean setString(String key, String param) {
    
            Jedis jedis = redisUtil.getJedis();
            String bKey = buildKey(key);
            String set = null;
            System.out.println("jedis=============="+jedis);
            set = jedis.set(bKey.getBytes(), SerializeUtil.serialize(param));
            if (!set.isEmpty() && (RETURN_OK).equals(set)) {
                return true;
            } else {
                return false;
            }
    
        }
    
        /** * ��ȡStringֵ * * @param key * @return String */
        @Override
        public String getString(String key) {
            Jedis jedis = redisUtil.getJedis();
            String bKey = buildKey(key);
            String retru = null;
            if (jedis == null || !jedis.exists(bKey)) {
                return null;
            }
            byte[] in = jedis.get(bKey.getBytes());
            retru = SerializeUtil.unserialize(in).toString();
            return retru;
    
        }
    
        /** * * @param key * @param bean */
        @Override
        public <T> boolean setBean(String key, Object bean) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            String set = null;
            set = jedis.set(bKey.getBytes(), SerializeUtil.serialize(bean));
            if (!set.isEmpty() && (RETURN_OK).equals(set)) {
                return true;
            } else {
                return false;
            }
    
        }
    
        /** * * @param key * @return T */
        @SuppressWarnings("unchecked")
        @Override
        public <T> T getBean(String key) {
            Jedis jedis = redisUtil.getJedis();
            String bKey = buildKey(key);
            T bean = null;
            if (jedis == null || !jedis.exists(bKey.getBytes())) {
                return null;
            }
            byte[] in = jedis.get(bKey.getBytes());
            bean = (T) SerializeUtil.unserialize(in);
            return bean;
    
        }
    
        /** * @param key * @param list */
        @Override
        public <T> boolean setList(String key, List<T> list) {
            Jedis jedis = redisUtil.getJedis();
            String bKey = buildKey(key);
            String set = null;
            set = jedis.set(bKey.getBytes(), SerializeUtil.serialize(list));
            if (!set.isEmpty() && (RETURN_OK).equals(set)) {
                return true;
            } else {
                return false;
            }
    
        }
    
        /** * * @param key * @return list */
        @SuppressWarnings("unchecked")
        @Override
        public <T> List<T> getList(String key) {
            Jedis jedis = redisUtil.getJedis();
            String bKey = buildKey(key);
            List<T> list = null;
            if (jedis == null || !jedis.exists(bKey.getBytes())) {
                return null;
            }
            byte[] in = jedis.get(bKey.getBytes());
            list = (List<T>) SerializeUtil.unserialize(in);
            return list;
    
        }
    
        /** * * @param <T> * @param key */
        @Override
        public <T> boolean setMap(String key, Map<String, T> map) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            String set = null;
            set = jedis.set(bKey.getBytes(), SerializeUtil.serialize(map));
            if (!set.isEmpty() && (RETURN_OK).equals(set)) {
                return true;
            } else {
                return false;
            }
    
        }
    
        /** * * @param key * @return Map */
        @Override
        @SuppressWarnings("unchecked")
        public <T> Map<String, T> getMap(String key) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            Map<String, T> map = null;
            if (jedis == null || !jedis.exists(bKey.getBytes())) {
                return null;
            }
            byte[] in = jedis.get(bKey.getBytes());
            map = (Map<String, T>) SerializeUtil.unserialize(in);
            return map;
        }
    
        @Override
        public boolean del(String key) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            Long del = (long) 0;
            if (jedis == null || !jedis.exists(bKey.getBytes())) {
                return false;
            }
            del = jedis.del(bKey.getBytes());
            if (del > 0) {
                return true;
            }
            return false;
        }
    
        @Override
        public <T> boolean setInteger(String key, Integer num) {
            Jedis jedis = redisUtil.getJedis();
            String bKey = buildKey(key);
            String set = null;
            set = jedis.set(bKey, String.valueOf(num));
            if (!set.isEmpty() && (RETURN_OK).equals(set)) {
                return true;
            } else {
                return false;
            }
    
        }
    
        @Override
        public Integer getSetInteger(String key, Integer num) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            String set = null;
            set = jedis.getSet(bKey, String.valueOf(num));
            return Integer.valueOf(set);
        }
    
        @Override
        public Integer getInteger(String key) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            String set = null;
            if (jedis == null || !jedis.exists(bKey)) {
                return null;
            }
            set = jedis.get(bKey);
            return Integer.valueOf(set);
        }
    
        @Override
        public <T> boolean setHash(String key, Map<String, String> map) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            String hmset = null;
            hmset = jedis.hmset(bKey, map);
            if (!hmset.isEmpty() && (RETURN_OK).equals(hmset)) {
                return true;
            } else {
                return false;
            }
        }
    
        @Override
        public Map<String, String> getAllHash(String key) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            Map<String, String> map = null;
            if (jedis == null || !jedis.exists(bKey)) {
                return null;
            }
            map = jedis.hgetAll(bKey);
            return map;
        }
    
        @Override
        public List<String> getHashm(String key, String... fields) {
            String bKey = buildKey(key);
            Jedis jedis = redisUtil.getJedis();
            List<String> list = null;
            if (jedis == null || !jedis.exists(bKey)) {
                return null;
            }
            list = jedis.hmget(bKey, fields);
            return list;
        }
    
        /* * (non-Javadoc) * * @see com.hc.redis.dao.RedisDao#login(java.lang.String, int) */
        @Override
        public String login(String userId, int second) {
            Jedis jedis = redisUtil.getJedis();
            String token = buildKey(userId);
            if (jedis == null || !jedis.exists(token)) {
                // token生产规则自定义ֵ
                jedis.setex(token, second, userId);
            } else {
                jedis.expire(token, second);
            }
    
            return token;
        }
    
        @Override
        public Boolean validate(String token) {
            Jedis jedis = redisUtil.getJedis();
            boolean flag = false;
            if (jedis == null || !jedis.exists(token)) {
                flag = false;
            } else {
                //重新设置有效时间
                jedis.expire(token, 10);
                flag = true;
            }
            return flag;
    
        }
    
        @Override
        public void logout(String token) {
            Jedis jedis = redisUtil.getJedis();
            if (jedis != null && jedis.exists(token)) {
                jedis.del(token);
            }
    
        }
    
        @Override
        public String getUserId(String token) {
            Jedis jedis = redisUtil.getJedis();
            String userId = null;
            if (jedis != null && jedis.exists(token)) {
                userId = jedis.get(token);
            }
            return userId;
        }
    
    }

redis配置文件redis.properties如下：

redis.ip=127.0.0.1
    redis.port=6379
    redis.maxActive=1024
    redis.maxIdle=200
    redis.maxWait=10000
    redis.testOnBorrow=true
    redis.testOnReturn=true
    redis.maxTotal=600 
    redis.timeBetweenEvictionRunsMillis=30000  
    redis.minEvictableIdleTimeMillis=30000

然后新增一个接口测试相关功能，在controller中新增：

@Autowired
        private RedisService redisService;
    
        @ApiOperation(value = "整合redis", notes = "整合redis")
        @RequestMapping(value = "/redis", method = RequestMethod.GET)
        public String reids() {
            redisService.setString("my1","20171213");
            return redisService.getString("my1");
        }

然后屏蔽掉之前的读取配置文件的接口，因为配置文件的ReadProperties文件已经改名了，不然会报错。

启动本地的redis，然后启动工程，在浏览器访问[http://127.0.0.1:8082/boot/redis][http_127.0.0.1_8082_boot_redis]。  
返回如下：

> 20171213  
> 说明redis集成完成。

[http_127.0.0.1_8082_boot_redis]: http://127.0.0.1:8082/boot/redis