SpringBoot整合Redis缓存

冷不防 2021-11-16 07:00 526阅读 0赞

**1.pom.xml添加redis依赖**

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

**2.application.properties配置redis连接属性**

# Redis数据库索引（默认为0）
    spring.redis.database=1
    # Redis服务器地址
    spring.redis.host=127.0.0.1
    # Redis服务器连接端口
    spring.redis.port=6379
    # Redis服务器连接密码
    spring.redis.password=123456
    # 连接池最大连接数（使用负值表示没有限制）
    spring.redis.pool.max-active=100
    # 连接池最大阻塞等待时间（使用负值表示没有限制）
    spring.redis.pool.max-wait=5000
    # 连接池中的最大空闲连接
    spring.redis.pool.max-idle=10
    # 连接池中的最小空闲连接
    spring.redis.pool.min-idle=0
    # 连接超时时间（毫秒）
    spring.redis.timeout=5000

**3.编写redis配置类**

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;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    @Configuration
    public class RedisConfig {
    
        @Bean
        public RedisTemplate<String,Object>redisTemplate(RedisConnectionFactory factory){
            RedisTemplate<String,Object> template = new RedisTemplate<>();
            template.setConnectionFactory(factory);
            //使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
            Jackson2JsonRedisSerializer<Object> 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);
            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;
        }
    
    }

**4.编写redis操作工具类**

import java.util.List;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    @Component
    public class RedisUtil {
    	
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    	
        /**
         * 普通缓存放入
         */
        public boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
        }
        
        /**
         * 普通缓存放入并设置时间(单位秒,time小于等于0,则设置无限期)
         */
        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 Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
        
        /**
         * 删除缓存(可以传一个值或多个)
         */
        @SuppressWarnings("unchecked")
        public void delete(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                } else {
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
        
        /**
         * 指定缓存失效时间(单位秒,expire返回1:成功地为该键设置了超时时间,返回0:键不存在或无法设置超时时间)
         */
        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获取过期时间(单位秒,getExpire返回大于0:表示距离过期还有多少秒,返回-1:永不过期,返回-2:过期且已删除)
         */
        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 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);
        }
        
        /**
         * 获取HashKey指定键值
         */
        public Object hashGet(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取HashKey所有键值
         */
        public Map<Object, Object> hashGet(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet放入
         */
        public boolean hashSet(String key, Map<String, Object> map) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        
        /**
         * HashSet放入并设置时间
         */
        public boolean hashSet(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;
            }
        }
        
        /**
         * 将list放入缓存
         */
        public boolean listSet(String key, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存并设置时间
         */
        public boolean listSet(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缓存的内容(0到-1代表所有值)
         */
        public List<Object> listGet(String key, long start, long end) {
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        
        /**
         * 通过索引 获取list中的值
         */
        public Object listGet(String key, long index) {
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        
        /**
         * 获取list缓存的长度
         */
        public long getListSize(String key) {
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        
    }

**5.测试使用**

@Controller
    public class Test {
    
        @Autowired
        private RedisUtil redisUtil;
    	
        @RequestMapping("/test")
        public String test(Model model,HttpServletRequest request) throws Exception{
    	    //普通类型
    	    redisUtil.set("ss", "哈哈");
    	    System.out.println("读取缓存普通类型："+redisUtil.get("ss"));
    	    //Map集合
    	    Map<String,Object> map = new HashMap<>();
    	    map.put("name", "小明");
    	    map.put("sex", "男");
    	    redisUtil.hashSet("map", map);
    	    System.out.println("读取缓存Map类型："+redisUtil.hashGet("map"));
    	    System.out.println("读取缓存Map类型指定元素："+redisUtil.hashGet("map","name"));
    	    //List集合
    	    List<Object> list = new ArrayList<>();
    	    Map<String,Object> map1 = new HashMap<>();
    	    map1.put("name", "小红");
    	    map1.put("sex", "女");
    	    list.add(map);
    	    list.add(map1);
    	    redisUtil.listSet("list", list);
    	    System.out.println("读取缓存List类型全部元素："+redisUtil.listGet("list",0,-1));
    	    System.out.println("读取缓存List类型第一个元素："+redisUtil.listGet("list",0));
    	    System.out.println("读取缓存List类型长度："+redisUtil.getListSize("list"));
    	    return "";
        }
    }

**Redis常用操作命令：**

**1.启动redis服务：**redis-server.exe redis.windows.conf

**2.连接redis服务：**redis-cli -h 127.0.0.1 -p 6379

auth 设置的密码

**3.清空所有缓存： **flushall

**通过bat命令启动Redis（例如：安装目录为F:\\reids）：**

@echo off
    title redis-server
    set ENV_HOME="F:\reids"
    F:
    cd %ENV_HOME%
    redis-server.exe redis.windows.conf
    @pause