「javacache配置」java @cacheable

本篇文章给大家谈谈javacache配置，以及java @cacheable对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、Java的应用缓存cache如何入门?
• 2、如何在普通的java工程下 加入jbosscache数据缓存
• 3、cache java
• 4、java ehcache
• 5、在java中Cache是什么，主要问的是关于EJB方面的
• 6、ehcache java 对象缓存怎么实现

Java的应用缓存cache如何入门?

跟session不是一个概念，简单的谈下我个人对缓存的看法吧，你可以把它想象成一个容量大的hashMap，可以往里面get set数据，由于数据存在内存当中而不是数据库中，所以存取速度较快。

java常用的缓存有：ehcache, oscache,jcache，这些cache都是单机的，即存在本机的内存中，另外分布式的cache我用过memcache，它被独立部署在一台服务器上，可以实现多个客户端共用缓存。

一般用到缓存的场景：1.在处理并发请求，需要及时响应的。2.加快系统响应速度。举个例子：比如购物网站有 售卖物品的排行榜，这种数据都是由数据库中N多表关联查询排序得到的，那么就可以存在缓存当中，当页面请求查看排行榜时直接取缓存中的数据。后台定时任务根据一定的时间间隔计算好排行结果，再替换到当前缓存中。 这就是一个简单的缓存应用示例。

具体用法你可以参考 各个缓存的说明文档，百度一下很多的。 纯手打，望采纳~

如何在普通的java工程下 加入jbosscache数据缓存

JBossCache包括两个模块：TreeCache和TreeCacheAOP。 TreeCache --是一个树形结构复制的事务处理缓存。 TreeCacheAOP --是一个“面向对象”缓存，它使用AOP来动态管理POJO

下面是一个基本的使用例子：

首先是初始化TreeCache

TreeCache tree = new TreeCache();

然后是读进配置文件

PropertyConfigurator config = new PropertyConfigurator(); config.configure("配置文件.xml");

然后开始服务

Tree.startService();

因为Tree的结构是用NODE来Access的，TreeCache这里就很简单的用：

/level1/level2/node1 来表示两级Tree下面的Node1。

现在我们添加几个要Cache的对象。

Tree.put("/level1/level2/node1", "key1", "value1"); String[] array = { "1", "2", "3", "4" } Tree.put("/level3/array/", "myarray", array);

大家可以看到，TreeCache里面可以存储任何种类的对象，包括所有复杂对象。

读取对象就很方便了，

String s = (String)Tree.get("/level1/level2/node1/", "key1");

value1就读出来了。

同理：

String[] sarr = (String[]) Tree.get("/level3/array/","myarray");

System.out.println(sarr[1]) 会显示2

最后停止服务：

Tree.stopService();

cache java

cache java是什么， 让我们一起了解一下？

Cache 是一个像 Map 一样的数据结构，它允许基于 Key 的临时储存。缓存被单个 CacheManager 拥有。

Java 的缓存 API 定义了五个核心接口：CachingProvider，CacheManager，Cache，Entry 和 ExpiryPolicy。

Java实现cache的基本机制是什么？

我这里说的cache不是指CPU和RAM之间的缓存，而是java应用中间常用的缓存。最常使用的场合就是访问数据库的时候为了提高效率而使用的 cache。一般的用法就是把数据从数据库读到内存，然后之后的数据访问都从内存来读，从而减少对数据库的读取次数来提高效率。

说了这么多，Java 下到底如何实现Cache，希望下面的实际案例可以帮助到你。 public class CacheFactory {    private static ConcurrentHashMap  caches = new ConcurrentHashMap();    private static ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);      private static void register(Cache cache) {       caches.put(cache.category(), cache);    }      private static void registerAll() {       register(new StockCache());    }      public static void init() {       registerAll();         for (Cache cache : caches.values()) {          executorService.scheduleAtFixedRate(new Runnable() {             @Override             public void run() {                cache.refresh();             }          }, 0, cache.interval(), TimeUnit.MILLISECONDS);       }    }      public static Cache getCache(String key) {       if (caches.contains(key)) {          return caches.get(key);       }       return null;    } }   // cache接口除了需要提供interval和refresh以外，还需要提供一个category来区分不同的Cache public interface Cache {    /**     * Refresh the cache. If succeed, return true, else return false;     *      * @return     */    boolean refresh();      /**     * How much time it will refresh the cache.     *      * @return     */    long interval();      /**     * Cache's category. Each cache has distinct category.     *      * @return     */    String category(); }

java ehcache

java ehcache是什么，让我们一起了解一下？

EhCache是一个纯Java的进程内缓存框架，具有快速、精干等特点。主要面向通用缓存，Java EE和轻量级容器，具有内存和磁盘存储，缓存加载器，缓存扩展，缓存异常处理程序的功能。

ehcache主要的特性有：

1、简单，快速。

2、提供Hibernate的缓存实现。

3、多种缓存策略。

4、缓存数据有两级：内存和磁盘，因此无需担心容量问题。

5、缓存数据会在虚拟机重启的过程中写入磁盘。

6、可以通过RMI、可插入API等方式进行分布式缓存。

7、具有缓存和缓存管理器的侦听接口。

8、支持多缓存管理器实例，以及一个实例的多个缓存区域。

Ehcache在java中是如何使用的？

具体代码如下：代码实现的功能非常简单，即创建CacheManager，往里面存放一个Cache，然后往cache里面存数据和取数据，目的是展示Ehcache的基本使用。 /**  * XXX.com Inc.  * Copyright (c) 2004-2014 All Rights Reserved.  */ package com.test.encache;   import net.sf.ehcache.Cache; import net.sf.ehcache.CacheManager; import net.sf.ehcache.Element;   /**  *   * @author XXX  * @version $Id: EncacheTest.java, v 0.1 2014年8月8日 下午5:30:03 XXX Exp $  */ public class EncacheTest {     //一些配置参数     //private final static String configFileName      = "ehcache.xml";     //private final static int    maxEntriesLocalHeap = 1000;     private static CacheManager cacheManager;     static String               cacheName = "cache1";       public static void main(String[] args) {         ehcacheSetUp();           ehcacheUse();     }       private static void ehcacheSetUp() {           cacheManager = CacheManager.create();           //CacheConfiguration configuration = new CacheConfiguration(configFileName,         //    maxEntriesLocalHeap);           //Cache cache = new Cache(configuration);         cacheManager.addCache(cacheName);       }       private static void ehcacheUse() {         Cache cache1 = cacheManager.getCache(cacheName);         String key = "key1";         String value = "value1";           writeSomeData(cache1, key, value);           Element element = readSomeData(cache1, key, value);           System.out.println(element);     }       private static void writeSomeData(Cache cache, String key, String value) {         cache.put(new Element(key, value));     }       private static Element readSomeData(Cache cache, String key, String value) {         return cache.get(key);     } }

在java中Cache是什么，主要问的是关于EJB方面的

什么是缓存(cache)

理解缓存

操作系统的任务主要是合理地调配系统的各种资源，为各种程序的运行提供环境，它可以看作是硬件和应用软件之间的一个媒介。其中对内存的管理是系统的最主要的职责，怎么样使有限的内存用在刀刃上，怎么要保证系统本身所需的内存（以防止死机，在win2000和winxp里这一点已经做的非常好了），怎样克服各种硬件连接的瓶颈。

本文主要就这种硬件连接的瓶颈问题展开一些讨论。大家知道计算机的主要硬件，硬盘，内存和处理器之间的速度是不一样的，其中处理器的速度是非常快的，内存次之，而硬盘的速度是很慢的（相对于处理器来说），一件任务的处理要通过处理器给出的指令，把相关数据从硬盘里调出来，到内存，在内存和处理器之间还会有许多数据的传输，内存本身不能处理数据，要通过处理器来处理，当他们一起工作的时候，由于处理器和内存工作得快，它们常在把事做完了没事做了，要等硬盘，这样就大大降低了系统的整体性能，不能发挥所有硬件的性能。为了解决这个问题，一个优秀的操作系统必然要有“缓存”来作为这些硬件之间的一个中间站，来缓和这种矛盾，从而一定程度上提高系统的性能，“缓存”处理的越好，系统的性能发挥的越好。所以研究“缓存”就有了它的意义。

看了上面的内容，以前对“缓存”没有认识的朋友应该理解它了。理解之后马上可以应用的地方就是在自购兼容机的时候。大家大可不必去追赶潮流，买什么P4处理器，而应该买一个快一点的硬盘，比如买个7200转的（或更快的），以减少瓶颈的矛盾。处理器吗，买赛扬好了，一般是没问题的，处理器大多数时候是闲着的，有时处理很多个大任务时可能会有些紧张，注意避免就可以了。

从某种角度讲，内存本身是硬盘和处理器之间的一个缓存，它的作用是缓解硬盘和处理器之间的尖锐矛盾的。当它被作为一个固定的部件后，它本身也成了需要用缓存来缓解瓶颈的对象。它对处理器和硬盘夹在中间，是他们的必经之路，硬盘与处理器之间的关系成了硬盘与内存和内存与处理器之间的双重关系。所以上面提到的瓶颈问题的处理归结为对内存的优化，即怎样处理好硬盘与内存之间的缓存很处理器与内存之间的缓存。

对于一个想了解操作系统的人来说，能够理解“缓存”对对它做适当的优化是比不可少的一节课。另外再不从一下，缓存的概念是很广泛的，这里专指内存的缓存。

缓存的优化

操作系统本身已经有了很多优化措施，而我们只能在它的优化措施的基础上根据我们的实际情况来优化。

1,最“著名”的缓存是页面文件，这个倒不是缓解速度的，而是缓解容量的，在速度上，硬盘不如内存，但是容量上，内存是不可能跟硬盘比的，当你运行一个程序需要大量数据，占有大量内存时，内存就要被塞满，怎么办呢？把那些暂时不用的放到硬盘里去，因为处理器总是只调用处理一个任务所需的数据，其他的准备的数据（就是那些可能要用的，但暂时还不用的）可以先放一放，如果内存放不下，就只好放到硬盘了。但是这样做是有代价的，当放到内存的数据重新要被使用时，你就得等很长时间等系统把在硬盘中得数据调上来。其实你可以感受到系统的这些动作，比如你打开IE或Office，第一次打开是很慢的，但是关闭后马上再打开就快很多，这是因为这时数据还没被系统“请”出内存，系统从内存中直接取得数据自然快了；另一个情况，当你开了一个photoshop这样的大软件，这时打开Office要比平时还慢一点，这是因为内存本来被photoshop占领着，要调入Office的数据到内存就必须把photoshop的数据“请”出内存，多了这个过程，打开自然要慢一些。

优化页面文件，可以做一下几条：

1）把页面文件放到系统盘之外，这样做主要是为了保持页面文件的连续性，硬盘读取数据是靠磁头在磁性物质上“读”得到数据的，页面文件放在物理上的不同区域，磁头就要跳来跳去，自然不利于效率。系统盘文件众多，页面文件几乎肯定不连续。所以要把它移到其他盘。要提醒一点，当你移动好页面文件后，要把原来的删除掉，系统不会自动删除。

2）如果有两个硬盘，把页面文件放在转速快的那个，原因上面已讲了很多遍了。

3）最大最小页面文件的设置原则。有很多人建议将这两个值设置成相等的，我不知道他们是那里来的依据，其实这样设置是不合理的。我们先要知道他们两个值的意义。一般情况下，内存是不会真的“塞满”，它会在内存储量到达一定程度时自动将一部分暂时不用的数据放到硬盘，最小页面文件是所说的“一定程度”的具体比例的决定因素，最小页面文件大，比例就低，反之则相反；最大页面文件是极限值，有时你开了很多程序，内存和最小页面文件都满了，就自动溢出到最大页面文件。所以，将两者设为一样大是不合理的。最小页面文件要小一些，这样能够在内存中尽可能存更多的数据，效率就高，最大页面文件大一些，以免出现“全满”的的情况。

4）winxp现在支持4G内存，哪怕你有5，6百M的内存，你都不需页面文件了，这时可以把页面文件禁掉。到注册表编辑器HKEY_LOCAL_MACHINESystemCurrentControlSetControlSession Manager Memory Management下，找到DisablePagingExecutive（禁用页面文件）设其值为1。

5）在同上的注册表编辑器位置上有个ClearPageFileAtShutdown（关机时清除页面文件），这里所说的“清除”页面文件（即虚拟内存）并非是指从硬盘上完全删除pagefile .sys这个文件，而是对其进行“清洗”和整理，从而为下次启动Win2K更好地利用虚拟内存作好准备。这样做还有利于安全，页面文件上的残留的数据是可以用特殊的工具读到的，而这些数据你可能并不想让人知道。这样做的代价是关闭系统时间会加长。 将其值设为1即可。

6）学过C的朋友们应该对操作内存有个概念，一个任务完成后，要用free函数来释放内存，但有很多软件在设计的时候，并没有在所有环节都这样做，这会造成无用的数据占据内存，对这种情况可以使用一些内存优化软件，让这钟软件来完成释放内存的动作。

2，下面介绍和优化一些不著名的缓存：

1）内存读取硬盘数据要经过一个系统缓存（system cache），它的位置是在内存的特定区域，它是用来缓解硬盘与内存之间的速度不平衡的。它是以牺牲内存资源来换取从硬盘读取数据时的速度的，有了这块缓存，系统能从硬盘预读所需的数据，减少系统等待的时间。如果你的内存很大，比如5，6百M，那么你除了可以采取上面说的关闭页面文件的方法外，还可以起用打的系统缓存。做法如下，进入注册表编辑器： HKEY_LOCAL_MACHINESystemCurrentControlSetControlSession Manager Memory Management，找到LargeSystemCache（启用大的系统缓存），将它的值设为1就可以了。

这样设置了后，systemcache从4M增加到8M，再win2000和winxp中，这个值是动态的，如果内存不足，systemcache占据的空间可以自动相应调整。

2）处理器从内存读取数据的缓存是什么呢？是二级数据高级缓存（缓冲），同样它也要在内存中占一个空间，所以最好是有了大内存之后再设置这个值。也需再注册表里设置，方法如下：进入 HKEY_LOCAL_MACHINESystemCurrentControlSetControlSession Manager Memory Management ，找到 SecondLevelDataCache，默认为256，大内存设为512。

好了经过了上面的介绍，我想对朋友们来说最重要收获的是加深了对缓存和操作系统的认识，至于优化的方法，我得承认一般的朋友是用不着去做的，当然“玩”一下也是很有意思的。

参考资料：

ehcache java 对象缓存怎么实现

1.技术背景：

    系统缓存是位于应用程序与物理数据源之间，用于临时存放复制数据的内存区域，目的是为减少应用程序对物理数据源访问的次数，从而提高应用程序的运行性能。缓存设想内存是有限的，缓存的时效性也是有限的，所以可以设定内存数量的大小可以执行失效算法，可以在内存满了的情况下，按照最少访问等算法将缓存直接移除或切换到硬盘上。

    Ehcache从Hibernate发展而来，逐渐涵盖了Cache界的全部功能，是目前发展势头最好的一个项目，具有快速、简单、低消耗、扩展性强、支持对象或序列化缓存，支持缓存或元素的失效，提供LRU、LFU和FIFO缓存策略，支持内存缓存和硬盘缓存和分布式缓存机制等特点。其中Cache的存储方式为内存或磁盘（ps：无须担心容量问题）

2.EhCahe的类层次介绍：

    主要分为三层，最上层是CacheManager，它是操作Ehcache的入口。可以通过CacheManager.getInstance()获得一个单子的CacheManager，或者通过CacheManager的构造函数创建一个新的CacheManager。每个CacheManger都管理多个Cache。每个Cache都以一种类Hash的方式，关联多个Element。Element就是我们用于存放缓存内容的地方。

3.环境搭建：

    很简单只需要将ehcache-2.1.0-distribution.tar.gz和ehcache-web-2.0.2-distribution.tar.gz挤压的jar包放入WEB-INF/lib下。

    再创建一个重要的配置文件ehcache.xml，可以从ehcache组件包中拷贝一个，也可以自己建立一个，需要放到classpath下，一般放于/WEB-INF/classed/ehcache.xml；具体的配置文件可以网上搜一下

4.实际运用

    一个网站的首页估计是被访问次数最多的，我们可以考虑给首页做一个页面缓存；

    缓存策略：应该是某个固定时间之内不变的，比如说2分钟更新一次，以应用结构page-filter-action-service-dao-db为例。

    位置：页面缓存做到尽量靠近客户的地方，就是在page和filter之间，这样的优点就是第一个用户请求后，页面被缓存，第二个用户在请求，走到filter这个请求就结束了，需要在走到action-service-dao-db，好处当然是服务器压力大大降低和客户端页面响应速度加快。

    首页页面缓存存活时间定为2分钟，也就是参数timeToLiveSeconds（缓存的存活时间）应该设置为120，同时timeToIdleSeconds（多长时间不访问缓存，就清楚该缓存）最好也设为2分钟或者小于2分钟。

接着我们来看一下SimplePageCachingFilter 的配置，

filter

filter-nameindexCacheFilterfilter-name

filter-class

net.sf.ehcache.constructs.web.filter.SimplePageCachingFilter

filter-class

filter

filter-mapping

filter-nameindexCacheFilterfilter-name

url-pattern*index.actionurl-pattern

filter-mapping

将上述代码加入到web.xml，那么当打开首页时，你会发现2分钟才会有一堆sql语句出现在控制台，也可以调整为5分钟，总之一切尽在掌控之中。

当然，如果你像缓存首页的部分内容时，你需要使用SimplePageFragmentCachingFilter这个filter，我看一下：

filter

filter-nameindexCacheFilterfilter-name

filter-class

net.sf.ehcache.constructs.web.filter.SimplePageFragmentCachingFilter

filter-class

filter

filter-mapping

filter-nameindexCacheFilterfilter-name

url-pattern*/index_right.jspurl-pattern

filter-mapping

如此我们将jsp页面通过jsp：include到其他页面，这样就做到了页面局部缓存的效果，这一点貌似没有oscache的tag好用。

此外cachefilter中还有一个特性，就是gzip，也就是缓存中的元素是被压缩过的，如果客户端浏览器支持压缩的话，filter会直接返回压缩过的流，这样节省了带宽，把解压的工作交给了客户端浏览即可，当然如果客户端不支持gzip，那么filter会把缓存的元素拿出来解压后在返回给客户端浏览器（大多数爬虫是不支持gzip的，所以filter也会解压后在返回流）。

总之，Ehcache是一个非常轻量级的缓存实现，而且从1.2之后支持了集群，而且是hibernate默认的缓存provider，本文主要介绍Ehcahe对页面缓存的支持，但是它的功能远不止如此，要用好缓存，对J2ee中缓存的原理、适用范围、适用场景等等都需要比较深刻的理解，这样才能用好用对缓存。

为了大家通过实际例子加深了解与场景运用，在奉献一个实例：

*在Spring中运用EhCache

    适用任意一个现有开源Cache Framework，要求可以Cache系统中service或者DAO层的get/find等方法返回结果，如果数据更新（适用了Create/update/delete），则刷新cache中相应的内容。

    根据需求，计划适用Spring AOP+enCache来实现这个功能，采用ehCache原因之一就是Spring提供了enCache的支持，至于为何仅仅支持ehcache而不支持oscache和jbosscache就无从得知了。

    AOP少不了拦截器，先创建一个实现了MethodInterceptor接口的拦截器，用来拦截Service/DAO的方法调用，拦截到方法后，搜索该方法的结果在cache中是否存在，如果存在，返回cache中结果，如果不存在返回数据库查询结果，并将结果返回到缓存。

public class MethodCacheInterceptor implements MethodInterceptor, InitializingBean

{

private static final Log logger = LogFactory.getLog(MethodCacheInterceptor.class);

private Cache cache;

public void setCache(Cache cache) {

this.cache = cache;

}

public MethodCacheInterceptor() {

super();

}

/**

* 拦截Service/DAO 的方法，并查找该结果是否存在，如果存在就返回cache 中的值，

* 否则，返回数据库查询结果，并将查询结果放入cache

*/

public Object invoke(MethodInvocation invocation) throws Throwable {

String targetName = invocation.getThis().getClass().getName();

String methodName = invocation.getMethod().getName();

Object[] arguments = invocation.getArguments();

Object result;

logger.debug("Find object from cache is " + cache.getName());

String cacheKey = getCacheKey(targetName, methodName, arguments);

Element element = cache.get(cacheKey);

Page 13 of 26

if (element == null) {

logger.debug("Hold up method , Get method result and create cache........!");

result = invocation.proceed();

element = new Element(cacheKey, (Serializable) result);

cache.put(element);

}

return element.getValue();

}

/**

* 获得cache key 的方法，cache key 是Cache 中一个Element 的唯一标识

* cache key 包括包名+类名+方法名，如com.co.cache.service.UserServiceImpl.getAllUser

*/

private String getCacheKey(String targetName, String methodName, Object[] arguments) {

StringBuffer sb = new StringBuffer();

sb.append(targetName).append(".").append(methodName);

if ((arguments != null)  (arguments.length != 0)) {

for (int i = 0; i  arguments.length; i++) {

sb.append(".").append(arguments[i]);

}

}

return sb.toString();

}

/**

* implement InitializingBean，检查cache 是否为空

*/

public void afterPropertiesSet() throws Exception {

Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");

}

}

上面的代码可以看到，在方法invoke中，完成了搜索cache/新建cache的功能

随后，再建立一个拦截器MethodCacheAfterAdvice，作用是在用户进行create/update/delete操作时来刷新、remove相关cache内容，这个拦截器需要实现AfterRetruningAdvice接口，将会在所拦截的方法执行后执行在afterReturning（object arg0，Method arg1，Object[] arg2,object arg3)方法中所预定的操作

public class MethodCacheAfterAdvice implements AfterReturningAdvice, InitializingBean

{

private static final Log logger = LogFactory.getLog(MethodCacheAfterAdvice.class);

private Cache cache;

Page 15 of 26

public void setCache(Cache cache) {

this.cache = cache;

}

public MethodCacheAfterAdvice() {

super();

}

public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws

Throwable {

String className = arg3.getClass().getName();

List list = cache.getKeys();

for(int i = 0;ilist.size();i++){

String cacheKey = String.valueOf(list.get(i));

if(cacheKey.startsWith(className)){

cache.remove(cacheKey);

logger.debug("remove cache " + cacheKey);

}

}

}

public void afterPropertiesSet() throws Exception {

Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");

}

}

该方法获取目标class的全名，如：com.co.cache.test.TestServiceImpl，然后循环cache的key list，刷新/remove cache中所有和该class相关的element。

接着就是配置encache的属性，如最大缓存数量、cache刷新的时间等等。

ehcache

diskStore path="c:\\myapp\\cache"/

defaultCache

maxElementsInMemory="1000"

eternal="false"

timeToIdleSeconds="120"

timeToLiveSeconds="120"

overflowToDisk="true"

/

cache name="DEFAULT_CACHE"

maxElementsInMemory="10000"

eternal="false"

timeToIdleSeconds="300000"

timeToLiveSeconds="600000"

overflowToDisk="true"

/

/ehcache

这里需要注意的是defaultCache定义了一个默认的cache，这个Cache不能删除，否则会抛出No default cache is configured异常。另外由于使用拦截器来刷新Cache内容，因此在定义cache生命周期时可以定义较大的数值，timeToIdleSeconds="30000000",timeToLiveSeconds="6000000"，好像还不够大？

然后再将Cache和两个拦截器配置到Spring的配置文件cache.xml中即可，需要创建两个“切入点”，分别用于拦截不同方法名的方法。在配置application.xml并且导入cache.xml。这样一个简单的Spring+Encache框架就搭建完成。

关于javacache配置和java @cacheable的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。