springboot结合redis做缓存

1.引入依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.6.2</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.1.3.RELEASE</version>
</dependency>

2.业务层添加注解

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    public void setUserMapper(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
//    @BaiZhiCacheable("users")
    //缓存名：users 数据的key=方法名
    @Cacheable(value="users",key="#root.methodName")
    public List<User> showAllUsers() {
        System.out.println("查询数据库");
        return userMapper.selectAllUsers();
    }

    @Override
//    @BaiZhiCacheable("users")
    //缓存名：users 数据的key=方法名+id参数值
    @Cacheable(value="users",key="#root.methodName+#id")
    public User showUser(Integer id) {
        System.out.println("查询数据库");
        return userMapper.selectUserById(id);
    }

    @Override
//    @BaiZhiCacheEvict("users")
    //缓存名：users 删除全部数据，在方法执行后执行缓存删除
    @CacheEvict(value="users",allEntries = true,beforeInvocation = false)
    public void removeUser(Integer id) {
        System.out.println("删除数据库");
        userMapper.deleteUserById(id);
    }
}

3.application.yml

spring:
  redis:
    lettuce:
      pool:
        max-active: 500
        max-idle: 50
        min-idle: 10
        max-wait: 30000
    host: 192.168.146.20
    port: 6379

4.入口类（注意注解不要少）

@SpringBootApplication
@MapperScan("com.baizhi.mapper")
@EnableCaching
//@EnableCaching注解是spring framework中的注解驱动的缓存管理功能。自spring版本3.1起加入了该注解。如果你使用了这个注解，那么你就不需要在XML文件中配置cache manager了
public class SpringBootRedisApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootRedisApplication.class,args);
    }

    //配置缓存管理器
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory){

        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);

        return new RedisCacheManager(redisCacheWriter,getRedisCacheConfiguration(20),
                getRedisCacheConfigurationMap());
    }

    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap(){
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        redisCacheConfigurationMap.put("users", getRedisCacheConfiguration(100));
        redisCacheConfigurationMap.put("books", getRedisCacheConfiguration(60));
        return redisCacheConfigurationMap;
    }
    //RedisCacheConfiguration 用于负责Redis的缓存配置
    private RedisCacheConfiguration getRedisCacheConfiguration(int seconds){
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        return redisCacheConfiguration
                .serializeValuesWith(
                        RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)
                )
                .entryTtl(Duration.ofSeconds(seconds));
    }
}