导读

当项目数据量大的时候，每次从数据库中查询数据要话费很长时间，不但影响用户的体验度，而且浪费了数据库的资源，所以需要额外增加中间件Redis来考虑解决，当然添加其他中间件也可以，目前仅仅简单的介绍下SpringBoot项目中使用Redis。

使用

添加依赖

  1. <dependency>
  2.     <groupId>org.springframework.data</groupId>
  3.     <artifactId>spring-data-redis</artifactId>
  4.     <version>2.1.14.RELEASE</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>redis.clients</groupId>
  8.     <artifactId>jedis</artifactId>
  9.     <version>3.0.1</version>
  10. </dependency>

添加配置信息

  1. redis:
  2.     host: localhost
  3.     port: 6379
  4.     password: 123456
  5.     database: 0
  6.     timeout: 15000
  7.     jedis:
  8.       pool:
  9.         min-idle: 4
  10.         max-idle: 8
  11.         max-active: 40
  12.         max-wait: 15000
  13.         numTestsPerEvictionRun: 3
  14.         minEvictableIdleTimeMillis: 300000
  15.         timeBetweenEvictionRunsMillis: 300000
  16.         testOnBorrow: true
  17.         testOnReturn: true
  18.         testWhileIdle: true

RedisConfig文件

  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import org.springframework.cache.annotation.EnableCaching;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  8. import org.springframework.data.redis.cache.RedisCacheManager;
  9. import org.springframework.data.redis.cache.RedisCacheWriter;
  10. import org.springframework.data.redis.connection.RedisConnectionFactory;
  11. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  12. import org.springframework.data.redis.serializer.RedisSerializationContext;
  14. import java.io.Serializable;
  15. import java.time.Duration;
  16. import java.util.HashMap;
  17. import java.util.Map;
  19. /**
  20.  * RedisConfig配置文件
  21.  */
  23. @Configuration
  24. @EnableCaching
  25. public class RedisConfig implements Serializable {
  27.     /**
  28.      * KeyGenerator该方法设置key的生成策略
  29.      */
  30.     /**
  31.     @Bean
  32.     public KeyGenerator keyGenerator() {
  33.         return new KeyGenerator() {
  34.             //为给定的方法及其参数生成一个键
  35.             //格式为：com.frog.mvcdemo.controller.FrogTestController-show-[params]
  36.             @Override
  37.             public Object generate(Object target, Method method, Object... params) {
  38.                 StringBuffer sb = new StringBuffer();
  39.                 sb.append(target.getClass().getName());//类名
  40.                 sb.append("-");
  41.                 sb.append(method.getName());//方法名
  42.                 sb.append("-");
  43.                 for (Object param: params ) {
  44.                     sb.append(param.toString());//参数
  45.                 }
  46.                 return sb.toString();
  47.             }
  48.         };
  49.     }
  50.     */
  52.     /**
  53.      * 设置redis缓存过期时间
  54.      */
  55.     @Bean
  56.     public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
  57.         return new RedisCacheManager(
  58.                 RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
  59.                 // 默认策略，未配置的 key 会使用这个 这里设置一个月
  60.                 this.getRedisCacheConfigurationWithTtl(60 * 60 * 12 * 30), 
  61.                 this.getRedisCacheConfigurationMap() // 指定 key 策略
  62.         );
  63.     }
  65.     private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
  66.         Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
  67.         //自定义设置缓存时间 这里设置12h
  68.         redisCacheConfigurationMap.put("defineCache", this.getRedisCacheConfigurationWithTtl(60 * 60 * 12));
  69.         return redisCacheConfigurationMap;
  70.     }
  72.     private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
  73.         Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
  74.         ObjectMapper om = new ObjectMapper();
  75.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  76.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  77.         jackson2JsonRedisSerializer.setObjectMapper(om);
  78.         RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
  79.         redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
  80.                 RedisSerializationContext
  81.                         .SerializationPair
  82.                         .fromSerializer(jackson2JsonRedisSerializer)
  83.         ).entryTtl(Duration.ofSeconds(seconds));
  85.         return redisCacheConfiguration;
  86.     }
  87. }

在实现层使用

a.未使用配置文件中key生成策略

未使用默认的key生成策略，也就是上述配置文件失效，使用@Cacheable注解，具体该注解如何使用，可以参考该篇文章：Spring缓存注解@Cacheable,@CachePut , @CacheEvict使用

  1. @Override
  2. @Cacheable(value = "defineCache", key = "#demoQuery.toGetKeyString()",unless = "#result==null||#result.size()<=0")
  3. public List<DemoVO> getAppRuleList(DemoQuery demoQuery) {
  4.     return demoMapper.getDemoList(demoQuery);
  5. }

DemoQuery添加 toGetKeyString 方法

  1. public String toGetKeyString() {
  2.         return "toGetKeyString{" +
  3.                 "name='" + name + '\'' +
  4.                 ", age='" + age + '\'' +
  5.                 ", address='" + address + '\'' +
  6.                 ", phone='" + phone + '\'' +
  7.                 ", job=" + job +
  8.                 ", birthday='" + birthday + '\'' +
  9.                 '}';
  10.     }

b.使用配置文件中key生成策略

  1. @Override
  2. @Cacheable(value = "defineCache", keyGenerator = "keyGenerator",unless = "#result==null||#result.size()<=0")
  3. public List<DemoVO> getAppRuleList(DemoQuery demoQuery) {
  4.     return demoMapper.getDemoList(demoQuery);
  5. }

自定义策略： key属性是用来指定Spring缓存方法的返回结果时对应的key的。该属性支持SpringEL表达式。当我们没有指定该属性时，Spring将使用默认策略生成key。

自定义策略是指我们可以通过Spring的EL表达式来指定我们的key。这里的EL表达式可以使用方法参数及它们对应的属性。使用方法参数时我们可以直接使用“#参数名”或者“#p参数index”。

注意

  • 使用@Cacheable注解的时候，指定的key不能是该类内部的方法，必须要从其他地方引用，不然会报错。

END

搞定~