传统mvc开发中在Servlet或普通java类中使用ehcache缓存

   之前在网上看过很多关于使用Hibernate自带的ehcache做二级缓存开发，结合了spring框架后对于访问的效率提高了不少，现在我把ehcahe从Hibernate脱离出来，在不使用hibernate的框架里，比如传统mvc:jsp+javabean+servlet中使用ehcache做二级缓存开发

 

   首先要使用ehcahe需要下载他的jar包 http://sourceforge.net/project/showfiles.php?group_id=93232 

   我用的是1.5.0的版本

 

   下载完毕后建立一个标准的java的web工程，需要将下载解压后文件夹中的ehcache-1.5.0.jar，ehcache-1.5.0-sources.jar，以及lib文件夹中的三个backport-util-concurrent-3.0.jar，commons-logging-1.0.4.jar，jsr107cache-1.0.jar，一共五个jar包拷入web工程的lib中去，这样此web工程就可以用ehcahe了，官方使用方法详见http://ehcache.sourceforge.net/samples.html

 

 

   ehcache在java类中的使用方法：

 

首先和在hibernate中是用ehcache一样，必须有ehcache的配置文件：ehcache.xml，这个文件在下载的压缩包中有，将其粘贴到工程的src下，按需求更改你的参数

 

我得配置是：

 

1. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2.          xsi:noNamespaceSchemaLocation="ehcache.xsd">
4.     <!--
5.     CacheManager Configuration
6.     ==========================
7.     An ehcache.xml corresponds to a single CacheManager.
8.     
9.     See instructions below or the ehcache schema (ehcache.xsd) on how to configure.
11.     System property tokens can be specified in this file which are replaced when the configuration is loaded.
12.     For example multicastGroupPort=${multicastGroupPort} can be replaced with the System property either
13.     from an environment variable or a system property specified with a command line switch such as
14.      -DmulticastGroupPort=4446.
16.     DiskStore configuration
17.     =======================
19.     The diskStore element is optional. To turn off disk store path creation, comment out the diskStore
20.     element below.
22.     Configure it if you have overflowToDisk or diskPersistent enabled for any cache.
24.     If it is not configured, and a cache is created which requires a disk store, a warning will be
25.      issued and java.io.tmpdir will automatically be used.
27.     diskStore has only one attribute - "path". It is the path to the directory where
28.     .data and .index files will be created.
30.     If the path is one of the following Java System Property it is replaced by its value in the
31.     running VM. For backward compatibility these are not specified without being enclosed in the ${token}
32.     replacement syntax.
34.     The following properties are translated:
35.     * user.home - User's home directory
36.     * user.dir - User's current working directory
37.     * java.io.tmpdir - Default temp file path
38.     * ehcache.disk.store.dir - A system property you would normally specify on the command line
39.       e.g. java -Dehcache.disk.store.dir=/u01/myapp/diskdir ...
41.     Subdirectories can be specified below the property e.g. java.io.tmpdir/one
42.     -->
43.     <diskStore path="java.io.tmpdir"/>
45.     <!--
46.     CacheManagerEventListener
47.     =========================
48.     Specifies a CacheManagerEventListenerFactory, be used to create a CacheManagerPeerProvider,
49.     which is notified when Caches are added or removed from the CacheManager.
51.     The attributes of CacheManagerEventListenerFactory are:
52.     * class - a fully qualified factory class name
53.     * properties - comma separated properties having meaning only to the factory.
55.     Sets the fully qualified class name to be registered as the CacheManager event listener.
57.     The events include:
58.     * adding a Cache
59.     * removing a Cache
61.     Callbacks to listener methods are synchronous and unsynchronized. It is the responsibility
62.     of the implementer to safely handle the potential performance and thread safety issues
63.     depending on what their listener is doing.
65.     If no class is specified, no listener is created. There is no default.
66.     -->
67.     <cacheManagerEventListenerFactory class="" properties=""/>
70.     <!--
71.     CacheManagerPeerProvider
72.     ========================
73.     (Enable for distributed operation)
75.     Specifies a CacheManagerPeerProviderFactory which will be used to create a
76.     CacheManagerPeerProvider, which discovers other CacheManagers in the cluster.
78.     The attributes of cacheManagerPeerProviderFactory are:
79.     * class - a fully qualified factory class name
80.     * properties - comma separated properties having meaning only to the factory.
82.     Ehcache comes with a built-in RMI-based distribution system with two means of discovery of
83.     CacheManager peers participating in the cluster:
84.     * automatic, using a multicast group. This one automatically discovers peers and detects
85.       changes such as peers entering and leaving the group
86.     * manual, using manual rmiURL configuration. A hardcoded list of peers is provided at
87.       configuration time.
89.     Configuring Automatic Discovery:
90.     Automatic discovery is configured as per the following example:
91.     <cacheManagerPeerProviderFactory
92.                         class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
93.                         properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1,
94.                                     multicastGroupPort=4446, timeToLive=32"/>
96.     Valid properties are:
97.     * peerDiscovery (mandatory) - specify "automatic"
98.     * multicastGroupAddress (mandatory) - specify a valid multicast group address
99.     * multicastGroupPort (mandatory) - specify a dedicated port for the multicast heartbeat
100.       traffic
101.     * timeToLive - specify a value between 0 and 255 which determines how far the packets will
102.       propagate.
104.       By convention, the restrictions are:
105.       0   - the same host
106.       1   - the same subnet
107.       32  - the same site
108.       64  - the same region
109.       128 - the same continent
110.       255 - unrestricted
112.     Configuring Manual Discovery:
113.     Manual discovery is configured as per the following example:
114.     <cacheManagerPeerProviderFactory class=
115.                           "net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
116.                           properties="peerDiscovery=manual,
117.                           rmiUrls=//server1:40000/sampleCache1|//server2:40000/sampleCache1
118.                           | //server1:40000/sampleCache2|//server2:40000/sampleCache2"
119.                           propertySeparator="," />
121.     Valid properties are:
122.     * peerDiscovery (mandatory) - specify "manual"
123.     * rmiUrls (mandatory) - specify a pipe separated list of rmiUrls, in the form
124.                             //hostname:port
126.     The hostname is the hostname of the remote CacheManager peer. The port is the listening
127.     port of the RMICacheManagerPeerListener of the remote CacheManager peer.
128.     
129.     Configuring JGroups replication:
130.     <cacheManagerPeerProviderFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"
131.                                      properties="connect=UDP(mcast_addr=231.12.21.132;mcast_port=45566;ip_ttl=32;
132.                                      mcast_send_buf_size=150000;mcast_recv_buf_size=80000):
133.                                      PING(timeout=2000;num_initial_members=6):
134.                                      MERGE2(min_interval=5000;max_interval=10000):
135.                                      FD_SOCK:VERIFY_SUSPECT(timeout=1500):
136.                                      pbcast.NAKACK(gc_lag=10;retransmit_timeout=3000):
137.                                      UNICAST(timeout=5000):
138.                                      pbcast.STABLE(desired_avg_gossip=20000):
139.                                      FRAG:
140.                                      pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;shun=false;print_local_addr=false)"
141.                                      propertySeparator="::"
142.             />
143.      The only property necessay is the connect String used by jgroups to configure itself. Refer to the Jgroups documentation for explanation
144.      of all the protocols. The example above uses UDP multicast. If the connect property is not specified the default JGroups connection will be
145.      used.       
147.     -->
148.     <cacheManagerPeerProviderFactory
149.             class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
150.             properties="peerDiscovery=automatic,
151.                         multicastGroupAddress=230.0.0.1,
152.                         multicastGroupPort=4446, timeToLive=1"
153.             propertySeparator=","
154.             />
157.     <!--
158.     CacheManagerPeerListener
159.     ========================
160.     (Enable for distributed operation)
162.     Specifies a CacheManagerPeerListenerFactory which will be used to create a
163.     CacheManagerPeerListener, which
164.     listens for messages from cache replicators participating in the cluster.
166.     The attributes of cacheManagerPeerListenerFactory are:
167.     class - a fully qualified factory class name
168.     properties - comma separated properties having meaning only to the factory.
170.     Ehcache comes with a built-in RMI-based distribution system. The listener component is
171.     RMICacheManagerPeerListener which is configured using
172.     RMICacheManagerPeerListenerFactory. It is configured as per the following example:
174.     <cacheManagerPeerListenerFactory
175.         class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
176.         properties="hostName=fully_qualified_hostname_or_ip,
177.                     port=40001,
178.                     socketTimeoutMillis=120000"
179.                     propertySeparator="," />
181.     All properties are optional. They are:
182.     * hostName - the hostName of the host the listener is running on. Specify
183.       where the host is multihomed and you want to control the interface over which cluster
184.       messages are received. Defaults to the host name of the default interface if not
185.       specified.
186.     * port - the port the RMI Registry listener listens on. This defaults to a free port if not specified.
187.     * remoteObjectPort - the port number on which the remote objects bound in the registry receive calls.
188.                          This defaults to a free port if not specified.
189.     * socketTimeoutMillis - the number of ms client sockets will stay open when sending
190.       messages to the listener. This should be long enough for the slowest message.
191.       If not specified it defaults 120000ms.
193.     -->
194.     <cacheManagerPeerListenerFactory
195.             class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"/>
198.     <!--
199.     Cache configuration
200.     ===================
202.     The following attributes are required.
204.     name:
205.     Sets the name of the cache. This is used to identify the cache. It must be unique.
207.     maxElementsInMemory:
208.     Sets the maximum number of objects that will be created in memory
210.     maxElementsOnDisk:
211.     Sets the maximum number of objects that will be maintained in the DiskStore
212.     The default value is zero, meaning unlimited.
214.     eternal:
215.     Sets whether elements are eternal. If eternal,  timeouts are ignored and the
216.     element is never expired.
218.     overflowToDisk:
219.     Sets whether elements can overflow to disk when the memory store
220.     has reached the maxInMemory limit.
222.     The following attributes and elements are optional.
224.     timeToIdleSeconds:
225.     Sets the time to idle for an element before it expires.
226.     i.e. The maximum amount of time between accesses before an element expires
227.     Is only used if the element is not eternal.
228.     Optional attribute. A value of 0 means that an Element can idle for infinity.
229.     The default value is 0.
231.     timeToLiveSeconds:
232.     Sets the time to live for an element before it expires.
233.     i.e. The maximum time between creation time and when an element expires.
234.     Is only used if the element is not eternal.
235.     Optional attribute. A value of 0 means that and Element can live for infinity.
236.     The default value is 0.
238.     diskPersistent:
239.     Whether the disk store persists between restarts of the Virtual Machine.
240.     The default value is false.
242.     diskExpiryThreadIntervalSeconds:
243.     The number of seconds between runs of the disk expiry thread. The default value
244.     is 120 seconds.
246.     diskSpoolBufferSizeMB:
247.     This is the size to allocate the DiskStore for a spool buffer. Writes are made
248.     to this area and then asynchronously written to disk. The default size is 30MB.
249.     Each spool buffer is used only by its cache. If you get OutOfMemory errors consider
250.     lowering this value. To improve DiskStore performance consider increasing it. Trace level
251.     logging in the DiskStore will show if put back ups are occurring. 
253.     memoryStoreEvictionPolicy:
254.     Policy would be enforced upon reaching the maxElementsInMemory limit. Default
255.     policy is Least Recently Used (specified as LRU). Other policies available -
256.     First In First Out (specified as FIFO) and Less Frequently Used
257.     (specified as LFU)
259.     Cache elements can also contain sub elements which take the same format of a factory class
260.     and properties. Defined sub-elements are:
262.     * cacheEventListenerFactory - Enables registration of listeners for cache events, such as
263.       put, remove, update, and expire.
265.     * bootstrapCacheLoaderFactory - Specifies a BootstrapCacheLoader, which is called by a
266.       cache on initialisation to prepopulate itself.
268.     * cacheExtensionFactory - Specifies a CacheExtension, a generic mechansim to tie a class
269.       which holds a reference to a cache to the cache lifecycle.
271.     * cacheExceptionHandlerFactory - Specifies a CacheExceptionHandler, which is called when
272.       cache exceptions occur.
274.     * cacheLoaderFactory - Specifies a CacheLoader, which can be used both asynchronously and
275.       synchronously to load objects into a cache.
277.     RMI Cache Replication
279.     Each cache that will be distributed needs to set a cache event listener which replicates
280.     messages to the other CacheManager peers. For the built-in RMI implementation this is done
281.     by adding a cacheEventListenerFactory element of type RMICacheReplicatorFactory to each
282.     distributed cache's configuration as per the following example:
284.     <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
285.          properties="replicateAsynchronously=true,
286.          replicatePuts=true,
287.          replicateUpdates=true,
288.          replicateUpdatesViaCopy=true,
289.          replicateRemovals=true
290.          asynchronousReplicationIntervalMillis=<number of milliseconds"
291.          propertySeparator="," />
293.     The RMICacheReplicatorFactory recognises the following properties:
295.     * replicatePuts=true|false - whether new elements placed in a cache are
296.       replicated to others. Defaults to true.
298.     * replicateUpdates=true|false - whether new elements which override an
299.       element already existing with the same key are replicated. Defaults to true.
301.     * replicateRemovals=true - whether element removals are replicated. Defaults to true.
303.     * replicateAsynchronously=true | false - whether replications are
304.       asynchronous (true) or synchronous (false). Defaults to true.
306.     * replicateUpdatesViaCopy=true | false - whether the new elements are
307.       copied to other caches (true), or whether a remove message is sent. Defaults to true.
309.     * asynchronousReplicationIntervalMillis=<number of milliseconds> - The asynchronous
310.       replicator runs at a set interval of milliseconds. The default is 1000. The minimum
311.       is 10. This property is only applicable if replicateAsynchronously=true
314.     For the Jgroups replication this is done with:
315.     <cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
316.                             properties="replicateAsynchronously=true, replicatePuts=true,
317.                             replicateUpdates=true, replicateUpdatesViaCopy=false,
318.                             replicateRemovals=true,asynchronousReplicationIntervalMillis=1000"/>
319.     This listener supports the same property than the RMICacheReplicationFactory. 
321.     Cluster Bootstrapping
323.     The RMIBootstrapCacheLoader bootstraps caches in clusters where RMICacheReplicators are
324.     used. It is configured as per the following example:
326.     <bootstrapCacheLoaderFactory
327.         class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"
328.         properties="bootstrapAsynchronously=true, maximumChunkSizeBytes=5000000"
329.         propertySeparator="," />
331.     The RMIBootstrapCacheLoaderFactory recognises the following optional properties:
333.     * bootstrapAsynchronously=true|false - whether the bootstrap happens in the background
334.       after the cache has started. If false, bootstrapping must complete before the cache is
335.       made available. The default value is true.
337.     * maximumChunkSizeBytes=<integer> - Caches can potentially be very large, larger than the
338.       memory limits of the VM. This property allows the bootstraper to fetched elements in
339.       chunks. The default chunk size is 5000000 (5MB).
342.     Cache Exception Handling
344.     By default, most cache operations will propagate a runtime CacheException on failure. An
345.     interceptor, using a dynamic proxy, may be configured so that a CacheExceptionHandler can
346.     be configured to intercept Exceptions. Errors are not intercepted.
348.     It is configured as per the following example:
350.       <cacheExceptionHandlerFactory class="com.example.ExampleExceptionHandlerFactory"
351.                                       properties="logLevel=FINE"/>
353.     Caches with ExceptionHandling configured are not of type Cache, but are of type Ehcache only,
354.     and are not available using CacheManager.getCache(), but using CacheManager.getEhcache().
357.     Cache Loader
359.     A default CacheLoader may be set which loads objects into the cache through asynchronous and
360.     synchronous methods on Cache. This is different to the bootstrap cache loader, which is used
361.     only in distributed caching.
363.     It is configured as per the following example:
365.         <cacheLoaderFactory class="com.example.ExampleCacheLoaderFactory"
366.                                       properties="type=int,startCounter=10"/>
368.     Cache Extension
370.     CacheExtensions are a general purpose mechanism to allow generic extensions to a Cache.
371.     CacheExtensions are tied into the Cache lifecycle.
373.     CacheExtensions are created using the CacheExtensionFactory which has a
374.     <code>createCacheCacheExtension()</code> method which takes as a parameter a
375.     Cache and properties. It can thus call back into any public method on Cache, including, of
376.     course, the load methods.
378.     Extensions are added as per the following example:
380.          <cacheExtensionFactory class="com.example.FileWatchingCacheRefresherExtensionFactory"
381.                              properties="refreshIntervalMillis=18000, loaderTimeout=3000,
382.                                          flushPeriod=whatever, someOtherProperty=someValue ..."/>
384.     -->
387.     <!--
388.     Mandatory Default Cache configuration. These settings will be applied to caches
389.     created programmtically using CacheManager.add(String cacheName).
391.     The defaultCache has an implicit name "default" which is a reserved cache name.
392.     -->
393.     <defaultCache
394.             maxElementsInMemory="1000"
395.             eternal="false"
396.             timeToIdleSeconds="120"
397.             timeToLiveSeconds="120"
398.             overflowToDisk="true"
399.             diskSpoolBufferSizeMB="30"
400.             maxElementsOnDisk="10000000"
401.             diskPersistent="false"
402.             diskExpiryThreadIntervalSeconds="120"
403.             memoryStoreEvictionPolicy="LRU"
404.             />
406.     <!--
407.     Sample caches. Following are some example caches. Remove these before use.
408.     -->
410.     <!--
411.     Sample cache named sampleCache1
412.     This cache contains a maximum in memory of 10000 elements, and will expire
413.     an element if it is idle for more than 5 minutes and lives for more than
414.     10 minutes.
416.     If there are more than 10000 elements it will overflow to the
417.     disk cache, which in this configuration will go to wherever java.io.tmp is
418.     defined on your system. On a standard Linux system this will be /tmp"
419.     -->
420.     <cache name="sampleCache1"
421.            maxElementsInMemory="10000"
422.            maxElementsOnDisk="1000"
423.            eternal="false"
424.            overflowToDisk="true"
425.            diskSpoolBufferSizeMB="20"
426.            timeToIdleSeconds="300"
427.            timeToLiveSeconds="600"
428.            memoryStoreEvictionPolicy="LFU"
429.             />
432.     <!--
433.     Sample cache named sampleCache2
434.     This cache has a maximum of 1000 elements in memory. There is no overflow to disk, so 1000
435.     is also the maximum cache size. Note that when a cache is eternal, timeToLive and
436.     timeToIdle are not used and do not need to be specified.
437.     -->
438.     <cache name="sampleCache2"
439.            maxElementsInMemory="1000"
440.            eternal="true"
441.            overflowToDisk="false"
442.            memoryStoreEvictionPolicy="FIFO"
443.             />
446.     <!--
447.     Sample cache named sampleCache3. This cache overflows to disk. The disk store is
448.     persistent between cache and VM restarts. The disk expiry thread interval is set to 10
449.     minutes, overriding the default of 2 minutes.
450.     -->
451.     <cache name="sampleCache3"
452.            maxElementsInMemory="500"
453.            eternal="false"
454.            overflowToDisk="true"
455.            timeToIdleSeconds="300"
456.            timeToLiveSeconds="600"
457.            diskPersistent="true"
458.            diskExpiryThreadIntervalSeconds="1"
459.            memoryStoreEvictionPolicy="LFU"
460.             />
463.     <!--
464.     Sample distributed cache named sampleDistributedCache1.
465.     This cache replicates using defaults.
466.     It also bootstraps from the cluster, using default properties.
467.     -->
468.     <cache name="sampleDistributedCache1"
469.            maxElementsInMemory="10"
470.            eternal="false"
471.            timeToIdleSeconds="100"
472.            timeToLiveSeconds="100"
473.            overflowToDisk="false">
474.         <cacheEventListenerFactory
475.                 class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>
476.         <bootstrapCacheLoaderFactory
477.                 class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"/>
478.     </cache>
481.     <!--
482.     Sample distributed cache named sampleDistributedCache2.
483.     This cache replicates using specific properties.
484.     It only replicates updates and does so synchronously via copy
485.     -->
486.     <cache name="sampleDistributedCache2"
487.            maxElementsInMemory="10"
488.            eternal="false"
489.            timeToIdleSeconds="100"
490.            timeToLiveSeconds="100"
491.            overflowToDisk="false">
492.         <cacheEventListenerFactory
493.                 class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
494.                 properties="replicateAsynchronously=false, replicatePuts=false,
495.                             replicateUpdates=true, replicateUpdatesViaCopy=true,
496.                             replicateRemovals=false"/>
497.     </cache>
499.     <!--
500.     Sample distributed cache named sampleDistributedCache3.
501.     This cache replicates using defaults except that the asynchronous replication
502.     interval is set to 200ms.
503.     -->
504.     <cache name="sampleDistributedCache3"
505.            maxElementsInMemory="10"
506.            eternal="false"
507.            timeToIdleSeconds="100"
508.            timeToLiveSeconds="100"
509.            overflowToDisk="false">
510.         <cacheEventListenerFactory
511.                 class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
512.                 properties="asynchronousReplicationIntervalMillis=200"/>
513.     </cache>
515.     
518. </ehcache>

其中的<cache>元素中的参数都是你设定的缓存参数，这里介绍几个常用的，其余可去http://ehcache.sourceforge.net/查询

 

maxElementsInMemory ---你打算往缓存中放入的对象个数，如果对象个数放满会把最先放入的挤出缓存，FIFO原则

 

eternal ---缓存中对象是否为永久的，假如是，超时配置将被忽略，对象从不过期，这里设为false，遵循FIFO原则

 

timeToIdleSeconds---缓存中对象冷却时间，即你放入缓存中的对象在这个时间中不使用，时间过后会自动从缓存中清除，如果使用了某对象重新计时，但不会超过timeToLiveSeconds

 

timeToLiveSeconds---缓存中对象存活时间，放入缓存的对象在这个时间过后会从缓存中清除

 

 overflowToDisk ---内存不足时，是否启用磁盘缓存，磁盘缓存需设置路径，此处不使用

 

<cache>元素的name参数标志一种cache的配置，如果不配置，系统回去找defaultCache

我这里使用了sampleCache1（在程序中获取cache时指定）

 

 

我的java测试类   CacheUtil

 

1. package util;
3. import net.sf.ehcache.Cache;
4. import net.sf.ehcache.CacheManager;
5. import net.sf.ehcache.Element;
8. public class CacheUtil {
9.     
10.      
11.      
12.      public static void main(String[] args){
13.          
14.          //每当开始使用ehcache的时候都要是用CacheManager来创建Cache
15.          String oldone = "test";
16.          CacheManager manager = CacheManager.create();//单例模式创建CacheManager ,没有特殊情况一定要使用单例模式创建，不然会对系统浪费很大，且容易出错
17.                   
18.          Cache cache = manager.getCache("sampleCache1"); //使用了sampleCache1的缓存配置
19.          Element element = new Element("key1", oldone );  //放入我想存入缓存的对象，这里是个字符串
20.          cache.put(element);//缓存中放入ehcache的Element 
21.          
22.          Element element2 = cache.get("key1");    //取出放入缓存的那个叫key1的Element 
23.          Object value = element2.getObjectValue();  //取出的对象是个Object 
24.          
25.          String newyf =(String)value;  //转化成实际的对象
26.          
27. //       System.out.println(newyf);
28. //       System.out.println(cache.getSize());
29. //       System.out.println(element2.getKey());
30.          
31.      }
32. }

   这样，存取的过程就完了，是不是很简单，这样就可以在普通的javaweb开发中是用ehcache了