Redis在Jedis中的使用，以及SpringBoot整合Redis

阳光穿透心脏的1/2处 2023-09-28 13:09 55阅读 0赞

**Jedis是Redis官方推荐的java连接开发工具**，但是现在的SpringBoot2.0以上的版本将Jedis换成Lettuce，但是Jedis还是很好用的，在Jedis中连接使用Redis，和Redis控制台命令完全一致。

1、使用idea创建一个meavn项目![471e662381df402daee787bb3a1eb589.png][]

2、在pom文件中添加依赖(Jedis和fastjson)

![9b7692df4dc0458ba0924f81988cbaf7.png][]

3、连接测试，连接的是本地的Redis服务，连接远程需要更改配置文件和关闭防火墙，先打开redis-server.exe，再进行下面的测试。

Jedis jedis = new Jedis("127.0.0.1",6379);
            System.out.println(jedis.ping());

![448981b63d2b43aeb279a079a37ee810.png][]

返回PONG，表示连接成功。

4、常用API练习

Jedis jedis = new Jedis("127.0.0.1",6379);
            System.out.println(jedis.ping());
            jedis.flushDB();
            jedis.set("name","jack");
            jedis.set("age","23");
            jedis.set("high","181");
            System.out.println("name: "+jedis.get("name")+"\nage: "+jedis.get("age")+"\nhigh: "+jedis.get("high"));
            jedis.lpush("list","1","2","3","4");
            System.out.println("list: "+jedis.lrange("list",0,-1));

![8e700b506306497d96bc237c3cfb559a.png][]

**SpringBoot支持Jedis**，在1.×版本的时候，SpringBoot的底层还是使用Jedis来连接Redis的，但是在2.×版本后，就换成了Lettuce。两者的区别如下：  
Jedis: 采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用 jedis pool 连接池！ 更像BIO模式！  
Lettuce: 采用netty，实例可以再多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据了，更像NIO模式！

1、创建springboot项目，可以使用Default：[https://start.spring.io/][https_start.spring.io]创建，也可以使用Custom:[https://start.aliyun.com/][https_start.spring.io]创建，只需要创建一个最简单的springboot项目即可。

![c3278948ae1f4d098e2dbdfc9e67c50f.png][]2、再pom.xml中添加依赖

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>2.1.7.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.54</version>
                <scope>compile</scope>
            </dependency>
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.10</version>
                <scope>compile</scope>
            </dependency>

![b76ab9b3abb14efd95b7510b4ccd62e8.png][]3、配置连接的application.properties文件，在src--main--resources下找到该文件

server.port=10001
    spring.redis.port=6379
    spring.redis.host=127.0.0.1

![151d399baad84ed49f45706858ee0744.png][] 4、测试连接，在scr-test-java-com-zjy-springboot\_redis下SpringbootRedisApplicationTests.class文件

@Autowired
        private RedisTemplate redisTemplate;
        @Test
        public void contextLoads() {
            redisTemplate.opsForValue().set("name","notebook");
            System.out.println("获取到的name: "+redisTemplate.opsForValue().get("name"));
        }

运行效果如下！证明Redis连接成功！并且加数据获取数据也成功了！![c1ea1806e97e4fd39a3e4b37c795936d.png][]

5、简单测试

// redisTemplate  #操作不同的数据类型，api和我们的指令是一样的 
    // opsForValue  #操作字符串 类似String 
    // opsForList  #操作List 类似List 
    // opsForSet  #操作set
    // opsForHash  #操作hash
    // opsForZSet  #操作zset
    // opsForGeo   #操作geo
    // opsForHyperLogLog  #操作HyperLogLog
    // 除了进本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务，和基本的 CRUD 
    // 获取redis的连接对象 
    // RedisConnection connection = redisTemplate.getConnectionFactory().getConnection(); 
    // connection.flushDb(); 
    // connection.flushAll();

6、对象的保存和读取，新增一个Student类(在src-main-java-com-zjy下创建entity包Student.class文件)，注意在redis中，对象的保存必须序列化后才能正常操作，不然会报错。

package com.zjy.entity;
    
    import lombok.Data;
    
    @Data
    public class Student {
        private Integer id;
        private String name;
        private Integer age;
    
    }

在scr-test-java-com-zjy-springboot\_redis下有SpringbootRedisApplicationTests.class中

@Test
        public void setStudent(){
            Student student = new Student();
            student.setId(001);
            student.setName("jack");
            student.setAge(23);
            redisTemplate.opsForValue().set("student",student);
            System.out.println(redisTemplate.opsForValue().get("student"));
        }

![b6017bb4984347bbba44d23b03f202c9.png][]

未进行序列化会报错，错误如下：![8276bebbcbd94ef0ba329222883cbddf.png][]

7、要自己定义封装RedisTemplate，为了在工作中更容易操作Redis，我们一般重新封装RedisTemplate类，如下：

先在src-main-java-com-zjy下创建config包，创建RedisConfig.class文件

package com.zjy.springboot_redis.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    public class RedisConfig {
        // 这是一个固定模板，拿去就可以直接使用！
        // 自己定义一个RedisTemplate
        @Bean
        @SuppressWarnings("all")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
            // 我们为了自己开发方便，一般直接使用 <String, Object>
            RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
            template.setConnectionFactory(factory);
            // Json序列化配置
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            // String 的序列化
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            // key采用String的序列化方式
            template.setKeySerializer(stringRedisSerializer);
            // hash的key也采用String的序列化方式
            template.setHashKeySerializer(stringRedisSerializer);
            // value序列化方式采用jackson
            template.setValueSerializer(jackson2JsonRedisSerializer);
            // hash的value序列化方式采用jackson
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
            template.afterPropertiesSet();
            return template;
        }
    }

再次执行之前序列化报错的代码：

![0d0f8f399a054e8786a330ea4d7b520b.png][]

8、为了方便封装RedisUtils类，因为在实际工作中我们不可能使用RedisTemplate来操作Redis的因为太繁琐了，我们需要自定义一个RedisUtils工具类来操作Redis，基本上常用的Redis操作都写在这里了，我们在工作中需要用什么，直接通过RedisUtils来使用即可！

package com.zjy.springboot_redis.util;
    
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    import javax.annotation.Resource;
    import java.util.Collection;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    @Component
    public final class RedisUtil {
        @Resource
        private RedisTemplate<String, Object> redisTemplate;
        public Set<String> keys(String keys){
            try {
                return redisTemplate.keys(keys);
            }catch (Exception e){
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 指定缓存失效时间
         * @param key 键
         * @param time 时间(秒)
         * @return
         */
        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 获取过期时间
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public long getExpire(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
        /**
         * 判断key是否存在
         * @param key 键
         * @return true 存在 false不存在
         */
        public boolean hasKey(String key) {
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * 删除缓存
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                } else {
                    redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
                }
            }
        }
        /**
         * 普通缓存获取
         * @param key 键
         * @return 值
         */
        public Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
        /**
         * 普通缓存放入
         * @param key 键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * 普通缓存放入, 不存在放入，存在返回
         * @param key 键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean setnx(String key, Object value) {
            try {
                redisTemplate.opsForValue().setIfAbsent(key,value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * 普通缓存放入并设置时间
         * @param key 键
         * @param value 值
         * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        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;
            }
        }
    
        /**
         * 普通缓存放入并设置时间,不存在放入，存在返回
         * @param key 键
         * @param value 值
         * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public boolean setnx(String key, Object value, long time) {
            try {
                if (time > 0) {
                    redisTemplate.opsForValue().setIfAbsent(key, value, time, TimeUnit.SECONDS);
                } else {
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 递增
         * @param key 键
         * @param delta 要增加几(大于0)
         * @return
         */
        public long incr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
        /**
         * 递减
         * @param key 键
         * @param delta 要减少几(小于0)
         * @return
         */
        public long decr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
        /**
         * HashGet
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public Object hget(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
        /**
         * 获取hashKey对应的所有键值
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object, Object> hmget(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
        /**
         * HashSet
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public boolean hmset(String key, Map<String, Object> map) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * HashSet 并设置时间
         * @param key 键
         * @param map 对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        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表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object 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表中的值
         * @param key 键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public void hdel(String key, Object... item) {
            redisTemplate.opsForHash().delete(key, item);
        }
        /**
         * 判断hash表中是否有该项的值
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item) {
            return redisTemplate.opsForHash().hasKey(key, item);
        }
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         * @param key 键
         * @param item 项
         * @param by 要增加几(大于0)
         * @return
         */
        public double hincr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, by);
        }
        /**
         * hash递减
         * @param key 键
         * @param item 项
         * @param by 要减少记(小于0)
         * @return
         */
        public double hdecr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
        /**
         * 根据key获取Set中的所有值
         * @param key 键
         * @return
         */
        public Set<Object> sGet(String key) {
            try {
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        /**
         * 根据value从一个set中查询,是否存在
         * @param key 键
         * @param value 值
         * @return true 存在 false不存在
         */
        public boolean sHasKey(String key, Object value) {
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * 将数据放入set缓存
         * @param key 键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Object... values) {
            try {
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        /**
         * 将set数据放入缓存
         * @param key 键
         * @param time 时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSetAndTime(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缓存的长度
         * @param key 键
         * @return
         */
        public long sGetSetSize(String key) {
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        /**
         * 移除值为value的
         * @param key 键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public long setRemove(String key, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        // ===============================list=================================
        /**
         * 获取list缓存的内容
         * @param key 键
         * @param start 开始
         * @param end 结束 0 到 -1代表所有值
         * @return
         */
        public List<Object> lGet(String key, long start, long end) {
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        /**
         * 获取list缓存的长度
         * @param key 键
         * @return
         */
        public long lGetListSize(String key) {
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        /**
         * 通过索引 获取list中的值
         * @param key 键
         * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
         * @return
         */
        public Object lGetIndex(String key, long index) {
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @param time 时间(秒)
         * @return
         */
        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放入缓存
         * @param key 键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * 将list放入缓存
         *
         * @param key 键
         * @param value 值
         * @param time 时间(秒)
         * @return
         */
        public boolean lSet(String key, List<Object> value, long time) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0){
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * 根据索引修改list中的某条数据
         * @param key 键
         * @param index 索引
         * @param value 值
         * @return
         */
        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
         * @param key 键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
        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;
            }
        }
    }

接下来进行测试，创建controller包，在包下创建TestController.class

package com.zjy.springboot_redis.controller;
    
    import com.zjy.springboot_redis.util.RedisUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @Slf4j
    @RestController
    @RequestMapping("/setRedisUtils")
    public class TestController {
        @Autowired
        private RedisUtil redisUtil;
    
        @GetMapping("/getName")
        public Map<String,Object> getName(@RequestParam Map<String,Object> param){
            Map<String,Object> map = new HashMap<>();
            map.put("name",redisUtil.get(param.get("name").toString()));
            return map;
        }
        @GetMapping("/setName")
        public Object setName(@RequestParam Map<String,Object> param){
            String nameKey = param.get("nameKey").toString();
            String nameValue = param.get("nameValue").toString();
            redisUtil.set(nameKey,nameValue);
            return "加入成功!";
        }
    }

启动springboot项目，然后打开浏览器，在web上进行测试，测试如下：

![71a9820cb5c1469b8dadc25d05f23ea2.png][]

![86c2aaddf49f4c96b6f564a1e9f4d67b.png][]

[471e662381df402daee787bb3a1eb589.png]: https://img-blog.csdnimg.cn/471e662381df402daee787bb3a1eb589.png
[9b7692df4dc0458ba0924f81988cbaf7.png]: https://img-blog.csdnimg.cn/9b7692df4dc0458ba0924f81988cbaf7.png
[448981b63d2b43aeb279a079a37ee810.png]: https://img-blog.csdnimg.cn/448981b63d2b43aeb279a079a37ee810.png
[8e700b506306497d96bc237c3cfb559a.png]: https://img-blog.csdnimg.cn/8e700b506306497d96bc237c3cfb559a.png
[https_start.spring.io]: https://start.aliyun.com/
[c3278948ae1f4d098e2dbdfc9e67c50f.png]: https://img-blog.csdnimg.cn/c3278948ae1f4d098e2dbdfc9e67c50f.png
[b76ab9b3abb14efd95b7510b4ccd62e8.png]: https://img-blog.csdnimg.cn/b76ab9b3abb14efd95b7510b4ccd62e8.png
[151d399baad84ed49f45706858ee0744.png]: https://img-blog.csdnimg.cn/151d399baad84ed49f45706858ee0744.png
[c1ea1806e97e4fd39a3e4b37c795936d.png]: https://img-blog.csdnimg.cn/c1ea1806e97e4fd39a3e4b37c795936d.png
[b6017bb4984347bbba44d23b03f202c9.png]: https://img-blog.csdnimg.cn/b6017bb4984347bbba44d23b03f202c9.png
[8276bebbcbd94ef0ba329222883cbddf.png]: https://img-blog.csdnimg.cn/8276bebbcbd94ef0ba329222883cbddf.png
[0d0f8f399a054e8786a330ea4d7b520b.png]: https://img-blog.csdnimg.cn/0d0f8f399a054e8786a330ea4d7b520b.png
[71a9820cb5c1469b8dadc25d05f23ea2.png]: https://img-blog.csdnimg.cn/71a9820cb5c1469b8dadc25d05f23ea2.png
[86c2aaddf49f4c96b6f564a1e9f4d67b.png]: https://img-blog.csdnimg.cn/86c2aaddf49f4c96b6f564a1e9f4d67b.png