Standardize caching in Java. Introduction to JCache and In-Memory data grid solutions

Transcription

1 Standardize caching in Java Introduction to JCache and In-Memory data grid solutions

2 Agenda 1. What is caching? 2. JCache overview 3. Quick walk through providers 4. C2MON highlights

3 What is caching?

4 What is caching? Cache: A high-performance, low-latency datastructure in which an application places a temporary copy of information that is likely to be used more than once

5 Benefits of using cache Performance Scale up get the most out of one machine Scale out add more capacity with more machines Usually very fast and easy to apply

6 When to use caching When applications use the same data more than once When cost (time / resources) of making an initial copy is lower than fetching or producing the data again or when it isfaster to request from a Cache

7 Some general use cases

8 JCache overview

9 What is JCache? A common mechanism for performing CRUD operations from Caches Provides core caching concepts and API Provides application portability between various Caching solutions

10 JCache: Main features Read/Write Integration support Cache Event Listeners Type-safety - fully generic ConcurrentMap like API Statistics Store-By-Value/Store-By-Reference Annotations support Support for local and distributed caching Topology Agnostic - Topologies not defined or restricted by the specification

11 Store-By-Value and Store-By-Reference JSR-107 storing mechanisms: Store-By-Reference (optional) Object key =... Object value =... cache.put(key, value); assert cache.get(key) == value; assert cache.iterator().next().getkey() == key; Store-By-Value(default)

12 Cache Consistency Consistency refers to the behavior of caches and the guarantees that exist when concurrent cache mutation occur together with the visibility of the mutations when multiple threads are accessing a cache. An implementation may provide support for different consistency models in addition to the required Default Consistency model. Method boolean containskey(k key) V get(k key) V getandput(k key, V value) Iterator<Cache.Entry<K, V>> iterator() void put(k key, V value) boolean putifabsent(k key, V value) boolean remove(k key) <T> T invoke(k key, EntryProcessor<K, V, T> entryprocessor, Object... arguments); Default Consistency last value happen-before happen-before last value happen-before happen-before plus compare and swap happen-before plus compare and swap happen-before

13 Cache Topologies Embedded approach Client/Server approach

14 Cache Types replicated cache partitioned cache

15 JCache Core interfaces

16 JCache API

17 CacheManager Configures and manages named Caches caches may be created dynamically or predefined provides Cache infrastructure provides Cache scopes(for clusters) provides important for Store-By-Value Cache ClassLoaders Provides Cache lifecycle management

18 Cache A Cache is a Map-like data-structure that permits the temporary storage of Key-based Values, some what like java.util.map data-structure. A Cache is owned by a single CacheManager.

19 Entry An Entry is a single key-value pair stored by a Cache.

20 ExpiryPolicy Eternal Cache entries will never expire. Access Cache entries will expire if they have not been accessed within a configured time interval. Creation Cache entries will expire after a configured time interval from when they were added to the cache. Update Cache entries will expire if they have not been modified within a configured time interval.

21 JCache Runtime Structure

22 JCache API example if Cache already exists, or it s configured in XML: CachingProvider provider = Caching.getCachingProvider(); CacheManager manager = provider.getcachemanager(); Cache<Long, Person> personcache = manager.getcache( personcache, Long.class, Person.class); personcache.put(1l, new Person()); Person person = personcache.get(1l); if Cache doesn t exist and we want to configure it programmatically: CacheManager cachemanager = Caching.getCachingProvider().getCacheManager(); MutableConfiguration<Long, Person> config = new MutableConfiguration<>(); config.settypes(long.class, Person.class); config.setstorebyvalue(true); // value is serialized cachemanager.createcache("personcache", config);

23 Atomic Operations: EntryProcessor allows develop Lock-Free API eliminates round-trips in distributed systems Needs Serialization (if distributed) An invocable function that allows applications to perform compound operations on a Cache.Entry atomically, according the defined* consistency of a Cache. Any Cache.Entry mutations will not take effect until after the EntryProcessor.process(MutableEntry, Object...) method has completed execution. Implementations may execute EntryProcessor}s in situ, thus avoiding locking, round-trips and expensive network transfers. JCache specification

24 EntryProcessor usage example String name = Foo ; cache.invoke(k key, (entry, arguments) -> { V value = entry.getvalue(); value.setname(name); entry.setvalue(value); return null; }); public class CustomEntryProcessor implements EntryProcessor<K, V, T> public T process(mutableentry<string, Long> entry, Object... arguments) throws EntryProcessorException { V value = entry.getvalue(); value.setname(arguments[0]); entry.setvalue(value); return null; } } // Usage cache.invoke(k key, new CustomEntryProcessor(), T arguments);

25 Cache Annotations The JCache covers the most common @CacheRemoveAll

26 JCache annotations = personcache ) public class PersonRepository public void put(@cachekey Long Person person) public Person get(@cachekey Long id) { Person person = // get object from DB return person; public void invalidate(@cachekey Long id) {} public void invalidateall() {}

27 JCache supporting frameworks

28 Cache Providers with JCache Support Ehcache Hazelcast Ignite Coherence Infinispan

29 Ehcache Terracotta as one of the companies supporting actively JSR107 Full JSR107 support Flexible Scalable minimal dependencies Open Source Licensing - Apache 2.0 license

30 Hazelcast Full TCK Compliant implementation for: Embedded Members Very fast and highly scalable JCache Implementation Dead simple Near Cache support

31 Apache Ignite Near Cache support fully JCache TCK compliant Distributed Queries Apache 2 license

32 C2MON use case evaluation

33 Current implementation of C2MON Cache module Runs on Ehcache + Terracotta Ehcache dependent Cluster based on Terracotta(license required) Limited amount of clients Forced Store-By-Value very complex clustered locking system

34 Goals Support for JCache standard Fully Open Source Clusterable Support of junit tests Auto detections of nodes in the cluster Easier cluster-locking mechanism No limitations on cache clients eventual replacement for JMS messaging Nice to have: Continuous query

35 Summary + lesson learned JCache vs vendor specific features Which is my favoured cache? Best documentation, material, resources

36 Thank you!

37 References JCache specification Hazelcast documentation Ignite documentation Ehcache documentation stackoverflow