效果实现

1.添加依赖

 <!--        Spring data redis 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--        commons-pool2 对象池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2.编写yml文件

 spring:
 	Redis:
      # 超时时间
      timeout: 10000ms
    # 服务器地址
      host: 127.0.0.1
    # 服务器端口
      port: 6379
    # 数据库
      database: 0
      #密码默认为空
      password:
      lettuce:
        pool:
          # 最大连接数，默认8
          max-active: 1024
          # 最大连接阻塞等待时间 ，默认-1
          max-wait: 10000ms
          #最大空闲连接
          max-idle: 200
          #最小空闲连接
          min-idle: 5

3.编写配置文件（更新了一个对缓存的管理）

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.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.*;

import java.time.Duration;

@EnableCaching//开启缓存
@Configuration//配置类
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        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);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    //针对缓存的管理
    @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);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

4.将商品添加值Redis缓存中

其实就只要加注释： @Cacheable(value = “AllGoods”)即可，然后根据value值就可以查询出来
如果不懂注释的逻辑，可以去看看我的下面这篇文章，不用注释写的。

Redis集成搜索功能(简单例子)

 	//@Cacheable(key = "'所有药品'",value = "AllGoods")
    @Cacheable(value = "AllGoods")
    @Override
    public List<MedicineVo> findAllMedicine() {
    //查询所有商品
        return medicineMapper.findAllMedicine();
    }

我代码里面第一个注释就是自己手写了key值。

5.清空Redis的缓存

 /**
     * 修改medicine表中的所有数据
     * @return 查询的数据
     */
    //清空Redis的缓存，一般用户更新和删除方法上面
    @CacheEvict(value = "AllGoods",allEntries = true)
    @Override
    public int updateMedicine(MedicineVo medicineVo) {
        return medicineMapper.updateMedicine(medicineVo);
    }

6.更新Redis缓存

 /**
     * 增加了medicien所以数据
     * @param medicineVo
     * @return
     */
    //更新redis的缓存 一般用于新增
    @CachePut(value = "AllGoods",key = "#medicineVo.medicineId")
    @Override
    public List<MedicineVo> addMedecine(MedicineVo medicineVo) {
        //这里我是先先增加，再去数据库里面查询数据，返回List数据，如果你上面返回的是int型的数据，那么就会缓存里面就只会存一个1，这是因为：CachePut是根据返回值存的数据。
        //其实还应该有逻辑判断，毕竟不管result怎么样，都会输出数据，逻辑不符，我偷懒就没写了。。。。
        int result = medicineMapper.addMedecine(medicineVo);
        return medicineMapper.findAllMedicine();
    }

其实在这里，我很迷茫。因为你用CachePut会在Redis中重新开辟一个缓存

别说什么，key值没对应上啥的，对应上也会新开辟出来一个新的缓存，好像并没有在原有的缓存中，进行更新操作。既然这样，我为什么不直接删除缓存呢？再从数据库将缓存中的数据重新填充，毕竟我写增加的时候，也进数据库进行更新了，只不过一个是用户去操作，一个早已经在逻辑上写好了。感觉并没有啥区别一样。。。。。

对三个注解的解释

@Cacheable 缓存 @CachePut：缓存更新 @CacheEvict：缓存删除

Redis查看工具：RedisDesktopManager

我是网上找的，你们搜一下吧。应该有的。

结语

如果对你有帮助，请支持一下，点赞评论+关注。