Tomcat解决静态文件DefaultServlet分析

问题的原因是，使用网页打开tomcat7服务器上一个只有静态内容的jsp页面，里面链接了gif文件，F5刷新的时候，css和gif文件请求返回304 not Mofified 头，而jsp请求还是返回200（想搞破坏，把jsp也能在通过304返回头直接读取用户端缓存，但jsp是servlet只可以在servlet容器中运行。。。）

由于jsp文件请求时tomcat的JspServlet解决的，而css和html、gif等静态文件默认是tomcat的DefaultServlet解决的（在tomcat配置文件conf/web.xml中有配置）。

先来看下tomcat7的DefaultServlet的源码：

服务端通过resource.lookupCache(path)从服务端缓存中读取资源取得CacheEntry，假如请求资源不存在CacheEntry.exists为false，则返回404。而后通过checkIfHeaders(request, response, cacheEntry.attributes)方法根据用户端请求头的If-None-Match，If-Modified-Since来判断请求资源能否被修改，假如未被修改，则返回304头，户端直接从用户端缓存中读取资源文件。假如第一次访问或者者ctrl+F5强制刷新或者者资源已修改过，默认返回Etag和Last-Modified头，，告知用户端下次访问能通过If-None-Match，If-Modified-Since比较返回304来判断能否可用用户端缓存。还有设置文件内容，content-length，range头等，最后输出内容：

if (!checkSendfile(request, response, cacheEntry, contentLength, null))

copy(cacheEntry, renderResult, ostream);

假如文件超过48k，判断能否用sendfile来输出大文件。

请求头中通过range请求部分下载，则：

if (!checkSendfile(request, response, cacheEntry, range.end – range.start + 1, range))

copy(cacheEntry, ostream, range);

2. protected void serveResource(HttpServletRequest request,
3. HttpServletResponse response,
4. boolean content)
5. throws IOException, ServletException {
7. boolean serveContent = content;
9. // Identify the requested resource path
10. String path = getRelativePath(request);
11. if (debug > 0) {
12. if (serveContent)
13. log(“DefaultServlet.serveResource: Serving resource '” +
14. path + “' headers and data”);
15. else
16. log(“DefaultServlet.serveResource: Serving resource '” +
17. path + “' headers only”);
18. }
19. // 从服务端缓存中读取资源
20. CacheEntry cacheEntry = resources.lookupCache(path);
21. //请求资源不存在，则返回404
22. if (!cacheEntry.exists) {
23. // Check if we're included so we can return the appropriate
24. // missing resource name in the error
25. String requestUri = (String) request.getAttribute(
26. RequestDispatcher.INCLUDE_REQUEST_URI);
27. if (requestUri == null) {
28. requestUri = request.getRequestURI();
29. } else {
30. // We're included
31. // SRV.9.3 says we must throw a FNFE
32. throw new FileNotFoundException(
33. sm.getString(“defaultServlet.missingResource”,
34. requestUri));
35. }
37. response.sendError(HttpServletResponse.SC_NOT_FOUND,
38. requestUri);
39. return;
40. }
42. // If the resource is not a collection, and the resource path
43. // ends with “/” or “\”, return NOT FOUND
44. if (cacheEntry.context == null) {
45. if (path.endsWith(“/”) || (path.endsWith(“\\”))) {
46. // Check if we're included so we can return the appropriate
47. // missing resource name in the error
48. String requestUri = (String) request.getAttribute(
49. RequestDispatcher.INCLUDE_REQUEST_URI);
50. if (requestUri == null) {
51. requestUri = request.getRequestURI();
52. }
53. response.sendError(HttpServletResponse.SC_NOT_FOUND,
54. requestUri);
55. return;
56. }
57. }
59. boolean isError =
60. response.getStatus() >= HttpServletResponse.SC_BAD_REQUEST;
62. // Check if the conditions specified in the optional If headers are
63. // satisfied.
64. if (cacheEntry.context == null) {
66. // Checking If headers
67. boolean included = (request.getAttribute(
68. RequestDispatcher.INCLUDE_CONTEXT_PATH) != null);
69. //checkIfHeaders根据用户端请求头的If-None-Match，If-Modified-Since
70. //来判断请求资源能否被修改，假如未被修改，则返回304头
71. //用户端直接从用户端缓存中读取资源文件。
72. if (!included && !isError &&
73. !checkIfHeaders(request, response, cacheEntry.attributes)) {
74. return;
75. }
77. }
79. // Find content type.
80. String contentType = cacheEntry.attributes.getMimeType();
81. if (contentType == null) {
82. contentType = getServletContext().getMimeType(cacheEntry.name);
83. cacheEntry.attributes.setMimeType(contentType);
84. }
86. ArrayList ranges = null;
87. long contentLength = -1L;
89. if (cacheEntry.context != null) {
91. // Skip directory listings if we have been configured to
92. // suppress them
93. if (!listings) {
94. response.sendError(HttpServletResponse.SC_NOT_FOUND,
95. request.getRequestURI());
96. return;
97. }
98. contentType = “text/html;charset=UTF-8”;
100. } else {
101. if (!isError) {
102. //第一次访问或者者ctrl+F5强制刷新或者者前面资源已修改过，静态文件解决
103. //默认返回Etag和Last-Modified，告知用户端下次访问能
104. //通过If-None-Match，If-Modified-Since比较返回304来判断能否可用用户端缓存
105. if (useAcceptRanges) {
106. // Accept ranges header
107. response.setHeader(“Accept-Ranges”, “bytes”);
108. }
110. // Parse range specifier
111. ranges = parseRange(request, response, cacheEntry.attributes);
113. // ETag header
114. response.setHeader(“ETag”, cacheEntry.attributes.getETag());
116. // Last-Modified header
117. response.setHeader(“Last-Modified”,
118. cacheEntry.attributes.getLastModifiedHttp());
119. }
121. // Get content length
122. contentLength = cacheEntry.attributes.getContentLength();
123. // Special case for zero length files, which would cause a
124. // (silent) ISE when setting the output buffer size
125. if (contentLength == 0L) {
126. serveContent = false;
127. }
129. }
131. ServletOutputStream ostream = null;
132. PrintWriter writer = null;
134. if (serveContent) {
136. // Trying to retrieve the servlet output stream
138. try {
139. ostream = response.getOutputStream();
140. } catch (IllegalStateException e) {
141. // If it fails, we try to get a Writer instead if we're
142. // trying to serve a text file
143. if ( (contentType == null)
144. || (contentType.startsWith(“text”))
145. || (contentType.endsWith(“xml”))
146. || (contentType.contains(“/javascript”)) ) {
147. writer = response.getWriter();
148. // Cannot reliably serve partial content with a Writer
149. ranges = FULL;
150. } else {
151. throw e;
152. }
153. }
155. }
157. // Check to see if a Filter, Valve of wrapper has written some content.
158. // If it has, disable range requests and setting of a content length
159. // since neither can be done reliably.
160. ServletResponse r = response;
161. long contentWritten = 0;
162. while (r instanceof ServletResponseWrapper) {
163. r = ((ServletResponseWrapper) r).getResponse();
164. }
165. if (r instanceof ResponseFacade) {
166. contentWritten = ((ResponseFacade) r).getContentWritten();
167. }
168. if (contentWritten > 0) {
169. ranges = FULL;
170. }
172. if ( (cacheEntry.context != null)
173. || isError
174. || ( ((ranges == null) || (ranges.isEmpty()))
175. && (request.getHeader(“Range”) == null) )
176. || (ranges == FULL) ) {
178. // Set the appropriate output headers
179. if (contentType != null) {
180. if (debug > 0)
181. log(“DefaultServlet.serveFile: contentType='” +
182. contentType + “'”);
183. response.setContentType(contentType);
184. }
185. if ((cacheEntry.resource != null) && (contentLength >= 0)
186. && (!serveContent || ostream != null)) {
187. if (debug > 0)
188. log(“DefaultServlet.serveFile: contentLength=” +
189. contentLength);
190. // Don't set a content length if something else has already
191. // written to the response.
192. if (contentWritten == 0) {
193. if (contentLength < Integer.MAX_VALUE) {
194. response.setContentLength((int) contentLength);
195. } else {
196. // Set the content-length as String to be able to use a
197. // long
198. response.setHeader(“content-length”,
199. “” + contentLength);
200. }
201. }
202. }
204. InputStream renderResult = null;
205. if (cacheEntry.context != null) {
207. if (serveContent) {
208. // Serve the directory browser
209. renderResult = render(getPathPrefix(request), cacheEntry);
210. }
212. }
214. // Copy the input stream to our output stream (if requested)
215. if (serveContent) {
216. try {
217. response.setBufferSize(output);
218. } catch (IllegalStateException e) {
219. // Silent catch
220. }
221. if (ostream != null) {
222. //这里是content输出，判断能否用sendfile来输出大文件
223. if (!checkSendfile(request, response, cacheEntry, contentLength, null))
224. copy(cacheEntry, renderResult, ostream);
225. } else {
226. copy(cacheEntry, renderResult, writer);
227. }
228. }
230. } else {
231. //
232. if ((ranges == null) || (ranges.isEmpty()))
233. return;
235. // Partial content response.
237. response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
239. if (ranges.size() == 1) {
241. Range range = ranges.get(0);
242. response.addHeader(“Content-Range”, “bytes “
243. + range.start
244. + “-” + range.end + “/”
245. + range.length);
246. long length = range.end – range.start + 1;
247. if (length < Integer.MAX_VALUE) {
248. response.setContentLength((int) length);
249. } else {
250. // Set the content-length as String to be able to use a long
251. response.setHeader(“content-length”, “” + length);
252. }
254. if (contentType != null) {
255. if (debug > 0)
256. log(“DefaultServlet.serveFile: contentType='” +
257. contentType + “'”);
258. response.setContentType(contentType);
259. }
261. if (serveContent) {
262. try {
263. response.setBufferSize(output);
264. } catch (IllegalStateException e) {
265. // Silent catch
266. }
267. if (ostream != null) {
268. //Range来实现资源文件部分内容传输
269. if (!checkSendfile(request, response, cacheEntry, range.end – range.start + 1, range))
270. copy(cacheEntry, ostream, range);
271. } else {
272. // we should not get here
273. throw new IllegalStateException();
274. }
275. }
277. } else {
279. response.setContentType(“multipart/byteranges; boundary=”
280. + mimeSeparation);
282. if (serveContent) {
283. try {
284. response.setBufferSize(output);
285. } catch (IllegalStateException e) {
286. // Silent catch
287. }
288. if (ostream != null) {
289. copy(cacheEntry, ostream, ranges.iterator(),
290. contentType);
291. } else {
292. // we should not get here
293. throw new IllegalStateException();
294. }
295. }
297. }
299. }
300. }

静态文件优先从缓存中读取：

首先从存在的资源缓存cache中查找，未找到则从不存在的资源的缓存notFoundCache中查找。假如找到，检查缓存能否有效。cache默认有效期5秒，5秒之内不检查原文件能否有修改，超过有效期，需要验证原文件的lastModified和ContendLenth和缓存中的能否一致，不一致清理缓存，一致则升级缓存的timestap再次5秒有效期。（这样的话，假如修改css或者js等静态文件，假如测试的人一直访问（5秒间隔内）这个页面，导致静态文件一直从服务端缓存中读取，那样无论能否强制刷新修改都不会生效啊。）未找到则生成CacheEntry，加载到相应的cache 或者notFoundCache中。当然，nonCacheable数组默认/WEB-INF/lib/, /WEB-INF/classes/路径下文件都不从缓存获取。这里cache缓存设计成一个有序数组，而notFoundCache设计为一个HashMap，cache操作略微复杂点。难道是由于cache释放内存需要更细粒度的控制?

2. protected CacheEntry cacheLookup(String lookupName) {
3. if (cache == null)
4. return (null);
5. String name;
6. if (lookupName == null) {
7. name = “”;
8. } else {
9. name = lookupName;
10. }
11. //无法被缓存的资源：/WEB-INF/lib/, /WEB-INF/classes/
12. for (int i = 0; i < nonCacheable.length; i++) {
13. if (name.startsWith(nonCacheable[i])) {
14. return (null);
15. }
16. }
17. //
18. CacheEntry cacheEntry = cache.lookup(name);
19. if (cacheEntry == null) {
20. cacheEntry = new CacheEntry();
21. cacheEntry.name = name;
22. // Load entry
23. cacheLoad(cacheEntry);
24. } else {
25. /*cache有效期5秒，5秒之内不检查原文件能否有修改，超过有效期，
26. 需要验证原文件的lastModified和ContendLenth和缓存中的能否一致，
27. 不一致清理缓存，一致则升级缓存的timestap再次5秒有效期。*/
28. if (!validate(cacheEntry)) {
29. if (!revalidate(cacheEntry)) {
30. cacheUnload(cacheEntry.name);
31. return (null);
32. } else {
33. cacheEntry.timestamp =
34. System.currentTimeMillis() + cacheTTL;
35. }
36. }
37. cacheEntry.accessCount++;
38. }
39. return (cacheEntry);
40. }