Java教程

SpringBoot整合Redis及使用讲解

本文主要是介绍SpringBoot整合Redis及使用讲解,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
      • 说明

        • SpringBoot操作数据使用spring-data
        • 在springboot2.x之后,原来使用的jedis被替换为了lettuce
        • jedis:采用的是直连,多个线程操作的话,是不安全的,想要避免不安全,使用jedis pool连接池,更像BIO模式
        • lettuce:采用netty,实例可以在多个线程中共享,不存在线程不安全的情况,可以减少线程的数量,更像Nio模式

        源码分析

        @Bean
        //我们可以自己定义一个RedisTemplate来替换默认的RedisTemplate
        @ConditionalOnMissingBean(name = "redisTemplate") 
        @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            //默认的RedisTemplate 没有过多的设置,redis对象都是需要序列化的
            //两个泛型都是Object, Object类型,我们后续使用都需要强制转换
        	RedisTemplate<Object, Object> template = new RedisTemplate<>();
        	template.setConnectionFactory(redisConnectionFactory);
        	return template;
        }
        
        @Bean
        //由于String是我们最常使用的类型,所以说单独提出了一个Bean
        @ConditionalOnMissingBean
        @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        	return new StringRedisTemplate(redisConnectionFactory);
        }
        
        •  

        整合测试

        1. 导入依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        
        •  
        1. 配置连接
        # SpringBoot的所有配置类,都有一个自动配置类
        # 自动配置类都会绑定一个properties类
        spring.redis.host = 180.76.150.213
        spring.redis.port = 6379
        spring.redis.password = 123
        
        •  
        1. 测试连接
        @SpringBootTest
        class Redis02SpringbootApplicationTests {
        
            @Autowired
            private RedisTemplate redisTemplate;
        
            @Test
            void contextLoads() {
                //redisTemplate,操作不同的数据类型,api和我们的指令是一样的
                //操作字符串,类似String
                redisTemplate.opsForValue();
                //操作List
                redisTemplate.opsForList();
                //......
                redisTemplate.opsForHash();
                //......
        
                //除了基本的操作,我们常用的方法都可以直接redisTemplate来操作,比如事务和基本的增删改查
                //获取连接对象
                RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
                connection.flushDb();
                connection.flushAll();
        
                //测试
                redisTemplate.opsForValue().set("key","zzysy");
                System.out.println(redisTemplate.opsForValue().get("key"));
            }
        }
        
        •  

        关于序列化问题:

        在这里插入图片描述在这里插入图片描述

        关于对象的保存:

        @Component
        @AllArgsConstructor
        @NoArgsConstructor
        @Data
        //此时没有进行序列化
        public class User {
            private String name;
            private int age;
        }
        
        •  
        @Test
        public void test() throws JsonProcessingException {
            User zzy = new User("zzy", 20);
            redisTemplate.opsForValue().set("user",zzy);
            System.out.println(redisTemplate.opsForValue().get("user"));
        }
        
        •  

        报错,提示无法序列化
        在这里插入图片描述
        对User序列化

        @Component
        @AllArgsConstructor
        @NoArgsConstructor
        @Data
        //进行序列化
        //在企业中,所有的pojo类都需要序列化
        public class User implements Serializable {
            private String name;
            private int age;
        }
        
        •  

        这次序列化成功
        在这里插入图片描述
        但是如果使用默认的序列化,添加的key前面有转义字符,不方便我们的操作,这时我们应当使用其他的序列化方法,下面来讲解
        在这里插入图片描述

        重新编写自己的RedisTemplate:

        @Configuration
        public class RedisConfig {
            //编写我们自己的RedisTemplate
            @Bean
            @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
            public RedisTemplate<String, Object> redisTemplates(RedisConnectionFactory redisConnectionFactory) {
                //我们为了开发方便,一般直接使用<String, Object>
                RedisTemplate<String, Object> template = new RedisTemplate<>();
                template.setConnectionFactory(redisConnectionFactory);
                //Jackson序列化配置
                Jackson2JsonRedisSerializer objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
                ObjectMapper om = new ObjectMapper();
                om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
                om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL,JsonTypeInfo.As.PROPERTY);
                objectJackson2JsonRedisSerializer.setObjectMapper(om);
                //String的序列化
                StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
                //key采用String的序列化方式
                template.setKeySerializer(stringRedisSerializer);
                //hash的key也采用String的序列化方式
                template.setHashKeySerializer(stringRedisSerializer);
                //value序列化方式采用Jackson
                template.setValueSerializer(objectJackson2JsonRedisSerializer);
                //hash序列化方式采用Jackson
                template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
                template.afterPropertiesSet();
                return template;
            }
        }
        
        •  

        重新测试:

        @SpringBootTest
        class Redis02SpringbootApplicationTests {
        	
            //对象名要和RedisConfig中的一致,要不然还是用的默认的RedisTemplate
            @Autowired
            private RedisTemplate redisTemplates;
        
            @Test
            public void test() throws JsonProcessingException {
                User zzy = new User("zzy", 20);
                redisTemplates.opsForValue().set("user",zzy);
                System.out.println(redisTemplates.opsForValue().get("user"));
            }
        }
        
        •  

        这是我们就可以使用我们自己设置的序列化将key添加进去了
        在这里插入图片描述

        在企业开发中,80%情况下都不会使用原生的方式编写代码:

        在这里插入图片描述
        我们来编写一个工具类RedisUtils

        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.data.redis.core.RedisTemplate;
        import org.springframework.stereotype.Component;
        import org.springframework.util.CollectionUtils;
        
        import java.util.List;
        import java.util.Map;
        import java.util.Set;
        import java.util.concurrent.TimeUnit;
        
        // 在我们真实的分发中,或者你们在公司,一般都可以看到一个公司自己封装RedisUtil
        @Component
        public final class RedisUtil {
        
            @Autowired
            private RedisTemplate<String, Object> redisTemplate;
            
            // =============================common============================
            /**
             * 指定缓存失效时间
             * @param key  键
             * @param time 时间(秒)
             */
            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(CollectionUtils.arrayToList(key));
                    }
                }
            }
        
        
            // ============================String=============================
        
            /**
             * 普通缓存获取
             * @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 值
             * @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 delta 要增加几(大于0)
             */
            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)
             */
            public long decr(String key, long delta) {
                if (delta < 0) {
                    throw new RuntimeException("递减因子必须大于0");
                }
                return redisTemplate.opsForValue().increment(key, -delta);
            }
        
        
            // ================================Map=================================
        
            /**
             * HashGet
             * @param key  键 不能为null
             * @param item 项 不能为null
             */
            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 对应多个键值
             */
            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)
             */
            public double hincr(String key, String item, double by) {
                return redisTemplate.opsForHash().increment(key, item, by);
            }
        
        
            /**
             * hash递减
             *
             * @param key  键
             * @param item 项
             * @param by   要减少记(小于0)
             */
            public double hdecr(String key, String item, double by) {
                return redisTemplate.opsForHash().increment(key, item, -by);
            }
        
        
            // ============================set=============================
        
            /**
             * 根据key获取Set中的所有值
             * @param key 键
             */
            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 键
             */
            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代表所有值
             */
            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 键
             */
            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倒数第二个元素,依次类推
             */
            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 值
             */
            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  时间(秒)
             */
            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;
                }
        
            }
        
        }
        
        •  

        使用工具类:

        @Autowired
        private RedisUtil redisUtil;
        
        @Test
        public void test() throws JsonProcessingException {
            redisUtil.set("name","zzy");
            System.out.println(redisUtil.get("name"));
        }
        
        •  

        在这里插入图片描述

 

原文链接:https://blog.csdn.net/weixin_46116099/article/details/122893281

这篇关于SpringBoot整合Redis及使用讲解的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!