TestEhcache.java

/**
 * 
 */
package ehcache;

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

import org.ehcache.Cache;
import org.ehcache.CacheManager;
import org.ehcache.PersistentCacheManager;
import org.ehcache.UserManagedCache;
import org.ehcache.config.CacheConfiguration;
import org.ehcache.config.Configuration;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.builders.UserManagedCacheBuilder;
import org.ehcache.config.units.EntryUnit;
import org.ehcache.config.units.MemoryUnit;
import org.ehcache.expiry.Duration;
import org.ehcache.expiry.Expirations;
import org.ehcache.xml.XmlConfiguration;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * http://www.ehcache.org/documentation/3.1/xsds.html
 * 
 * @author dzh
 * @date Nov 4, 2016 5:08:07 PM
 * @since 1.0
 */
public class TestEhcache {

    private CacheManager cacheManager;

    static Logger LOG = LoggerFactory.getLogger(TestEhcache.class);

    @Before
    public void init() {
        cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("preConfigured",
                        CacheConfigurationBuilder
                                .newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.heap(10))
                                .withExpiry(Expirations.timeToLiveExpiration(Duration.of(20, TimeUnit.SECONDS))))
                .build();
        cacheManager.init();

        // PersistentCacheManager persistentCacheManager =
        // CacheManagerBuilder.newCacheManagerBuilder()
        // .with(CacheManagerBuilder.persistence(getStoragePath() +
        // File.separator + "myData"))
        // .withCache("threeTieredCache",
        // CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class,
        // String.class,
        // ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10,
        // EntryUnit.ENTRIES)
        // .offheap(1, MemoryUnit.MB).disk(20, MemoryUnit.MB)))
        // .build(true);
        // persistentCacheManager.close();
    }

    @Test
    public void xmlConfigTest() {
        final URL myUrl = this.getClass().getResource("ehcache.xml");
        Configuration xmlConfig = new XmlConfiguration(myUrl);
        CacheManager myCacheManager = CacheManagerBuilder.newCacheManager(xmlConfig);
        //
        // XmlConfiguration xmlConfiguration = new XmlConfiguration(
        // getClass().getResource("/configs/docs/template-sample.xml"));
        // CacheConfigurationBuilder<Long, String> configurationBuilder =
        // xmlConfiguration
        // .newCacheConfigurationBuilderFromTemplate("example", Long.class,
        // String.class);
        // configurationBuilder =
        // configurationBuilder.withResourcePools(ResourcePoolsBuilder.heap(1000));
    }

    @Test
    public void cacheConfigTest() {
        CacheConfiguration<Long, String> usesConfiguredInCacheConfig = CacheConfigurationBuilder
                .newCacheConfigurationBuilder(Long.class, String.class,
                        ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, MemoryUnit.KB).offheap(10,
                                MemoryUnit.MB))
                .withSizeOfMaxObjectGraph(1000).withSizeOfMaxObjectSize(1000, MemoryUnit.B).build();

        CacheConfiguration<Long, String> usesDefaultSizeOfEngineConfig = CacheConfigurationBuilder
                .newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.newResourcePoolsBuilder()
                        .heap(10, MemoryUnit.KB).offheap(10, MemoryUnit.MB))
                .build();

        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withDefaultSizeOfMaxObjectSize(500, MemoryUnit.B).withDefaultSizeOfMaxObjectGraph(2000)
                .withCache("usesConfiguredInCache", usesConfiguredInCacheConfig)
                .withCache("usesDefaultSizeOfEngine", usesDefaultSizeOfEngineConfig).build(true);

        Cache<Long, String> usesConfiguredInCache = cacheManager.getCache("usesConfiguredInCache", Long.class,
                String.class);
        usesConfiguredInCache.put(1L, "one");
        // assertThat(usesConfiguredInCache.get(1L), equalTo("one"));

        Cache<Long, String> usesDefaultSizeOfEngine = cacheManager.getCache("usesDefaultSizeOfEngine", Long.class,
                String.class);
        usesDefaultSizeOfEngine.put(1L, "one");
        // assertThat(usesDefaultSizeOfEngine.get(1L), equalTo("one"));

        cacheManager.close();
    }

    @Test
    public void udpateResourcePool() {
        // ResourcePools pools =
        // ResourcePoolsBuilder.newResourcePoolsBuilder().heap(20L,
        // EntryUnit.ENTRIES).build();
        // cache.getRuntimeConfiguration().updateResourcePools(pools);
        // assertThat(
        // cache.getRuntimeConfiguration().getResourcePools().getPoolForResource(ResourceType.Core.HEAP).getSize(),
        // is(20L));
    }

    @Test
    public void createCacheTest() {
        Cache<Long, String> myCache = cacheManager.createCache("myCache", CacheConfigurationBuilder
                .newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.heap(10)).build());

        myCache.put(1L, "da one!");
        String value = myCache.get(1L);
        LOG.info(value);
    }

    /**
     * -XX:MaxDirectMemorySize
     */
    @Test
    public void offHeadpManagedTest() {
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("tieredCache",
                        CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
                                ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, EntryUnit.ENTRIES).offheap(10,
                                        MemoryUnit.MB)))
                .build(true);

        cacheManager.close();
    }

    @Test
    public void diskManagedTest() {
        String path = "";
        PersistentCacheManager persistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .with(CacheManagerBuilder.persistence(path + File.separator + "myData"))
                .withCache("persistent-cache",
                        CacheConfigurationBuilder
                                .newCacheConfigurationBuilder(Long.class,
                                        String.class, ResourcePoolsBuilder.newResourcePoolsBuilder()
                                                .heap(10, EntryUnit.ENTRIES).disk(10, MemoryUnit.MB, true)))
                .build(true);

        persistentCacheManager.close();
    }

    @Test
    @Ignore
    public void userManagedCacheTest() {
        UserManagedCache<Long, String> userManagedCache = UserManagedCacheBuilder
                .newUserManagedCacheBuilder(Long.class, String.class).build(false);
        userManagedCache.init();

        userManagedCache.put(1L, "da one!");
        userManagedCache.close();

        String value = userManagedCache.get(1L);
        LOG.info(value);
    }

    @Test
    public void removeCacheTest() {
        Cache<Long, String> preConfigured = cacheManager.getCache("preConfigured", Long.class, String.class);
        cacheManager.removeCache("preConfigured");

    }

    @After
    public void close() {
        cacheManager.close();
    }

}