SpringCloud——Redis的使用

使用微服务的时候将一些经常使用的数据存放在Redis中来减少对数据库的访问并提高性能

1.在pom文件中导入Redis依赖包

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <exclusions>
            <exclusion>
                <groupId>io.lettuce</groupId>
                <artifactId>lettuce-core</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!--导入jedis包，Springboot2.0以后data-redis的底层使用的是lettuce,可以跟换为jedis-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>

2.在微服务的yml中配置Redis的一些基本配置信息

spring:
 redis:
       database: 1  #redis数据库索引  默认为0
       host: 127.0.0.1  #redis服务器地址
       port: 6379  #redis的端口
       password: 123456  #redis的密码
       jedis:  #redis的连接池
         pool:
           max-wait: 2000ms  #连接池的最大阻塞时间
           min-idle: 2  #连接池最小的空闲连接
           max-idle: 8  #连接池的最大空闲连接

3.对Redis配置一个配置类，将Redis中的数据进行序列化，这样返回到前端的数据是以json的格式

@Configuration
public class CacheConfig extends CachingConfigurerSupport {

    @Resource
    private RedisConnectionFactory factory;

    /**
     * 自定义生成redis-key ， 类名.方法名
     * @return
     */
    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return (o, method, objects) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(o.getClass().getName()).append(".");
            sb.append(method.getName()).append(".");
            for (Object obj : objects) {
                sb.append(obj.toString());
            }
            return sb.toString();
        };
    }

    //使用JSON进行序列化
    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        //JSON格式序列化
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
         //key的序列化
        redisTemplate.setKeySerializer(genericJackson2JsonRedisSerializer);
        //value的序列化
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        //hash结构key的虚拟化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //hash结构value的虚拟化
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        return redisTemplate;
    }

    @Bean
    @Override
    public CacheResolver cacheResolver() {
        return new SimpleCacheResolver(cacheManager());
    }

    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        // 用于捕获从Cache中进行CRUD时的异常的回调处理器。
        return new SimpleCacheErrorHandler();
    }
    //缓存管理器
    @Bean
    @Override
    public CacheManager cacheManager() {
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                        .disableCachingNullValues() //不允许空值
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));//值使用JSON虚拟化
        return RedisCacheManager.builder(factory).cacheDefaults(cacheConfiguration).build();
    }
} 

4.测试——使用RedisTemlate写入缓存

@RunWith(SpringRunner.class)
@SpringBootTest(classes = TestApp.class)
public class RedisTemplateTest {

   @Autowired
   private RedisTemplate<String,String> redisTemplate;

   @Test
   public void test(){
      redisTemplate.opsForValue().set("张飞","吃秤砣" );
   }
}

推荐使用RedisDesktopManager软件，更加清晰的展示数据

5.使用SpringCache+Redis进行缓存，这样做的优点在于使用注解进行缓存的写入、删除等操作

5.1在启动类上打上注解

@SpringBootApplication //启动类
@EnableEurekaClient  //eureka的客户端
@EnableCaching  //导入这个注解使用打注解的方式进行缓存
public class CourseApp {

    public static void main(String[] args) {
        SpringApplication.run(CourseApp.class, args);
    }
}

5.2在方法上打上注解 该方法的返回值会自动将数据放入到缓存中并且是json的格式（在上面第三 步已经配置过来）

 /**
     *查询课程分类树  使用循环的方式去查询到所有的数据
     */
    @Override
    //打上这个注解  优先当使用查询的时候优先使用缓存中的数据  如果缓存中没有再去查询数据库中数据  再放入到缓存中
    //RedisConstants.KEY_COURSE_TYPE_TREE 指定一个Redis的表（可以为多张表）  key为库的后缀（不重要）
    @Cacheable(cacheNames = RedisConstants.KEY_COURSE_TYPE_TREE,key = "'ALL'")
    public List<CourseType> treeData() {
        //使用方法获取到分类树
        List<CourseType> firstCourseType = getCourseTypes();
        //返回新数据
        return firstCourseType;
    }

5.2在方法上打上注解 执行该方法会将Redis中指定的表中的数据删除

//如果为新增需要删除缓存中的所有数据
    @Override
    //CacheEvict注解  执行这个方法会将Redis中指定的表中的数据删除
    @CacheEvict(cacheNames = RedisConstants.KEY_COURSE_TYPE_TREE,key = "'ALL'")
    public boolean insert(CourseType entity) {
        return super.insert(entity);
    }

5.2其他的一些注解
@CachePut 当需要更新而不干扰方法的运行的时候，可以使用该注解也就是说，始终执行该方法，并将结果放入缓存(已经有缓存就更新缓存)，注解参数与@Cacheable相同

@Caching 在使用缓存的时候，有可能会同时进行更新和删除，会出现同时使用多个注解的情况.而@Caching可以实现

@CacheConfig:缓存提供了许多的注解选项，但是有一些公用的操作，我们可以使用

@CacheConfig在类上进行全局设置

6.Redis的缓存穿透
当一个请求先去缓存中查询数据时没有找到数据，然后再去数据库中查找数据，但是这条数据是条假数据（缓存和数据库中都不存在的数据），如果这个请求并发量非常高那么它就可以击穿Redis的缓存机制，这样数据库的压力就非常大。

解决方式 在数据库中查询为空的情况仍然将它缓存在Redis中，这样下次再方法就会在Redis中查询到一个空数据，减少对数据库的访问。

7.Redis的缓存雪崩
在短时间内大量的缓存失效，对数据库的访问量增大

解决方式 使用加锁的方式，只允许一个线程去查询和写缓存来减少对数据库的访问量