General approach
You can use the Coherence API with caches backed by a database mapped through JPA. The grid accesses relational data through JPA CacheLoader and CacheStore implementations. In this “traditional” Coherence approach, TopLink Grid provides CacheLoader and CacheStore implementations that are optimized for EclipseLink JPA. (EclipseLinkJPACacheLoader and EclipseLinkJPACacheStore) which are both contained in the toplink-grid.jar file. Going this way, you use the standard JPA run-time configuration file persistence.xml and the JPA mapping file orm.xml. The Coherence cache configuration file coherence-cache-config.xml must be specified to override the default Coherence settings and define the CacheStore caching scheme.
Details
The CacheLoader implementation redirects all read operations/queries directly to the database via EclipseLink. The CacheStore takes care for all write operations (insert, update, delete) which are executed against the database using EclipseLink. This solution is basically independent from GlassFish and it’s JPA provider. You simply use Coherence with it’s native API and Coherence takes care of persisting the entities. This approach is referred to as “Traditional Coherence Configuration” in the documentation.
Preparation
In order to get this and each of the following examples to work, we need to make some preparations. First one is to get all the needed software. Get your copy of Java SE Development Kit 6u23, GlassFish 3.1 (Part of NetBeans), MySQL Community Server (5.5.9), TopLink (11.1.1.4.0) and Coherence (3.6.1.0). Any IDE would work. I based all examples on NetBeans 7.0 Beta2. You should start by installing the bits and pieces. Create an empty “coherence” db with MySQL. We will use this one for all examples. I will NOT guide you through this. I’ll start with the relevant Coherence parts. This will be the configuration you need to follow the other parts of this series, too. So you’d better keep it ;)
Unzip your Coherence download to a suitable location (e.g. x:\Oracle\coherence\) and check the installation by setting up and running the sample cache server application. Change to the \bin folder and execute the cache-server.cmd/sh. Prior to this make sure, that the JAVA_HOME variable is pointing to a valid JDK install. If everything went smoothly you get message: “Started DefaultCacheServer…”. One simple side note: Coherence is cluster-aware. Which means, it automatically tries to discover other running Coherence nodes in your subnet. If you are seeing any other output than “ActualMemberSet=MemberSet(Size=1,” you should stop here and configure Coherence to run on your machine only. Great. All set. Let’s go and execute the example client. Start coherence.cmd/sh and wait for the output “Map (?):”. If you check back with the server console you will see something like this:
(thread=Cluster, member=1): Member 2 joined Service Management with senior member 1
Play around with it and try the following commands, each confirmed with return: help, cache myCache, put message “hello”, get message, size, list, bye. For further help please consult the tutorial.
Move it into practice
Start a new Java/Java Class Library project with NetBeans. Name it “GridEntityExample” (check the dedicated lib folder box). Add coherence.jar, toplink-grid.jar and mysql-connector-java-5.1.13-bin.jar to the lib folder and add them to the projects dependencies.
Add two new packages entities and server (e.g. net.eisele.coherence.entities, net.eisele.coherence.server) and
As we already have the cache-server example, it’s easy to modify it to fit our needs. Add a new Entity Class (Employee) to the entities package. Change the primary key type to “int” and click next. Select EclipseLink JPA 2.0 from the dropdown box. As the wizard will not let you finish without, create a new Database Connection (jdbc:mysql://localhost:3306/coherence) and click finish. Add two private Strings (firstName, lastName) and their getters and setters to the entity. Remove the @GeneratedValue from the id attribute (more on that later). Some tweaks in the persistence.xml finish up the configuration. Add the following:
<property name="eclipselink.ddl-generation" value="create-tables" /> <property name="eclipselink.ddl-generation.output-mode" value="database" /> <property name="eclipselink.jdbc.read-connections.min" value="1" /> <property name="eclipselink.jdbc.write-connections.min" value="1" /> <property name="eclipselink.jdbc.batch-writing" value="JDBC" /> <property name="eclipselink.logging.level" value="FINE" /> <property name="eclipselink.logging.thread" value="false" /> <property name="eclipselink.logging.session" value="false" /> <property name="eclipselink.logging.exceptions" value="false" /> <property name="eclipselink.logging.timestamp" value="false"/>
Now we need a simple StartCacheServer class which should resist in the server package. Give it a simple main method:
public static void main(String[] args) throws UnknownHostException {
// Restrict Coherence to localhost
System.setProperty("tangosol.coherence.wka", InetAddress.getLocalHost().getHostAddress());
// Start CacheServer
DefaultCacheServer.main(new String[0]);
}
Now we have to configure Coherence. This is done via the coherence-cache-config.xml file. The complete file can be found in the tutorial. The key to success is the second init-param for the class-scheme. You have to reference the persistence unit from the persistence.xml there:
<init-param> <param-type>java.lang.String</param-type> <param-value>GridEntityExamplePU</param-value> </init-param>
Right-click StartCacheServer and run it. You should see the already know message: “Started DefaultCacheServer…”.
Ok. Now we are going to insert our first employee into the database. Create a simple InsertExample class:
public static void main(String[] args) throws UnknownHostException {
// Restrict Coherence to localhost
System.setProperty("tangosol.coherence.wka", InetAddress.getLocalHost().getHostAddress());
// Disable local storage--need to start independent CacheServer
System.setProperty("tangosol.coherence.distributed.localstorage", "false");
// Get the configured Cache
NamedCache cache = CacheFactory.getCache("Employee");
//Create a new Employee
Employee emp = new Employee();
emp.setFirstName("Markus");
emp.setLastName("Eisele");
emp.setId(1);
//Put the Employee into the cache
cache.put(1, emp);
}
Run it and check with your db, if the newly created Employee is there. It should be :)
Done. That’s all. Ok, where exactly is the GlassFish part?
Using this approach with GlassFish
It’s simple as hell. Create a new domain (let’s call it coherence) and create a new WebApplication (lets call it GridEntityWeb). Add the GridEntityExample project and the coherence.jar as dependencies. Now you have to configure the cache. This is done again via a coherence-cache-config.xml. Create one in WEB-INF/classes and make it reference the EclipseLinkJPA service-name.
<cache-config> <caching-scheme-mapping> <cache-mapping> <cache-name>*</cache-name> <scheme-name>distributed-eclipselink</scheme-name> </cache-mapping> </caching-scheme-mapping> <caching-schemes> <distributed-scheme> <scheme-name>distributed-eclipselink</scheme-name> <service-name>EclipseLinkJPA</service-name> </distributed-scheme> </caching-schemes> </cache-config>
That’s all. Make sure the StartCacheServer is running and fire up your GlassFish domain together with your application. If you simply copy the few lines from the InsertExample you can quickly test if everything is working. All left to do now is to find a nice and clean way to integrate this into your application. Maybe you could come up with a generic Coherence crud service (probably based on Adam’s proposal).
Drawbacks and thoughts
When using this approach, it is essential to configure the persistence unit to ensure that no changes are made to entities when they are inserted or updated. Any changes made to entities by the JPA provider are not reflected in the Coherence cache. This means that the entity in the cache will not match the database contents. In particular, entities should not use ID generation, for example, @GeneratedValue, to obtain an ID. That means that in order to insert an object into a Coherence cache, you need to provide its identity as well, to serve as the key.
The ID is typically the key under which the entity is stored in Coherence. Optimistic locking (for example, @Version) should not be used as it may lead to a database transaction commit failure.
So in general this is not really a commonly use approach which only fits with some special scenarios where you are fighting with big loads of data.
But what exactly is the deal here. Let’s see: If you run the configured example in a loop and insert 12.635 Employee objects, it takes roughly 13 minutes on my machine. This happens if you run Coherence in synchronous mode. But you can utilize a feature called “write-behind” to improve application response time by performing database updates asynchronously. If you add one single line to the CacheServer’s coherence-cache-config.xml:
<write-delay>10s</write-delay>
the needed time to issue the inserts from an application point of view shrinks to 9 seconds! Of course, the running server still needs it’s time to process the updates asynchronously but for the client this is the optimal behavior.
Enough for now. I will try to explain more an more concepts running my way through the examples. As you might have guessed, there is a lot to know if you work with caches. Next part will cover Coherence as L2 cache for EclipseLink with GlassFish. Thanks for reading. Stay tuned.
Reference: High Performance JPA with GlassFish and Coherence – Part 2 from our JCG partner Markus Eisele at the “Enterprise Software Development with Java” Blog
- High performance JPA with GlassFish and Coherence – Part 1
- High Performance JPA with GlassFish and Coherence – Part 3
- Developing and Testing in the Cloud
- Configuration Management in Java EE
- Leaked: Oracle WebLogic Server 12g
- Java EE6 Decorators: Decorating classes at injection time
- Java Tutorials and Android Tutorials list
