redis(七)之springboot整合redis

缺乏、安全感 2022-03-01 05:30 416阅读 0赞

# 1.使用redisTemplate的方式 #

1.pom.xml

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

2.application.properties里面添加

# Redis数据库索引（默认为0）
    spring.redis.database=0
    # Redis服务器地址
    spring.redis.host=127.0.0.1
    # Redis服务器连接端口
    spring.redis.port=6379
    # Redis服务器连接密码（默认为空）
    spring.redis.password=
    # 连接超时时间（毫秒）
    spring.redis.timeout=3000
    #最大空闲数
    redis.maxIdle=300  
    #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
    #redis.maxActive=600
    #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
    redis.maxTotal=1000  
    #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
    redis.maxWaitMillis=1000  
    #连接的最小空闲时间 默认1800000毫秒(30分钟)
    redis.minEvictableIdleTimeMillis=300000  
    #每次释放连接的最大数目,默认3
    redis.numTestsPerEvictionRun=1024  
    #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
    redis.timeBetweenEvictionRunsMillis=30000  
    #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    redis.testOnBorrow=true  
    #在空闲时检查有效性, 默认false
    redis.testWhileIdle=true

3.创建RedisUtil类

package cn.itcast.ssm.util;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.*;
    import org.springframework.stereotype.Service;
    import org.springframework.util.CollectionUtils;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    /** * @author wsw * @Package cn.itcast.ssm.util * @Description: * @date 19-3-21 上午11:30 */
    
    @Service
    public class RedisUtil { 
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        private static double size = Math.pow(2, 32);
    
    
        /** * 写入缓存 * * @param key * @param offset 位 8Bit=1Byte * @return */
        public boolean setBit(String key, long offset, boolean isShow) { 
            boolean result = false;
            try { 
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.setBit(key, offset, isShow);
                result = true;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return result;
        }
    
        /** * 写入缓存 * * @param key * @param offset * @return */
        public boolean getBit(String key, long offset) { 
            boolean result = false;
            try { 
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                result = operations.getBit(key, offset);
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return result;
        }
    
    
        /** * 写入缓存 * * @param key * @param value * @return */
        public boolean set(final String key, Object value) { 
            boolean result = false;
            try { 
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                result = true;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return result;
        }
        /** * 写入缓存并设置有效时间 * * @param key * @param value * @return */
        public boolean settime(final String key, Object value,long time) { 
            boolean result = false;
            try { 
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value,time,TimeUnit.SECONDS);
                result = true;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return result;
        }
        /** * 写入缓存设置时效时间 * * @param key * @param value * @return */
        public boolean set(final String key, Object value, Long expireTime) { 
            boolean result = false;
            try { 
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
                result = true;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return result;
        }
    
        /** * 批量删除对应的value * * @param keys */
        public void remove(final String... keys) { 
            for (String key : keys) { 
                remove(key);
            }
        }
    
    
        /** * 删除对应的value * * @param key */
        public void remove(final String key) { 
            if (exists(key)) { 
                redisTemplate.delete(key);
            }
        }
    
        /** * 判断缓存中是否有对应的value * * @param key * @return */
        public boolean exists(final String key) { 
            return redisTemplate.hasKey(key);
        }
    
        /** * 读取缓存 * * @param key * @return */
        public Object get(final String key) { 
            Object result = null;
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            result = operations.get(key);
            return result;
        }
    
        /** * 哈希 添加 * * @param key * @param hashKey * @param value */
        public void hmSet(String key, Object hashKey, Object value) { 
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            hash.put(key, hashKey, value);
        }
    
        /** * 哈希获取数据 * * @param key * @param hashKey * @return */
        public Object hmGet(String key, Object hashKey) { 
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            return hash.get(key, hashKey);
        }
    
        /** * 列表添加 * * @param k * @param v */
        public void lPush(String k, Object v) { 
            ListOperations<String, Object> list = redisTemplate.opsForList();
            list.rightPush(k, v);
        }
        /** * 列表添加 * * @param k * @param v */
        public void lPushtime(String k, Object v,long time) { 
            ListOperations<String, Object> list = redisTemplate.opsForList();
            list.rightPush(k, v,time);
        }
      /* *//** * 将list放入缓存 * @param key 键 * @param value 值 * @param time 时间(秒) * @return */
        public boolean lSetlist(String key, Object value, long time) { 
            try { 
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0) redisTemplate.expire(key, time, TimeUnit.SECONDS);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 列表获取 * * @param k * @param l * @param l1 * @return */
        public List<Object> lRange(String k, long l, long l1) { 
            ListOperations<String, Object> list = redisTemplate.opsForList();
            return list.range(k, l, l1);
        }
    
        /** * 集合添加 * * @param key * @param value */
        public void add(String key, Object value) { 
            SetOperations<String, Object> set = redisTemplate.opsForSet();
            set.add(key, value);
        }
    
        /** * 集合获取 * * @param key * @return */
        public Set<Object> setMembers(String key) { 
            SetOperations<String, Object> set = redisTemplate.opsForSet();
            return set.members(key);
        }
    
        /** * 有序集合添加 * * @param key * @param value * @param scoure */
        public void zAdd(String key, Object value, double scoure) { 
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            zset.add(key, value, scoure);
        }
    
        /** * 有序集合获取 * * @param key * @param scoure * @param scoure1 * @return */
        public Set<Object> rangeByScore(String key, double scoure, double scoure1) { 
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            redisTemplate.opsForValue();
            return zset.rangeByScore(key, scoure, scoure1);
        }
    
    
        //第一次加载的时候将数据加载到redis中
        public void saveDataToRedis(String name) { 
            double index = Math.abs(name.hashCode() % size);
            long indexLong = new Double(index).longValue();
            boolean availableUsers = setBit("availableUsers", indexLong, true);
        }
    
        //第一次加载的时候将数据加载到redis中
        public boolean getDataToRedis(String name) { 
    
            double index = Math.abs(name.hashCode() % size);
            long indexLong = new Double(index).longValue();
            return getBit("availableUsers", indexLong);
        }
    
        /** * 有序集合获取排名 * * @param key 集合名称 * @param value 值 */
        public Long zRank(String key, Object value) { 
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            return zset.rank(key,value);
        }
    
    
        /** * 有序集合获取排名 * * @param key */
        public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start,long end) { 
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key,start,end);
            return ret;
        }
    
        /** * 有序集合添加 * * @param key * @param value */
        public Double zSetScore(String key, Object value) { 
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            return zset.score(key,value);
        }
    
    
        /** * 有序集合添加分数 * * @param key * @param value * @param scoure */
        public void incrementScore(String key, Object value, double scoure) { 
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            zset.incrementScore(key, value, scoure);
        }
    
    
        /** * 有序集合获取排名 * * @param key */
        public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start, long end) { 
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key,start,end);
            return ret;
        }
    
        /** * 有序集合获取排名 * * @param key */
        public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) { 
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
            return ret;
        }
    
        }

4.在service中使用

@Autowired
        CropMapper cropMapper;
        @Autowired
        RedisUtil redisUtil;
        @Override
        public List<Crop> selectAllCropName() { 
            //从缓存中获取
            List namelist= redisUtil.lRange("namelist",0,-1);
            //如果缓存中没有，则从mysql中获取
            if(namelist.size()==0){ 
                List list=cropMapper.selectByExample(null);
                for(Object crop:list){ 
                    Crop crop1=(Crop)crop;
                    namelist.add(crop1.getName());
                }
            }
            //加入缓存中并设置过期时间120s
            redisUtil.lSetlist("namelist",namelist,120);
            return  namelist;
        }

# 2.springboot整合redis缓存注解@Cacheable、@CacheEvict、@CachePut #

##### @Cacheable： #####

主要用来配置方法，能够根据方法的请求参数对其结果进行缓存。即当重复使用相同参数调用方法的时候，方法本身不会被调用执行，即方法本身被略过了，取而代之的是方法的结果直接从缓存中找到并返回了。  
参数：  
value：缓存的名字，必须指定至少一个。  
key:缓存的key，可以为空，如果指定要按照SpEL表达式编写；如果不指定，则缺省按照方法的所有参数进行组合。  
condition：缓存的条件，可以为空，使用SpEL编写，返回true或者false，只有为true才能缓存。

##### @CachePut： #####

这个注释可以确保方法被执行，同时方法的返回值也被记录到缓存中，用于更新缓存与数据库。  
参数同上。

##### @CacheEvict #####

删除缓存。参数:allEntries：true表示清除value中的全部缓存，默认为false。其余参数同上  
1.pom.xml依赖

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

2.RedisConfig

@Configuration
    @EnableCaching
    public class RedisConfig { 
    
        @Bean
        public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory redisConnectionFactory){ 
            RedisTemplate<String,String> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            return redisTemplate;
        }
        //自定义key
        @Bean
        public KeyGenerator simpleKeyGenerator() { 
            return (o, method, objects) -> { 
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.append(o.getClass().getSimpleName());
                stringBuilder.append(".");
                stringBuilder.append(method.getName());
                stringBuilder.append("[");
                for (Object obj : objects) { 
                    stringBuilder.append(obj.toString());
                }
                stringBuilder.append("]");
    
                return stringBuilder.toString();
            };
        }
        //默认缓存时间
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { 
            return new RedisCacheManager(
                    RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                    this.getRedisCacheConfigurationWithTtl(60), // 默认策略，未配置的 key 会使用这个
                    this.getRedisCacheConfigurationMap() // 指定 key 策略
            );
        }
        //自定义缓存时间
        private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() { 
            Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        /* redisCacheConfigurationMap.put("SelectMax_T", this.getRedisCacheConfigurationWithTtl(30));*/
            return redisCacheConfigurationMap;
        }
    
        private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) { 
            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);
    
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
            redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                    RedisSerializationContext
                            .SerializationPair
                            .fromSerializer(jackson2JsonRedisSerializer)
            ).entryTtl(Duration.ofSeconds(seconds));
    
            return redisCacheConfiguration;
        }
    
    }

3.使用

@Override
        @CachePut(value = "Max_T",key="'CropId:'+#p0")
        public double UpdateMax_T(int CropId,double Max_T) { 
            List list=parameterMapper.selectByExample(null);
            for(Object parameter_:list){ 
                Parameter parameter=(Parameter) parameter_;
                if(parameter.getCropId()==CropId){ 
                   parameter.setMaxT(Max_T);
                   parameterMapper.updateByExample(parameter, new ParameterExample());
                }
            }
            return Max_T;
        }
    
        @Override
        @Cacheable(value = "Max_T",key="'CropId:'+#p0")
        public double SelectMax_T(int CropId) { 
            Double Max_T=0.0;
            List list=parameterMapper.selectByExample(null);
            for(Object parameter_:list){ 
                Parameter parameter=(Parameter) parameter_;
                if(parameter.getCropId()==CropId){ 
                    Max_T=parameter.getMaxT();
                }
            }
            return Max_T;
        }