JCache Using JCache
9 likes5,065 views
Using JCache This document discusses Java Caching (JCache), the Java standard for caching APIs specified in JSR-107. It introduces caching concepts and benefits, describes the key interfaces and classes in JCache like CacheManager and Cache, and demonstrates features like entry processors. It also discusses JCache implementations like Hazelcast and annotations for method-level caching. The future of JCache is outlined, with plans for JCache 1.1, 2.0 aligned with Java EE 8, and 3.0 aligned with future Java versions. The document ends with information on Hazelcast's JCache support.
![JCache: Entry Processors
(custom atomic operations for everyone!)
public class IncrementProcessor<K>
implements EntryProcessor<K, Integer, Integer>, Serializable {
@Override
public Integer process(MutableEntry<K, Integer> entry, Object... arguments) {
if (entry.exists()) {
int amount = arguments.length == 0 ? 1 : (Integer)arguments[0];
int current = entry.getValue();
entry.setValue(count + amount);
return current;
} else {
throw new IllegalStateException(“no entry exists”);
}
}](https://image.slidesharecdn.com/jcache281115-151129135159-lva1-app6892/85/JCache-Using-JCache-31-320.jpg)
JCache Using JCache
- 1. Using JCache GREG LUCK, CO-SPEC LEAD JSR107 @GREGRLUCK CEO | HAZELCAST 28 NOVEMBER 2015 JCache
- 2. Agenda • Introduction to Caching • Java Caching (JCache), JSR-107 • Code Demo
- 4. 4 Benefits of Caching Performance Offload expenisve or non-scalabl parts of your architecture Scale up – get the most out of one machine Scale out – add more capacity with more machines Excellent Buffer against load variability And… Usually very fast and easy to apply
- 5. 5 When to Use Caching – When applications use the same data more than once – When cost (time / resources) of making an initial copy is less than fetching or producing the data again or when faster to request from a Cache
- 6. 1 2 3 4 Common Problem Areas that Benefit Anything Web Scale Anything where the data is across the network Compound Data Objects Data Persistence
- 7. 7 Database Caching Cache Cache ApplicationApplicationApplicationApplication Data Store Moving data from the database into the cache increases processing speed and can reduce database licensing and maintenance costs. Speed Costs Scalability ~200 us Average Response Time Cache Cache
- 8. 8 Flash/SSD (serialized form) Local Storage Heap (Objects) Opaque to GC in RAM (serialized form) <100 ns < 100ns +deserialization time 2 500 1,000+ Latency) Size (GB) Caches are built primarily in RAM in-process or distributed Network Storage Scaleout across the network (serialized form) < 50us +deserialitzation time < 140us for 1Gbps < 70us for 10Gbps/40Gbps +deserialitzation time 20,000+
- 9. ‘s law Predicted System Speedup = 1 / ((1 – Proportion Sped Up) + Proportion Sped Up / Speed up)) Estimated Performance Improvements
- 10. 10 Cache Efficiency = cache hits / total hits ➡ High efficiency = high offload ➡ High efficiency = high performance ➡ How to increase: ➡Put reference data in the cache ➡Put long lived in the cache. ➡Consider frequency of mutability of data ➡Put highly used data in cache ➡Increase the size of the cache. Today you can create TB sized caches 10
- 11. 11 Problems to Consider • Standalone Caches and the N * problem – As each entry expires, the backing system gets N requests for data where n is the number of standalone caches. Solution: Use a distributed cache • Consistency with the System of Record – How to keep the cache in sync with changes in a backing system. Solution: Match mutability of data with data safety configuration. Update the cache and backing store at the same time. • Consistency with other cache nodes – How to keep all cache nodes in sync: Solution: Use a distributed cache and match consistency configuration with data mutability 11
- 13. Java Caching (JCache) • What? – Java Caching (JCache) standardized Caching for the Java Platform* – A common mechanism to create, access, update and remove information from Caches • How? – JSR-107: Java Caching Specification (JCache) – Java Community Process (JCP) 2.9
- 14. Java Caching (JCache) • Why? – Standardize! Standardize! Standardize! • Core Caching Concepts • Core Caching API – Provide application portability between Caching solutions • Big & Small, Open & Commercial – Caching is ubiquitous!
- 15. Java Caching (Jcache) When? Item Date JCache Final Spec Released 18 March 2014 Spring 4.1 September 2014 Hazelcast 3.3.1 TCK Compliant September 2014 Hazelcast 3.4 (with High-Density Memory Store) November 2014 Hazelcast 3.6 (with High-Density Caching) July 2015
- 16. Implementations • Implementations – JCache Reference Implementation – Hazelcast – Oracle Coherence – Terracotta Ehcache – Infinispan – GridGain – TayzGrid • Keep Track – https://jcp.org/aboutJava/communityprocess/implementati ons/jsr107/index.html 16
- 17. Java Caching (JCache) • Which Platform?
- 18. Java Caching (JCache) Project Hosting – JCP Project: • http://jcp.org/en/jsr/detail?id=107 – Source Code: • https://github.com/jsr107 – Forum: • https://groups.google.com/forum/?fromgroups#!forum /jsr107
- 19. Java Caching (JCache) How to get it. Apache Maven: (via Maven Central Repository) <dependency> <groupId>javax.cache</groupId> <artifactId>cache-api</artifactId> <version>1.0</version> </dependency>
- 21. Caches and Caching JSR107 Cache Definition: A high-performance, low- latency data-structure* in which an application places a temporary copy of information that is likely to be used more than once
- 22. Maps vs Cache APIs java.util.Map (Java 6/7) Key-Value Based API Supports Atomic Updates Entries Don’t Expire Entries Aren’t Evicted Entries Stored On-Heap Store-By-Reference javax.cache.Cache (Java 6) Key-Value Based API Supports Atomic Updates Entries May Expire Entries May Be Evicted Entries Stored Anywhere (ie: topologies) Store-By-Value and Store-By- Reference Supports Integration (ie: Loaders / Writers) Supports Observation (ie: Listeners) Entry Processors Statistics
- 23. JCache: Features • java.util.ConcurrentMap like API • Atomic Operations • Lock-Free • Read-Through / Write-Through Integration Support • Cache Event Listeners • Fully Generic API = type-safety • Statistics • Annotations (for frameworks and containers) • Store-By-Value semantics (optional store-by-reference)
- 24. JCache: Features • Topology Agnostic – Topologies not defined or restricted by the specification • Efficiently supports: – “local” in-memory Caching and – “distributed” server-based Caching
- 26. JCache: Runtime Structure Caching “service loader” CachingProvider “SPI implementation” CacheManager “manager of caches” Cache “interface to a Cache” Loads & Tracks * * * Created & Managed By Created & Managed By “application” Uses.. *
- 27. JCache: Cache Managers javax.cache.CacheManager • Establishes, configures, manages and owns named Caches – Caches may be pre-define or dynamically created at runtime • Provides Cache infrastructure and resources • Provides Cache “scoping” (say in a Cluster) • Provides Cache ClassLoaders (important for store-by-value) • Provides Cache lifecycle management
- 28. JCache: Hello World (via a Cache Manager) // acquire the default CacheManager CacheManager manager = Caching.getCacheManager(); // acquire a previously configured cache (via CacheManager) Cache<Integer, String> cache = manager.getCache(“my-cache”, Integer.class, String.class); // put something in the cache cache.put(123, “Hello World”); // get something from the cache String message = cache.get(123);
- 29. Cache Interface & Methods (in IDE)
- 30. JCache: Entry Processors (custom atomic operations for everyone!) // acquire a cache Cache<String, Integer> cache = manager.getCache(“my-cache”, String.class, Integer.class); // increment a cached value by 42, returning the old value int value = cache.invoke(“key”, new IncrementProcessor<>(), 42);
- 31. JCache: Entry Processors (custom atomic operations for everyone!) public class IncrementProcessor<K> implements EntryProcessor<K, Integer, Integer>, Serializable { @Override public Integer process(MutableEntry<K, Integer> entry, Object... arguments) { if (entry.exists()) { int amount = arguments.length == 0 ? 1 : (Integer)arguments[0]; int current = entry.getValue(); entry.setValue(count + amount); return current; } else { throw new IllegalStateException(“no entry exists”); } }
- 32. JCache: Entry Processors (custom atomic operations for everyone!) • Eliminate Round-Trips! (in distributed systems) • Enable development of a Lock-Free API! (simplifies applications) *May need to be Serializable (in distributed systems) Cache Application Cache Application
- 33. JCache: Entry Processors Which is better? // using an entry processor? int value = cache.invoke(“key”, new IncrementProcessor<>(), 42); // using a lock based API? cache.lock(“key”); int current = cache.get(“key”); cache.put(“key”, current + 42); cache.unlock(“key”);
- 34. Annotations • JSR107 introduces a standardized set of caching annotations, which do method level caching interception on annotated classes running in dependency injection containers. • Caching annotations are becoming increasingly popular: –Ehcache Annotations for Spring –Spring 3’s caching annotations. • JSR107 Annotations will be added to: –Java EE 8 (planned?) –Spring 4.1 (released)
- 35. Annotation Operations • The JSR107 annotations cover the most common cache operations: • @CacheResult • @CachePut • @CacheRemove • @CacheRemoveAll
- 36. Fully Annotated Class Example @CacheDefaults(cacheName = "blogManager") public class BlogManager { @CacheResult public Blog getBlogEntry(String title) {...} @CacheRemove public void removeBlogEntry(String title) {...} @CacheRemoveAll public void removeAllBlogs() {...} @CachePut public void createEntry(@CacheKey String title, @CacheValue Blog blog) {...} @CacheResult public Blog getEntryCached(String randomArg, @CacheKey String title){...} }
- 37. Specific Overrides public class DomainDao { @CachePut(cacheName="domainCache") public void updateDomain(String domainId, @CacheKey int index, @CacheValue Domain domain) { ... } }
- 38. The Future? • JCache 1.1 (2015) – Maintenance Release being worked on • JCache 2.0 (2016-) – Java 8 Language Features (Lambda & Streams) – Servlet 4.0 Integration / Session Caching? – Java EE 8 Alignment? • JCache 3.0 (2017?) – Java 10 Language Features? 38
- 40. Hazelcast JCache Support • Full implementation for: – Hazelcast.newHazelcastInstance() – HazelcastClient.newHazelcastClient() • TCK Compliant • JCache with Hi-Density Memory Store • Docs: http://docs.hazelcast.org/docs/latest- dev/manual/html-single/hazelcast- documentation.html#jcache-overview
- 42. Or Download • Download from hazelcast.org/download • Maven: <dependency> <groupId>com.hazelcast</groupId> <artifactId>hazelcast</artifactId> <version>3.5.4</version> </dependency>
- 43. QUESTIONS? 43 • Greg Luck – (@gregrluck) – greg@hazelcast.com