当前位置：首页 > news >正文

redis入门到精通系列（十）：springboot集成redis及redis工具类的编写

news 来源：原创 2024/5/20 1:30:03

欢迎关注同名微信公众号《Java鱼仔》，我们一起冲大厂

（一）概述

在前面的博客系列中，我们把redis的基础语法配置等比较详细的讲了一遍，但如果要用现在更多的是集成到spring系列的框架之中，今天我们就来讲解springboot集成redis的方法以及一些注意点。

（二）项目依赖

springboot对于redis的集成十分友好，我们创建springboot项目时可以直接勾选SpringDataRedis即可直接引入redis的相关依赖。

Spring Data Redis的依赖如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

按住Ctrl左键点击spring-boot-starter-data-redis可以看到redis中所引用的依赖，我们可以看到客户端从以前的jedis变成了lettuce

Lettuce 和 Jedis 都是Redis的client，所以他们都可以连接 Redis Server。

Jedis在实现上是直接连接的Redis Server，如果在多线程环境下是非线程安全的。每个线程都去拿自己的 Jedis 实例，当连接数量增多时，资源消耗阶梯式增大，连接成本就较高了。

Lettuce的连接是基于Netty的，Netty 是一个多线程、事件驱动的 I/O 框架。连接实例可以在多个线程间共享，当多线程使用同一连接实例时，是线程安全的。

所以在后续的使用中，我们将使用lettuce代替掉jedis。

（三）配置文件配置

关于配置文件是如何配置的，许多人的方法就是直接去百度查询redis集成到springboot配置文件如何写，这种方式虽然能解决问题，但是还有更好的办法就是查源码。我们点开项目目录下的External Libraries,找到spring-boot-autoconfigure，

然后在这个自动配置的配置文件中去寻找redis相关的配置

看到第一个就是我们要找的配置文件，源码如下：

我们关注两个点，第一个是配置文件的属性，也就是第一个红框框出来的位置，另一个就是@ConditionalOnMissingBean注解，这个注解的意思是如果我们自己写了一个名字为redisTemplate的Bean，源码中的这个Bean就不会生效，我的秒杀项目实战中就自己写了redisTemplate这样一个Bean。

下面点开第一个红框中的RedisProperties,这是我们配置文件所要参考的类:

所有的配置文件都在这里了，我们可以看到host和port都给了默认的值，这也意味着如果只是在本地跑的话，你在springboot的application.properties中甚至不需要配置。

作为教程系列的博客，我还是会配上：

#配置rediszuowe
spring.redis.host=127.0.0.1
spring.redis.port=6379

（四）在springboot中使用redis

在springboot使用redis和直接操作redis的语法十分类似，首先我们需要引入RedisTemplate，通过源码我们也看到了，我们可以直接使用RedisTemplate，也可以自己写一个Bean自己配置，系统自带的RedisTemplate只设置了一个连接工厂，而没有设置序列化等其他参数，因此如果在正式项目中我们都会自己定义这样一个redisTemplate。

直接在test包下进行测试

@SpringBootTest
class RedisSpringbootApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void contextLoads() {
        //相当于redis中的string类型
        redisTemplate.opsForValue().set("k1","v1");
        System.out.println(redisTemplate.opsForValue().get("k1"));
    }
}

在redis中的操作都可以通过opsForXXX来实现，比如redis中的String可以通过opsForValue()实现，redis的五种数据结构分别对应于redisTemplate的以下五种方法：

redisTemplate.opsForValue();
redisTemplate.opsForHash();
redisTemplate.opsForList();
redisTemplate.opsForSet();
redisTemplate.opsForZSet();

(五)编写一个redis的通用配置类

通过进入RedisTemplate的源码我们可以看到，redis所有的序列化都采用了Jdk的序列化方式

这种方式的问题在于我们传输到redis中的数据会出现乱码，比如以上面的例子为例，我们设置一个key为“k1”，value为"v1"的数据，看一下redis的控制台：

为了解决这个问题我们需要自己去定义序列化方式，一般来说我们会给key定义为String的序列化方式，value定义为json的序列化方式。下面的这个工具类属于通用的工具类，可以在项目中直接使用

@Configuration
public class RedisConfig {
    //自定义的redistemplate
    @Bean(name = "redisTemplate")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        //创建一个RedisTemplate对象，为了方便返回key为string，value为Object
        RedisTemplate<String,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //设置json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new
                Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper=new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance);
        //string的序列化
        StringRedisSerializer stringRedisSerializer=new StringRedisSerializer();
        //key采用string的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //value采用jackson的序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hashkey采用string的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //hashvalue采用jackson的序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

配置完成后再使用redisTemplate时就会使用我们自定义的这个redistemplate，数据传输也不会再乱码。

(六) 编写一个redis的通用工具类

我在接下来的代码中封装了redis的一个通用工具类，之后在使用redis时可以直接采用RedisUtil工具类操控，让代码更加的精炼。

/**
 * @author by: Liyu
 * @ClassName: RedisUtil
 * @Description: TODO
 * @Date: 2020/8/16 23:08
 */
@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;
    /**
     * 指定缓存失效时间
     */
    public boolean expire(String key,long time){
        try {
            if (time>0){
                redisTemplate.expire(key,time, TimeUnit.SECONDS);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key获取过期时间
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     *判断key是否存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     *删除缓存
     */
    public void del(String... key){
        if (key!=null&&key.length>0){
            if (key.length==1){
                redisTemplate.delete(key[0]);
            }else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 根据key获取value
     */
    public Object get(String key){
        return key==null ? null :redisTemplate.opsForValue().get(key);
    }

    /**
     * set方法
     */
    public  boolean set(String key,Object value){
        try {
            redisTemplate.opsForValue().set(key,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * set 方法带时间
     */
    public boolean set(String key,Object value,long time){
        try {
            if (time>0){
                redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
            }else {
                set(key,value);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 增加
     */
    public long incr(String key,long delta){
        if (delta<0){
            throw new RuntimeException("递增数必须大于0");
        }
        return redisTemplate.opsForValue().increment(key,delta);
    }

    /**
     * 减少
     */
    public long decr(String key,long delta){
        if (delta<0){
            throw new RuntimeException("递增数必须大于0");
        }
        return redisTemplate.opsForValue().increment(key,-delta);
    }

    // =======================hash===============================

    /**
     * hash set
     */
    public boolean hSet(String key,String item,String value){
        try {
            redisTemplate.opsForHash().put(key,item,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * hash set 并设置时间
     */
    public boolean hSet(String key,String item,String value,long time){
        try {
            redisTemplate.opsForHash().put(key,item,value);
            if (time>0){
                expire(key,time);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * hash mset
     */
    public boolean hmset(String key,Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key,map);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * Hash mSet并设置时间
     */
    public boolean hmset(String key,Map<String,Object> map, long time){
        try {
            redisTemplate.opsForHash().putAll(key,map);
            if (time>0){
                expire(key,time);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * Hash get
     */
    public Object hGet(String key,String item){
        return redisTemplate.opsForHash().get(key,item);
    }

    /**
     * 获取hashKey的所有键值
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 删除hash表的数据
     */
    public void hDel(String key,Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }

    /**
     * 判断hash表中是否存在数据
     */
    public boolean hHasKey(String key,String item){
        return redisTemplate.opsForHash().hasKey(key,item);
    }

    /**
     * hash递增，如果不存在就会创建一个，返回递增后的值
     */
    public double hIncr(String key,String item,double by){
        return redisTemplate.opsForHash().increment(key,item,by);
    }
    /**
     * hash递减
     */
    public double hDecr(String key,String item,double by){
        return redisTemplate.opsForHash().increment(key,item,-by);
    }

    //===========================set=======================
    /**
     * 根据key获取Set中的所有值
     */
    public Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 根据value从一个set中查值
     */
    public boolean sHasKey(String key,Object object){
        try{
            return redisTemplate.opsForSet().isMember(key,object);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 将数据放入set
     */
    public long sSet(String key ,Object... values){
        try {
            return redisTemplate.opsForSet().add(key,values);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 将数据放入set并设置时间
     */
    public long sSet(String key ,long time ,Object... values){
        try {
            long count=redisTemplate.opsForSet().add(key,values);
            if (time>0){
                expire(key,time);
            }
            return count;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 获取set的长度
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 移除值为value的
     */
    public long sRemove(String key,Object... values){
        try {
            Long count=redisTemplate.opsForSet().remove(key,values);
            return count;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    //==============================List==============================
    /**
     * 获取list的长度
     */
    public long lGetListSize(String key){
        try{
            return redisTemplate.opsForList().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 通过索引获取List中的值
     */
    public Object lGetIndex(String key,long index){
        try{
            return redisTemplate.opsForList().index(key,index);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 存放数据到list
     */
    public boolean lSet(String key,Object value){
        try{
            redisTemplate.opsForList().rightPush(key,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 存放数据到list,并设置时间
     */
    public boolean lSet(String key,Object value,long time){
        try{
            redisTemplate.opsForList().rightPush(key,value);
            if (time>0){
                expire(key,time);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 将list集合放入缓存
     */
    public boolean lSet(String key,Object... values){
        try{
            redisTemplate.opsForList().rightPushAll(key,values);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 将list集合放入缓存,并设置时间
     */
    public boolean lSet(String key,long time,Object... values){
        try{
            redisTemplate.opsForList().rightPushAll(key,values);
            if (time>0){
                expire(key,time);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 根据索引修改list中的某条数据
     */
    public boolean lUpdateIndex(String key,long index,Object value){
        try{
            redisTemplate.opsForList().set(key,index,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 移除n个值为value
     */
    public long lRemove(String key,long count,Object value){
        try{
            long remove=redisTemplate.opsForList().remove(key,count,value);
            return remove;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
}