fine-cache模块

• 数据缓存

依赖

• pom.xml

<!--fine-cache-->
<dependency>
    <groupId>cn.finemap</groupId>
    <artifactId>fine-cache</artifactId>
    <version>${fine.version}</version>
    <!-- 如果引用fine-auth，排除redis依赖 -->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </exclusion>
        <exclusion>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </exclusion>
    </exclusions>
</dependency>

配置

• src/main/resources/application.yml

# 使用连接池配置
spring:
  profiles:
    include: cache
  data:
    redis: 
      port: 6379
      host: 127.0.0.1
      password: 
      database: 0
      timeout: 10s
      lettuce:
        pool:
          # 连接池最大连接数
          max-active: 200
          # 连接池最大阻塞等待时间（使用负值表示没有限制）
          max-wait: -1ms
          # 连接池中的最大空闲连接
          max-idle: 10
          # 连接池中的最小空闲连接
          min-idle: 0

启动类开启缓存

@EnableCaching
public class FineExampleApplication {
  // xxx：启动程序
}

使用缓存

// 添加缓存
@Cacheable(value="name",key="#student.id",condition="#student.id>2")
// 清除缓存
@CacheEvict(value="name",allEntries=true)

创建子模块：fine-cache

• 在fine-parent中创建：fine-cache子模块

fine-cache

• 创建子模块：New > Module...
• 添加redis缓存依赖
• 添加缓存配置

依赖

• fine-cache/pom.xml

<dependencies>
    <!-- redis缓存 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>${spring-boot.version}</version>
    </dependency>
    <!-- spring-cache -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
        <version>${spring-boot.version}</version>
    </dependency>
    <!-- 提供Redis连接池 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>${commons-pool2.version}</version>
    </dependency>
    <!--fine-commons-->
    <dependency>
        <groupId>cn.finemap</groupId>
        <artifactId>fine-commons</artifactId>
        <version>${fine.version}</version>
        <optional>true</optional>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

缓存application-cache.yml

• src/main/resources/application-cache.yml

# 缓存配置
spring:
  cache:
    type: redis
    redis:
      # 项目前缀
      key-prefix: "${spring.application.name}:"
      # 缓存过期时间：单位分钟，43200分钟 = 30天
      # time-to-live: 43200

缓存配置类

• cn/finemap/cache/RedisConfig.java

@Configuration
@EnableCaching
@SuppressWarnings("all")
public class RedisConfig {

    //项目前缀
    @Value("${spring.cache.redis.key-prefix}")
    private String prefix;

    // 缓存过期时间：分钟
    @Value("${spring.cache.redis.time-to-live:43200}")
    private long ttl;

    /**
     * 配置缓存序列化方式
     * @return
     */
    @Bean
    public GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer() {
        String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
        ObjectMapper objectMapper = new ObjectMapper();
        // 处理Date类型
        objectMapper.setDateFormat(new SimpleDateFormat(DATE_TIME_FORMAT));
        objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
        objectMapper.registerModule(new JavaTimeModule()
                // 处理LocalDateTime类型
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)))
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT))));
        // 序列化java对象时，将类的信息写入redis
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        return new GenericJackson2JsonRedisSerializer(objectMapper);
    }

    /**
     * RedisTemplate配置
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(@Autowired(required = false) RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer<?> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        //key 采用的String 的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //hashde key 也采用String的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        //value 序列化方式采用jackson
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer());
        //hash 的 value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer());
        // 默认序列化方式
        redisTemplate.setDefaultSerializer(genericJackson2JsonRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 配置缓存管理器
     * @param factory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        // 配置序列化方式
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(ttl)) // 配置缓存时长
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer()))
                .prefixCacheNameWith(prefix); // 添加统一前缀;
        // 配置缓存管理器
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }

}

维护父工程：fine-parent

fine-parent

• 添加该子模块
• 在父工程中，管理版本参数

pom

• fine-parent/pom.xml

<!-- 版本参数 -->
<properties>
    <!-- fine-cache -->
    <commons-pool2.version>2.11.1</commons-pool2.version>
</properties>

fine-cache使用

• 在启动类中添加@EnableCaching，开启缓存支持。
• 注解会利用配置好的CacheManager的缓存前缀和缓存时长。
• 工具类已经配置缓存前缀

注解使用

// 添加缓存
@Cacheable(value = "user", key = "#paramName")
public Result<User> getData(String paramName){
    // 如果redis中存在，直接返回
    // 如果redis中不存在，执行函数，返回结果存储到系统中
    // 存储名称：应用名称前缀:user::paramName，存储值为Result序列化后的String
}

// 清除缓存
@CacheEvict(cacheNames = "user", key = "#paramName", allEntries=true)
public void clearData(String paramName){
    // 根据存储名称清除数据
}

工具类

// 获取缓存工具类
@Autowired
private RedisUtils redisUtils;

RedisTemplate

• 推荐使用应用名称作为缓存前缀

// 获取缓存Bean
@Resource
private RedisTemplate redisTemplate;