当前位置: 首页>后端>正文

缓存详解-在java项目中使用缓存

一、概述

在java项目中经常有使用缓存的场景,这时候如何使用缓存就很重要了,本篇文章言简意赅,带你读透缓存

二、java常用的缓存

在java项目中经常使用到的缓存主要分为两个种类
1、内存类
java中的Map、List等容器实现类可以用来作为本地缓存。
一些本地缓存框架,类似ehcache,guava中实现的缓存。
2、中间件类
redis、memcache等等

三、使用缓存将会面临的一些问题

穿透

指的是一种攻击,恶意访问一个不存在的key导致请求到数据库上
防范:对空值也缓存。并对数据库查询加锁,限制同时访问数据库的线程数

雪崩

指的在某一段时间缓存集中失效会造成雪崩,主要的解决方案有:
1.分散缓存的过期时间
2.限流

击穿

和雪崩有些类似,指的是某几个热点key失效的时候瞬间大量并发查询缓存后的存储层,导致存储层堵塞或者宕机。和雪崩的区别在于雪崩是很多key,而击穿集中在几个key

总结

其实知道了这些可能出现的问题,就有很多种办法可以去避免这些可能出现的问题。其实在缓存失效的时候不一定所有的请求都要去查存储层,可以加某些限制,让少部分请求去查询存储层,大部分请求等待缓存。这样可以保证系统的稳定性

三、缓存淘汰策略

如果是使用了缓存,那就涉及到缓存淘汰的策略,最常用的就是ttl过期时间淘汰。同时也有一些其他的的淘汰策略可以适用于各种场景。

缓存淘汰

一般来说使用过期时间设置缓存有很大的限制,一般会有一些缓存淘汰算法来淘汰缓存。

缓存淘汰算法

LRU

简单的来说就是以下三步

  • 新数据插入到链表头部;
  • 每当缓存命中(即缓存数据被访问),则将数据移到链表头部;
  • 当链表满的时候,将链表尾部的数据丢弃。
FIFO

直接用一个队列实现,最早加入的最早淘汰,如果当前数据已经加入过,则不操作队列

LFU

侧重访问频率,实现的重点在于如何写compare函数来比较两个数据的频率高低,从而进行排序,末尾淘汰。

其他的淘汰算法

还有一些其他的淘汰算法:

  • 2Q(Two Queues):同时采用 FIFO 和 LRU 两个队列,首次访问数据时加入到 FIFO 队列中,如果数据在 FIFO 队列移除之前被再次访问,数据会被移动到 LRU 队列中。
  • LRU-K :是一种 LRU 算法的增强版,在 LRU 维护队列的基础上,再添加一个队列维护数据访问的次数,由原来访问 1 次会被添加到缓存中,改为访问 K 次才会被加入到缓存中。
  • ARC:在IBM Almaden研究中心开发,这个缓存算法同时跟踪记录LFU和LRU,以及驱逐缓存条目,来获得可用缓存的最佳使用。

常见缓存的缓存淘汰策略实现

Ehcache 中的缓存淘汰

Ehcache 提供了 3 种淘汰机制(驱逐策略),分别是 LRU(默认),LFU,FIFO。但是 Ehcache 的淘汰却不是给予全局的策略,执行步骤如下:

  • 判断是否超过最大容量限制
  • 在缓存中随机取出不超过 30 个元素作为样本
  • 根据淘汰策略确定需要淘汰的元素
  • 在缓存中移除元素
redis 中的缓存淘汰

在 redis 中可以配置 6 中淘汰机制:

  • noeviction:不删除策略, 达到最大内存限制时, 如果需要更多内存, 直接返回错误信息。
  • allkeys-lru:所有 key 通用,优先删除最近最少使用 (LRU) 的 key。
  • volatile-lru:只限于设置了 expire 的部分; 优先删除最近最少使用 (LRU) 的 key。
  • allkeys-random:所有 key 通用; 随机删除一部分 key。
  • volatile-random:只限于设置了 expire 的部分; 随机删除一部分 key。
  • volatile-ttl:只限于设置了 expire 的部分; 优先删除剩余时间 (time to live,TTL)
Guava 中的缓存淘汰

Guava 在维护缓存数据的同时,还维护了 WirteQueue 和 AccessQueue,分别用来记录写入的记录和访问的记录。总体来说有 4 种淘汰策略:

  • Size-base Eviction:基于使用量的淘汰策略。
  • Timed Eviction:基于时间驱逐,提供了根据访问时间(expireAfterAccess)和根据写入时间(expireAfterWrite)。
  • Reference-based Eviction:基于引用驱逐(通过 java 的软、弱引用实现)。
  • Explicit Removals:显示移除。

在Spring项目中优雅的实现缓存

在以MVC分层的spring项目中经常会有对service层或者是dao层做缓存的需求。比较优雅的实现方式是使用aop切面去解决。而在Spring中,已经对缓存切面有实现。可以通过使用@Cacheable注解修饰需要缓存的方法来实现切面缓存

在Springboot中,可以通过实现cacheManager来实现@Cacheable的底层。这里展示一种使用redis和ehcache的一种实现。(网上有很多种实现,选择喜欢的一种风格即可)
1、在启动类加上@EnableCaching注解开启缓存支持
2、编写config类,代码如下

import com.google.common.collect.ImmutableMap;
import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.Resource;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;

import java.time.Duration;
import java.util.Map;

/**
 * @author QiuPengJun
 * @version 1.0
 * @date 2020/7/29 15:57
 */
@Configuration
@EnableCaching
@EnableConfigurationProperties(CacheProperties.class)
public class CacheManagerConfiguration {
    private final CacheProperties cacheProperties;
    public CacheManagerConfiguration(CacheProperties cacheProperties)    {
        this.cacheProperties = cacheProperties;
    }
    public interface CacheManagerNames {
        String REDIS_CACHE_MANAGER = "redisCacheManager";
        String EHCACHE_CACHE_MANAGER = "ehCacheManager";
    }

    @Bean(name = CacheManagerNames.REDIS_CACHE_MANAGER)
    public RedisCacheManager redisCacheManager(RedisConnectionFactory factory) {
        Map<String, RedisCacheConfiguration> expires = ImmutableMap.<String, RedisCacheConfiguration>builder()
                .put("15sCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(
                        Duration.ofMillis(15000)
                ))
                .put("30sCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(
                        Duration.ofMillis(30000)
                ))
                .put("60sCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(
                        Duration.ofMillis(60000)
                ))
                .put("120sCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(
                        Duration.ofMillis(120000)
                ))
                .build();


        return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(factory)
                .withInitialCacheConfigurations(expires)
                .build();
    }

    @Bean(name = CacheManagerNames.EHCACHE_CACHE_MANAGER)
    @Primary
    public EhCacheCacheManager ehCacheManager() {
        Resource resource = this.cacheProperties.getEhcache().getConfig();
        resource = this.cacheProperties.resolveConfigLocation(resource);
        EhCacheCacheManager ehCacheManager = new EhCacheCacheManager(
                EhCacheManagerUtils.buildCacheManager(resource)
        );
        ehCacheManager.afterPropertiesSet();
        return ehCacheManager;
    }
}

从代码可看到,redis缓存方面,代码配置了15s,30s,60s,120s的过期时间的缓存实现,可以根据需要配置不同的过期时间,然后通过CacheName来区分,也就是代码里的15sCache、30sCache这种。
而ehcache则直接读取了配置文件,这部分下面会讲到
3、编写配置文件

spring:
  application:
    name: authority-management
  redis:
    host: 58.215.52.151
    port: 4041
    lettuce:
      pool:
        max-active: 8
        max-wait: 200
        max-idle: 8
        min-idle: 2
    timeout: 2000
  cache:
    ehcache:
      config: classpath:ehcache.xml
    type: EHCACHE
server:
  port: 8920

我把我demo项目的配置文件直接贴出来了,其中先是配置了redis的ip端口并配置lettuce线程池参数,然后配置ehcache的配置文件路径,ehcache配置文件如下:

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false" monitoring="autodetect"
         dynamicConfig="true">

    <diskStore path="java.io.tmpdir/ehcache"/>

    <defaultCache
            maxElementsInMemory="50000"
            eternal="false"
            timeToIdleSeconds="3600"
            timeToLiveSeconds="3600"
            overflowToDisk="true"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
    />

  <cache name="ehCacheTest"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="3600"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU"
           statistics="true">
    </cache>
</ehcache>

可以看到除了默认配置外,还加了一个名为ehCacheTest的缓存配置,使用了LRU的缓存淘汰算法。其他的参数可以参考官网解释,这里不做多描述。可以配置多个不同名字的缓存来适用各种场景

4、在代码中使用@Cacheable注解来使用缓存

import com.example.ehcache.bootdemo.config.CacheManagerConfiguration;
import com.example.ehcache.bootdemo.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

/**
 * @author QiuPengJun
 * @version 1.0
 * @date 2020/7/29 16:23
 */
@Component
public class TestServiceImpl implements TestService {
    public static final String TEST_TWO ="testTwo";
    @Autowired
    TestService testService;

    /**
     * 用redis做方法級別緩存
     * @param key 入參
     * @return 模拟数据库查询结果
     */
    @Cacheable(key = "#key", cacheNames = "120cache",
            cacheManager = CacheManagerConfiguration.CacheManagerNames.REDIS_CACHE_MANAGER)
    @Override
    public String testRedis(String key) {
        System.out.println("redis没有数据,到数据库查询");
        return "testRedis";
    }

    /**
     * 用ehcache做方法級別緩存,内部调用使用redis做缓存的方法,实现二级缓存
     * @param key 入參
     * @return 模拟数据库查询结果
     */
    @Cacheable(key = "#key", cacheNames = "ehCacheTest",
            cacheManager = CacheManagerConfiguration.CacheManagerNames.EHCACHE_CACHE_MANAGER)
    @Override
    public String testTwo(String key) {
        System.out.println("Ehcache 没有数据,到redis查询");
        return testService.testRedis(key);
    }

    @Cacheable(key = "#key", cacheNames = "ehCacheTest",
            cacheManager = CacheManagerConfiguration.CacheManagerNames.EHCACHE_CACHE_MANAGER)
    @Override
    public String testEhcache(String key) {
        System.out.println("ehcache没有数据,到数据库查询");
        return "testEhcache";
    }

}

以上代码仅用于测试,如果是写业务需要更加严谨
可以看到上面代码使用了 @Cacheable的三个字段,key:表示存储在缓存的key,这里需要谨慎设置,cacheNames:就是上文经常提到的缓存名,用来区分不同配置的缓存,cacheManager :通过config我们配置了两个选择,可以选redis或者ehcache;
代码彩蛋:可以看到这个类使用Autowire注入了自己,然后再testTwo方法中调用了注入类的testRedis方法,实现了一个ehcache+redis的二级缓存。为什么注入自己?这里不多描述,可以百度搜索同一个类里@Cacheable缓存不起作用。当然本人不推荐这种写法,很容易哪天就自己坑自己。

二级缓存推荐的实现

上文已经提到了二级缓存的实现,并且给出了简单的示例(反面示例),笔者推荐一下两种实现方式
1、使用两个类去做二级缓存,比如在service做一层缓存,在dao做一层缓存,或者再service层做两层缓存。用@Cacheable来实现
2、自己定义注解和切面,一键实现二级缓存。这样来说更加灵活。(网上有实现的示例)


https://www.xamrdz.com/backend/3he1925160.html

相关文章: