redis(七)之springboot整合redis

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

1.使用redisTemplate的方式

1.pom.xml

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-data-redis</artifactId>
  4.         </dependency>

2.application.properties里面添加

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

3.创建RedisUtil类

  1. package cn.itcast.ssm.util;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.*;
  5. import org.springframework.stereotype.Service;
  6. import org.springframework.util.CollectionUtils;
  8. import java.io.Serializable;
  9. import java.util.*;
  10. import java.util.concurrent.TimeUnit;
  11. /** * @author wsw * @Package cn.itcast.ssm.util * @Description: * @date 19-3-21 上午11:30 */
  13. @Service
  14. public class RedisUtil { 
  16.     @Autowired
  17.     private RedisTemplate redisTemplate;
  19.     private static double size = Math.pow(2, 32);
  22.     /** * 写入缓存 * * @param key * @param offset 位 8Bit=1Byte * @return */
  23.     public boolean setBit(String key, long offset, boolean isShow) { 
  24.         boolean result = false;
  25.         try { 
  26.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  27.             operations.setBit(key, offset, isShow);
  28.             result = true;
  29.         } catch (Exception e) { 
  30.             e.printStackTrace();
  31.         }
  32.         return result;
  33.     }
  35.     /** * 写入缓存 * * @param key * @param offset * @return */
  36.     public boolean getBit(String key, long offset) { 
  37.         boolean result = false;
  38.         try { 
  39.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  40.             result = operations.getBit(key, offset);
  41.         } catch (Exception e) { 
  42.             e.printStackTrace();
  43.         }
  44.         return result;
  45.     }
  48.     /** * 写入缓存 * * @param key * @param value * @return */
  49.     public boolean set(final String key, Object value) { 
  50.         boolean result = false;
  51.         try { 
  52.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  53.             operations.set(key, value);
  54.             result = true;
  55.         } catch (Exception e) { 
  56.             e.printStackTrace();
  57.         }
  58.         return result;
  59.     }
  60.     /** * 写入缓存并设置有效时间 * * @param key * @param value * @return */
  61.     public boolean settime(final String key, Object value,long time) { 
  62.         boolean result = false;
  63.         try { 
  64.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  65.             operations.set(key, value,time,TimeUnit.SECONDS);
  66.             result = true;
  67.         } catch (Exception e) { 
  68.             e.printStackTrace();
  69.         }
  70.         return result;
  71.     }
  72.     /** * 写入缓存设置时效时间 * * @param key * @param value * @return */
  73.     public boolean set(final String key, Object value, Long expireTime) { 
  74.         boolean result = false;
  75.         try { 
  76.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  77.             operations.set(key, value);
  78.             redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
  79.             result = true;
  80.         } catch (Exception e) { 
  81.             e.printStackTrace();
  82.         }
  83.         return result;
  84.     }
  86.     /** * 批量删除对应的value * * @param keys */
  87.     public void remove(final String... keys) { 
  88.         for (String key : keys) { 
  89.             remove(key);
  90.         }
  91.     }
  94.     /** * 删除对应的value * * @param key */
  95.     public void remove(final String key) { 
  96.         if (exists(key)) { 
  97.             redisTemplate.delete(key);
  98.         }
  99.     }
  101.     /** * 判断缓存中是否有对应的value * * @param key * @return */
  102.     public boolean exists(final String key) { 
  103.         return redisTemplate.hasKey(key);
  104.     }
  106.     /** * 读取缓存 * * @param key * @return */
  107.     public Object get(final String key) { 
  108.         Object result = null;
  109.         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  110.         result = operations.get(key);
  111.         return result;
  112.     }
  114.     /** * 哈希 添加 * * @param key * @param hashKey * @param value */
  115.     public void hmSet(String key, Object hashKey, Object value) { 
  116.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
  117.         hash.put(key, hashKey, value);
  118.     }
  120.     /** * 哈希获取数据 * * @param key * @param hashKey * @return */
  121.     public Object hmGet(String key, Object hashKey) { 
  122.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
  123.         return hash.get(key, hashKey);
  124.     }
  126.     /** * 列表添加 * * @param k * @param v */
  127.     public void lPush(String k, Object v) { 
  128.         ListOperations<String, Object> list = redisTemplate.opsForList();
  129.         list.rightPush(k, v);
  130.     }
  131.     /** * 列表添加 * * @param k * @param v */
  132.     public void lPushtime(String k, Object v,long time) { 
  133.         ListOperations<String, Object> list = redisTemplate.opsForList();
  134.         list.rightPush(k, v,time);
  135.     }
  136.   /* *//** * 将list放入缓存 * @param key 键 * @param value 值 * @param time 时间(秒) * @return */
  137.     public boolean lSetlist(String key, Object value, long time) { 
  138.         try { 
  139.             redisTemplate.opsForList().rightPush(key, value);
  140.             if (time > 0) redisTemplate.expire(key, time, TimeUnit.SECONDS);
  141.             return true;
  142.         } catch (Exception e) { 
  143.             e.printStackTrace();
  144.             return false;
  145.         }
  146.     }
  148.     /** * 列表获取 * * @param k * @param l * @param l1 * @return */
  149.     public List<Object> lRange(String k, long l, long l1) { 
  150.         ListOperations<String, Object> list = redisTemplate.opsForList();
  151.         return list.range(k, l, l1);
  152.     }
  154.     /** * 集合添加 * * @param key * @param value */
  155.     public void add(String key, Object value) { 
  156.         SetOperations<String, Object> set = redisTemplate.opsForSet();
  157.         set.add(key, value);
  158.     }
  160.     /** * 集合获取 * * @param key * @return */
  161.     public Set<Object> setMembers(String key) { 
  162.         SetOperations<String, Object> set = redisTemplate.opsForSet();
  163.         return set.members(key);
  164.     }
  166.     /** * 有序集合添加 * * @param key * @param value * @param scoure */
  167.     public void zAdd(String key, Object value, double scoure) { 
  168.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  169.         zset.add(key, value, scoure);
  170.     }
  172.     /** * 有序集合获取 * * @param key * @param scoure * @param scoure1 * @return */
  173.     public Set<Object> rangeByScore(String key, double scoure, double scoure1) { 
  174.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  175.         redisTemplate.opsForValue();
  176.         return zset.rangeByScore(key, scoure, scoure1);
  177.     }
  180.     //第一次加载的时候将数据加载到redis中
  181.     public void saveDataToRedis(String name) { 
  182.         double index = Math.abs(name.hashCode() % size);
  183.         long indexLong = new Double(index).longValue();
  184.         boolean availableUsers = setBit("availableUsers", indexLong, true);
  185.     }
  187.     //第一次加载的时候将数据加载到redis中
  188.     public boolean getDataToRedis(String name) { 
  190.         double index = Math.abs(name.hashCode() % size);
  191.         long indexLong = new Double(index).longValue();
  192.         return getBit("availableUsers", indexLong);
  193.     }
  195.     /** * 有序集合获取排名 * * @param key 集合名称 * @param value 值 */
  196.     public Long zRank(String key, Object value) { 
  197.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  198.         return zset.rank(key,value);
  199.     }
  202.     /** * 有序集合获取排名 * * @param key */
  203.     public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start,long end) { 
  204.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  205.         Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key,start,end);
  206.         return ret;
  207.     }
  209.     /** * 有序集合添加 * * @param key * @param value */
  210.     public Double zSetScore(String key, Object value) { 
  211.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  212.         return zset.score(key,value);
  213.     }
  216.     /** * 有序集合添加分数 * * @param key * @param value * @param scoure */
  217.     public void incrementScore(String key, Object value, double scoure) { 
  218.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  219.         zset.incrementScore(key, value, scoure);
  220.     }
  223.     /** * 有序集合获取排名 * * @param key */
  224.     public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start, long end) { 
  225.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  226.         Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key,start,end);
  227.         return ret;
  228.     }
  230.     /** * 有序集合获取排名 * * @param key */
  231.     public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) { 
  232.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  233.         Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
  234.         return ret;
  235.     }
  237.     }

4.在service中使用

  1. @Autowired
  2.     CropMapper cropMapper;
  3.     @Autowired
  4.     RedisUtil redisUtil;
  5.     @Override
  6.     public List<Crop> selectAllCropName() { 
  7.         //从缓存中获取
  8.         List namelist= redisUtil.lRange("namelist",0,-1);
  9.         //如果缓存中没有，则从mysql中获取
  10.         if(namelist.size()==0){ 
  11.             List list=cropMapper.selectByExample(null);
  12.             for(Object crop:list){ 
  13.                 Crop crop1=(Crop)crop;
  14.                 namelist.add(crop1.getName());
  15.             }
  16.         }
  17.         //加入缓存中并设置过期时间120s
  18.         redisUtil.lSetlist("namelist",namelist,120);
  19.         return  namelist;
  20.     }

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依赖

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-cache</artifactId>
  4.     </dependency>

2.RedisConfig

  1. @Configuration
  2. @EnableCaching
  3. public class RedisConfig { 
  5.     @Bean
  6.     public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory redisConnectionFactory){ 
  7.         RedisTemplate<String,String> redisTemplate = new RedisTemplate<>();
  8.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  9.         return redisTemplate;
  10.     }
  11.     //自定义key
  12.     @Bean
  13.     public KeyGenerator simpleKeyGenerator() { 
  14.         return (o, method, objects) -> { 
  15.             StringBuilder stringBuilder = new StringBuilder();
  16.             stringBuilder.append(o.getClass().getSimpleName());
  17.             stringBuilder.append(".");
  18.             stringBuilder.append(method.getName());
  19.             stringBuilder.append("[");
  20.             for (Object obj : objects) { 
  21.                 stringBuilder.append(obj.toString());
  22.             }
  23.             stringBuilder.append("]");
  25.             return stringBuilder.toString();
  26.         };
  27.     }
  28.     //默认缓存时间
  29.     @Bean
  30.     public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { 
  31.         return new RedisCacheManager(
  32.                 RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
  33.                 this.getRedisCacheConfigurationWithTtl(60), // 默认策略，未配置的 key 会使用这个
  34.                 this.getRedisCacheConfigurationMap() // 指定 key 策略
  35.         );
  36.     }
  37.     //自定义缓存时间
  38.     private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() { 
  39.         Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
  40.     /* redisCacheConfigurationMap.put("SelectMax_T", this.getRedisCacheConfigurationWithTtl(30));*/
  41.         return redisCacheConfigurationMap;
  42.     }
  44.     private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) { 
  45.         Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
  46.         ObjectMapper om = new ObjectMapper();
  47.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  48.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  49.         jackson2JsonRedisSerializer.setObjectMapper(om);
  51.         RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
  52.         redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
  53.                 RedisSerializationContext
  54.                         .SerializationPair
  55.                         .fromSerializer(jackson2JsonRedisSerializer)
  56.         ).entryTtl(Duration.ofSeconds(seconds));
  58.         return redisCacheConfiguration;
  59.     }
  61. }

3.使用

  1. @Override
  2.     @CachePut(value = "Max_T",key="'CropId:'+#p0")
  3.     public double UpdateMax_T(int CropId,double Max_T) { 
  4.         List list=parameterMapper.selectByExample(null);
  5.         for(Object parameter_:list){ 
  6.             Parameter parameter=(Parameter) parameter_;
  7.             if(parameter.getCropId()==CropId){ 
  8.                parameter.setMaxT(Max_T);
  9.                parameterMapper.updateByExample(parameter, new ParameterExample());
  10.             }
  11.         }
  12.         return Max_T;
  13.     }
  15.     @Override
  16.     @Cacheable(value = "Max_T",key="'CropId:'+#p0")
  17.     public double SelectMax_T(int CropId) { 
  18.         Double Max_T=0.0;
  19.         List list=parameterMapper.selectByExample(null);
  20.         for(Object parameter_:list){ 
  21.             Parameter parameter=(Parameter) parameter_;
  22.             if(parameter.getCropId()==CropId){ 
  23.                 Max_T=parameter.getMaxT();
  24.             }
  25.         }
  26.         return Max_T;
  27.     }

发表评论

表情：
评论列表 （有 0 条评论，449人围观）

还没有评论，来说两句吧...

相关阅读