springboot06-cache

SpringBoot緩存

作用

將運行結果緩存，以後再要相同的數據，直接從緩存中獲取，不用再調用方法；
springboot默認使用的是ConCurrentMapManeger

重要知識點

註解講解

1.@Cacheable：添加緩存組件，一般在方法執行前執行，先查詢cache組件map，有則直接用沒有則執行方法

    @Cacheable(cacheNames = {"dept"},keyGenerator = "myKeyGenerator")
    public Department getDeptById(Integer id){
        Department department = departmentMapper.getDeptById(id);
        return department;
    }

2.@CachePut：添加緩存，先執行方法再更新緩存，用於更新數據庫

    @CachePut(value = {"dept"})
    public Department updateDept(Department department){
        departmentMapper.updateDept(department);
        System.out.println("service方法執行");
        return department;
    }

3.@CacheEvict：刪除緩存

    @CacheEvict(cacheNames = "dept",key = "#id")
    public void delDept(Integer id){
        departmentMapper.deleteDeptById(id);
    }

4.@Caching：自定義複雜的緩存規則

5.@CacheConfig: 抽取緩存中的公共部分

@CacheConfig(cacheNames="dept",cacheManager = "employeeCacheManager") //抽取緩存的公共配置

springboot整合Redis

導入依賴

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

添加依賴後springboot，就會默認使用redis緩存，進行redis自動化配置

系統配置文件

spring:
  redis:
    database: 0
    ## Redis服務器地址
    host: 192.168.1.103
    ## Redis服務器連接端口
    port: 6379
    ## Redis服務器連接密碼（默認爲空）
    password:
    ## 連接超時時間（毫秒）
    # timeout: 1800000
    ## 連接池最大連接數（使用負值表示沒有限制）
    jedis:
      pool:
        max-active: 8
        ## 連接池最大阻塞等待時間（使用負值表示沒有限制）
        max-wait: -1
        ## 連接池中的最大空閒連接
        max-idle: 8
        ## 連接池中的最小空閒連接
        min-idle: 0

Redis配置文件

@Configuration
@EnableCaching
public class MyRedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);

        // 使用Jackson2JsonRedisSerialize 替換默認序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 設置value的序列化規則和 key的序列化規則
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();

        return redisTemplate;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer 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);

        // 配置序列化（解決亂碼的問題）,過期時間30秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(1800000))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

配置好redis後註解與原來的默認cache緩存一樣