Spring中的优秀工具类（1）：文件资源操做和 Web 相关工具类

文件资源操做

文件资源的操做是应用程序中常见的功能，如当上传一个文件后将其保存在特定目录下，从指定地址加载一个配置文件等等。咱们通常使用 JDK 的 I/O 处理类完成这些操做，但对于通常的应用程序来讲，JDK 的这些操做类所提供的方法过于底层，直接使用它们进行文件操做不但程序编写复杂并且容易产生错误。相比于 JDK 的 File，Spring 的 Resource 接口（资源概念的描述接口）抽象层面更高且涵盖面更广，Spring 提供了许多方便易用的资源操做工具类，它们大大下降资源操做的复杂度，同时具备更强的普适性。这些工具类不依赖于 Spring 容器，这意味着您能够在程序中象通常普通类同样使用它们。

加载文件资源

Spring 定义了一个 org.springframework.core.io.Resource 接口，Resource 接口是为了统一各类类型不一样的资源而定义的，Spring 提供了若干 Resource 接口的实现类，这些实现类能够轻松地加载不一样类型的底层资源，并提供了获取文件名、URL 地址以及资源内容的操做方法。

访问文件资源

假设有一个文件地位于 Web 应用的类路径下，您能够经过如下方式对这个文件资源进行访问：

• 经过 FileSystemResource 以文件系统绝对路径的方式进行访问；

• 经过 ClassPathResource 以类路径的方式进行访问；

• 经过 ServletContextResource 以相对于 Web 应用根目录的方式进行访问。

相比于经过 JDK 的 File 类访问文件资源的方式，Spring 的 Resource 实现类无疑提供了更加灵活的操做方式，您能够根据状况选择适合的 Resource 实现类访问资源。下面，咱们分别经过 FileSystemResource 和 ClassPathResource 访问同一个文件资源：

清单 1. FileSourceExample

 package com.baobaotao.io; 
 import java.io.IOException; 
 import java.io.InputStream; 
 import org.springframework.core.io.ClassPathResource; 
 import org.springframework.core.io.FileSystemResource; 
 import org.springframework.core.io.Resource; 
 public class FileSourceExample { 
    public static void main(String[] args) { 
        try { 
            String filePath = 
            "D:/masterSpring/chapter23/webapp/WEB-INF/classes/conf/file1.txt"; 
            // ① 使用系统文件路径方式加载文件
            Resource res1 = new FileSystemResource(filePath); 
            // ② 使用类路径方式加载文件
            Resource res2 = new ClassPathResource("conf/file1.txt"); 
            InputStream ins1 = res1.getInputStream(); 
            InputStream ins2 = res2.getInputStream(); 
            System.out.println("res1:"+res1.getFilename()); 
            System.out.println("res2:"+res2.getFilename()); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
 }

在获取资源后，您就能够经过 Resource 接口定义的多个方法访问文件的数据和其它的信息：如您能够经过 getFileName() 获取文件名，经过 getFile() 获取资源对应的 File 对象，经过 getInputStream() 直接获取文件的输入流。此外，您还能够经过 createRelative(String relativePath) 在资源相对地址上建立新的资源。

在 Web 应用中，您还能够经过 ServletContextResource 以相对于 Web 应用根目录的方式访问文件资源，以下所示：

 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> 
 <jsp:directive.page import="
    org.springframework.web.context.support.ServletContextResource"/> 
 <jsp:directive.page import="org.springframework.core.io.Resource"/> 
 <% 
    // ① 注意文件资源地址以相对于 Web 应用根路径的方式表示
    Resource res3 = new ServletContextResource(application, 
        "/WEB-INF/classes/conf/file1.txt"); 
    out.print(res3.getFilename()); 
 %>

对于位于远程服务器（Web 服务器或 FTP 服务器）的文件资源，您则能够方便地经过 UrlResource 进行访问。

为了方便访问不一样类型的资源，您必须使用相应的 Resource 实现类，是否能够在不显式使用 Resource 实现类的状况下，仅根据带特殊前缀的资源地址直接加载文件资源呢？ Spring 提供了一个 ResourceUtils 工具类，它支持“classpath:”和“file:”的地址前缀，它可以从指定的地址加载文件资源，请看下面的例子：

清单 2. ResourceUtilsExample

 package com.baobaotao.io; 
 import java.io.File; 
 import org.springframework.util.ResourceUtils; 
 public class ResourceUtilsExample { 
    public static void main(String[] args) throws Throwable{ 
        File clsFile = ResourceUtils.getFile("classpath:conf/file1.txt"); 
        System.out.println(clsFile.isFile()); 

        String httpFilePath = "file:D:/masterSpring/chapter23/src/conf/file1.txt"; 
        File httpFile = ResourceUtils.getFile(httpFilePath); 
        System.out.println(httpFile.isFile());        
    } 
 }

ResourceUtils 的 getFile(String resourceLocation) 方法支持带特殊前缀的资源地址，这样，咱们就能够在不和 Resource 实现类打交道的状况下使用 Spring 文件资源加载的功能了。

本地化文件资源

本地化文件资源是一组经过本地化标识名进行特殊命名的文件，Spring 提供的 LocalizedResourceHelper 容许经过文件资源基名和本地化实体获取匹配的本地化文件资源并以 Resource 对象返回。假设在类路径的 i18n 目录下，拥有一组基名为 message 的本地化文件资源，咱们经过如下实例演示获取对应中国大陆和美国的本地化文件资源：

清单 3. LocaleResourceTest

 package com.baobaotao.io; 
 import java.util.Locale; 
 import org.springframework.core.io.Resource; 
 import org.springframework.core.io.support.LocalizedResourceHelper; 
 public class LocaleResourceTest { 
    public static void main(String[] args) { 
        LocalizedResourceHelper lrHalper = new LocalizedResourceHelper(); 
        // ① 获取对应美国的本地化文件资源
        Resource msg_us = lrHalper.findLocalizedResource("i18n/message", ".properties", 
        Locale.US); 
        // ② 获取对应中国大陆的本地化文件资源
        Resource msg_cn = lrHalper.findLocalizedResource("i18n/message", ".properties", 
        Locale.CHINA); 
        System.out.println("fileName(us):"+msg_us.getFilename()); 
        System.out.println("fileName(cn):"+msg_cn.getFilename()); 
    } 
 }

虽然 JDK 的 java.util.ResourceBundle 类也能够经过类似的方式获取本地化文件资源，可是其返回的是 ResourceBundle 类型的对象。若是您决定统一使用 Spring 的 Resource 接表征文件资源，那么 LocalizedResourceHelper 就是获取文件资源的很是适合的帮助类了。

文件操做

在使用各类 Resource 接口的实现类加载文件资源后，常常须要对文件资源进行读取、拷贝、转存等不一样类型的操做。您能够经过 Resource 接口所提供了方法完成这些功能，不过在大多数状况下，经过 Spring 为 Resource 所配备的工具类完成文件资源的操做将更加方便。

文件内容拷贝

第一个咱们要认识的是 FileCopyUtils，它提供了许多一步式的静态操做方法，可以将文件内容拷贝到一个目标 byte[]、String 甚至一个输出流或输出文件中。下面的实例展现了 FileCopyUtils 具体使用方法：

清单 4. FileCopyUtilsExample

 package com.baobaotao.io; 
 import java.io.ByteArrayOutputStream; 
 import java.io.File; 
 import java.io.FileReader; 
 import java.io.OutputStream; 
 import org.springframework.core.io.ClassPathResource; 
 import org.springframework.core.io.Resource; 
 import org.springframework.util.FileCopyUtils; 
 public class FileCopyUtilsExample { 
    public static void main(String[] args) throws Throwable { 
        Resource res = new ClassPathResource("conf/file1.txt"); 
        // ① 将文件内容拷贝到一个 byte[] 中
        byte[] fileData = FileCopyUtils.copyToByteArray(res.getFile()); 
        // ② 将文件内容拷贝到一个 String 中
        String fileStr = FileCopyUtils.copyToString(new FileReader(res.getFile())); 
        // ③ 将文件内容拷贝到另外一个目标文件
        FileCopyUtils.copy(res.getFile(), 
        new File(res.getFile().getParent()+ "/file2.txt")); 

        // ④ 将文件内容拷贝到一个输出流中
        OutputStream os = new ByteArrayOutputStream(); 
        FileCopyUtils.copy(res.getInputStream(), os); 
    } 
 }

每每咱们都经过直接操做 InputStream 读取文件的内容，可是流操做的代码是比较底层的，代码的面向对象性并不强。经过 FileCopyUtils 读取和拷贝文件内容易于操做且至关直观。如在 ① 处，咱们经过 FileCopyUtils 的 copyToByteArray(File in) 方法就能够直接将文件内容读到一个 byte[] 中；另外一个可用的方法是 copyToByteArray(InputStream in)，它将输入流读取到一个 byte[] 中。

若是是文本文件，您可能但愿将文件内容读取到 String 中，此时您可使用 copyToString(Reader in) 方法，如 ② 所示。使用 FileReader 对 File 进行封装，或使用 InputStreamReader 对 InputStream 进行封装就能够了。

FileCopyUtils 还提供了多个将文件内容拷贝到各类目标对象中的方法，这些方法包括：

方法	说明
static void copy(byte[] in, File out)	将 byte[] 拷贝到一个文件中
static void copy(byte[] in, OutputStream out)	将 byte[] 拷贝到一个输出流中
static int copy(File in, File out)	将文件拷贝到另外一个文件中
static int copy(InputStream in, OutputStream out)	将输入流拷贝到输出流中
static int copy(Reader in, Writer out)	将 Reader 读取的内容拷贝到 Writer 指向目标输出中
static void copy(String in, Writer out)	将字符串拷贝到一个 Writer 指向的目标中

在实例中，咱们虽然使用 Resource 加载文件资源，但 FileCopyUtils 自己和 Resource 没有任何关系，您彻底能够在基于 JDK I/O API 的程序中使用这个工具类。

属性文件操做

咱们知道能够经过 java.util.Properties 的 load(InputStream inStream) 方法从一个输入流中加载属性资源。Spring 提供的 PropertiesLoaderUtils 容许您直接经过基于类路径的文件地址加载属性资源，请看下面的例子：

 package com.baobaotao.io; 
 import java.util.Properties; 
 import org.springframework.core.io.support.PropertiesLoaderUtils; 
 public class PropertiesLoaderUtilsExample { 
    public static void main(String[] args) throws Throwable {    
        // ① jdbc.properties 是位于类路径下的文件
        Properties props = PropertiesLoaderUtils.loadAllProperties("jdbc.properties"); 
        System.out.println(props.getProperty("jdbc.driverClassName")); 
    } 
 }

通常状况下，应用程序的属性文件都放置在类路径下，因此 PropertiesLoaderUtils 比之于 Properties#load(InputStream inStream) 方法显然具备更强的实用性。此外，PropertiesLoaderUtils 还能够直接从 Resource 对象中加载属性资源：

方法	说明
static Properties loadProperties(Resource resource)	从 Resource 中加载属性
static void fillProperties(Properties props, Resource resource)	将 Resource 中的属性数据添加到一个已经存在的 Properties 对象中

特殊编码的资源

当您使用 Resource 实现类加载文件资源时，它默认采用操做系统的编码格式。若是文件资源采用了特殊的编码格式（如 UTF-8），则在读取资源内容时必须事先经过 EncodedResource 指定编码格式，不然将会产生中文乱码的问题。

清单 5. EncodedResourceExample

 package com.baobaotao.io; 
 import org.springframework.core.io.ClassPathResource; 
 import org.springframework.core.io.Resource; 
 import org.springframework.core.io.support.EncodedResource; 
 import org.springframework.util.FileCopyUtils; 
 public class EncodedResourceExample { 
        public static void main(String[] args) throws Throwable  { 
            Resource res = new ClassPathResource("conf/file1.txt"); 
            // ① 指定文件资源对应的编码格式（UTF-8）
            EncodedResource encRes = new EncodedResource(res,"UTF-8"); 
            // ② 这样才能正确读取文件的内容，而不会出现乱码
            String content  = FileCopyUtils.copyToString(encRes.getReader()); 
            System.out.println(content);  
    } 
 }

EncodedResource 拥有一个 getResource() 方法获取 Resource，但该方法返回的是经过构造函数传入的原 Resource 对象，因此必须经过 EncodedResource#getReader() 获取应用编码后的 Reader 对象，而后再经过该 Reader 读取文件的内容。

回页首

Web 相关工具类

您几乎老是使用 Spring 框架开发 Web 的应用，Spring 为 Web 应用提供了不少有用的工具类，这些工具类能够给您的程序开发带来不少便利。在这节里，咱们将逐一介绍这些工具类的使用方法。

操做 Servlet API 的工具类

当您在控制器、JSP 页面中想直接访问 Spring 容器时，您必须事先获取 WebApplicationContext 对象。Spring 容器在启动时将 WebApplicationContext 保存在 ServletContext 的属性列表中，经过 WebApplicationContextUtils 工具类能够方便地获取 WebApplicationContext 对象。

WebApplicationContextUtils

当 Web 应用集成 Spring 容器后，表明 Spring 容器的 WebApplicationContext 对象将以 WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE 为键存放在 ServletContext 属性列表中。您固然能够直接经过如下语句获取 WebApplicationContext：

 WebApplicationContext wac = (WebApplicationContext)servletContext. 
 getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

但经过位于 org.springframework.web.context.support 包中的 WebApplicationContextUtils 工具类获取 WebApplicationContext 更方便：

 WebApplicationContext wac =WebApplicationContextUtils. 
 getWebApplicationContext(servletContext);

当 ServletContext 属性列表中不存在 WebApplicationContext 时，getWebApplicationContext() 方法不会抛出异常，它简单地返回 null。若是后续代码直接访问返回的结果将引起一个 NullPointerException 异常，而 WebApplicationContextUtils 另外一个 getRequiredWebApplicationContext(ServletContext sc) 方法要求 ServletContext 属性列表中必定要包含一个有效的 WebApplicationContext 对象，不然立刻抛出一个 IllegalStateException 异常。咱们推荐使用后者，由于它能提早发现错误的时间，强制开发者搭建好必备的基础设施。

WebUtils

位于 org.springframework.web.util 包中的 WebUtils 是一个很是好用的工具类，它对不少 Servlet API 提供了易用的代理方法，下降了访问 Servlet API 的复杂度，能够将其当作是经常使用 Servlet API 方法的门面类。

下面这些方法为访问 HttpServletRequest 和 HttpSession 中的对象和属性带来了方便：

方法	说明
Cookie getCookie(HttpServletRequest request, String name)	获取 HttpServletRequest 中特定名字的 Cookie 对象。若是您须要建立 Cookie， Spring 也提供了一个方便的 CookieGenerator 工具类；
Object getSessionAttribute(HttpServletRequest request, String name)	获取 HttpSession 特定属性名的对象，不然您必须经过 request.getHttpSession.getAttribute(name) 完成相同的操做；
Object getRequiredSessionAttribute(HttpServletRequest request, String name)	和上一个方法相似，只不过强制要求 HttpSession 中拥有指定的属性，不然抛出异常；
String getSessionId(HttpServletRequest request)	获取 Session ID 的值；
void exposeRequestAttributes(ServletRequest request, Map attributes)	将 Map 元素添加到 ServletRequest 的属性列表中，当请求被导向（forward）到下一个处理程序时，这些请求属性就能够被访问到了；

此外，WebUtils 还提供了一些和 ServletContext 相关的方便方法：

方法	说明
String getRealPath(ServletContext servletContext, String path)	获取相对路径对应文件系统的真实文件路径；
File getTempDir(ServletContext servletContext)	获取 ServletContex 对应的临时文件地址，它以 File 对象的形式返回。

下面的片段演示了使用 WebUtils 从 HttpSession 中获取属性对象的操做：

 protected Object formBackingObject(HttpServletRequest request) throws Exception { 
    UserSession userSession = (UserSession) WebUtils.getSessionAttribute(request, 
        "userSession"); 
    if (userSession != null) { 
        return new AccountForm(this.petStore.getAccount( 
        userSession.getAccount().getUsername())); 
    } else { 
        return new AccountForm(); 
    } 
 }

Spring 所提供的过滤器和监听器

Spring 为 Web 应用提供了几个过滤器和监听器，在适合的时间使用它们，能够解决一些常见的 Web 应用问题。

延迟加载过滤器

Hibernate 容许对关联对象、属性进行延迟加载，可是必须保证延迟加载的操做限于同一个 Hibernate Session 范围以内进行。若是 Service 层返回一个启用了延迟加载功能的领域对象给 Web 层，当 Web 层访问到那些须要延迟加载的数据时，因为加载领域对象的 Hibernate Session 已经关闭，这些致使延迟加载数据的访问异常。

Spring 为此专门提供了一个 OpenSessionInViewFilter 过滤器，它的主要功能是使每一个请求过程绑定一个 Hibernate Session，即便最初的事务已经完成了，也能够在 Web 层进行延迟加载的操做。

OpenSessionInViewFilter 过滤器将 Hibernate Session 绑定到请求线程中，它将自动被 Spring 的事务管理器探测到。因此 OpenSessionInViewFilter 适用于 Service 层使用 HibernateTransactionManager 或 JtaTransactionManager 进行事务管理的环境，也能够用于非事务只读的数据操做中。

要启用这个过滤器，必须在 web.xml 中对此进行配置：

…
 <filter> 
    <filter-name>hibernateFilter</filter-name> 
    <filter-class> 
    org.springframework.orm.hibernate3.support.OpenSessionInViewFilter 
    </filter-class> 
 </filter> 
 <filter-mapping> 
    <filter-name>hibernateFilter</filter-name> 
    <url-pattern>*.html</url-pattern> 
 </filter-mapping> 
…

上面的配置，咱们假设使用 .html 的后缀做为 Web 框架的 URL 匹配模式，若是您使用 Struts 等 Web 框架，能够将其改成对应的“*.do”模型。

中文乱码过滤器

在您经过表单向服务器提交数据时，一个经典的问题就是中文乱码问题。虽然咱们全部的 JSP 文件和页面编码格式都采用 UTF-8，但这个问题仍是会出现。解决的办法很简单，咱们只须要在 web.xml 中配置一个 Spring 的编码转换过滤器就能够了：

 <web-app> 
 <!---listener 的配置 --> 
 <filter> 
    <filter-name>encodingFilter</filter-name> 
    <filter-class> 
        org.springframework.web.filter.CharacterEncodingFilter ① Spring 编辑过滤器
    </filter-class> 
    <init-param> ② 编码方式
        <param-name>encoding</param-name> 
        <param-value>UTF-8</param-value> 
    </init-param> 
    <init-param> ③ 强制进行编码转换
        <param-name>forceEncoding</param-name> 
        <param-value>true</param-value> 
    </init-param> 
    </filter> 
    <filter-mapping> ② 过滤器的匹配 URL 
        <filter-name>encodingFilter</filter-name> 
        <url-pattern>*.html</url-pattern> 
    </filter-mapping> 

 <!---servlet 的配置 --> 
 </web-app>

这样全部以 .html 为后缀的 URL 请求的数据都会被转码为 UTF-8 编码格式，表单中文乱码的问题就能够解决了。

请求跟踪日志过滤器

除了以上两个经常使用的过滤器外，还有两个在程序调试时可能会用到的请求日志跟踪过滤器，它们会将请求的一些重要信息记录到日志中，方便程序的调试。这两个日志过滤器只有在日志级别为 DEBUG 时才会起做用：

方法	说明
org.springframework.web.filter.ServletContextRequestLoggingFilter	该过滤器将请求的 URI 记录到 Common 日志中（如经过 Log4J 指定的日志文件）；
org.springframework.web.filter.ServletContextRequestLoggingFilter	该过滤器将请求的 URI 记录到 ServletContext 日志中。

如下是日志过滤器记录的请求跟踪日志的片段：

(JspServlet.java:224) - JspEngine --> /htmlTest.jsp 
(JspServlet.java:225) - ServletPath: /htmlTest.jsp 
(JspServlet.java:226) - PathInfo: null 
(JspServlet.java:227) - RealPath: D:\masterSpring\chapter23\webapp\htmlTest.jsp 
(JspServlet.java:228) - RequestURI: /baobaotao/htmlTest.jsp 
…

经过这个请求跟踪日志，程度调试者能够详细地查看到有哪些请求被调用，请求的参数是什么，请求是否正确返回等信息。虽然这两个请求跟踪日志过滤器通常在程序调试时使用，可是即便程序部署不将其从 web.xml 中移除也不会有大碍，由于只要将日志级别设置为 DEBUG 以上级别，它们就不会输出请求跟踪日志信息了。

转存 Web 应用根目录监听器和 Log4J 监听器

Spring 在 org.springframework.web.util 包中提供了几个特殊用途的 Servlet 监听器，正确地使用它们能够完成一些特定需求的功能。好比某些第三方工具支持经过 ${key} 的方式引用系统参数（便可以经过 System.getProperty() 获取的属性），WebAppRootListener 能够将 Web 应用根目录添加到系统参数中，对应的属性名能够经过名为“webAppRootKey”的 Servlet 上下文参数指定，默认为“webapp.root”。下面是该监听器的具体的配置：

清单 6. WebAppRootListener 监听器配置

…
 <context-param> 
    <param-name>webAppRootKey</param-name> 
    <param-value>baobaotao.root</param-value> ① Web 应用根目录以该属性名添加到系统参数中
 </context-param> 
…
② 负责将 Web 应用根目录以 webAppRootKey 上下文参数指定的属性名添加到系统参数中
 <listener> 
    <listener-class> 
    org.springframework.web.util.WebAppRootListener 
    </listener-class> 
 </listener> 
…

这样，您就能够在程序中经过 System.getProperty("baobaotao.root") 获取 Web 应用的根目录了。不过更常见的使用场景是在第三方工具的配置文件中经过 ${baobaotao.root} 引用 Web 应用的根目录。好比如下的 log4j.properties 配置文件就经过 ${baobaotao.root} 设置了日志文件的地址：

 log4j.rootLogger=INFO,R 
 log4j.appender.R=org.apache.log4j.RollingFileAppender 
 log4j.appender.R.File=${baobaotao.root}/WEB-INF/logs/log4j.log ① 指定日志文件的地址
 log4j.appender.R.MaxFileSize=100KB 
 log4j.appender.R.MaxBackupIndex=1 
 log4j.appender.R.layout.ConversionPattern=%d %5p [%t] (%F:%L) - %m%n

另外一个专门用于 Log4J 的监听器是 Log4jConfigListener。通常状况下，您必须将 Log4J 日志配置文件以 log4j.properties 为文件名并保存在类路径下。Log4jConfigListener 容许您经过 log4jConfigLocation Servlet 上下文参数显式指定 Log4J 配置文件的地址，以下所示：

① 指定 Log4J 配置文件的地址
 <context-param> 
    <param-name>log4jConfigLocation</param-name> 
    <param-value>/WEB-INF/log4j.properties</param-value> 
 </context-param> 
…
② 使用该监听器初始化 Log4J 日志引擎
 <listener> 
    <listener-class> 
    org.springframework.web.util.Log4jConfigListener 
    </listener-class> 
 </listener> 
…

提示

一些 Web 应用服务器（如 Tomcat）不会为不一样的 Web 应用使用独立的系统参数，也就是说，应用服务器上全部的 Web 应用都共享同一个系统参数对象。这时，您必须经过 webAppRootKey 上下文参数为不一样 Web 应用指定不一样的属性名：如第一个 Web 应用使用 webapp1.root 而第二个 Web 应用使用 webapp2.root 等，这样才不会发生后者覆盖前者的问题。此外，WebAppRootListener 和 Log4jConfigListener 都只能应用在 Web 应用部署后 WAR 文件会解包的 Web 应用服务器上。一些 Web 应用服务器不会将 Web 应用的 WAR 文件解包，整个 Web 应用以一个 WAR 包的方式存在（如 Weblogic），此时由于没法指定对应文件系统的 Web 应用根目录，使用这两个监听器将会发生问题。

Log4jConfigListener 监听器包括了 WebAppRootListener 的功能，也就是说，Log4jConfigListener 会自动完成将 Web 应用根目录以 webAppRootKey 上下文参数指定的属性名添加到系统参数中，因此当您使用 Log4jConfigListener 后，就没有必须再使用 WebAppRootListener 了。

Introspector 缓存清除监听器

Spring 还提供了一个名为 org.springframework.web.util.IntrospectorCleanupListener 的监听器。它主要负责处理由 JavaBean Introspector 功能而引发的缓存泄露。IntrospectorCleanupListener 监听器在 Web 应用关闭的时会负责清除 JavaBean Introspector 的缓存，在 web.xml 中注册这个监听器能够保证在 Web 应用关闭的时候释放与其相关的 ClassLoader 的缓存和类引用。若是您使用了 JavaBean Introspector 分析应用中的类，Introspector 缓存会保留这些类的引用，结果在应用关闭的时候，这些类以及 Web 应用相关的 ClassLoader 不能被垃圾回收。不幸的是，清除 Introspector 的惟一方式是刷新整个缓存，这是由于无法准确判断哪些是属于本 Web 应用的引用对象，哪些是属于其它 Web 应用的引用对象。因此删除被缓存的 Introspection 会致使将整个 JVM 全部应用的 Introspection 都删掉。须要注意的是，Spring 托管的 Bean 不须要使用这个监听器，由于 Spring 的 Introspection 所使用的缓存在分析完一个类以后会立刻从 javaBean Introspector 缓存中清除掉，并将缓存保存在应用程序特定的 ClassLoader 中，因此它们通常不会致使内存资源泄露。可是一些类库和框架每每会产生这个问题。例如 Struts 和 Quartz 的 Introspector 的内存泄漏会致使整个的 Web 应用的 ClassLoader 不能进行垃圾回收。在 Web 应用关闭以后，您还会看到此应用的全部静态类引用，这个错误固然不是由这个类自身引发的。解决这个问题的方法很简单，您仅需在 web.xml 中配置 IntrospectorCleanupListener 监听器就能够了：

 <listener> 
    <listener-class> 
    org.springframework.web.util.IntrospectorCleanupListener 
    </listener-class> 
 </listener>

回页首

小结

本文介绍了一些经常使用的 Spring 工具类，其中大部分 Spring 工具类不但能够在基于 Spring 的应用中使用，还能够在其它的应用中使用。使用 JDK 的文件操做类在访问类路径相关、Web 上下文相关的文件资源时，每每显得拖泥带水、拐弯抹角，Spring 的 Resource 实现类使这些工做变得轻松了许多。

在 Web 应用中，有时你但愿直接访问 Spring 容器，获取容器中的 Bean，这时使用 WebApplicationContextUtils 工具类从 ServletContext 中获取 WebApplicationContext 是很是方便的。WebUtils 为访问 Servlet API 提供了一套便捷的代理方法，您能够经过 WebUtils 更好的访问 HttpSession 或 ServletContext 的信息。

Spring 提供了几个 Servlet 过滤器和监听器，其中 ServletContextRequestLoggingFilter 和 ServletContextRequestLoggingFilter 能够记录请求访问的跟踪日志，你能够在程序调试时使用它们获取请求调用的详细信息。WebAppRootListener 能够将 Web 应用的根目录以特定属性名添加到系统参数中，以便第三方工具类经过 ${key} 的方式进行访问。Log4jConfigListener 容许你指定 Log4J 日志配置文件的地址，且能够在配置文件中经过 ${key} 的方式引用 Web 应用根目录，若是你须要在 Web 应用相关的目录建立日志文件，使用 Log4jConfigListener 能够很容易地达到这一目标。

Web 应用的内存泄漏是最让开发者头疼的问题，虽然不正确的程序编写多是这一问题的根源，也有多是一些第三方框架的 JavaBean Introspector 缓存得不到清除而致使的，Spring 专门为解决这一问题配备了 IntrospectorCleanupListener 监听器，它只要简单在 web.xml 中声明该监听器就能够了。