注 : 文章中的每一步都不可缺少。

导入依赖

为方便之后数据对象编写，同时导入 lombok 的依赖，这样就可以通过注解自动生成getter、setter和初始化方法了。

Maven

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <version>1.18.4</version>
</dependency>

Gradle

implementation('org.springframework.boot:spring-boot-starter-data-redis')
annotationProcessor('org.projectlombok:lombok:1.18.4')
compileOnly('org.projectlombok:lombok:1.18.4')

添加 Redis 服务配置

在 application.yml 配置文件中加入 redis 配置。

spring:
  redis:
    #设置数据库索引
    database: 0
    #Redis服务器地址
    host: 192.168.1.100
    #Redis服务器连接端口
    port: 6379
    #Redis服务器连接密码（默认为空）
    password: 123456
    #连接池最大连接数（使用负值表示没有限制）
    pool:
      max-active: 10
      #连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1
      #连接池中的最大空闲连接
      max-idle: 10
      #连接池中的最小空闲连接
      min-idle: 0
    #连接超时时间（毫秒）
    timeout:  60000

直接使用 RedisTemplate 操作缓存

操作缓存的 Service 类

@Service
public class RedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void set(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
}

通过注释方法操作缓存

RedisConfig 配置 RedisTemplate 和 CacheManage

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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.StringRedisSerializer;
import java.time.Duration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean(name="redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        StringRedisSerializer serializer = new StringRedisSerializer();
        // value值的序列化采用fastJsonRedisSerializer
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);
        // key的序列化采用StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        // 设置缓存的默认过期时间，也是使用Duration设置
        config = config.entryTtl(Duration.ofMinutes(1))
                .disableCachingNullValues();     // 不缓存空值

        // 设置一个初始化的缓存空间set集合
        Set<String> cacheNames =  new HashSet<>();
        cacheNames.add("my-redis-cache1");
        cacheNames.add("my-redis-cache2");

        // 对每个缓存空间应用不同的配置
        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
        configMap.put("my-redis-cache1", config);
        configMap.put("my-redis-cache2", config.entryTtl(Duration.ofSeconds(120)));

        // 使用自定义的缓存配置初始化一个cacheManager
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .initialCacheNames(cacheNames)  // 注意这两句的调用顺序，一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
                .withInitialCacheConfigurations(configMap)
                .build();
        return cacheManager;
    }
}

定义数据对象类

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {

    private String name;
    private Integer age;
}

通过注解对方法添加缓存操作支持

添加@Cacheable注解后，find方法如果对应 id 的对象在缓存中不存在，则执行方法内过程并返回，同时将返回对象放入缓存中；如果对应 id 的对象在缓存中已存在，则直接返回缓存中的对象。

@Service
public class RedisService {

    @Cacheable(cacheNames = "users",key = "'id_' + #id")
    public User find(Integer id) {
        User u = User.builder()
                .name("名称" + RandomUtils.nextInt(1000, 2000))
                .age(RandomUtils.nextInt(0, 100))
                .build();
        return u;
    }
}

其他注释说明

除了注解@Cacheable还有其他注解，下面简要说明，具体请见【Springboot2.0整合Redis(注解开发)】。

• @CacheEvcit:应用到删除数据的方法上，调用方法时会从缓存中删除对应key的数据；
• @CachePut:应用到写数据的方法上，如新增/修改方法，调用方法时会自动把相应的数据放入缓存。

参考

Springboot2.0整合Redis(注解开发)
GitChat付费课程 : 微服务一站式开发