前期配置与准备

pom文件引入cache和redis的依赖

<!-- 使用redis做缓存 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-cache</artifactId>
</dependency>

配置application.properties

## Redis部分
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1ms
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=5000

## Cache部分
#缓存的名称集合，多个采用逗号分割
spring.cache.cache-names=
#缓存的类型，官方提供了很多，这里我们填写redis
spring.cache.type=redis
#是否缓存null数据，默认是false
spring.cache.redis.cache-null-values=false
#redis中缓存超时的时间，默认60000ms
spring.cache.redis.time-to-live=60000
#缓存数据key是否使用前缀，默认是true
spring.cache.redis.use-key-prefix=true
#缓存数据key的前缀，在上面的配置为true时有效，
spring.cache.redis.key-prefix=

配置Configuration

package com.HaijieLi.blog.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
 * @author Li Haijie
 * @date 2019/9/5 14:48
 */
@Configuration
public class CacheConfig  extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        config = config.entryTtl(Duration.ofMinutes(60*30));
        // 设置一个初始化的缓存空间set集合
        Set<String> cacheNames =  new HashSet<>();
        cacheNames.add("common");
        // 对每个缓存空间应用不同的配置
        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
        configMap.put("common",  config.entryTtl(Duration.ofSeconds(60*60*24*4)));
        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                .initialCacheNames(cacheNames)
                .withInitialCacheConfigurations(configMap)
                .build();
        return cacheManager;
    }
}

启动类Application添加@EnableCaching注解

package com.HaijieLi.blog;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching
public class BlogApplication{
	public static void main(String[] args) {
		SpringApplication.run(BlogApplication.class, args);
	}
}

缓存注解的使用

使用缓存来实现缓存的最大好处就是可以减少对原来代码功能的改动性，使得我们可以完全不用理会原本的代码逻辑的情况下来增加或者删除的缓存的功能

@Cacheable的使用

@Cacheable：调用方法时先从缓存中查询有没有对应key的数据，如果有直接从缓存获取返回，如果没有则执行方法，将返回值存入缓存中。

参数	解释
value	缓存的名称，在配置文件中定义，至少指定一个
key	如果自定义要按照 SpEL 表达式编写；如果不指定，则会按照参数进行整合
condition	默认所有都进行缓存，使用 SpEL 表达式编写，表达式为true 才进行缓存

样例代码

@Cacheable(value = "common", key = "'blog_'+#user_id+'_'+#id", condition = "#result != null ")
@Override
public Blog findBlogByUserIdAndId(Long user_id, Long id) {
    System.out.println("不命中缓存：user_id = " + user_id + "，id = " + id);
   //TODO 实现的逻辑代码
}

@CacheEvict的使用

@CacheEvict：调用方法后从缓存中删除对应key的数据

参数	解释
value	缓存的名称，在配置文件中定义，至少指定一个
key	如果自定义要按照 SpEL 表达式编写；如果不指定，则会按照参数进行整合
allEntries	是否清空所有缓存内容，默认为false
beforeInvocation	是否在方法执行前就清空,默认为false

样例代码

@CacheEvict(value = "common" , key = "'blog_'+#userId+'_'+#blog.id")
@Override
@Transactional
public int update(Blog blog, Long userId) {
    //TODO 实现的逻辑代码
}