Java tutorial
/* * Copyright 2004-2008 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.impalaframework.web.servlet; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.MalformedURLException; import java.net.URL; import java.net.URLConnection; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; import java.util.zip.GZIPOutputStream; import javax.servlet.ServletException; import javax.servlet.ServletOutputStream; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.util.AntPathMatcher; import org.springframework.util.ClassUtils; import org.springframework.util.PathMatcher; import org.springframework.util.StringUtils; import org.springframework.web.servlet.HttpServletBean; /** * Special resource servlet for efficiently resolving and rendering static resources from within a JAR file. * Based on original source code from Spring Web Flow js module. No other changes have been applied to the file at time of initial checkin. * * @author Jeremy Grelle * @author Scott Andrews * @author Phil Zoio */ public class ResourceServlet extends HttpServletBean { private static final long serialVersionUID = 1L; private static final String HTTP_CONTENT_LENGTH_HEADER = "Content-Length"; private static final String HTTP_LAST_MODIFIED_HEADER = "Last-Modified"; private static final String HTTP_EXPIRES_HEADER = "Expires"; private static final String HTTP_CACHE_CONTROL_HEADER = "Cache-Control"; private static final Log log = LogFactory.getLog(ResourceServlet.class); private final String protectedPath = "/?WEB-INF/.*"; private String jarPathPrefix = "META-INF"; private boolean gzipEnabled = true; private Set<String> allowedResourcePaths = new HashSet<String>(); { allowedResourcePaths.add("/**/*.css"); allowedResourcePaths.add("/**/*.gif"); allowedResourcePaths.add("/**/*.ico"); allowedResourcePaths.add("/**/*.jpeg"); allowedResourcePaths.add("/**/*.jpg"); allowedResourcePaths.add("/**/*.js"); allowedResourcePaths.add("/**/*.png"); allowedResourcePaths.add("META-INF/**/*.css"); allowedResourcePaths.add("META-INF/**/*.gif"); allowedResourcePaths.add("META-INF/**/*.ico"); allowedResourcePaths.add("META-INF/**/*.jpeg"); allowedResourcePaths.add("META-INF/**/*.jpg"); allowedResourcePaths.add("META-INF/**/*.js"); allowedResourcePaths.add("META-INF/**/*.png"); }; private Map<String, String> defaultMimeTypes = new HashMap<String, String>(); { defaultMimeTypes.put(".css", "text/css"); defaultMimeTypes.put(".gif", "image/gif"); defaultMimeTypes.put(".ico", "image/vnd.microsoft.icon"); defaultMimeTypes.put(".jpeg", "image/jpeg"); defaultMimeTypes.put(".jpg", "image/jpeg"); defaultMimeTypes.put(".js", "text/javascript"); defaultMimeTypes.put(".png", "image/png"); } private Set<String> compressedMimeTypes = new HashSet<String>(); { compressedMimeTypes.add("text/*"); } private int cacheTimeout = 31556926; protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String rawResourcePath = rawResourcePath(request); if (log.isDebugEnabled()) { log.debug("Attempting to GET resource: " + rawResourcePath); } URL[] resources = getRequestResourceURLs(request); if (resources == null || resources.length == 0) { if (log.isDebugEnabled()) { log.debug("Resource not found: " + rawResourcePath); } response.sendError(HttpServletResponse.SC_NOT_FOUND); return; } prepareResponse(response, resources, rawResourcePath); OutputStream out = selectOutputStream(request, response); try { for (int i = 0; i < resources.length; i++) { URLConnection resourceConn = resources[i].openConnection(); resourceConn.setUseCaches(false); InputStream in = resourceConn.getInputStream(); try { byte[] buffer = new byte[1024]; int bytesRead = -1; while ((bytesRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesRead); } } finally { in.close(); } } } finally { out.close(); } } private OutputStream selectOutputStream(HttpServletRequest request, HttpServletResponse response) throws IOException { String acceptEncoding = request.getHeader("Accept-Encoding"); String mimeType = response.getContentType(); if (gzipEnabled && StringUtils.hasText(acceptEncoding) && acceptEncoding.indexOf("gzip") > -1 && matchesCompressedMimeTypes(mimeType)) { log.debug("Enabling GZIP compression for the current response."); return new GZIPResponseStream(response); } else { return response.getOutputStream(); } } private boolean matchesCompressedMimeTypes(String mimeType) { PathMatcher pathMatcher = new AntPathMatcher(); Iterator<String> compressedMimeTypesIt = compressedMimeTypes.iterator(); while (compressedMimeTypesIt.hasNext()) { String compressedMimeType = compressedMimeTypesIt.next(); if (pathMatcher.match(compressedMimeType, mimeType)) { return true; } } return false; } private void prepareResponse(HttpServletResponse response, URL[] resources, String rawResourcePath) throws IOException { long lastModified = -1; int contentLength = 0; String mimeType = null; for (int i = 0; i < resources.length; i++) { URLConnection resourceConn = resources[i].openConnection(); if (resourceConn.getLastModified() > lastModified) { lastModified = resourceConn.getLastModified(); } String currentMimeType = getServletContext().getMimeType(resources[i].getPath()); if (currentMimeType == null) { String extension = resources[i].getPath().substring(resources[i].getPath().lastIndexOf('.')); currentMimeType = (String) defaultMimeTypes.get(extension); } if (mimeType == null) { mimeType = currentMimeType; } else if (!mimeType.equals(currentMimeType)) { throw new MalformedURLException("Combined resource path: " + rawResourcePath + " is invalid. All resources in a combined resource path must be of the same mime type."); } contentLength += resourceConn.getContentLength(); } response.setContentType(mimeType); response.setHeader(HTTP_CONTENT_LENGTH_HEADER, Long.toString(contentLength)); response.setDateHeader(HTTP_LAST_MODIFIED_HEADER, lastModified); if (cacheTimeout > 0) { configureCaching(response, cacheTimeout); } } protected long getLastModified(HttpServletRequest request) { if (log.isDebugEnabled()) { log.debug("Checking last modified of resource: " + request.getPathInfo()); } URL[] resources; try { resources = getRequestResourceURLs(request); } catch (MalformedURLException e) { return -1; } if (resources == null || resources.length == 0) { return -1; } long lastModified = -1; for (int i = 0; i < resources.length; i++) { URLConnection resourceConn; try { resourceConn = resources[i].openConnection(); } catch (IOException e) { return -1; } if (resourceConn.getLastModified() > lastModified) { lastModified = resourceConn.getLastModified(); } } return lastModified; } private URL[] getRequestResourceURLs(HttpServletRequest request) throws MalformedURLException { String rawResourcePath = rawResourcePath(request); String appendedPaths = request.getParameter("appended"); if (StringUtils.hasText(appendedPaths)) { rawResourcePath = rawResourcePath + "," + appendedPaths; } String[] localResourcePaths = StringUtils.delimitedListToStringArray(rawResourcePath, ","); URL[] resources = new URL[localResourcePaths.length]; for (int i = 0; i < localResourcePaths.length; i++) { String localResourcePath = localResourcePaths[i]; if (!isAllowed(localResourcePath)) { if (log.isWarnEnabled()) { log.warn("An attempt to access a protected resource at " + localResourcePath + " was disallowed."); } return null; } URL resource = getServletContext().getResource(localResourcePath); if (resource == null) { String jarResourcePath = jarPathPrefix + localResourcePath; if (!isAllowed(jarResourcePath)) { if (log.isWarnEnabled()) { log.warn("An attempt to access a protected resource at " + jarResourcePath + " was disallowed."); } return null; } if (jarResourcePath.startsWith("/")) { jarResourcePath = jarResourcePath.substring(1); } if (log.isDebugEnabled()) { log.debug("Searching classpath for resource: " + jarResourcePath); } resource = ClassUtils.getDefaultClassLoader().getResource(jarResourcePath); } if (resource == null) { if (resources.length > 1) { log.debug("Combined resource not found: " + localResourcePath); } return null; } else { resources[i] = resource; } } return resources; } private String rawResourcePath(HttpServletRequest request) { String rawResourcePath = request.getPathInfo(); //FIXME test if (rawResourcePath == null && request instanceof ModuleHttpServletRequest) { ModuleHttpServletRequest moduleRequest = (ModuleHttpServletRequest) request; return moduleRequest.getModulePathInfo(); } return rawResourcePath; } private boolean isAllowed(String resourcePath) { if (resourcePath.matches(protectedPath)) { return false; } PathMatcher pathMatcher = new AntPathMatcher(); Iterator<String> allowedResourcePathsIt = allowedResourcePaths.iterator(); while (allowedResourcePathsIt.hasNext()) { String pattern = allowedResourcePathsIt.next(); if (pathMatcher.match(pattern, resourcePath)) { return true; } } return false; } /** * Set HTTP headers to allow caching for the given number of seconds. * @param seconds number of seconds into the future that the response should be cacheable for */ private void configureCaching(HttpServletResponse response, int seconds) { // HTTP 1.0 header response.setDateHeader(HTTP_EXPIRES_HEADER, System.currentTimeMillis() + seconds * 1000L); // HTTP 1.1 header response.setHeader(HTTP_CACHE_CONTROL_HEADER, "max-age=" + seconds); } private class GZIPResponseStream extends ServletOutputStream { private ByteArrayOutputStream byteStream = null; private GZIPOutputStream gzipStream = null; private boolean closed = false; private HttpServletResponse response = null; private ServletOutputStream servletStream = null; public GZIPResponseStream(HttpServletResponse response) throws IOException { super(); closed = false; this.response = response; this.servletStream = response.getOutputStream(); byteStream = new ByteArrayOutputStream(); gzipStream = new GZIPOutputStream(byteStream); } public void close() throws IOException { if (closed) { throw new IOException("This output stream has already been closed"); } gzipStream.finish(); byte[] bytes = byteStream.toByteArray(); response.setContentLength(bytes.length); response.addHeader("Content-Encoding", "gzip"); servletStream.write(bytes); servletStream.flush(); servletStream.close(); closed = true; } public void flush() throws IOException { if (closed) { throw new IOException("Cannot flush a closed output stream"); } gzipStream.flush(); } public void write(int b) throws IOException { if (closed) { throw new IOException("Cannot write to a closed output stream"); } gzipStream.write((byte) b); } public void write(byte b[]) throws IOException { write(b, 0, b.length); } public void write(byte b[], int off, int len) throws IOException { if (closed) { throw new IOException("Cannot write to a closed output stream"); } gzipStream.write(b, off, len); } @SuppressWarnings("unused") public boolean closed() { return (this.closed); } @SuppressWarnings("unused") public void reset() { // noop } } /** * Set whether to apply gzip compression to resources if the requesting client supports it. */ public void setGzipEnabled(boolean gzipEnabled) { this.gzipEnabled = gzipEnabled; } /** * Set allowed resources as an comma separated String of URL patterns, e.g. "META-INF/** /*.js", The paths may be * any Ant-style pattern parsable by AntPathMatcher. * * @see AntPathMatcher */ public void setAllowedResourcePaths(String allowedResourcePaths) { this.allowedResourcePaths = new HashSet<String>( Arrays.asList(StringUtils.tokenizeToStringArray(allowedResourcePaths, ",", true, true))); } /** * Set comma separated MIME types that should have gzip compression applied. Typically, gzip compression is only * useful for text based content. Ant-style patterns are supported, e.g. "text/*". * * @see AntPathMatcher */ public void setCompressedMimeTypes(String compressedMimeTypes) { this.compressedMimeTypes = new HashSet<String>( Arrays.asList(StringUtils.tokenizeToStringArray(compressedMimeTypes, ",", true, true))); } /** * Set the default path prefix to apply to resources being served from jar files. Default is "META-INF". */ public void setJarPathPrefix(String jarPathPrefix) { this.jarPathPrefix = jarPathPrefix; } /** * Set the number of seconds resources should be cached by the client. Zero disables caching. Default is one year. */ public void setCacheTimeout(int cacheTimeout) { this.cacheTimeout = cacheTimeout; } }