How to avoid Cache misses?

Question

Hi,
Before I explain the problem here's my current setup.
- Distributed/partitioned cache
- Annotated JPA classes
- Backing map linked to an oracle database
- Objects are stored in POF format
- C++ extend client
When I request an item that does not exist in the cache, the JPA magic forms a query and assembles the object and stores that inside the cache.
However if the query returns no results then coherence sends back a cache miss. Our existing object hierarchy can request items that don't exist (this infrastructure is vast and entrenched and changing it is not an option). This blows any near cache performance out of the water.
What I want to do is to intercept a cache miss and store a null object in the cache on that key (by null it will be 4 bytes in length). The client code can interpret the null object as a cache miss and everything will work as usual - however the null object will be stored in the near cache and performance will return.
My problem is, as annotated JPA does all the 'magic', I don't get to intercept if the query returns an empty set. I've tried both map triggers and listeners, however as expected they don't get called as no result set is generated.
Does anyone know of an entry point where I can return an object to coherence in the event of a query returning an empty set. I'd also like the ability to configure this behaviour on a per cache basis.
Any help gratefully received.
Thanks
Rich
Edited by: Rich Carless on Jan 6, 2011 1:56 PM

Answer 1

Hi,
If you are using 3.6 you can do this by writing a sub-class of JpaCacheStore that implements BinaryEntryStore or a more genric way (which would suit other people who have asked similar questions recently) would be to write an implementation of BinaryEntryStore that wraps another cache store.
Here is one I knocked up recently...
package org.gridman.coherence.cachestore;
import com.tangosol.net.BackingMapManagerContext;
import com.tangosol.net.CacheFactory;
import com.tangosol.net.DefaultConfigurableCacheFactory;
import com.tangosol.net.cache.BinaryEntryStore;
import com.tangosol.net.cache.CacheStore;
import com.tangosol.run.xml.XmlElement;
import com.tangosol.util.Binary;
import com.tangosol.util.BinaryEntry;
import java.util.Set;
public class WrapperBinaryCacheStore implements BinaryEntryStore {
    private BackingMapManagerContext context;
    private CacheStore wrapped;
    public WrapperBinaryCacheStore(BackingMapManagerContext context, ClassLoader loader, String cacheName, XmlElement cacheStoreConfig) {
        this.context = context;
        DefaultConfigurableCacheFactory cacheFactory = (DefaultConfigurableCacheFactory) CacheFactory.getConfigurableCacheFactory();
        DefaultConfigurableCacheFactory.CacheInfo info = cacheFactory.findSchemeMapping(cacheName);
        XmlElement xmlConfig = cacheStoreConfig.getSafeElement("class-scheme");
        wrapped = (CacheStore)cacheFactory.instantiateAny(info, xmlConfig, context, loader);
    @Override
    public void erase(BinaryEntry binaryEntry) {
        wrapped.erase(binaryEntry.getKey());
    @SuppressWarnings({"unchecked"})
    @Override
    public void eraseAll(Set entries) {
        for (BinaryEntry entry : (Set<BinaryEntry>)entries) {
            erase(entry);
    @Override
    public void load(BinaryEntry binaryEntry) {
        Object value = wrapped.load(binaryEntry.getKey());
        binaryEntry.updateBinaryValue((Binary) context.getValueToInternalConverter().convert(value));
    @SuppressWarnings({"unchecked"})
    @Override
    public void loadAll(Set entries) {
        for (BinaryEntry entry : (Set<BinaryEntry>)entries) {
            load(entry);
    @Override
    public void store(BinaryEntry binaryEntry) {
        wrapped.store(binaryEntry.getKey(), binaryEntry.getValue());
    @SuppressWarnings({"unchecked"})
    @Override
    public void storeAll(Set entries) {
        for (BinaryEntry entry : (Set<BinaryEntry>)entries) {
            store(entry);
}Using the JPA example from the Coherence 3.6 Tutorial you would configure it like this...
<distributed-scheme>
    <scheme-name>jpa-distributed</scheme-name>
    <service-name>JpaDistributedCache</service-name>
    <backing-map-scheme>
        <read-write-backing-map-scheme>
            <internal-cache-scheme>
                <local-scheme/>
            </internal-cache-scheme>
            <cachestore-scheme>
                <class-scheme>
                    <class-name>org.gridman.coherence.cachestore.WrapperBinaryCacheStore</class-name>
                    <init-params>
                        <init-param>
                            <param-type>com.tangosol.net.BackingMapManagerContext</param-type>
                            <param-value>{manager-context}</param-value>
                        </init-param>
                        <init-param>
                            <param-type>java.lang.ClassLoader</param-type>
                            <param-value>{class-loader}</param-value>
                        </init-param>
                        <init-param>
                            <param-type>java.lang.String</param-type>
                            <param-value>{cache-name}</param-value>
                        </init-param>
                        <init-param>
                            <param-type>com.tangosol.run.xml.XmlElement</param-type>
                            <param-value>
                                <class-scheme>
                                    <class-name>com.tangosol.coherence.jpa.JpaCacheStore</class-name>
                                    <init-params>
                                        <init-param>
                                            <param-type>java.lang.String</param-type>
                                            <param-value>{cache-name}</param-value>
                                        </init-param>
                                        <init-param>
                                            <param-type>java.lang.String</param-type>
                                            <param-value>com.oracle.handson.{cache-name}</param-value>
                                        </init-param>
                                        <init-param>
                                            <param-type>java.lang.String</param-type>
                                            <param-value>JPA</param-value>
                                        </init-param>
                                    </init-params>
                                </class-scheme>
                            </param-value>
                        </init-param>
                    </init-params>
                </class-scheme>
            </cachestore-scheme>
        </read-write-backing-map-scheme>
    </backing-map-scheme>
    <autostart>true</autostart>
</distributed-scheme>As you can see the WrapperBinaryCacheStore takes four cpnstructor parameters (set up in the init-params)
<li>First is the Backing Map Context
<li>Second is the ClassLoader
<li>Third is the cache name
<li>Fourth is the XML configuration for the cache store you want to wrap
If the load method of the wrapped cache store returns null (i.e. nothing in the DB matches the key) then instead of returning null, the BinaryEntry is updated with a Binary representing null. Because the corresponding key is now in the cache with a value of null then the cache store will not be called again for the same key.
Note If you do this and then subsequently your DB is updated with values for the keys thet were previously null (by something other than Coherence) then Coherence will not load them as it is never going to call load for those keys again.
I have given the code above a quick test and it seems to work fine.
If you are using 3.5 then you can still do this but you need to use the Coherence Incubator Commons library which has a version of BinaryCacheStore. The code and config will be similar but not identical.
JK
Edited by: Jonathan.Knight on Jan 6, 2011 3:50 PM