Spring Boot教程七：集成redis

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/wang_shuyu/article/details/78793849

redis在开发中常用于缓存，用户权限管理，消息队列等功能，今天学习一下springboot集成redis的方式，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。
返回如下：

20171213
说明redis集成完成。