缓存：

Redis exception; nested exception is io.lettuce.core.RedisException: io.netty.util.internal.OutOfDirectMemoryError: failed to allocate 46137344 byte(s) of direct memory (used: 58720256, max: 100663296)问题：

缓存穿透、缓存雪崩、缓存击穿：

缓存穿透：

缓存雪崩：

缓存击穿：

Redis缓存的应用：

增加缓存的逻辑：

private Map<String, List<Catelog2Vo>> getDataFromDb() {
    String catalogJson = redisTemplate.opsForValue().get("catalogJson");
    if (!StringUtils.isEmpty(catalogJson)) {
        // 如果缓存不为null 直接返回。
        Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catelog2Vo>>>() {
        });
        return result;
    }
    System.out.println("查询了数据库")
		// 这里写业务逻辑
    // 3、查到的数据放入缓存,将对象转为JSON，放入缓存中
    String s = JSON.toJSONString(parent_cid);
    redisTemplate.opsForValue().set("catalogJson", s, 1, TimeUnit.DAYS);
    return parent_cid;
}

锁的使用：

本地锁：

public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithLocalLock() {
synchronized (this) {
        // 得到锁以后 应该再去缓存中确定一次，如果没有才需要继续查询
        String catalogJson = redisTemplate.opsForValue().get("catalogJson");
        if (!StringUtils.isEmpty(catalogJson)) {
            // 如果缓存不为null 直接返回。
            Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catelog2Vo>>>() {
            });
            return result;
        }
        System.out.println("查询了数据库");
					/**
					        这里写业务代码
					* */
					
        // 3、查到的数据放入缓存,将对象转为JSON，放入缓存中
        String s = JSON.toJSONString(parent_cid);
        redisTemplate.opsForValue().set("catalogJson", s, 1, TimeUnit.DAYS);
        return parent_cid;
    }
}

分布式锁：

分布式下如何实现加锁：

public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbRedisLock() {
        String uuid = UUID.randomUUID().toString();
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);

        if (lock) {
            System.out.println("获取分布式锁成功");
            Map<String, List<Catelog2Vo>> dataFromDb;
            try {
                dataFromDb = getDataFromDb();
            } finally {
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                Long lock1 = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);
            }
            return dataFromDb;
        } else {
            System.out.println("获取分布式锁失败，等待重试");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {

            }
            return getCatalogJsonFromDbRedisLock(); //自璇的方式
        }
    }

通过Redisson实现分布式锁：

RLock lock = redisson.getLock("anyLock");// 最常见的使用方法
lock.lock();
// 加锁以后 10 秒钟自动解锁// 无需调用 unlock 方法手动解锁
lock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待 100 秒，上锁以后 10 秒自动解锁 boolean res = lock.tryLock(100,
10, TimeUnit.SECONDS);
if (res) {
		try {
		...	
   } finally {
      lock.unlock();
	}
}

public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbRedissonLock() {
    // 锁的名字，名字一样 锁就一样，锁的粒度越细，锁的速度越快。
    // 锁的粒度： 具体缓存的是某个数据， 11-号商品； product-11-lock  product-12-lock
    RLock lock = redisson.getLock("catalogJson-lock");
    lock.lock();
    Map<String, List<Catelog2Vo>> dataFromDb;
    try {
        dataFromDb = getDataFromDb();
    } finally {
        lock.unlock();
    }
    return dataFromDb;

}

缓存一致性问题：

读模式：

写模式：

双写模式：

失效模式：

解决方案：

总结：

SpringCache的引入和使用：

整合SpringCache 简化缓存开发：

引入依赖：

<!--引入SpringCache简化开发-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<!--引入redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

写配置：

• @Cacheable: Triggers cache population. ：触发将数据保存到缓存的操作

• @CacheEvict: Triggers cache eviction. 触发将数据从缓存删除的操作

• @CachePut: Updates the cache without interfering with the method execution.
不影响方法执行更新缓存

• @Caching: Regroups multiple cache operations to be applied on a method.
组合以上多个操作

• @CacheConfig: Shares some common cache-related settings at class-level.
在类级别共享缓存的相同配置

开始使用缓存功能：

将数据保存为JSON格式：

原理：

配置：

@Configuration
@EnableCaching
@EnableConfigurationProperties({CacheProperties.class})
public class MyCacheConfig {

@Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties){
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        //config = config.entryTtl();
        config =config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        config =config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        // 将配置文件中的所有东西都生效
        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        if(redisProperties.getTimeToLive()!=null){
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if(redisProperties.getKeyPrefix()!=null){
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if(redisProperties.isCacheNullValues()){
            config = config.disableCachingNullValues();
        }
        if(redisProperties.isUseKeyPrefix()){
            config = config.disableKeyPrefix();
        }
        return config;
    }

}

写模式使用SpringCache：

@Caching(evict = {
        @CacheEvict(value = "category",key = "'getLevel1Categorys'"),
        @CacheEvict(value = "category",key = "'getCatalogJson'")
})

@CachePut注解：

SpringCache的不足：

读模式：

写模式（缓存与数据库一直）：

总结