tomcat和jetty对静态资源的处理和客户端缓存的处理

最新推荐文章于 2019-01-03 11:14:08 发布
最新推荐文章于 2019-01-03 11:14:08 发布
阅读量385 收藏
点赞数
分类专栏： apache&jetty&tomcat&jboss 文章标签： java web.xml 运维

tomcat和jetty对静态资源的处理和客户端缓存的处理

 

原文链接：http://www.javaarch.net/jiagoushi/867.htm

 

这两个默认servlet名称都是defaultservlet，然后在web.xml中就可以添加下面的配置让应用支持都静态资源的处理，对应的这些静态资源的目录则是在webapp根目录下，这里其实可以不用配置servlet名称，对于名称为default的url，tomcat和jetty都会作为静态资源文件处理

 

	<servlet-mapping>
     	<servlet-name>default</servlet-name>
    	 <url-pattern>*.css</url-pattern>
	</servlet-mapping>
	 
	<servlet-mapping>
	    <servlet-name>default</servlet-name>
	    <url-pattern>*.gif</url-pattern>
	 </servlet-mapping>
	    
	 <servlet-mapping>
	     <servlet-name>default</servlet-name>
	     <url-pattern>*.jpg</url-pattern>
	 </servlet-mapping>
	    
	 <servlet-mapping>
	     <servlet-name>default</servlet-name>
	     <url-pattern>*.js</url-pattern>
	 </servlet-mapping>
	 
	 <servlet-mapping>
	     <servlet-name>default</servlet-name>
	     <url-pattern>*.swf</url-pattern>
	 </servlet-mapping>



那么我们来看看tomcat和jetty对静态资源的客户端缓存的处理逻辑：


tomcat，tomcat在default的servlet支持一些参数，如果有需要那么就需要配置servlet了，

 

 

	<servlet>  
	  <servlet-name>default</servlet-name>  
	  <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>  
	  <init-param>  
		  <param-name>debug</param-name>  
		  <param-value>0</param-value>  
	  </init-param>  
	  <init-param>  
		  <param-name>listings</param-name>  
		  <param-value>false</param-value>  
	  </init-param>  
	  <load-on-startup>1</load-on-startup>  
	</servlet>


在对于静态资源处理的客户端缓存的代码如下

 

 

	// ETag header
    response.setHeader("ETag", cacheEntry.attributes.getETag());

    // Last-Modified header
    response.setHeader("Last-Modified", cacheEntry.attributes.getLastModifiedHttp());


这里的etag计算规则如下：

 

 

	long contentLength = getContentLength();
	long lastModified = getLastModified();
	if ((contentLength >= 0) || (lastModified >= 0)) {
		weakETag = "W/\"" + contentLength + "-" +
				   lastModified + "\"";
	}



输出的reponse header如下：

 

 

	HTTP/1.1 200 OK
	Server: Apache-Coyote/1.1
	Accept-Ranges: bytes
	ETag: W/"7482-1371188756000"
	Last-Modified: Fri, 14 Jun 2013 05:45:56 GMT
	Content-Type: text/css;charset=GBK
	Content-Length: 7482
	Date: Sun, 16 Jun 2013 07:05:37 GMT


第二次请求时，会先对reqeust的etag和last-modified进行比对，如果没更新的话则返回304

 

 

protected ArrayList<Range> parseRange(HttpServletRequest request,
            HttpServletResponse response,
            ResourceAttributes resourceAttributes) throws IOException {

        // Checking If-Range
        String headerValue = request.getHeader("If-Range");

        if (headerValue != null) {

            long headerValueTime = (-1L);
            try {
                headerValueTime = request.getDateHeader("If-Range");
            } catch (IllegalArgumentException e) {
                // Ignore
            }

            String eTag = resourceAttributes.getETag();
            long lastModified = resourceAttributes.getLastModified();

            if (headerValueTime == (-1L)) {

                // If the ETag the client gave does not match the entity
                // etag, then the entire entity is returned.
                if (!eTag.equals(headerValue.trim()))
                    return FULL;

            } else {

                // If the timestamp of the entity the client got is older than
                // the last modification date of the entity, the entire entity
                // is returned.
                if (lastModified > (headerValueTime + 1000))
                    return FULL;

            }

        }


第二次返回：

 

 

	HTTP/1.1 304 Not Modified
	Server: Apache-Coyote/1.1
	ETag: W/"2640-1371187966000"
	Date: Sun, 16 Jun 2013 07:23:27 GMT


那么这里对静态资源浏览器就自动能够缓存起来了。当然tomcat和jetty服务器也会对静态资源进行缓存。


jetty对这个处理也差不多，不过jetty对于静态资源的缓存策略可以做更多参数设置，这些参数都是在web.xml配置servlet的时候可以进行设置的。

 

 

_cacheControl=getInitParameter("cacheControl");

        String resourceCache = getInitParameter("resourceCache");
        int max_cache_size=getInitInt("maxCacheSize", -2);
        int max_cached_file_size=getInitInt("maxCachedFileSize", -2);
        int max_cached_files=getInitInt("maxCachedFiles", -2);
        if (resourceCache!=null)
        {
            if (max_cache_size!=-1 || max_cached_file_size!= -2 || max_cached_files!=-2)
                LOG.debug("ignoring resource cache configuration, using resourceCache attribute");
            if (_relativeResourceBase!=null || _resourceBase!=null)
                throw new UnavailableException("resourceCache specified with resource bases");
            _cache=(ResourceCache)_servletContext.getAttribute(resourceCache);

            LOG.debug("Cache {}={}",resourceCache,_cache);
        }

        _etags = getInitBoolean("etags",_etags);



处理代码：


写header

 

 

    /* ------------------------------------------------------------ */
    protected void writeHeaders(HttpServletResponse response,HttpContent content,long count)
    throws IOException
    {        
        if (content.getContentType()!=null && response.getContentType()==null)
            response.setContentType(content.getContentType().toString());

        if (response instanceof Response)
        {
            Response r=(Response)response;
            HttpFields fields = r.getHttpFields();

            if (content.getLastModified()!=null)
                fields.put(HttpHeader.LAST_MODIFIED,content.getLastModified());
            else if (content.getResource()!=null)
            {
                long lml=content.getResource().lastModified();
                if (lml!=-1)
                    fields.putDateField(HttpHeader.LAST_MODIFIED,lml);
            }

            if (count != -1)
                r.setLongContentLength(count);

            writeOptionHeaders(fields);
            
            if (_etags)
                fields.put(HttpHeader.ETAG,content.getETag());
        }
        else
        {
            long lml=content.getResource().lastModified();
            if (lml>=0)
                response.setDateHeader(HttpHeader.LAST_MODIFIED.asString(),lml);

            if (count != -1)
            {
                if (count<Integer.MAX_VALUE)
                    response.setContentLength((int)count);
                else
                    response.setHeader(HttpHeader.CONTENT_LENGTH.asString(),Long.toString(count));
            }

            writeOptionHeaders(response);

            if (_etags)
                response.setHeader(HttpHeader.ETAG.asString(),content.getETag().toString());
        }
    }


判断静态资源是否修改过

 

 

 /* ------------------------------------------------------------ */
    /* Check modification date headers.
     */
    protected boolean passConditionalHeaders(HttpServletRequest request,HttpServletResponse response, Resource resource, HttpContent content)
    throws IOException
    {
        try
        {
            if (!HttpMethod.HEAD.is(request.getMethod()))
            {
                if (_etags)
                {
                    String ifm=request.getHeader(HttpHeader.IF_MATCH.asString());
                    if (ifm!=null)
                    {
                        boolean match=false;
                        if (content!=null && content.getETag()!=null)
                        {
                            QuotedStringTokenizer quoted = new QuotedStringTokenizer(ifm,", ",false,true);
                            while (!match && quoted.hasMoreTokens())
                            {
                                String tag = quoted.nextToken();
                                if (content.getETag().toString().equals(tag))
                                    match=true;
                            }
                        }

                        if (!match)
                        {
                            Response r = Response.getResponse(response);
                            r.reset(true);
                            r.setStatus(HttpServletResponse.SC_PRECONDITION_FAILED);
                            return false;
                        }
                    }
                    
                    String ifnm=request.getHeader(HttpHeader.IF_NONE_MATCH.asString());
                    if (ifnm!=null && content!=null && content.getETag()!=null)
                    {
                        // Look for GzipFiltered version of etag
                        if (content.getETag().toString().equals(request.getAttribute("o.e.j.s.GzipFilter.ETag")))
                        {
                            Response r = Response.getResponse(response);
                            r.reset(true);
                            r.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                            r.getHttpFields().put(HttpHeader.ETAG,ifnm);
                            return false;
                        }
                        
                        
                        // Handle special case of exact match.
                        if (content.getETag().toString().equals(ifnm))
                        {
                            Response r = Response.getResponse(response);
                            r.reset(true);
                            r.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                            r.getHttpFields().put(HttpHeader.ETAG,content.getETag());
                            return false;
                        }

                        // Handle list of tags
                        QuotedStringTokenizer quoted = new QuotedStringTokenizer(ifnm,", ",false,true);
                        while (quoted.hasMoreTokens())
                        {
                            String tag = quoted.nextToken();
                            if (content.getETag().toString().equals(tag))
                            {
                                Response r = Response.getResponse(response);
                                r.reset(true);
                                r.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                                r.getHttpFields().put(HttpHeader.ETAG,content.getETag());
                                return false;
                            }
                        }
                        
                        // If etag requires content to be served, then do not check if-modified-since
                        return true;
                    }
                }
                
                // Handle if modified since
                String ifms=request.getHeader(HttpHeader.IF_MODIFIED_SINCE.asString());
                if (ifms!=null)
                {
                    //Get jetty's Response impl
                    Response r = Response.getResponse(response);
                                       
                    if (content!=null)
                    {
                        String mdlm=content.getLastModified();
                        if (mdlm!=null)
                        {
                            if (ifms.equals(mdlm))
                            {
                                r.reset(true);
                                r.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                                r.flushBuffer();
                                return false;
                            }
                        }
                    }

                    long ifmsl=request.getDateHeader(HttpHeader.IF_MODIFIED_SINCE.asString());
                    if (ifmsl!=-1)
                    {
                        if (resource.lastModified()/1000 <= ifmsl/1000)
                        { 
                            r.reset(true);
                            r.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                            r.flushBuffer();
                            return false;
                        }
                    }
                }

                // Parse the if[un]modified dates and compare to resource
                long date=request.getDateHeader(HttpHeader.IF_UNMODIFIED_SINCE.asString());

                if (date!=-1)
                {
                    if (resource.lastModified()/1000 > date/1000)
                    {
                        response.sendError(HttpServletResponse.SC_PRECONDITION_FAILED);
                        return false;
                    }
                }

            }
        }
        catch(IllegalArgumentException iae)
        {
            if(!response.isCommitted())
                response.sendError(400, iae.getMessage());
            throw iae;
        }
        return true;
    }


第一次访问的response header头：

 

 

	HTTP/1.1 200 OK
	Server: Apache-Coyote/1.1
	Accept-Ranges: bytes
	ETag: W/"7482-1371188756000"
	Last-Modified: Fri, 14 Jun 2013 05:45:56 GMT
	Content-Type: text/css;charset=GBK
	Content-Length: 7482
	Date: Sun, 16 Jun 2013 07:05:37 GMT

 

 


第二次访问：

 

	HTTP/1.1 304 Not Modified
	Server: Jetty(6.1.26)



 

不过处理静态资源大型网站肯定不是tomcat或者jetty，基本都是用apache或者nginx等来处理静态处理，性能更好。这里只是列出tomcat和jetyy对静态资源的处理和客户端缓存的支持。

zhongweij
关注
专栏目录
[细节]Tomcat对静态资源的缓存支持
Zerohuan的专栏
10-30 1万+
使用tomcat时我们可以通过配置DefaultServlet来支持对静态资源的访问，而DefaultServlet是具有缓存功能的，下面通过对关键的源码对其进行分析并介绍如何通过配置来控制tomcat静态资源的缓存行为。 1. 配置DefaultServlet： 我们有两种方式来配置资源，一种是通过部署描述符，另一种就是通过代码进行配置： 通过代码配置DefaultServ
Jetty嵌入式开发之静态资源
weixin_33895604的博客
01-10 920
ResourceHandler 提到静态资源加载不得不提到的一个类，这是jetty提供的静态资源处理类。 Server server = new Server(8080); //封装静态资源访问路径 ContextHandler contextHandler = new ContextHandler("/index"); ResourceHandler resour...
spring内置jetty 配置静态资源
chuancheng5233的博客
05-18 925
最近做的项目用的框架是spring+jersey+jetty，这个框架原来只用于接口项目，但本次做的项目需要加入静态资源，由于我是第一次使用jetty，还是在spring中内置，不知道该如何解决，后来在网上查了一下资料，也只找到了jetty相关的配置文件，于是我就改了一下放入了spri...
jetty 缓存文件地址
q421022的专栏
06-29 3915
jetty 编译文件路径
Tomcat无法加载css和js等静态资源文件的解决思路
09-15
首先，如果你的环境中同时配置了Apache服务器和Tomcat，那么可能由于配置不当导致静态资源请求没有正确地转发到Tomcat处理。Apache可以通过mod_proxy模块将HTTP请求代理到Tomcat，使得静态资源请求能够被Tomcat正确...
SpringMVC 3.0静态资源处理详解
- 默认配置：Spring MVC默认不会拦截静态资源请求，这通常由Web服务器（如Tomcat、Jetty等）来处理。 - 自定义配置：可以通过在`web.xml`中配置`<mvc:resources>`元素或在Spring MVC配置类中使用`@ResourceMapping...
Spring MVC 静态资源处理原理与注解解析
通常，应用服务器如Tomcat或Jetty，有一个默认的Servlet，负责处理静态资源，如CSS、JavaScript、图片等。这些资源不会经过Spring MVC的 DispatcherServlet。但是，当需要自定义静态资源的处理方式，或者在Spring ...
jsp 缓存处理
12-11
5. **浏览器缓存**：客户端浏览器会缓存静态资源和动态内容，以减少网络传输。 ### 二、JSP页面缓存的实现 #### 1. 服务端方法 服务端通过设置HTTP响应头控制浏览器缓存策略： ```java response.setHeader(...
Jetty 启动后缓存页面,不重新启动更新
月溅星河长路漫漫 的博客
12-07 2400
版本参数:9.1.4.v20140401 Jetty 启动后发现web页面一直处于缓存状态, 启动期间不能正常编译或更新  Jetty 的发行包运行期间会默认锁定所部署的文件, 使用文件缓存 后来发现在 jetty-webapp 包org/eclipse/jetty/webapp/webdefault.xml下配置文件中有这么一项配置: useFileMappedBuffe
jetty启动器资源配置文件
08-17
jetty启动配置文件
JAVA 探索之路01 -tomcat原理及静态缓存
Ys8888N的博客
01-03 370
一  tomcat 原理 1. 代码结构     配置:   1. 配置文件    2. 配置tomcat容器   3. 请求request 和响应response     4. 处理服务servlet 运行流程:   客户端请求[inputStream]   &gt;MyTomcat容器[servlet.serivce(request, response)]    &gt;request...
tomcat缓存静态资源深入Apache
weixin_34335458的博客
02-25 429
tomcat缓存静态资源深入Apache 之前看过APACH及nginx的对于静态资源（含JS，图片，CSS等）部分的缓存，用于加速并减轻后台实际网络服务器的压力。 静态资源缓存是WEB服务器优化的一种手段，基本原理如下： 1.客户端浏览器请求服务器一个服务（该服务含有图片，JS等静态资源），通常会对于每一个网页中的独立图片或JS文件发送一个HTTP请...
激活web容器对静态资源的默认servlet处理
weixin_33985507的博客
05-04 282
在某些servlet的url匹配模式使用/时会拦截一些静态的资源的请求导致无法正确访问，可以采取web容器默认的servlet来处理，当然那些mvc一般也都提供了处理的方法，用何种方式可以自行决定，这里只介绍web容器的默认servlet的处理。 注意：要写在MVC框架的servlet的前面 tomcat: &lt;servlet-mapping&gt; &lt;servle...
深入Jetty源码之Buffer
zlxfogger的专栏
04-07 722
概述 在Jetty中Buffer是对Java中Stream IO中的buffer和NIO中的buffer的抽象表示，它主要用于缓存连接中读取和写入的数据。在Jetty中，对每个连接使用Buffer从其InputStream中读取字节数据，或将处理后的响应字节写入OutputStream中，从而Jetty其他模块在处理请求和响应数据时直接和Buffer打交道，而不需要关注底层IO流。 
Jetty 加载资源的相关问题
抱朴守拙
05-27 640
Jetty 加载资源有一定的顺序和策略，这里开一个头，以后慢慢填充相关的案例和资料： 1 今天在调试一个临时项目时，碰到了一件很奇怪的问题，当Jetty Server的Custom context root设置为 “/” 时，总是无法正常加载app的图片资源。更奇怪的是，其他同事同样从svn上check下来代码，都能正常运行。而且，如果配置 Custom context root 为 “
Resin与其他容器（tomcat/jetty）默认处理Servlet
小程序员成长中......
03-23 1456
在tomcat或jetty容器中，我们可以采用default servlet进行一些默认处理，比如静态文件处理 1、Tomcat DefualtServlet 原文描述：The default servlet is the servlet which serves static resources as well as serves the directory listings (if dir
禁止 Jetty 使用映射缓存
hynet的专栏
03-07 4723
当你想试图去修改正在被访问的资源文件，像 CSS、JS、FTL等，这时候你修改完成想保存的时候，是保存不了的。你必须停掉 Jetty 容器(如果是在CMD下运行的 Jetty 容器，按 Ctrl + C 停掉 Jetty)，才能保存。保存完成后必须重新启动 Jetty 容器才能看见效果。这样做无论是对修改 .css、.js、.ftl 等都非常麻烦和不爽。 究其原因，这是 Jetty 使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值