高并发数据缓存池（基于EHcache）

最新推荐文章于 2023-06-30 10:05:11 发布
最新推荐文章于 2023-06-30 10:05:11 发布
阅读量642 收藏 1
点赞数
分类专栏： java 文章标签： java cache 缓存 ehcache

在高并发的场景里面经常会使用到localcache内容，但是一直没有一个很好的内存管理工具。在开发的时候发现了ehcache，这么一个开源的工具。唯一的缺点就是无法对于多块数据单元进行一个有效的管理，并且在数据过期的时候无法提供有效的更新机制，所以这里写了一个数据缓存池来满足这个需求。

下面是设计组织结构：

这里主要是在数据实体内部封装了数据更新器，这样在数据过期的时候可以调用更新器的方法。

1. Ehcache数据缓冲的具体代码：（主要是get方法内部进行数据更新，使用对象锁的方式来进行数据过期的并发控制，缺点是可能在非常高的并发里面会出现数据阻塞的现象，但是因为这里大部分都是内存的运算操作，所以相对来说阻塞的效果还好）

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package com.tmall.lafite.core.manager.localcache;
 
import java.util.List;
 
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.concurrent.LockType;
import net.sf.ehcache.concurrent.ReadWriteLockSync;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.store.MemoryStoreEvictionPolicy;
 
import com.tmall.lafite.core.LafiteResult;
import com.tmall.lafite.core.ResultCode;
 
/**
  * cache数据实体
  * @author wangxiao
  *
  */
public class LafiteCache {
     
     private CacheManager cacheManager = null ;
     private Cache cacheImpl = null ;
     
     ReadWriteLockSync rwLock = new ReadWriteLockSync();
     
     private int capability = 30 ;
     private long expireTime = 30 ;
     
     public static final int DEFAULT_CAPABILITY = 30 ;
     public static final int DEFAULT_EXPIRETIME = 30 ;
     
     private String cacheName = "Tair Local Cache" ;
     
     public LafiteCache(String id, int capability, long expireTimeMS) {
         this .cacheName = id;
         this .capability = capability;
         this .expireTime = expireTimeMS;
     }
     
     public void setExpireTime( long expireTimeMS) {
         this .expireTime = expireTimeMS;
     }
     
     public void setCapacity( int cap) {
         cacheImpl.getCacheConfiguration().setMaxEntriesLocalHeap(cap);
     }
     
     public long getExpireTime() {
         return expireTime;
     }
 
     @SuppressWarnings ( "deprecation" )
     public void initialize() {
         CacheConfiguration cacheConfiguration = new CacheConfiguration();
         cacheConfiguration.setDiskPersistent( false );
         
         cacheConfiguration.name(cacheName)
                           .maxEntriesLocalHeap(capability)
                           .diskPersistent( false )
                           .memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LRU);
                          // .timeToLiveSeconds(expireTime);
         //cacheConfiguration.transactionalMode("LOCAL");
         //Configuration config = new Configuration().name(cacheName).cache(cacheConfiguration);
         
         cacheManager = CacheManager.create();
         
         cacheImpl =  new Cache(cacheConfiguration);
         cacheManager.addCache(cacheImpl);
         //cache = MemoryStore.create(cacheImpl, new UnboundedPool());
         
     }
     
     public int size() {
         return ( int ) cacheImpl.getSize();
     }
     
     public void destroy() {
         cacheImpl.dispose();
         //cacheManager.removeCache(cacheName);
         cacheManager.shutdown();
     }
     
     public void clear() {
         rwLock.lock(LockType.WRITE);
         try {
             cacheImpl.removeAll();
         } finally {
             rwLock.unlock(LockType.WRITE);
         }
     }
     
     public void del(Object key) {
         cacheImpl.remove(key);
         return ;
     }
     
     public void put(Object key, Object value) {
         cacheImpl.put( new Element(key, value));
         return ;
     }
     
     public LafiteResult get(Object key) {
         LafiteResult lafiteResult = new LafiteResult();
         
         Element element = cacheImpl.get(key);
         if (element == null ) {
             lafiteResult.setError(ResultCode.Error.Cache.NO_DATA);
             return lafiteResult;
         }
         long now = System.currentTimeMillis();
         
         long pastTime = now - element.getLastUpdateTime();
         if (pastTime >= expireTime) {
             // double check
             synchronized (element) {
                 pastTime = now - element.getLastUpdateTime();
                 if (pastTime >= expireTime) {
                     // expired, update entry
                     element.updateUpdateStatistics();
                     lafiteResult.setError(ResultCode.Error.Cache.DATA_OVERDUE);
                 }
             }
         }
         // element object value never null;
         lafiteResult.setDefaultModel(element.getObjectValue());
         return lafiteResult;
     }
     
     @SuppressWarnings ( "unchecked" )
     public List<Object> getKeys() {
         List<Object> keys = cacheImpl.getKeys();
         return keys;
     }
}

2. 数据逻辑单元定义（这里封装了数据容器单元，把原来的数据池方法传入，在数据更新的时候使用namespace来获取内存实体，进而来获取数据。）

（注：这里目前还没有想好是否把数据的初始化放在容器当中，这里暂时不放入。只是在容器里面进行初始化方法的调用，真正的数据设置方式由逻辑单元获取数据池进行自身的put）

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.tmall.lafite.core.manager.localcache.util;
 
import org.springframework.beans.factory.annotation.Autowired;
 
import com.tmall.lafite.core.LafiteResult;
import com.tmall.lafite.core.manager.localcache.LafiteContainer;
 
/**
  * 缓存逻辑单元
  * @author wangxiao
  *
  */
public abstract class LogicCenter {
     @Autowired
     private LafiteContainer lafiteContainer;
     
     /**
      * 初始化方法
      * @return
      */
     public abstract Object initialize();
     
     /**
      * 回调函数
      * @param lafiteCache
      * @param key
      * @return
      */
     public abstract Object callBack(String namespace, Object key, LafiteResult lafiteResult);
 
     public LafiteContainer getLafiteContainer() {
         return lafiteContainer;
     }
}
3. 数据池（数据池，使用init来循环调用内存实体里的逻辑单元进行数据的初始化）
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
package com.tmall.lafite.core.manager.localcache;
 
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.tmall.lafite.core.LafiteResult;
import com.tmall.lafite.core.ResultCode;
import com.tmall.lafite.core.manager.localcache.entity.CacheEntity;
import com.tmall.lafite.core.manager.localcache.util.LogicCenter;
 
/**
  * cache容器
  * @author wangxiao
  *
  */
public class LafiteContainer {
     
     protected final Logger logger = LoggerFactory.getLogger(LafiteContainer. class );
 
     private Map<String, CacheEntity> cacheMap = new ConcurrentHashMap<String, CacheEntity>();
     
     /**
      * 注册缓存对象
      * @param namespace
      * @param key
      * @param lafiteCache 缓存对象
      * @param logicCenter 逻辑对象 （包含：初始化方法和callback方法）
      * @return
      */
//  public String register(String namespace, String key, LafiteCache lafiteCache, LogicCenter logicCenter) {
//      if(namespace != null && StringUtils.isEmpty(key) && lafiteCache != null) {
//          if(cacheMap.containsKey(namespace)) {
//              return ResultCode.Error.Cache.NAMESPACE_REPETITION;
//          }
//         
//          CacheEntity cacheEntity = new CacheEntity(lafiteCache, logicCenter);
//          try {
//              cacheEntity.initialize();
//          } catch (Exception e) {
//              logger.error("LafiteContainer.register ", e);
//          }
//          cacheMap.put(namespace, cacheEntity);
//          return null;
//      }
//      return ResultCode.Error.Cache.COMMON_PARAM_LOST;
//  }
     
     /**
      * 获取cache内的数据
      * @param namespace
      * @param key
      * @return
      */
     public LafiteResult get(String namespace, Object key) {
         LafiteResult lafiteResult = new LafiteResult();
         CacheEntity cacheEntity = cacheMap.get(namespace); //获取缓存实体
         if (cacheEntity == null ) {
             lafiteResult.setError(ResultCode.Error.Cache.NO_CACHEENTITY);
         } else {
             LafiteCache lafiteCache = cacheEntity.getLafiteCache();
             LafiteResult result = lafiteCache.get(key);
             if (ResultCode.Error.Cache.NO_DATA.equals(result.getError())
                     || ResultCode.Error.Cache.DATA_OVERDUE.equals(result.getError())) {
                 cacheEntity.getLogicCenter().callBack(namespace, key, result); //数据过期触发callback事件
             }
             lafiteResult = result;
         }
         
         return lafiteResult;
     }
     
     /**
      * 获取指定命名空间的全部数据
      *  这里采用的是逐条遍历的方式
      * @param namespace
      * @return
      */
     public LafiteResult getAll(String namespace) {
         LafiteResult lafiteResult = new LafiteResult();
         List<Object> objects = new ArrayList<Object>();
         
         CacheEntity cacheEntity = cacheMap.get(namespace);
         if (cacheEntity == null ) {
             lafiteResult.setError(ResultCode.Error.Cache.NO_CACHEENTITY);
         } else {
             LafiteCache lafiteCache = cacheEntity.getLafiteCache();
             List<Object> keys = lafiteCache.getKeys();
             if (keys.isEmpty()) {
                 lafiteResult.setError(ResultCode.Error.Cache.NO_DATA);
             } else {
                 for (Object key : keys) {
                     LafiteResult lr = get(namespace, key);
                     objects.add(lr.getDefaultModel());
                 }
             }
         }
         lafiteResult.setDefaultModel(objects);
         return lafiteResult;
     }
     
     /**
      * 设置数据对象内容
      * @param namespace
      * @param key
      * @param value
      * @return
      */
     public LafiteResult put(String namespace, Object key, Object value) {
         LafiteResult lafiteResult = new LafiteResult();
         CacheEntity cacheEntity = cacheMap.get(namespace);
         if (cacheEntity == null ) {
             lafiteResult.setError(ResultCode.Error.Cache.NO_CACHEENTITY);
         } else {
             LafiteCache lafiteCache = cacheEntity.getLafiteCache();
             lafiteCache.put(key, value);
         }
         return lafiteResult;
     }
 
     public void setCacheMap(Map<String, CacheEntity> cacheMap) {
         this .cacheMap = cacheMap;
     }
 
     public Map<String, CacheEntity> getCacheMap() {
         return cacheMap;
     }
     
     public void initialize() {
         
         new Thread( new Runnable() {
             @Override
             public void run() {
                 for (String key : cacheMap.keySet()) {
                     try {
                         CacheEntity cacheEntity = cacheMap.get(key);
                         if (cacheEntity != null ) {
                             LogicCenter logicCenter = cacheEntity.getLogicCenter();
                             if (logicCenter != null ) {
                                 logicCenter.initialize();
                             }
                         }
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
                 
             }
         }).start();
         
     }
}<span></span>
4. spring初始化方式
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<!-- 权限角色缓存
  <bean id= "permitRoleCache" class = "com.tmall.lafite.core.manager.localcache.LafiteCache" init-method= "initialize" >
  <constructor-arg value= "_permit_role_cache_" />
  <constructor-arg value= "100" />
  <constructor-arg value= "2000" />
  </bean>
  <bean id= "permitRoleLogicCenter" class = "com.tmall.lafite.core.manager.permit.cache.PermitRoleLogicCenter" />
  <bean id= "permitRoleCacheEntity" class = "com.tmall.lafite.core.manager.localcache.entity.CacheEntity" >
  <property name= "logicCenter" ref= "permitRoleLogicCenter" />
  <property name= "lafiteCache" ref= "permitRoleCache" />
  </bean>
  -->
   
  <!-- 缓存容器 -->
  <bean id= "lafiteContainer" class = "com.tmall.lafite.core.manager.localcache.LafiteContainer" init-method= "initialize" >
  <!-- 
  <property name= "cacheMap" >
      <map>
          <entry key= "PermitCommon" value-ref= "permitCommonCacheEntity" />
          <entry key= "PermitAlgorithm" value-ref= "permitAlgorithmCacheEntity" />
          <entry key= "PermitRole" value-ref= "permitRoleCacheEntity" />
      </map>
     </property> 
     -->
  </bean>

5. 使用示例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Autowired
     private LafiteContainer lafiteContainer;
     
     private String namespace = LafiteNameSpace.PermitCommon;
 
     @SuppressWarnings ( "unchecked" )
     @Transactional
     public List<PermitCommonDO> getPermitDOCache() {
         LafiteResult lafiteResult = lafiteContainer.getAll(namespace);
         if (lafiteResult.getDefaultModel() != null ) {
             return (List<PermitCommonDO>) lafiteResult.getDefaultModel();
         }
         return null ;
     }
codepython
关注
专栏目录
ehcahce2.6实现数据缓存
09-03
利用ehcache2.6实现数据缓存
基于EHcache实现高并发数据缓存池
救护车
07-15 1259
在高并发的场景里面经常会使用到localcache内容，但是一直没有一个很好的内存管理工具。在开发的时候发现了ehcache，这么一个开源的工具。唯一的缺点就是无法对于多块数据单元进行一个有效的管理，并且在数据过期的时候无法提供有效的更新机制，所以这里写了一个数据缓存池来满足这个需求。 下面是设计组织结构： 这里主要是在数据实体内部封装了数据更新器，这样在数据过期的时候可以调用
Ehcache缓存回收策略
weixin_34265814的博客
03-23 143
Ehcache缓存 简介 Ehcache是一个用JAVA实现的，使用简单，高速，实现线程安全的缓存管理类库，Ehcache提供了用内存，磁盘文件存储，以及分布式存储方式等多种灵活的Cache管理方案。采用限制比较宽松的Apache License v2.0作为授权方式，被广泛地用于Hibernate,Spring,Cocoon等其他开源框架。 缓存回收就是当缓存满了的时候，Ehcache会根...
Ehcache 页面缓存
cuiyaoqiang的博客
06-24 2729
页面缓存，毫无疑问，几乎所有的网站的首页都是访问率最高的，而首页上的数据来源又是非常广泛的，大多数来自不同的对象，而且有可能来自不同的db ，所以给首页做缓存是一个不错的主意，那么主页的缓存策略是什么样子的呢，我认为应该是某个固定时间之内不变的，比如说2 分钟更新一次。那么这个缓存应该做在什么地方呢，让我们来看一下，假设您的应用的结构是page-filter-action-service-dao-d
Ehcache（07）——Ehcache对并发的支持
dengkuituo0680的博客
01-21 104
Ehcache对并发的支持 在高并发的情况下，使用Ehcache缓存时，由于并发的读与写，我们读的数据有可能是错误的，我们写的数据也有可能意外的被覆盖。所幸的是Ehcache为我们提供了针对于缓存元素Key的Read（读）、Write（写）锁。当一个线程获取了某一Key的Read锁之后，其它线程获取针对于同一个Key的Read锁不会受到限制，但其它线程（包括获取了该...
高并发缓存器（基于ehcache）
08-23
**高并发缓存器（基于ehcache）** 在IT行业中，面对高并发场景时，缓存技术是提高系统性能和响应速度的关键手段。基于ehcache的缓存器是一种常见的解决方案，它能够在内存中存储常用数据，减少对数据库的访问，从而...
Ehcache分布式缓存与其在SpringBoot应用
10-12
总的来说，Ehcache在SpringBoot中的应用能显著提升系统的响应速度和可扩展性，尤其是在处理大量数据或高并发场景下。通过灵活的配置和丰富的API，开发者可以定制适合自身业务需求的缓存策略，进一步优化应用性能。...
SecondaryCache:基于ehcache、redis实现的二级缓存系统，用akka实现服务器间缓存数据变化后的通信
05-01
"基于ehcache、redis实现"表明该系统结合了两种缓存的优点，ehcache通常用于轻量级的本地缓存，而redis则提供更强大的分布式缓存功能。 【描述分析】 描述中提到"用akka实现服务器间缓存数据变化后的通信"，这意味...
基于Java的ehcache(Java缓存框架 EhCache).zip
06-15
总结来说，EhCache作为Java环境中常用的缓存框架，通过其强大的功能和易用性，帮助企业或开发者构建高性能的应用系统，有效地提升了数据访问效率，降低了数据库的压力。在实际开发中，合理利用EhCache，能够显著提升...
基于JGROUPS的ehcache的分布式缓存复制
06-01
在IT行业中，分布式缓存是一种优化高并发场景下数据访问性能的重要技术，它通过在网络中的多台服务器上分发数据来提高系统的响应速度和可扩展性。本文将深入探讨基于JGROUPS的Ehcache实现的分布式缓存复制，这是一种...
使用EhCache+SSM实现数据缓存
mrleeapple的专栏
10-17 1933
在项目的开发过程中，经常会考虑到提高用户访问效率，降低服务器的压力，这个时候会用到数据缓存。当前实现缓存的技术有很多， 例如: jCache、Ehcache以及缓存服务器redis，redis作为分布式系统重要的组成部分，该技术的使用以及相关的一些问题会在后面的文章当中详细介绍。 目前，我将要提到的就是Ehcache和Spring项目的整合实现缓存。 前期的准备工作：（实体类
Ehcache的并发支持
py_xin的博客
10-18 7597
在高并发的情况下, 使用Ehcache缓存时, 由于并发的读与写, 我们读的数据有可能是错误的, 我们写的数据也有可能意外的被覆盖. 所幸的是Ehcache为我们提供了针对于缓存元素Key的Read(读)/Write(写)锁. Key的read锁可以同时被多个线程持有, 但要等到这些线程都释放掉read锁后, 其他线程才能获得write锁, 而且同一时间key的write锁只能被一个线程持有.
缓存EhCache简单用法
shenzhen_zsw的专栏
03-27 234
EhCache介绍 1）EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认CacheProvider。 Ehcache是一种广泛使用的开源Java分布式缓存。 主要面向通用缓存,Java EE和轻量级容器。 它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST...
利用 Ehcache 分布式缓存，轻松打造商业级高并发、高性能API接口
最新发布
Java知音
06-30 322
1、前言，我们为什么要用缓存？①普通API接口或应用，当访问量较小时，可以不考虑缓存。但大型API接口、应用，当QPS达到2000左右时(QPS一般指每秒查询率，即每秒2000次访问)，MySQL数据库即开始报警，如果不使用缓存，系统很可能会出现延迟、拒绝、服务器资源占满，最后崩溃宕机。②缓存无非就是不想频繁去读数据库、不想频繁去调用接口，主要实现两个用途：高性能、高并发。一个商业级API接口，当...
利用Ehcache分布式缓存，轻松打造商业级高并发、高性能API接口!
m0_59562547的博客
07-31 790
1、前言，我们为什么要用缓存？ ①普通API接口、网站、应用，当访问量较小时，可以不考虑缓存。但大型API接口、网站、应用，当QPS达到2000左右时(QPS一般指每秒查询率，即每秒2000次访问)，MySQL数据库即开始报警，如果不使用缓存，系统很可能会出现延迟、拒绝、服务器资源占满，最后崩溃宕机。 ②缓存无非就是不想频繁去读数据库、不想频繁去调用接口，主要实现两个用途：高性能、高并发。一个商业级API接口，当加入缓存技术，实现几万甚至十几万QPS是基本没有任何问题的。 ③今天，我们就在上一讲利用S
使用ehcache高并发场景下速度慢问题
chris的专栏
04-21 5433
问题描述：使用ehcache，缓存大小小于实际保存对象大小，进行大量对象会写入磁盘，但是由于多线程同时处理调用getkeys，会阻塞。 解决办法：在存在大量对象放入磁盘时，禁止使用getKeys方法。
缓存框架——Ehcache总结
weixin_38938338的博客
07-14 909
文章目录0. 问题0.11. CacheManager EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点 ehcache直接在jvm虚拟机中缓存，速度快，效率高；但是缓存共享麻烦，集群分布式应用不方便。 redis是通过socket访问到缓存服务，效率比Ehcache低，比数据库要快很多，处理集群和分布式缓存方便，有成熟的方案。 如果是单个应用或者对缓存访问要求很高的应用，用ehcache。如果是大型系统，存在缓存共享、分布式部署、缓存内容很大的，建议用redis。 0. 问题 0.1
Ehcache详细解读
四火专栏
05-31 1730
Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大，最初知道它，是从Hibernate的缓存开始的。网上中文的EhCache材料以简单介绍和配置方法居多，如果你有这方面的问题，请自行google；对于API，官网上介绍已经非常清楚，请参见官网；但是很少见到特性说明和对实现原理的分析，因此在这篇文章里面，我会详细介绍和分析EhCache的特性，加上一些自己的理解和思...
Ehcache：高性能Java缓存库
"Ehcache是一个开源的、基于标准的分布式缓存库，旨在提升系统性能、减轻数据库压力并实现可伸缩性。它支持内存和磁盘存储，并能通过Terracotta扩展到分布式环境。Ehcache以其快速、轻量级和可扩展的特性著称，适用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值