Client side caching in GWT

We have a gwt-client, which recieves quite a lot of data from our servers. Logically, i want to cache the data on the client side, sparing the server from unnecessary requests.

As of today i have let it up to my models to handle the caching of data, which doesn't scale very well. It's also become a problem since different developers in our team develop their own "caching" functionality, which floods the project with duplications.

I'm thinking about how one could implement a "single point of entry", that handl开发者_Python百科es all the caching, leaving the models clueless about how the caching is handled.

Does anyone have any experience with client side caching in GWT? Is there a standard approach that can be implemented?

I suggest you look into gwt-presenter and the CachingDispatchAsync . It provides a single point of entry for executing remote commands and therefore a perfect opportunity for caching.

A recent blog post outlines a possible approach.

You might want to take a look at the Command Pattern; Ray Ryan held a talk at Google IO about best practices in GWT, here is a transcript: http://extgwt-mvp4g-gae.blogspot.com/2009/10/gwt-app-architecture-best-practices.html

He proposes the use of the Command Pattern using Action and Response/Result objects which are thrown in and out the service proxy. These are excellent objects to encapsulate any caching that you want to perform on the client.

Here's an excerpt: "I've got a nice unit of currency for implementing caching policies. May be whenever I see the same GET request twice, I'll cache away the response I got last time and just return that to myself immediately. Not bother with a server-side trip."

In a fairly large project, I took another direction. I developed a DtoCache object which essentially held a reference to each AsyncCallback that was expecting a response from a service call in a waiting queue. Once the DtoCache received the objects from the server, they were cached inside the DtoCache. The cached result was henceforth returned to all queued and newly created AsyncCallbacks for the same service call.

For an already-fully-built, very sophisticated caching engine for CRUD operations, consider Smart GWT. This example demonstrates the ability to do client-side operations adaptively (when the cache allows it) while still supporting paging for large datasets:

http://www.smartclient.com/smartgwt/showcase/#grid_adaptive_filter_featured_category

This behavior is exposed via the ResultSet class if you need to put your own widgets on top of it:

http://www.smartclient.com/smartgwtee/javadoc/com/smartgwt/client/data/ResultSet.html

There are two levels of caching:

• Caching during one browser session.
• Caching cross browser sessions, e.g the cached data should be available after browser restarted.

What to cache: depend on your application, you may want to cache

• Protected data for particular user
• Public static (or semi-static, e.g rarely to change) data

How to cache:

• For the first caching level, we can use GWT code as suggested in the answers or write your own one.
• For the second one, we must use Browser caching features. The standard approach is put your data inside html (whether static html files or dynamic generated by jsp/servlet for example). Your application then use http://code.google.com/webtoolkit/doc/latest/DevGuideCodingBasicsOverlay.html techniques to get the data.

I thought Itemscript was kind of neat. It's a RESTful JSON database that works on both the client (GWT) and server.

Check it out!

-JP