Pump your Java with Caching

25 08 2008

So you want caching. First thing to see are if your application are applicable for it. There’s the 80/20 rule saying that you need to be maximum 20% writing on what you intend to cache, if you deviate too much from these numbers caching stuff could actually slow you down. I had some fun with this on my own “production” machine an old p3 500mhz (keep that in mind when you see results).

Im gonna write about my current stack which are Apache Http+Apache Tomcat, JPA / Hibernate + spring & Apache Wicket, this does’nt mean that you cant benefit from the ideas though if you arent using these frameworks, which leads me to what I believe are number one rule with caching:

Non intrusion , cache needs to be applied lightly in a non intrusive way

That way you can easily switch it off, switch strategies etc.

So with my stack you can actually introduce caching in each layer if you want to, i’ll start at Hibernate.

Caching with Hibernate

As I used Hibernate and my application seemed a bit heavy on the database I optimized everything, but Hibernate I thought lets start here. So I did, enabling the query cache and 2nd level cache were actually very simple and few lines of code. But this approach were very intrusive as the application needed to know about the caching mechanism, I went ahead any how. I spent 2 days pondering why it did not work, I kept getting cache misses even though I saw that the queries were added to the cache. Hibernate forum werent being responsive so I thought maybe theres another way. Which leads me to next thing.

btw I just bought Java Persitence with Hibernate http://www.manning.com/bauer2/ to help me digg into the cache with Hibernate.

Caching with Spring modules cache

So the spring guys has an non intrusive way of applying caching. It’s really simple :

ApplicationContext.xml add:

<import resource="classpath:cacheContext.xml" />

cacheContext.xml :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:ehcache="http://www.springmodules.org/schema/ehcache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd">

  [4]<ehcache:config failQuietly="true"
configLocation="classpath:ehcache.xml"/>

    <bean id="myCacheKeyGenerator" class="zeuzgroup.core.cache.ZeuzCacheKeyGenerator"/>
    <bean id="myCachingListener" class="zeuzgroup.core.cache.ZeuzCachingListener"/>

    <ehcache:methodMapInterceptors
            cachingInterceptorId="cachingInterceptor"
            flushingInterceptorId="flushingInterceptor">

        <ehcache:cacheKeyGenerator refId="myCacheKeyGenerator"/>

        <ehcache:cachingListeners>
            <ehcache:cachingListener refId="myCachingListener"/>
        </ehcache:cachingListeners>

[1]<ehcache:caching cacheName="translationCache"
methodFQN="zeuzgroup.core.localization.ITranslationService.get*"/>

<!--  Flush cache -->
    [2]<ehcache:flushing cacheNames="translationCache" methodFQN="zeuzgroup.core.localization.ITranslationService.put*" when="after"/>
    </ehcache:methodMapInterceptors>

    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames">
            <list>
               [3] <idref bean="translations"/>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>cachingInterceptor</value>
                <value>flushingInterceptor</value>
            </list>
        </property>
    </bean>
</beans>
ehcache.xml
  1. setup target methods to cache
  2. setup which metods that evict cache
  3. point at beans to look in
  4. point at ehcache.xml

As you can notice theres two beans further more defined(myCachinglistener and mycachingkeygenerator), you can just use the default implementation provided. Although you might want to use your own keygenerator if using datetime properties in your objects, if your methods return objects with new stamps your cache will not be hit. In my setup my wicket page went from 12s to display to 4s (having a 2s round trip).

ehcache.xml

<diskStore path="java.io.tmpdir" />
<defaultCache maxElementsInMemory="1000" eternal="false"
 timeToIdleSeconds="0" timeToLiveSeconds="500" overflowToDisk="true"
 diskPersistent="false" diskExpiryThreadIntervalSeconds="500" />
 <cache name="translationCache" maxElementsInMemory="75000"
eternal="true" timeToIdleSeconds="0" timeToLiveSeconds="0" overflowToDisk="false"
diskPersistent="false"
 diskExpiryThreadIntervalSeconds="3600" />

Above are also pretty straight forward.. Now onto the next part.

Caching with Wicket, or preparation for web cache.

Caching statefull pages? Well you can. But remember that if you do when others look at the page you cache they’ll get the same result. Please remember that you cant cache pages with ajax on (AFAIK).

So this means that if you have a “simple” solution where you have users that can be either authorized or not it’s pretty straight forward. I went ahead and chose all the pages where my users arent logged in to be cachable. I decided to go with ehcache’s web cache namely the simplefiltercache. And to make it visible for the cache when a page could be cachable I added a noop parameter to all my pages called cache it has the value true. The simplest way to work with a cache are using urls, you might be able to do something http codes and cache all that does not sets the cache control header. But that’s stretching it to far for me.

Code:

public abstract class MyPage extends WebPage {
public static final String CACHEABLE = "cache";

private PageParameters myPageParameters;
[1]    public Boolean canCache() {

        if (MySession.class.isInstance(this.getSession())) {
            MySession mySession = (MySession) this.getSession();
            return !mySession.isAuthorized();
        }
        return true;
    }
    public MyPage(PageParameters pageParameters) {
[2]	myPageParameters = pageParameters;
[3]        BookmarkablePageLink creditsLink = new BookmarkablePageLink("credits",
                CreditsPage.class, getPageParameters(getSession().getLocale()));
        add(creditsLink);
}
[4]   protected PageParameters getPageParameters(Locale locale) {
        PageParameters pageParameters = new PageParameters();
        if (canCache() && !pageParameters.containsKey(CACHEABLE)) {
            pageParameters.add(CACHEABLE, "true");
        }
        if (!canCache()) {
            pageParameters.remove(CACHEABLE);
        }
        if (zeuzPageParameters != null) {
            pageParameters.putAll(zeuzPageParameters);
            if (pageParameters.containsKey("locale")) {
                pageParameters.remove("locale");
            }
        }

        pageParameters.add("locale", locale.getLanguage());
        return pageParameters;

}
Okay so 4 simple steps are needed to make our wicket pages cachable:

  1. Make a method that can determine if a page are cachable or not
  2. Keep a reference to the page parameters the page were initialized with.
  3. Use bookmarkablePageLink’s so that url’s are stable
  4. This is where the magic are done, add the cachable parameter to appropriate pages, notice that if you have a multilingual application you need that as a parameter otherwise the locale of the pages will be the one that last caused a miss.

Note : I had to set this to get stable parameter positions in urls:

        // Be able to sort page parametes
        UnitTestSettings.setSortUrlParameters(true);

Okay so now our wicket pages can be cached, now we just setup the cache:

add in ehcache.xml

<cache name=”SimplePageCachingFilter” overflowToDisk=”true” maxElementsInMemory=”500″ timeToLiveSeconds=”86400″ timeToIdleSeconds=”43200″/>

if you want define flush methods in cacheContex.xml:

    <ehcache:flushing cacheNames="SimplePageCachingFilter" methodFQN="zeuzgroup.core.provider.IDBDao.persistExercise*" when="after"/>

For me this made the page I talked about earlier go from 4s to 0.2s to display.

Conclusion

So I tried several approaches before comming to the approach showed above (regarding wicket). I tried creating a custom a IRequestEncodingStrategy, did’nt work for me but it’s my fault nothing todo with wicket. Sometimes simple are better I guess. An annoying thing were that apparently that my pages when in danish locale were’nt encoded with html entities (this caused chars like æ ø å to get corrupted), i’ve submitted a patch to wicket to support this http://issues.apache.org/jira/browse/WICKET-1795 , it’s just for component though a general setting would be nice. I think above are pretty straight forward, but of course it would be nice if wicket support something like it out of the box, but then again it requires many thing that only you as the developer can decide. Using above approach you’re free to chose ehwebcachefilter like i did or something else like Apache http, if you dont select ehcache, you’ll loose the evict option. But there might be other options. The above approach should be usable with other web frameworks aswell.

Advertisements

Actions

Information

2 responses

28 12 2010
timothy

Hi Nino,

It is nice to read your sharing on caching.

And it is OK if you can share the codes used in the above?

For example,

zeuzgroup.core.cache.ZeuzCacheKeyGenerator
zeuzgroup.core.cache.ZeuzCachingListener

Thank you!

29 12 2010
ninomartinez

sure,

public class ZeuzCacheKeyGenerator implements CacheKeyGenerator {

private static final org.apache.log4j.Logger LOGGER = Logger.getLogger(ZeuzCacheKeyGenerator.class);

/**
* Flag that indicates if this generator should generate the hash code of the
* arguments passed to the method to apply caching to. If
false,
* this generator uses the default hash code of the arguments.
*/
private boolean generateArgumentHashCode;

/**
* Construct a HashCodeCacheKeyGenerator.
*/
public ZeuzCacheKeyGenerator() {
}

/**
* Construct a HashCodeCacheKeyGenerator.
*
* @param generateArgumentHashCode the new value for the flag that indicates if this generator should
* generate the hash code of the arguments passed to the method to
* apply caching to. If false, this generator uses
* the default hash code of the arguments.
*/
public ZeuzCacheKeyGenerator(boolean generateArgumentHashCode) {
this();
setGenerateArgumentHashCode(generateArgumentHashCode);
}

/**
* @see CacheKeyGenerator#generateKey(MethodInvocation)
*/
public final Serializable generateKey(MethodInvocation methodInvocation) {
HashCodeCalculator hashCodeCalculator = new HashCodeCalculator();

Method method = methodInvocation.getMethod();
hashCodeCalculator.append(System.identityHashCode(method));

Object[] methodArguments = methodInvocation.getArguments();
if (methodArguments != null) {
int methodArgumentCount = methodArguments.length;

for (int i = 0; i < methodArgumentCount; i++) {
Object methodArgument = methodArguments[i];
if (methodArgument instanceof Date) {
continue;
}
int hash = 0;

if (generateArgumentHashCode) {
hash = Reflections.reflectionHashCode(methodArgument);
} else {
hash = Objects.nullSafeHashCode(methodArgument);
}

hashCodeCalculator.append(hash);
}
}

long checkSum = hashCodeCalculator.getCheckSum();
int hashCode = hashCodeCalculator.getHashCode();

Serializable cacheKey = new HashCodeCacheKey(checkSum, hashCode);
LOGGER.debug(cacheKey + " for method [" + methodInvocation.getMethod() + "]");
return cacheKey;
}

/**
* Sets the flag that indicates if this generator should generate the hash
* code of the arguments passed to the method to apply caching to. If
* false, this generator uses the default hash code of the
* arguments.
*
* @param newGenerateArgumentHashCode the new value of the flag
*/
public final void setGenerateArgumentHashCode(
boolean newGenerateArgumentHashCode) {
generateArgumentHashCode = newGenerateArgumentHashCode;
}

}

and

package zeuzgroup.core.cache;

import java.io.Serializable;

import org.apache.log4j.Logger;
import org.springmodules.cache.CachingModel;
import org.springmodules.cache.interceptor.caching.CachingListener;

public class ZeuzCachingListener implements CachingListener {

private static final org.apache.log4j.Logger log = Logger
.getLogger(ZeuzCachingListener.class);

public void onCaching(Serializable key, Object obj, CachingModel model) {
log.debug("Cache new entry with key [" + key + "] value [" + obj + "] model [" + model + "]");
}
}

BTW I\ve put up a small cache framework for guice, which uses annotations to detect cachable prospects,

https://ninomartinez.wordpress.com/2010/05/14/guice-caching-interceptors/

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s




%d bloggers like this: