<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.lzyan.ehcache.demo</groupId>
  <artifactId>EhcacheDemo</artifactId>
  <version>v0.1</version>
  <name>EhcacheDemo</name>
  
  <dependencies>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache-core</artifactId>
            <version>2.6.6</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.6</version>
        </dependency>
    </dependencies>
    
</project>

<ehcache updateCheck="false" dynamicConfig="false">
    
    
    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User‘s home directory
         user.dir - User‘s current working directory
         java.io.tmpdir - Default temp file path -->
    <diskStore path="D:/tmp/test/ehcache"/>
    
    <cacheManagerEventListenerFactory class="" properties=""/>

    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required for defaultCache:

        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.
        -->
    <defaultCache
        maxElementsInMemory="1000"
        eternal="false"
        timeToIdleSeconds="1200000"
        timeToLiveSeconds="1200000"
        overflowToDisk="true"
        />

    <cache name="icache-global"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="1800"
        timeToLiveSeconds="1800"
        overflowToDisk="true"
        />
    
    <cache name="SimplePageCachingFilter"
           maxElementsInMemory="10000"
           maxElementsOnDisk="1000"
           eternal="false"
           overflowToDisk="true"
           timeToIdleSeconds="300"
           timeToLiveSeconds="600"
           memoryStoreEvictionPolicy="LFU"
            />
</ehcache>

import java.net.URL;
import java.util.concurrent.TimeUnit;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

public class EhCache_v2 {
    
    public static void main(String[] args) throws Exception {
        System.out.println("main(): begin ...");
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        URL url = loader.getResource("ehcache.xml");
        //创建一个缓存管理器
        CacheManager manager = CacheManager.create(url);
        String names[] = manager.getCacheNames();
        System.out.println("Available caches list: \n---------");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
        System.out.println("---------");
        
        if(names.length > 0){
            System.out.println("Selected_CacheName=" + names[0]);
        }
        Cache cache = manager.getCache(names[0]);
        cache.put(new Element("name", "admin"));
        
        Element element = cache.get("name");
        System.out.println("getValue()=" + element.getValue());        
        Object obj = element.getObjectValue();
        System.out.println("getObjectValue()=" + obj);
        
        TimeUnit.SECONDS.sleep(3);
        
        ThreadAction action = new ThreadAction();
        action.setCacheName(cache.getName());
        action.setManager(manager);
        action.start();

        System.out.println("=== main thread is return! ===");
    }
    
}

class ThreadAction extends Thread{
    private String cacheName;
    private CacheManager manager ;
    
    
    @Override
    public void run() {
        try {
            Thread.sleep(3000);
            Cache cache = manager.getCache(cacheName);
            Element element = cache.get("name");
            System.out.println("run(): 从缓存中取得数据:" + element.getObjectValue());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }
    
    public CacheManager getManager() {
        return manager;
    }
    public void setManager(CacheManager manager) {
        this.manager = manager;
    }

    public String getCacheName() {
        return cacheName;
    }
    public void setCacheName(String cacheName) {
        this.cacheName = cacheName;
    }

}

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

public class EhCache {
    
    public static void main(String[] args) {
        System.out.println("main(): begin ...");
        // CacheManager manager = new CacheManager();
        //创建一个缓存管理器
        CacheManager singletonManager = CacheManager.create();
        //建立一个缓存实例
        Cache memoryOnlyCache = new Cache("testCache", 5000, false, false, 5, 2);
        //在内存管理器中添加缓存实例
        singletonManager.addCache(memoryOnlyCache);
        Cache cache = singletonManager.getCache("testCache");
        //使用缓存
        Element element = new Element("key1", "value1");
        cache.put(element);
        cache.put(new Element("key1", "value2"));

        element = cache.get("key1");
        Object value = element.getObjectValue();
        System.out.println(value);

        int elementsInMemory = cache.getSize();
        System.out.println(elementsInMemory);

        long elementsInMemory2 = cache.getMemoryStoreSize();
        System.out.println(elementsInMemory2);

        Object obj = element.getObjectValue();
        cache.remove("key1");
        System.out.println(obj);
        singletonManager.shutdown();
        // manager.shutdown();
        System.out.println("main(): over ...");
    }
    
}