Imcache: N-level caching with offheap, memcache, redis and more
Imcache by Cetsoft

      

Imcache is a Java Caching Library.Imcache intends to speed up applications by providing a means to manage cached data. It offers solutions ranging from small applications to large scale applications. It supports n-level caching hierarchy where it supports various kind of caching methods like heap, offheap, and more. Imcache will also support well-known caching solutions like memcache and redis. To extend, you can define a heapcache backed by offheap cache which is also backed by database. If a key is not found in heap, it will be asked to offheap and so on. In order to use imcache, you need to specify your dependency as follows.


Pom Reference

<dependency>
  <groupId>com.cetsoft</groupId>
  <artifactId>imcache</artifactId>
  <version>0.1.1</version><!--Can be updated for later versions-->
</dependency>


Simple Application

Cache<String,User> cache = CacheBuilder.heapCache().
cacheLoader(new CacheLoader<String, User>() {
    public User load(String key) {
        return userDAO.get(key);
    }
}).evictionListener(new EvictionListener<String, User>{
    public onEviction(String key, User user){
        userDAO.save(key, user);
    }
}).capacity(10000).build();
//If there is not a user in the heap cache it'll be loaded via userDAO.
User user = cache.get("#unique identifier"); 
User newUser = new User("email", "Richard", "Murray")
//When maximum value for cache size is reached, eviction event occurs.
//In case of eviction, newUser will be saved to db.
cache.put(newUser.getEmail(), newUser);


The Cache Interface

Imcache supports simple operation defined by the cache interface. Cache interface provides general methods that is implemented by all imcache caches. See the methods below.

public interface Cache<K, V> {
    void put(K key, V value);
    V get(K key);
    V invalidate(K key);
    void clear()
    double hitRatio();
}


The Cache Builder

Cache Builder is one of the core asset of the imcache. You can create simple heapCaches to complexOffHeapCaches via 
Cache Builder. Let's see Cache Builder in action below.

void example(){
    Cache<Integer,Integer> cache = CacheBuilder.heapCache().
    cacheLoader(new CacheLoader<Integer, Integer>() {
    //Here you can load the key from another cache like offheapcache
        public Integer load(Integer key) {
            return null;
        }
    }).capacity(10000).build(); 
}


The Cache Loader

The CacheLoader interface for loading values with specified keys. The class that is interested in loading values 
from a resource implements this interface. When data is not found the cache, load method of CacheLoader is called.


The Eviction Listener

The listener interface for receiving eviction events. The class that is interested in processing a eviction event
implements this interface. When the eviction event occurs,that object's onEviction method is invoked.


The Heap Cache

HeapCache uses LRU(Least Recently Used) as eviction strategy by the help of LinkedHashMap. As a result, 
HeapCache discards the least recently used items first when eviction required. Eviction occurs if the size of
the cache is equal to the cache capacity in a put operation.


The Concurrent Heap Cache

ConcurrentHeapCache uses LRU(Least Recently Used) as eviction strategy by the help of ConcurrentLinkedHashMap. 
As a result, ConcurrentHeapCache discards the least recently used items firstwhen eviction required.
Eviction occurs if the size of the cache is equal to the cache capacity in a put operation


The Off Heap Cache

The Class OffHeapCache is a cache that uses offheap byte buffers to store or retrieve data by serializing
items into bytes. To do so, OffHeapCache uses pointers to point array location of an item. OffHeapCache clears
the buffers periodically to gain free space if buffers are dirty(unused memory). It also does eviction depending on
access time to the objects.
To make offheap cache work to JVM Parameters "-XX:MaxDirectMemorySize=4g" must be set. Buffer capacity of 8 mb 
is a good choice to start OffHeapCache. Let's see sample OffHeapCache use.

void example(){
    //8388608 is 8 MB and 10 buffers. 8MB*10 = 80 MB.
    OffHeapByteBufferStore bufferStore = new OffHeapByteBufferStore(8388608, 10);
    final Cache<Integer,SimpleObject> offHeapCache = CacheBuilder.offHeapCache().
    storage(bufferStore).build();
}

By default configuration, OffHeapCache will try to clean the places which are not used and marked as 
dirty periodically. What is more, it will do eviction periodically, too.


The Versioned Off Heap Cache

The Class VersionedOffHeapCache is a type of offheap cache where cache items have versions that are incremented for each update.
To make versioned off heap cache work to JVM Parameters "-XX:MaxDirectMemorySize=4g" must be set. Buffer capacity of 8 mb 
is a good choice to start VersionedOffHeapCache. Let's see sample VersionedOffHeapCache use.

void example(){
    //8388608 is 8 MB and 10 buffers. 8MB*10 = 80 MB.
    OffHeapByteBufferStore bufferStore = new OffHeapByteBufferStore(8388608, 10);
    final Cache<Integer,VersionedItem<SimpleObject>> offHeapCache = 
    CacheBuilder.versionedOffHeapCache().storage(bufferStore).build();
    VersionedItem<SimpleObject> versionedItem = offHeapCache.get(12);
}


Searching, Indexing and Query Execution

imcache provides searching for all the caches by default. Searching is done by execute method of SearchableCache.
Execute method takes a Query as an input and returns results as list. A query consists of criteria and filter. Here
is an example use for queries.

void example(){
    SearchableCache<Integer, SimpleObject> cache = CacheBuilder.heapCache().
    addIndex("j", IndexType.RANGE_INDEX).build();
    cache.put(0, createObject());
    cache.put(1, createObject());
    cache.put(2, createObject());
    List<SimpleObject> objects = cache.execute(CacheQuery.newQuery().
    setCriteria(new BetweenCriteria("j",1,3).or(new ETCriteria("j", 3))).
    setFilter(new LEFilter("k", 3)));
    for (SimpleObject simpleObject : objects) {
        System.out.println(simpleObject);
    }
}

To learn more about imcache please look at examples provided.

      

    