Question

I am developing a Java web application that bases it behavior through large XML configuration files that are loaded from a web service. As these files are not actually required until a particular section of the application is accessed, they are loaded lazily. When one of these files are required, a query is sent to the webservice to retrieve the corresponding file. As some of the configuration files are likely to be used much, much more often than others I’d like to setup some kind of caching (with maybe a 1 hour expiration time) to avoid requesting the same file over and over.

The files returned by the web service are the same for all users across all sessions. I do not use JSP, JSF or any other fancy framework, just plain servlets.

My question is, what is considered a best practice to implement such a global, static cache within a java Web application? Is a singleton class appropriate, or will there be weird behaviors due to the J2EE containers? Should I expose something somewhere through JNDI? What shall I do so that my cache doesn’t get screwed in clustered environments (it’s OK, but not necessary, to have one cache per clustered server)?

Given the informations above, Would it be a correct implementation to put an object responsible for caching as a ServletContext attribute?

Note: I do not want to load all of them at startup and be done with it because that would

1). overload the webservice whenever my application starts up
2). The files might change while my application is running, so I would have to requery them anyway
3). I would still need a globally accessible cache, so my question still holds

Update: Using a caching proxy (such as squid) may be a good idea, but each request to the webservice will send rather large XML query in the post Data, which may be different each time. Only the web application really knows that two different calls to the webservice are actually equivalent.

Thanks for your help

Answer 1

Your question contains several separate questions together. Let’s start slowly. ServletContext is good place where you can store handle to your cache. But you pay by having cache per server instance. It should be no problem. If you want to register cache in wider range consider registering it into JNDI.

The problem with caching. Basically, you are retrieving xml via webservice. If you are accesing this webservice via HTTP you can install simple HTTP proxy server on your side which handle caching of xml. The next step will be caching of resolved xml in some sort of local object cache. This cache can exists per server without any problem. In this second case the EHCache will do perfect job. In this case the chain of processing will be like this Client - http request -> servlet -> look into local cache - if not cached -> look into http proxy (xml files) -> do proxy job (http to webservice).

Pros:

• Local cache per server instance, which contains only objects from requested xmls
• One http proxy running on same hardware as our webapp.
• Possibility to scale webapp without adding new http proxies for xml files.

Cons:

• Next level of infrastructure
• +1 point of failure (http proxy)
• More complicated deployment

Update: don’t forget to always send HTTP HEAD request into proxy to ensure that cache is up to date.