[置顶] j2ee页面静态化方案encache web cache框架源码分析2
encache的web cache代码分析
1.抽象filter分析
public abstract class Filter implements javax.servlet.Filter {
......
public final void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
throws ServletException, IOException {
final HttpServletRequest httpRequest = (HttpServletRequest) request;
final HttpServletResponse httpResponse = (HttpServletResponse) response;
try {
//NO_FILTER set for RequestDispatcher forwards to avoid double gzipping
if (filterNotDisabled(httpRequest)) { //判断是否需要进行改cache filter的处理，防止再次进入，简单的通过获取attribute属性来判断
doFilter(httpRequest, httpResponse, chain);
} else {
chain.doFilter(request, response);
}
} catch (final Throwable throwable) {
logThrowable(throwable, httpRequest);
}
}
protected boolean filterNotDisabled(final HttpServletRequest httpRequest) {
return httpRequest.getAttribute(NO_FILTER) == null;
}
......
//提供几个抽象方法供子类覆盖
/**
* A template method that performs any Filter specific destruction tasks.
* Called from {@link #destroy()}
*/
protected abstract void doDestroy();
/**
* A template method that performs the filtering for a request.
* Called from {@link #doFilter(ServletRequest,ServletResponse,FilterChain)}.
*/
protected abstract void doFilter(final HttpServletRequest httpRequest, final HttpServletResponse httpResponse,
final FilterChain chain) throws Throwable;
/**
* A template method that performs any Filter specific initialisation tasks.
* Called from {@link #init(FilterConfig)}.
* @param filterConfig
*/
protected abstract void doInit(FilterConfig filterConfig) throws Exception;
}2.实现上面filter的CachingFilter类分析
public abstract class CachingFilter extends Filter{
//初始化参数列表
public void doInit(FilterConfig filterConfig) throws CacheException {
synchronized (this.getClass()) {
if (blockingCache == null) {
setCacheNameIfAnyConfigured(filterConfig); //从web.xml里面取出encache对应配置的cache名称
final String localCacheName = getCacheName();
Ehcache cache = getCacheManager().getEhcache(localCacheName); //根据cachename从encache管理器获取cache实例
if (cache == null) {
throw new CacheException("cache '" + localCacheName
+ "' not found in configuration");
}
if (!(cache instanceof BlockingCache)) {
// decorate and substitute
BlockingCache newBlockingCache = new BlockingCache(cache);
getCacheManager().replaceCacheWithDecoratedCache(cache,
newBlockingCache);
}
blockingCache = (BlockingCache) getCacheManager().getEhcache(
localCacheName); //这里使用的是blockingCache
Integer blockingTimeoutMillis = parseBlockingCacheTimeoutMillis(filterConfig);//从init-param里面获取设置的blocking的超时时间
if (blockingTimeoutMillis != null && blockingTimeoutMillis > 0) {
blockingCache.setTimeoutMillis(blockingTimeoutMillis);
}
}
}
}
protected void doFilter(final HttpServletRequest request,
final HttpServletResponse response, final FilterChain chain)
throws AlreadyGzippedException, AlreadyCommittedException,
FilterNonReentrantException, LockTimeoutException, Exception {
if (response.isCommitted()) {
throw new AlreadyCommittedException(
"Response already committed before doing buildPage.");
}
logRequestHeaders(request);//记录request的日志
PageInfo pageInfo = buildPageInfo(request, response, chain);//从缓存里面取出缓存页面信息，如果缓存中不存在，则通过 chain.doFilter(request, wrapper);处理后，再把页面存入缓存，
if (pageInfo.isOk()) {
if (response.isCommitted()) {
throw new AlreadyCommittedException(
"Response already committed after doing buildPage"
+ " but before writing response from PageInfo.");
}
writeResponse(request, response, pageInfo);//更新request的header，status，cookie等相关信息，因为如果从缓存获取的话，需要把所有信息都写到response
}
}
//再来看看buildPageInfo的处理
/**
* Build page info either using the cache or building the page directly.
* <p/>
* Some requests are for page fragments which should never be gzipped, or
* for other pages which are not gzipped.
*/
protected PageInfo buildPageInfo(final HttpServletRequest request,
final HttpServletResponse response, final FilterChain chain)
throws Exception {
// Look up the cached page
final String key = calculateKey(request);//构造key，抽象方法，由子类覆盖
PageInfo pageInfo = null;
try {
checkNoReentry(request); //检查是否是同一个请求再次今夕，通过localthread来判断，如果已经进入过，则抛出FilterNonReentrantException异常，否则记录已经该请求进入处理
Element element = blockingCache.get(key); //从缓存取出对象
if (element == null || element.getObjectValue() == null) {
try {
// Page is not cached - build the response, cache it, and
// send to client
pageInfo = buildPage(request, response, chain);//如果缓存不存在，则正常处理，
if (pageInfo.isOk()) {//如果处理ok，
if (LOG.isDebugEnabled()) {
LOG.debug("PageInfo ok. Adding to cache "
+ blockingCache.getName() + " with key "
+ key);
}
blockingCache.put(new Element(key, pageInfo));//则把页面内容重新存入缓存
} else {
if (LOG.isDebugEnabled()) {
LOG.debug("PageInfo was not ok(200). Putting null into cache "
+ blockingCache.getName()
+ " with key "
+ key);
}
blockingCache.put(new Element(key, null));//如果处理出错，则缓存设置为null
}
} catch (final Throwable throwable) {
// Must unlock the cache if the above fails. Will be logged
// at Filter
blockingCache.put(new Element(key, null));
throw new Exception(throwable);
}
} else {
pageInfo = (PageInfo) element.getObjectValue();//如果缓存存在，则取出内容
}
} catch (LockTimeoutException e) {
// do not release the lock, because you never acquired it
throw e;
} finally {
// all done building page, reset the re-entrant flag
visitLog.clear();
}
return pageInfo;
}
/**
* Builds the PageInfo object by passing the request along the filter chain
*
* @param request
* @param response
* @param chain
* @return a Serializable value object for the page or page fragment
* @throws AlreadyGzippedException
* if an attempt is made to double gzip the body
* @throws Exception
*/
//缓存不存在时的处理
protected PageInfo buildPage(final HttpServletRequest request,
final HttpServletResponse response, final FilterChain chain)
throws AlreadyGzippedException, Exception {
// Invoke the next entity in the chain
final ByteArrayOutputStream outstr = new ByteArrayOutputStream();
final GenericResponseWrapper wrapper = new GenericResponseWrapper(
response, outstr);//这个responsewrapper，用于保存正常处理后的状态，cookie，header，结果信息，用于缓存
chain.doFilter(request, wrapper);//缓存不存在，则跳过由后续filter处理
wrapper.flush();
long timeToLiveSeconds = blockingCache.getCacheConfiguration()
.getTimeToLiveSeconds();
// Return the page info
return new PageInfo(wrapper.getStatus(), wrapper.getContentType(),
wrapper.getCookies(), outstr.toByteArray(), true,
timeToLiveSeconds, wrapper.getAllHeaders());//构造信息的该请求的缓存对象信息
}
/**
* Writes the response from a PageInfo object.
* <p/>
* Headers are set last so that there is an opportunity to override
*
* @param request
* @param response
* @param pageInfo
* @throws IOException
* @throws DataFormatException
* @throws ResponseHeadersNotModifiableException
*
*/
//从pageinfo里面取出response的相关信息写入到当前的response中
protected void writeResponse(final HttpServletRequest request,
final HttpServletResponse response, final PageInfo pageInfo)
throws IOException, DataFormatException,
ResponseHeadersNotModifiableException {
boolean requestAcceptsGzipEncoding = acceptsGzipEncoding(request);
setStatus(response, pageInfo);//设置response的状态
setContentType(response, pageInfo);//设置response的contentType
setCookies(pageInfo, response);//设置response的cookie
// do headers last so that users can override with their own header sets
setHeaders(pageInfo, requestAcceptsGzipEncoding, response);//设置response的header
writeContent(request, response, pageInfo);//设置response的内容
}
//比如：
protected void setContentType(final HttpServletResponse response,
final PageInfo pageInfo) {
String contentType = pageInfo.getContentType();
if (contentType != null && contentType.length() > 0) {
response.setContentType(contentType);
}
}
/**
* Set the serializableCookies
*
* @param pageInfo
* @param response
*/
protected void setCookies(final PageInfo pageInfo,
final HttpServletResponse response) {
final Collection cookies = pageInfo.getSerializableCookies();
for (Iterator iterator = cookies.iterator(); iterator.hasNext();) {
final Cookie cookie = ((SerializableCookie) iterator.next())
.toCookie();
response.addCookie(cookie);
}
}
/**
* Status code
*
* @param response
* @param pageInfo
*/
protected void setStatus(final HttpServletResponse response,
final PageInfo pageInfo) {
response.setStatus(pageInfo.getStatusCode());
}
protected void writeContent(final HttpServletRequest request,
final HttpServletResponse response, final PageInfo pageInfo)
throws IOException, ResponseHeadersNotModifiableException {
byte[] body;
boolean shouldBodyBeZero = ResponseUtil.shouldBodyBeZero(request,
pageInfo.getStatusCode());
if (shouldBodyBeZero) {
body = new byte[0];
} else if (acceptsGzipEncoding(request)) {
body = pageInfo.getGzippedBody();
if (ResponseUtil.shouldGzippedBodyBeZero(body, request)) {
body = new byte[0];
} else {
ResponseUtil.addGzipHeader(response);
}
} else {
body = pageInfo.getUngzippedBody();
}
response.setContentLength(body.length);
OutputStream out = new BufferedOutputStream(response.getOutputStream());
out.write(body);
out.flush();
}
}
对于checkNoReentry的实现，很简单
* Check that this caching filter is not being reentered by the same
* recursively. Recursive calls will block indefinitely because the first
* request has not yet unblocked the cache.
* <p/>
* This condition usually indicates an error in filter chaining or
* RequestDispatcher dispatching.
*
* @param httpRequest
* @throws FilterNonReentrantException
* if reentry is detected
*/
protected void checkNoReentry(final HttpServletRequest httpRequest)
throws FilterNonReentrantException {
String filterName = getClass().getName();
if (visitLog.hasVisited()) {
throw new FilterNonReentrantException(
"The request thread is attempting to reenter" + " filter "
+ filterName + ". URL: "
+ httpRequest.getRequestURL());
} else {
// mark this thread as already visited
visitLog.markAsVisited();
if (LOG.isDebugEnabled()) {
LOG.debug("Thread {} has been marked as visited.", Thread
.currentThread().getName());
}
}
}
/**
* threadlocal class to check for reentry
*
* @author hhuynh
*
*/
private static class VisitLog extends ThreadLocal<Boolean> {
@Override
protected Boolean initialValue() {
return false;
}
public boolean hasVisited() {
return get();
}
public void markAsVisited() {
set(true);
}
public void clear() {
super.remove();
}
}当然还有两个抽象方法
* Gets the CacheManager for this CachingFilter. It is therefore up to
* subclasses what CacheManager to use.
* <p/>
* This method was introduced in ehcache 1.2.1. Older versions used a
* singleton CacheManager instance created with the default factory method.
*
* @return the CacheManager to be used
* @since 1.2.1
*/
protected abstract CacheManager getCacheManager();
/**
* CachingFilter works off a key.
* <p/>
* The key should be unique. Factors to consider in generating a key are:
* <ul>
* <li>The various hostnames that a request could come through
* <li>Whether additional parameters used for referral tracking e.g. google
* should be excluded to maximise cache hits
* <li>Additional parameters can be added to any page. The page will still
* work but will miss the cache. Consider coding defensively around this
* issue.
* </ul>
* <p/>
* Implementers should differentiate between GET and HEAD requests otherwise
* blank pages can result. See SimplePageCachingFilter for an example
* implementation.
*
* @param httpRequest
* @return the key, generally the URL plus request parameters
*/
protected abstract String calculateKey(final HttpServletRequest httpRequest);3.SimplePageCachingFilter的处理
public class SimplePageCachingFilter extends CachingFilter {
public static final String DEFAULT_CACHE_NAME = "SimplePageCachingFilter";
private static final Logger LOG = LoggerFactory.getLogger(SimplePageCachingFilter.class);
protected String getCacheName() {
if (cacheName != null && cacheName.length() > 0) {
LOG.debug("Using configured cacheName of {}.", cacheName);
return cacheName;
} else {
LOG.debug("No cacheName configured. Using default of {}.", DEFAULT_CACHE_NAME);
return DEFAULT_CACHE_NAME;
}
}
protected CacheManager getCacheManager() {
return CacheManager.getInstance();
}
protected String calculateKey(HttpServletRequest httpRequest) {
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(httpRequest.getMethod()).append(httpRequest.getRequestURI()).append(httpRequest.getQueryString());
String key = stringBuffer.toString();
return key;
}
}
而SimpleCachingHeadersPageCachingFilter的处理
public class SimpleCachingHeadersPageCachingFilter extends SimplePageCachingFilter{
@Override
protected PageInfo buildPage(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
throws AlreadyGzippedException, Exception {
PageInfo pageInfo = super.buildPage(request, response, chain);
final List<Header<? extends Serializable>> headers = pageInfo.getHeaders();
long ttlMilliseconds = calculateTimeToLiveMilliseconds();
//Remove any conflicting headers
for (final Iterator<Header<? extends Serializable>> headerItr = headers.iterator(); headerItr.hasNext();) {
final Header<? extends Serializable> header = headerItr.next();
final String name = header.getName();
if ("Last-Modified".equalsIgnoreCase(name) ||
"Expires".equalsIgnoreCase(name) ||
"Cache-Control".equalsIgnoreCase(name) ||
"ETag".equalsIgnoreCase(name)) {
headerItr.remove();
}
}
//add expires and last-modified headers
//trim the milliseconds off the value since the header is only accurate down to the second
long lastModified = pageInfo.getCreated().getTime();
lastModified = TimeUnit.MILLISECONDS.toSeconds(lastModified);
lastModified = TimeUnit.SECONDS.toMillis(lastModified);
headers.add(new Header<Long>("Last-Modified", lastModified));
headers.add(new Header<Long>("Expires", System.currentTimeMillis() + ttlMilliseconds));
headers.add(new Header<String>("Cache-Control", "max-age=" + ttlMilliseconds / MILLISECONDS_PER_SECOND));
headers.add(new Header<String>("ETag", generateEtag(ttlMilliseconds)));
return pageInfo;
}
@Override
protected void writeResponse(HttpServletRequest request, HttpServletResponse response, PageInfo pageInfo)
throws IOException, DataFormatException, ResponseHeadersNotModifiableException {
final List<Header<? extends Serializable>> headers = pageInfo.getHeaders();
for (final Header<? extends Serializable> header : headers) {
if ("ETag".equals(header.getName())) {
String requestIfNoneMatch = request.getHeader("If-None-Match");
if (header.getValue().equals(requestIfNoneMatch)) {
response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
// use the same date we sent when we created the ETag the first time through
//response.setHeader("Last-Modified", request.getHeader("If-Modified-Since"));
return;
}
break;
}
if ("Last-Modified".equals(header.getName())) {
long requestIfModifiedSince = request.getDateHeader("If-Modified-Since");
if (requestIfModifiedSince != -1) {
final Date requestDate = new Date(requestIfModifiedSince);
final Date pageInfoDate;
switch (header.getType()) {
case STRING:
pageInfoDate = this.getHttpDateFormatter().parseDateFromHttpDate((String)header.getValue());
break;
case DATE:
pageInfoDate = new Date((Long)header.getValue());
break;
default:
throw new IllegalArgumentException("Header " + header + " is not supported as type: " + header.getType());
}
if (!requestDate.before(pageInfoDate)) {
response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
response.setHeader("Last-Modified", request.getHeader("If-Modified-Since"));
return;
}
}
}
}
super.writeResponse(request, response, pageInfo);
}
}这个类对于缓存的内容的头信息 Last-Modified Expires Cache-Control ETag删除，替换成当前encache里面的系统信息，输出的时候也输出encache处理过的头信息，这样我们就不管浏览器的缓存处理了，只能等待encache的缓存过期。
4.PageFragmentCachingFilter的简单处理
protected PageInfo buildPage(final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain) throws AlreadyGzippedException, Exception {
// Invoke the next entity in the chain
final ByteArrayOutputStream outstr = new ByteArrayOutputStream();
final GenericResponseWrapper wrapper = new GenericResponseWrapper(response, outstr);
chain.doFilter(request, wrapper);
wrapper.flush();
long timeToLiveSeconds = blockingCache.getCacheConfiguration().getTimeToLiveSeconds();
// Return the page info
return new PageInfo(wrapper.getStatus(), wrapper.getContentType(),
wrapper.getCookies(),
outstr.toByteArray(), false, timeToLiveSeconds, wrapper.getAllHeaders()); //其中第五个参数false表示不存储gzip过的信息
}
/**
* Assembles a response from a cached page include.
* These responses are never gzipped
* The content length should not be set in the response, because it is a fragment of a page.
* Don't write any headers at all.
*/
//也不处理gzip过的信息
protected void writeResponse(final HttpServletResponse response, final PageInfo pageInfo) throws IOException {
// Write the page
final byte[] cachedPage = pageInfo.getUngzippedBody();
//needed to support multilingual
final String page = new String(cachedPage, response.getCharacterEncoding());
String implementationVendor = response.getClass().getPackage().getImplementationVendor();
if (implementationVendor != null && implementationVendor.equals("\"Evermind\"")) {
response.getOutputStream().print(page);
} else {
response.getWriter().write(page);
}
}5.PageInfo缓存对象的几个要点
public class PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
private static final Logger LOG = LoggerFactory.getLogger(PageInfo.class);
private static final int FOUR_KB = 4196;
private static final int GZIP_MAGIC_NUMBER_BYTE_1 = 31;
private static final int GZIP_MAGIC_NUMBER_BYTE_2 = -117;
private static final long ONE_YEAR_IN_SECONDS = 60 * 60 * 24 * 365;
//存储的信息包括状态码，contentType，cookie，body，是否gzip过，过期时间，headers等信息
public PageInfo(final int statusCode, final String contentType,
final Collection cookies,
final byte[] body, boolean storeGzipped, long timeToLiveSeconds,
final Collection<Header<? extends Serializable>> headers) throws AlreadyGzippedException {
//Note that the ordering is switched with headers at the end to deal with the erasure issues with Java generics causing
//a conflict with the deprecated PageInfo header
this.init(statusCode, contentType, headers, cookies, body, storeGzipped, timeToLiveSeconds);
}
/**
* @param ungzipped the bytes to be gzipped
* @return gzipped bytes
*/
//提供的gzip处理方法
private byte[] gzip(byte[] ungzipped) throws IOException, AlreadyGzippedException {
if (isGzipped(ungzipped)) {
throw new AlreadyGzippedException("The byte[] is already gzipped. It should not be gzipped again.");
}
final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
final GZIPOutputStream gzipOutputStream = new GZIPOutputStream(bytes);
gzipOutputStream.write(ungzipped);
gzipOutputStream.close();
return bytes.toByteArray();
}
private byte[] ungzip(final byte[] gzipped) throws IOException {
final GZIPInputStream inputStream = new GZIPInputStream(new ByteArrayInputStream(gzipped));
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(gzipped.length);
final byte[] buffer = new byte[FOUR_KB];
int bytesRead = 0;
while (bytesRead != -1) {
bytesRead = inputStream.read(buffer, 0, FOUR_KB);
if (bytesRead != -1) {
byteArrayOutputStream.write(buffer, 0, bytesRead);
}
}
byte[] ungzipped = byteArrayOutputStream.toByteArray();
inputStream.close();
byteArrayOutputStream.close();
return ungzipped;
}
}
6.GzipFilter的filter，这个filter对于浏览器支持gzip的则进行gzip压缩之后输出
