Setting the max-age header will cache the results for a specified time. For heavily loaded pages, even setting short expires times can significantly improve performance.

Note, pages using sessions should not be cached, although more sophisticated headers like "Cache-Control: private" can specify caching only for the session's browser.

The following example sets expiration for 15 seconds. So the counter should update slowly.

max-age is useful for database generated pages which are continuously, but slowly updated. To cache based on something with a known modified date, like a file, you can use If-Modified.

When designing and testing your cached page, it's important to see how Resin is caching the page. To turn on logging for caching, you'll add the following to your resin.conf:

The output will look something like the following:

An application can also set the Expires header to enable caching, when the expiration date is a specific time instead of an interval. For heavily loaded pages, even setting short expires times can significantly improve performance. Sessions should be disabled for caching.

The following example sets expiration for 15 seconds. So the counter should update slowly.

Expires is useful for database generated pages which are continuously, but slowly updated. To cache based on something with a known modified date, like a file, you can use If-Modified.

The If-Modified headers let you cache based on an underlying change date. For example, the page may only change when an underlying source page changes. Resin lets you easily use If-Modified by overriding methods in HttpServlet or in a JSP page.

The following page only changes when the underlying 'test.xml' page changes.

If-Modified pages are useful in combination with the cache-mapping configuration.

Caching servlets is exactly like caching JSP pages (or XTP or static files.) Resin's caching mechanism works like a proxy cache: it don't care how the page is generated; as long as the proper caching headers are set, the page will be cached.

Because Resin follows the HTTP caching spec, setting caching on a page which relies on sessions will make the page cacheable. You can test this by hitting the following page with separate browsers.

Normally, this behavior is not what you want. Instead, you may want the browser to cache the page, but not let other browsers see the same page. To do that, you'll set the "Cache-Control: private" header. You'll need to use addHeader, not setHeader, so the browser will get both "Cache-Control" directives.

Resin can cache subpages even when the top page can't be cached. Sites allowing user personalization will often design pages with jsp:include subpages. Some subpages are user-specific and can't be cached. Others are common to everybody and can be cached.

Resin treats subpages as independent requests, so they can be cached independent of the top-level page. Try the following, use the first expires counter example as the included page. Create a top-level page that looks like:

In some cases, you'll want to have separate cached pages for the same URL depending on the capabilities of the browser. Using gzip compression is the most important example. Browsers which can understand gzip-compressed files receive the compressed page while simple browsers will see the uncompressed page. Using the "Vary" header, Resin can cache different versions of that page.

In many cases, logged in users get specialized pages, but anonymous users all see the same page. In this case, you can still take advantage of Resin's caching, but you'll need to do a little work in your design.

First, you'll need to create an include() subpage that contains the common page. The top page can't be cached because it depends on whether a user is logged in or not.

You must use include() because forward() is cached just like the top page. The top page isn't cacheable because of the user login, so the forwarded page isn't cacheable either.

Here's what a sample subpage might look like:

The top page slightly trickier because it needs to pass the user to the subpage. You need to pass a unique id. If you pass a boolean logged-in parameter, all logged in users will see the same page.

Of course, the top-level page could also be a servlet:

Resin includes an anonymous user caching feature. If a user is not logged in, she will get a cached page. If she's logged in, she'll get her own page. This feature will not work if anonymous users are assigned cookies for tracking purposes.

To make anonymous caching work, you must set the Cache-Control: x-anonymous header. If you omit the x-anonymous header, Resin will use the Expires to cache the same page for every user.

The top page must still set the Expires or If-Modified header, but Resin will take care of deciding if the page is cacheable or not. If the request has any cookies, Resin will not cache it or use the cached page. If it has no cookies, Resin will use the cached page.

When using x-anonymous, user tracking cookies will make the page uncacheable even if the page is the same for all users. Resin chooses to cache or not based on the existence of any cookies in the request, whether they're used or not.

cache-mapping assigns a max-age and Expires to an If-Modified cacheable page. It does not affect max-age or Expires cached pages. The FileServlet takes advantage of cache-mapping because it's an If-Modified servlet.

Often, you want a long Expires time for a page to a browser. For example, any gif will not change for 24 hours. That keeps browsers from asking for the same gif every five seconds; that's especially important for tiny formatting gifs. However, as soon as that page or gif changes, you want the change immediately available to any new browser or to a browser using reload.

Here's how you would set the Expires to 24 hours for a gif, based on the default FileServlet.

The cache-mapping automatically generates the Expires header. It only works for cacheable pages setting If-Modified or ETag. It will not affect pages explicily setting Expires or non-cacheable pages. So it's safe to create a cache-mapping for *.jsp even if only some are cacheable.