大厂都在用EhCache,它到底比Redis强在哪里?

梦叶草789
发布于 2022-9-9 15:00
浏览
0收藏

故事背景
随着硬件价格的走低,大家对硬件的依赖越来越高。甚至听说,代码不重要,不行就加机器呗。比如缓存的使用,通常有基于虚拟机内存、基于磁盘存储、基于中间件(Redis内存)等方式,我们都知道,最适合的才是最好的,但实践中,往往是动不动就直接上Redis。

那么,Redis一定是最好的选择吗?单不说对内存的要求,从效率和性能上来说,也未必是最优的。所以,不同的场景使用不同的缓存策略才是高手应该追求的。

这篇文章就带大家认识除Redis之外的另一种缓存框架:EhCache。之所以要写写,也是因为项目中运用了此框架,同时又遇到点问题,于是决定深入研究一下。研究之后,发现还真有点意思~

 

EhCache简介
EhCache是一个纯Java的进程内缓存框架,具有快速、精干的特点。注意的这里的关键字进程,基于进程的缓存直觉告诉我们效率肯定要高一些,因为它直接在进程之内进行操作,但不同应用之间缓存的共享可能就会有问题。

EhCache是Hibernate中默认的CacheProvider,Spring Boot也对其进行了支持,Spring中提供的缓存抽象也支持对EhCache缓存框架的绑定,而且支持基于注解的方式来使用。因此,EhCache是一款被广泛使用的基于Java的高速缓存框架,使用起来也非常方便。

EhCache提供了多种缓存策略,主要分为内存和磁盘两级,是一款面向通用缓存、Java EE和轻量级容器的缓存框架。

 

EhCache的特点
简单说一下该框架的特点:

 ● 简单、快速,拥有多种缓存策略;
 ● 缓存数据有两级:内存和磁盘,无需担心容量问题;
 ● 缓存数据会在虚拟机重启的过程中写入磁盘;
 ● 可以通过RMI、可插入API等方式进行分布式缓存;
 ● 具有缓存和缓存管理器的侦听接口;
 ● 支持多缓存管理器实例,以及一个实例的多个缓存区域,并提供Hibernate的缓存实现;
EhCache可以单独使用,但通常会与Mybatis、Shiro等三方类库结合使用。本人项目中使用EhCache就是结合Shiro来使用的。

除了优点,EhCache也还有一些缺点。比如,非常占用磁盘空间,这是因为DiskCache的算法简单,只是对元素直接追加存储。这样虽然可以提高效率,但在使用频繁的系统中,磁盘很快会满。

另外就是不能保证数据安全,当然突然kill掉Java进程时,可能会产生冲突。EhCache解决冲突的方法是重建Cache,这对Cache数据需要保持时可能会产生影响。Cache只是简单的加速,不能保证数据的安全。

 

EhCache与Redis
EhCache直接在JVM中进行缓存,速度快,效率高。与Redis相比,操作简单、易用、高效,虽然EhCache也提供有缓存共享的方案,但对分布式集群的支持不太好,缓存共享实现麻烦。

Redis是通过Socket访问到缓存服务,效率比EhCache低,比数据库要快很多,处理集群和分布式缓存方便,有成熟的方案。

所以,如果是单体应用,或对缓存访问要求很高,可考虑采用EhCache;如果是大型系统,存在缓存共享、分布式部署、缓存内容很大时,则建议采用Redis。

 

EhCache架构图
看一下EhCache的架构图,大概了解一下它由几部分组成。

大厂都在用EhCache,它到底比Redis强在哪里?-鸿蒙开发者社区

Ehcache-architecture

Cache Replication部分提供了缓存复制的机制,用于分布式环境。EhCache最初是独立的本地缓存框架组件,在后期的发展中,结合Terracotta服务阵列模型,可以支持分布式缓存集群,主要有RMI、JGroups、JMS和Cache Server等传播方式进行节点间通信。

In-process APIs则提供了基于JSR、JMX等标准的支持,能够较好的兼容和移植,同时对各类对象有较完善的监控管理机制。

Network APIs则对外提供了基于RESTful API、JMS API、Cache Server等方式的支持。

在使用过程中,需要关注的核心部分便是中间的Core部分了。它包含了核心的API和概念:

 ● CacheManager:缓存管理器,可以通过单例或者多例的方式创建,也是Ehcache的入口类。
 ● Cache:每个CacheManager可以管理多个Cache,每个Cache可以采用hash的方式管理多个Element。所有cache都实现了Ehcache接口;
 ● Element:单条缓存数据的组成单位,用于存放真正缓存内容的。
三者的管理可以用下图表示:

大厂都在用EhCache,它到底比Redis强在哪里?-鸿蒙开发者社区

CacheManager

缓存过期策略
在架构图中还可以看到Memory Store LRU、Memory Store LFU、Memory Store FIFO等内存存储算法。也就是当缓存占用空间接近临界值时,会采用上面的淘汰策略来清理掉一部分数据。

EhCache提供了三种淘汰算法:

 ● FIFO:First In First Out,先进先出。判断被存储的时间,离目前最远的数据优先被淘汰。
 ● LRU:Least Recently Used,最近最少使用。判断最近被使用的时间,目前最远的数据优先被淘汰。
 ● LFU:Least Frequently Used,最不经常使用。在一段时间内,数据被使用次数最少的,优先被淘汰。
Ehcache采用的是懒淘汰机制,每次往缓存放入数据时,都会存一个时间,在读取时要和设置的时间做TTL比较来判断是否过期。

 

EhCache实战解析
了解了上面的基础知识之后,来实验一下EhCache如何使用。其中EhCache2.x和EhCache3.x的使用差距较大。

这里采用比较新的3.9.6版本,不同的版本在API的使用上会有所差异。

 

基于API使用EhCache
EhCache提供了基于API和xml两种形式创建CacheManger和Cache。先来看基于API的形式:

在pom文件中引入EhCache依赖:

<dependency>
      <groupId>org.ehcache</groupId>
      <artifactId>ehcache</artifactId>
      <version>3.9.6</version>
</dependency> 

创建并使用的代码如下:

public class EhCacheTest {

 @Test
 public void test() {
  // 1、先创建一个CacheManagerBuilder;
  // 2、使用CacheManagerBuilder创建一个预配置(pre-configured)缓存:第一个参数为别名,第二个参数用来配置Cache;
  // 3、build方法构建并初始化;build中true参数表示进行初始化。
  CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
    .withCache("preConfigured",
      CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
        ResourcePoolsBuilder.heap(100)).build())
    .build(true);

  // 取回在设定的pre-configured,对于key和value值类型,要求是类型安全的,否则将抛出ClassCastException异常。
  Cache<Long, String> preConfigured = cacheManager.getCache("preConfigured", Long.class, String.class);

  System.out.println("从缓存中获取key为preConfigured:" + preConfigured);

  // 根据需求,通过CacheManager创建出新的Cache。实例化和完整实例化的Cache将通过CacheManager.getCache API返回。
  Cache<Long, String> myCache = cacheManager.createCache("myCache",
    CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
      ResourcePoolsBuilder.heap(100)).build());
  // 使用put方法存储数据
  myCache.put(1L, "da one!");
  // 使用get方法获取数据
  String value = myCache.get(1L);
  System.out.println("从缓存中获取key为1L:" + value);
  // close方法将释放CacheManager所管理的缓存资源
  cacheManager.close();
 }
}

上述代码基于API的形式演示了如何创建CacheManager及Cache,并对Cache进行设置和获取。

 

基于XML使用EhCache
依赖Jar包不变,在src/main/resources/目录下创建配置文件 ehcache.xml。

<config
        xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
        xmlns='http://www.ehcache.org/v3'
        xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core.xsd">

    <cache alias="foo">
        <key-type>java.lang.String</key-type>
        <value-type>java.lang.String</value-type>
        <resources>
            <heap unit="entries">20</heap>
            <offheap unit="MB">10</offheap>
        </resources>
    </cache>

    <cache-template name="myDefaults">
        <key-type>java.lang.Long</key-type>
        <value-type>java.lang.String</value-type>
        <heap unit="entries">200</heap>
    </cache-template>

    <cache alias="bar" uses-template="myDefaults">
        <key-type>java.lang.Number</key-type>
    </cache>

    <cache alias="simpleCache" uses-template="myDefaults" />

</config>

3.x版本与2.x版本有所区别,在xml配置文件上非常明显。2.x中以ehcache元素为根节点,而3.x则以config为根节点。

在上述xml中包含三部分:

 ● 普通缓存cache-foo:别名为foo的缓存,缓存的Key-Value值类型均为String。如果没有指定,默认就是Object类型。
 ● 缓存模板cache-template:实现一个配置抽象,以便在未来可以进行扩展;
 ● 基于缓存模板的cache-bar:使用了cache-template模板myDefaults,并且覆盖了key-type类型,myDefaults的key-type是Long类型,覆盖后成了Number类型;
cache中其他属性及元素:

 ● name为名称;
 ● alias为别名;
 ● key-type为key的类型;
 ● value-type为value的类型;
 ● heap指定堆中可创建的实体格式,其中unit="entries",表示后面的20是实体;
 ● offheap表示在开始淘汰过期缓存项之前,可以分配多达10M的堆内存;
 ● uses-template表示使用模板的名称;
当然,也可以通过persistence元素来配置缓存的目录等。其他属性的使用,大家可以慢慢探索。

 

基于Spring Boot使用EhCache
前面已经提到,Spring对缓存进行了支持,Spring Boot也对缓存进行了自动配置的支持。下面就基于Spring Boot来完成EhCache的集成以及使用案例演示。

在Spring Boot中引入对应的starter:

<!-- ehcache依赖-->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
 <groupId>org.ehcache</groupId>
 <artifactId>ehcache</artifactId>
 <version>3.9.6</version>
</dependency>

在application.properties中配置添加如下配置:

spring.cache.ehcache.config=ehcache.xml

在Spring Boot启动类上添加@EnableCaching注解:

@EnableCaching
@SpringBootApplication
@MapperScan("com.secbro.mapper")
public class SpringBootMainApplication {
 public static void main(String[] args) {
  SpringApplication.run(SpringBootMainApplication.class, args);
 }
}

创建一个用户缓存的实体类Person:

@Data
public class Person {

 public Person(int id,String name){
  this.id = id;
  this.name = name;
 }

 private int id;

 private String name;
}

对应的Service方法实现:

public interface PersonService {
 Person getById(int id);
}

@Slf4j
@Service("personService")
public class PersonServiceImpl implements PersonService {

 @Cacheable(value = "personCache", key = "#id")
 @Override
 public Person getById(int id) {
  log.info("查询id={}的用户", id);
  if (id == 1) {
   return new Person(1, "Tom");
  } else if (id == 2) {
   return new Person(2, "Jim");
  }
  return new Person(3, "Other");
 }
}

通过Spring提供@Cacheable注解指定了缓存的名称为personCache,key为id。在方法内打印日志,如果调用到方法内,则会打印。

编写单元测试类:

@Slf4j
@SpringBootTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class PersonServiceTest {

 @Resource
 private PersonService personService;

 @org.junit.jupiter.api.Order(1)
 @Test
 void testCache() throws InterruptedException {
  log.info("第1次查询id=1的数据");
  personService.getById(1);
  log.info("第2次查询id=1的数据");
  personService.getById(1);
  Thread.sleep(3000);
 }
}

两次调用对应的方法,打印日志如下:

c.s.s.PersonServiceTest                  : 第1次查询id=1的数据
c.s.s.i.PersonServiceImpl                : 查询id=1的用户
c.s.s.PersonServiceTest                  : 第2次查询id=1的数据

可以看到,第一进入方法内进行查询,第二次便走了缓存。

关于Spring提供的cache注解的使用还有很多使用方法和场景,这里就不再展开了。

 

小结
因为工作恰好用到该技术,就钻研并写成文章带大家领略了EhCache的基本知识、技术架构、使用场景、API使用以及基于Spring Boot的集成。整体而言,算是入门级别的,大家可以在此基础上进一步学习扩展。至于EhCache对分布式的支持部分,本文并未涉及,主要原因是使用起来并没那么好用,如果感兴趣的话可自行研究。

 

 

 

 

文章转载自公众号:程序员新视界

已于2022-9-9 15:00:53修改
收藏
回复
举报
回复
    相关推荐