• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

Spring的模块化是很强的，各个功能模块都是独立的，我们可以选择的使用。这一章先从Spring的IoC开始。所谓IoC就是一个用XML来定义生成对象的模式，我们看看如果来使用的。

　　数据模型

　　1、如下图所示有三个类，Human（人类）是接口，Chinese（中国人）是一个子类，American（美国人）是另外一个子类。

　　

　　源代码如下：

package cn.com.chengang.spring;public interface Human {void eat();void walk();}package cn.com.chengang.spring;public class Chinese implements Human {/* （非 Javadoc）* @see cn.com.chengang.spring.Human#eat()*/public void eat() {System.out.println("中国人对吃很有一套");}/* （非 Javadoc）* @see cn.com.chengang.spring.Human#walk()*/public void walk() {System.out.println("中国人行如飞");}}package cn.com.chengang.spring;public class American implements Human {/* （非 Javadoc）* @see cn.com.chengang.spring.Human#eat()*/public void eat() {System.out.println("美国人主要以面包为主");}/* （非 Javadoc）* @see cn.com.chengang.spring.Human#walk()*/public void walk() {System.out.println("美国人以车代步，有四肢退化的趋势");}} 


　　2、对以上对象采用工厂模式的用法如下

　　创建一个工厂类Factory，如下。这个工厂类里定义了两个字符串常量，所标识不同的人种。getHuman方法根据传入参数的字串，来判断要生成什么样的人种。

package cn.com.chengang.spring;public class Factory {public final static String CHINESE = "Chinese";public final static String AMERICAN = "American";public Human getHuman(String ethnic) {if (ethnic.equals(CHINESE))return new Chinese();else if (ethnic.equals(AMERICAN))return new American();elsethrow new IllegalArgumentException("参数(人种)错误");}} 

　　下面是一个测试的程序，使用工厂方法来得到了不同的“人种对象”，并执行相应的方法。

package cn.com.chengang.spring;public class ClientTest {public static void main(String[] args) {Human human = null;human = new Factory().getHuman(Factory.CHINESE);human.eat();human.walk();human = new Factory().getHuman(Factory.AMERICAN);human.eat();human.walk();}} 


　　控制台的打印结果如下：

        

　　3、采用Spring的IoC的用法如下：

　　在项目根目录下创建一个bean.xml文件

＜?xml version="1.0" encoding="UTF-8"?＞
＜!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="Chinese" class="cn.com.chengang.spring.Chinese"/＞
＜bean id="American" class="cn.com.chengang.spring.American"/＞
＜/beans＞ 


　　bean.xml的位置如下图，注意不要看花眼把它看成是lib目录下的了，它是在myspring目录下的。

        

　　修改ClientTest程序如下：

package cn.com.chengang.spring;import org.springframework.context.ApplicationContext;import org.springframework.context.support.FileSystemXmlApplicationContext;public class ClientTest {public final static String CHINESE = "Chinese";public final static String AMERICAN = "American";public static void main(String[] args) {// Human human = null;// human = new Factory().getHuman(Factory.CHINESE);// human.eat();// human.walk();// human = new Factory().getHuman(Factory.AMERICAN);// human.eat();// human.walk();ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");Human human = null;human = (Human) ctx.getBean(CHINESE);human.eat();human.walk();human = (Human) ctx.getBean(AMERICAN);human.eat();human.walk();}} 

　　从这个程序可以看到，ctx就相当于原来的Factory工厂，原来的Factory就可以删除掉了。然后又把Factory里的两个常量移到了ClientTest类里，整个程序结构基本一样。

　　再回头看原来的bean.xml文件的这一句：

　　＜bean id="Chinese" class="cn.com.chengang.spring.Chinese"/＞

　　id就是ctx.getBean的参数值，一个字符串。class就是一个类（包名＋类名）。然后在ClientTest类里获得Chinese对象就是这么一句

　　human = （Human） ctx.getBean（CHINESE）；

　　因为getBean方法返回的是Object类型，所以前面要加一个类型转换。

　　总结

　　（1）也许有人说，IoC和工厂模式不是一样的作用吗，用IoC好象还麻烦一点。

　　举个例子，如果用户需求发生变化，要把Chinese类修改一下。那么前一种工厂模式，就要更改Factory类的方法，并且重新编译布署。而IoC只需要将class属性改变一下，并且由于IoC利用了Java反射机制，这些对象是动态生成的，这时我们就可以热插拨Chinese对象（不必把原程序停止下来重新编译布署）

　　（2）也许有人说，即然IoC这么好，那么我把系统所有对象都用IoC方式来生成。

　　注意，IoC的灵活性是有代价的：设置步骤麻烦、生成对象的方式不直观、反射比正常生成对象在效率上慢一点。因此使用IoC要看有没有必要，我认为比较通用的判断方式是：用到工厂模式的地方都可以考虑用IoC模式。

　　（3）在上面的IoC的方式里，还有一些可以变化的地方。比如，bean.xml不一定要放在项目录下，也可以放在其他地方，比如cn.com.chengang.spring包里。不过在使用时也要变化一下，如下所示：

　　new FileSystemXmlApplicationContext（"src/cn/com/chengang/spring/bean.xml"）；

　　另外，bean.xml也可以改成其他名字。这样我们在系统中就可以分门别类的设置不同的bean.xml.

　　（4）关于IoC的低侵入性。

　　什么是低侵入性？如果你用过Struts或EJB就会发现，要继承一些接口或类，才能利用它们的框架开发。这样，系统就被绑定在Struts、EJB上了，对系统的可移植性产生不利的影响。如果代码中很少涉及某一个框架的代码，那么这个框架就可以称做是一个低侵入性的框架。

　　Spring的侵入性很低，Humen.java、Chinese.java等几个类都不必继承什么接口或类。但在ClientTest里还是有一些Spring的影子：FileSystemXmlApplicationContext类和ctx.getBean方式等。

　　现在，低侵入性似乎也成了判定一个框架的实现技术好坏的标准之一。

　　（5）关于bean.xml的用法

　　bean.xml的用法还有很多，其中内容是相当丰富的。假设Chinese类里有一个humenName属性（姓名），那么原的bean.xml修改如下。此后生成Chinese对象时，“陈刚”这个值将自动设置到Chinese类的humenName属性中。而且由于singleton为true这时生成Chinese对象将采用单例模式，系统仅存在一个Chinese对象实例。

＜?xml version="1.0" encoding="UTF-8"?＞＜!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"     "http://www.springframework.org/dtd/spring-beans.dtd"＞＜beans＞＜bean id="Chinese" class="cn.com.chengang.spring.Chinese" singleton="true"＞＜property name="humenName"＞＜value＞陈刚＜/value＞＜/property＞＜/bean＞＜bean id="American" class="cn.com.chengang.spring.American"/＞＜/beans＞ 


　　关于bean.xml的其它用法，不再详细介绍了，大家自己拿Spring的文档一看就明白了。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

我们来分析一下这个Demo，它的业务逻辑是求图形的面积，如果把日志服务的代码直接写在业务逻辑中，那么业务逻辑就不是纯净的，而服务也不能被其他业务逻辑共享，所以我们需要把日志服务单独写成一个类，然后通过Spring的AOP实现，动态的把服务插入到业务逻辑中。理解了这点我们再来看IOC，其实IOC的核心思想就是面向接口编程；在这里求圆的面积和求正方形的面积是不一样的，那么为了减弱对象与对象的之间的依赖关系，我们需要对业务逻辑进行抽象，即定义圆形和正方形的接口－－几何图形。 
//定义业务逻辑的抽象－－Figure接口
package mypack;
public interface Figure {
 
 void computeArea();
}
 
//定义业务逻辑的实现－－圆形
package mypack;
public class Round implements Figure{
 public void computeArea() {
  System.out.println("计算圆形面积");
 }
}
//定义业务逻辑的实现－－正方形
package mypack;
public class Square implements Figure{
 public void computeArea() {
  System.out.println("计算正方形面积");
 }
}
 //对业务逻辑封装的抽象
package mypack;
public interface ComputeInterface {
 public abstract void compute();
}
//对业务逻辑进行封装，并采用set注入方式来实现依赖注入
package mypack;
public class Compute implements ComputeInterface {
 private Figure figure;
 public Figure getFigure() {
  return figure;
 }
 public void setFigure(Figure figure) {       //set注入
  this.figure = figure;
 }
 
 public void compute(){      //业务逻辑封装
  figure.computeArea();
 }
}
 
//将日志服务从业务逻辑中剥离出来产生一个Advice，这个Advice从而可以为其他业务逻辑反复使用
package mypack;
import java.lang.reflect.*;
import java.util.logging.*;
import org.springframework.aop.*;
public class LogBeforeAdvice implements MethodBeforeAdvice{
 private Logger loger = Logger.getLogger(this.getClass().getName());
 
 public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
  loger.log(Level.INFO, "方法开始启动 " + arg0);  
 }
  
}
 
//applicationContext.xml在后面做了很多事情，如实现依赖注入和产生动态代理对象将Advice织入到业务逻辑中
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
 <bean id="round" class="mypack.Round">
 </bean>
 
 <bean id="square" class="mypack.Square">
 </bean>
 
 <bean id="compute" class="mypack.Compute">
  <property name="figure">
   <ref bean="round"/>
  </property>
 </bean>
 
 <bean id="logBeforeAdvice" class="mypack.LogBeforeAdvice">
 </bean>
 
 <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  
  <property name="proxyInterfaces">
   <value>mypack.ComputeInterface</value>
  </property> 
  
  <property name="target">
   <ref bean="compute"/>
  </property>
  
  <property name="interceptorNames">
   <list>
    <value>logBeforeAdvice</value>
   </list>
  </property>
 </bean>
</beans>
 
//最后来写一段测试代码来测试上面的代码
package mypack;
import org.springframework.context.*;
import org.springframework.context.support.*;
public class TestDemo {
 
 public static void main(String[] args) {
  ApplicationContext context = new FileSystemXmlApplicationContext("applicationContext.xml");
  
  ComputeInterface comp = (ComputeInterface)context.getBean("proxy");
  comp.compute();
 }
 
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

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>

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

Spring 不但提供了一个功能全面的应用开发框架，本身还拥有众多可以在程序编写时直接使用的工具类，您不但可以在 Spring 应用中使用这些工具类，也可以在其它的应用中使用，这些工具类中的大部分是可以在脱离 Spring 框架时使用的。了解 Spring 中有哪些好用的工具类并在程序编写时适当使用，将有助于提高开发效率、增强代码质量。

在这个分为两部分的文章中，我们将从众多的 Spring 工具类中遴选出那些好用的工具类介绍给大家。第 1 部分 介绍了与文件资源操作和 Web 相关的工具类。在第 2 部分中将介绍特殊字符转义和方法入参检测工具类。

特殊字符转义

由于 Web 应用程序需要联合使用到多种语言，每种语言都包含一些特殊的字符，对于动态语言或标签式的语言而言，如果需要动态构造语言的内容时，一个我们经常会碰到的问题就是特殊字符转义的问题。下面是 Web 开发者最常面对需要转义的特殊字符类型：

HTML 特殊字符； 
JavaScript 特殊字符； 
SQL 特殊字符； 
如果不对这些特殊字符进行转义处理，则不但可能破坏文档结构，还可以引发潜在的安全问题。Spring 为 HTML 和 JavaScript 特殊字符提供了转义操作工具类，它们分别是 HtmlUtils 和 JavaScriptUtils。

HTML 特殊字符转义

HTML 中 <，>，& 等字符有特殊含义，它们是 HTML 语言的保留字，因此不能直接使用。使用这些个字符时，应使用它们的转义序列：

&：& 
" ：" 
< ：< 
> ：> 
由于 HTML 网页本身就是一个文本型结构化文档，如果直接将这些包含了 HTML 特殊字符的内容输出到网页中，极有可能破坏整个 HTML 文档的结构。所以，一般情况下需要对动态数据进行转义处理，使用转义序列表示 HTML 特殊字符。下面的 JSP 网页将一些变量动态输出到 HTML 网页中：


清单 1. 未进行 HTML 特殊字符转义处理网页
                
<%@ page language="java" contentType="text/html; charset=utf-8"%>
<%!
   String userName = "</td><tr></table>";
   String address = " \" type=\"button";
 %>
<table border="1">
   <tr>
     <td>姓名：</td><td><%=userName%></td> ①
   </tr>
   <tr>
     <td>年龄：</td><td>28</td>
   </tr>
</table>
 <input value="<%=address%>"  type="text" /> ②
 


在 ① 和 ② 处，我们未经任何转义处理就直接将变量输出到 HTML 网页中，由于这些变量可能包含一些特殊的 HTML 的字符，它们将可能破坏整个 HTML 文档的结构。我们可以从以上 JSP 页面的一个具体输出中了解这一问题：

<table border="1">
   <tr>
     <td>姓名：</td><td></td><tr></table></td> 
     ① 破坏了 <table> 的结构
   </tr>
   <tr>
     <td>年龄：</td><td>28</td>
   </tr>
</table>
 <input value=" " type="button"  type="text" /> 
 ② 将本来是输入框组件偷梁换柱为按钮组件
 


融合动态数据后的 HTML 网页已经面目全非，首先 ① 处的 <table> 结构被包含 HTML 特殊字符的 userName 变量截断了，造成其后的 <table> 代码变成无效的内容；其次，② 处 <input> 被动态数据改换为按钮类型的组件（type="button"）。为了避免这一问题，我们需要事先对可能破坏 HTML 文档结构的动态数据进行转义处理。Spring 为我们提供了一个简单适用的 HTML 特殊字符转义工具类，它就是 HtmlUtils。下面，我们通过一个简单的例子了解 HtmlUtils 的具体用法：


清单 2. HtmpEscapeExample
                
package com.baobaotao.escape;
import org.springframework.web.util.HtmlUtils;
public class HtmpEscapeExample {
    public static void main(String[] args) {
        String specialStr = "<div id=\"testDiv\">test1;test2</div>";
        String str1 = HtmlUtils.htmlEscape(specialStr); ①转换为HTML转义字符表示
        System.out.println(str1);
       
        String str2 = HtmlUtils.htmlEscapeDecimal(specialStr); ②转换为数据转义表示
        System.out.println(str2);
       
        String str3 = HtmlUtils.htmlEscapeHex(specialStr); ③转换为十六进制数据转义表示
        System.out.println(str3);
       
        ④下面对转义后字符串进行反向操作
        System.out.println(HtmlUtils.htmlUnescape(str1));
        System.out.println(HtmlUtils.htmlUnescape(str2));
        System.out.println(HtmlUtils.htmlUnescape(str3));
    }
}
 


HTML 不但可以使用通用的转义序列表示 HTML 特殊字符，还可以使用以 # 为前缀的数字序列表示 HTML 特殊字符，它们在最终的显示效果上是一样的。HtmlUtils 提供了三个转义方法：

方法 说明 
static String htmlEscape(String input)  将 HTML 特殊字符转义为 HTML 通用转义序列； 
static String htmlEscapeDecimal(String input)  将 HTML 特殊字符转义为带 # 的十进制数据转义序列； 
static String htmlEscapeHex(String input)  将 HTML 特殊字符转义为带 # 的十六进制数据转义序列； 

此外，HtmlUtils 还提供了一个能够将经过转义内容还原的方法：htmlUnescape(String input)，它可以还原以上三种转义序列的内容。运行以上代码，您将可以看到以下的输出：

str1:<div id="testDiv">test1;test2</div>
str2:<div id="testDiv">test1;test2</div>
str3:<div id="testDiv">test1;test2</div>
<div id="testDiv">test1;test2</div>
<div id="testDiv">test1;test2</div>
<div id="testDiv">test1;test2</div>
 


您只要使用 HtmlUtils 对代码 清单 1 的 userName 和 address 进行转义处理，最终输出的 HTML 页面就不会遭受破坏了。

JavaScript 特殊字符转义

JavaScript 中也有一些需要特殊处理的字符，如果直接将它们嵌入 JavaScript 代码中，JavaScript 程序结构将会遭受破坏，甚至被嵌入一些恶意的程序。下面列出了需要转义的特殊 JavaScript 字符：

' ：\' 
" ：\" 
\ ：\\ 
走纸换页： \f 
换行：\n 
换栏符：\t 
回车：\r 
回退符：\b 
 
我们通过一个具体例子演示动态变量是如何对 JavaScript 程序进行破坏的。假设我们有一个 JavaScript 数组变量，其元素值通过一个 Java List 对象提供，下面是完成这一操作的 JSP 代码片断：


清单 3. jsTest.jsp：未对 JavaScript 特殊字符进行处理
                
<%@ page language="java" contentType="text/html; charset=utf-8"%>
<jsp:directive.page import="java.util.*"/>
<%
  List textList = new ArrayList();
  textList.add("\";alert();j=\"");
%>
<script>
  var txtList = new Array();
   <% for ( int i = 0 ; i < textList.size() ; i++) { %>
     txtList[<%=i%>] = "<%=textList.get(i)%>"; 
	 ① 未对可能包含特殊 JavaScript 字符的变量进行处理
   <% } %>
</script>
 


当客户端调用这个 JSP 页面后，将得到以下的 HTML 输出页面：

<script>
  var txtList = new Array();
   txtList[0] = "";alert();j=""; ① 本来是希望接受一个字符串，结果被植入了一段JavaScript代码
</script>
 


由于包含 JavaScript 特殊字符的 Java 变量直接合并到 JavaScript 代码中，我们本来期望 ① 处所示部分是一个普通的字符串，但结果变成了一段 JavaScript 代码，网页将弹出一个 alert 窗口。想像一下如果粗体部分的字符串是“";while(true)alert();j="”时会产生什么后果呢？

因此，如果网页中的 JavaScript 代码需要通过拼接 Java 变量动态产生时，一般需要对变量的内容进行转义处理，可以通过 Spring 的 JavaScriptUtils 完成这件工作。下面，我们使用 JavaScriptUtils 对以上代码进行改造：

<%@ page language="java" contentType="text/html; charset=utf-8"%>
<jsp:directive.page import="java.util.*"/>
<jsp:directive.page import="org.springframework.web.util.JavaScriptUtils"/>
<%
  List textList = new ArrayList();
  textList.add("\";alert();j=\"");
%>
<script>
   var txtList = new Array();
   <% for ( int i = 0 ; i < textList.size() ; i++) { %>
   ① 在输出动态内容前事先进行转义处理
   txtList[<%=i%>] = "<%=JavaScriptUtils.javaScriptEscape(""+textList.get(i))%>";
   <% } %>
</script>
 


通过转义处理后，这个 JSP 页面输出的结果网页的 JavaScript 代码就不会产生问题了：

<script>
   var txtList = new Array();
   txtList[0] = "\";alert();j=\"";
   ① 粗体部分仅是一个普通的字符串，而非一段 JavaScript 的语句了
</script>
 


SQL特殊字符转义

应该说，您即使没有处理 HTML 或 JavaScript 的特殊字符，也不会带来灾难性的后果，但是如果不在动态构造 SQL 语句时对变量中特殊字符进行处理，将可能导致程序漏洞、数据盗取、数据破坏等严重的安全问题。网络中有大量讲解 SQL 注入的文章，感兴趣的读者可以搜索相关的资料深入研究。

虽然 SQL 注入的后果很严重，但是只要对动态构造的 SQL 语句的变量进行特殊字符转义处理，就可以避免这一问题的发生了。来看一个存在安全漏洞的经典例子：

SELECT COUNT(userId) 
FROM t_user 
WHERE userName='"+userName+"' AND password ='"+password+"';
 


以上 SQL 语句根据返回的结果数判断用户提供的登录信息是否正确，如果 userName 变量不经过特殊字符转义处理就直接合并到 SQL 语句中，黑客就可以通过将 userName 设置为 “1' or '1'='1”绕过用户名/密码的检查直接进入系统了。

所以除非必要，一般建议通过 PreparedStatement 参数绑定的方式构造动态 SQL 语句，因为这种方式可以避免 SQL 注入的潜在安全问题。但是往往很难在应用中完全避免通过拼接字符串构造动态 SQL 语句的方式。为了防止他人使用特殊 SQL 字符破坏 SQL 的语句结构或植入恶意操作，必须在变量拼接到 SQL 语句之前对其中的特殊字符进行转义处理。Spring 并没有提供相应的工具类，您可以通过 jakarta commons lang 通用类包中（spring/lib/jakarta-commons/commons-lang.jar）的 StringEscapeUtils 完成这一工作：


清单 4. SqlEscapeExample
                
package com.baobaotao.escape;
import org.apache.commons.lang.StringEscapeUtils;
public class SqlEscapeExample {
    public static void main(String[] args) {
        String userName = "1' or '1'='1";
        String password = "123456";
        userName = StringEscapeUtils.escapeSql(userName);
        password = StringEscapeUtils.escapeSql(password);
        String sql = "SELECT COUNT(userId) FROM t_user WHERE userName='"
            + userName + "' AND password ='" + password + "'";
        System.out.println(sql);
    }
}
 


事实上，StringEscapeUtils 不但提供了 SQL 特殊字符转义处理的功能，还提供了 HTML、XML、JavaScript、Java 特殊字符的转义和还原的方法。如果您不介意引入 jakarta commons lang 类包，我们更推荐您使用 StringEscapeUtils 工具类完成特殊字符转义处理的工作。



 


 回页首 
 



方法入参检测工具类

Web 应用在接受表单提交的数据后都需要对其进行合法性检查，如果表单数据不合法，请求将被驳回。类似的，当我们在编写类的方法时，也常常需要对方法入参进行合法性检查，如果入参不符合要求，方法将通过抛出异常的方式拒绝后续处理。举一个例子：有一个根据文件名获取输入流的方法：InputStream getData(String file)，为了使方法能够成功执行，必须保证 file 入参不能为 null 或空白字符，否则根本无须进行后继的处理。这时方法的编写者通常会在方法体的最前面编写一段对入参进行检测的代码，如下所示：

public InputStream getData(String file) {
    if (file == null || file.length() == 0|| file.replaceAll("\\s", "").length() == 0) {
        throw new IllegalArgumentException("file入参不是有效的文件地址");
    }
…
}
 


类似以上检测方法入参的代码是非常常见，但是在每个方法中都使用手工编写检测逻辑的方式并不是一个好主意。阅读 Spring 源码，您会发现 Spring 采用一个 org.springframework.util.Assert 通用类完成这一任务。

Assert 翻译为中文为“断言”，使用过 JUnit 的读者都熟知这个概念，它断定某一个实际的运行值和预期想一样，否则就抛出异常。Spring 对方法入参的检测借用了这个概念，其提供的 Assert 类拥有众多按规则对方法入参进行断言的方法，可以满足大部分方法入参检测的要求。这些断言方法在入参不满足要求时就会抛出 IllegalArgumentException。下面，我们来认识一下 Assert 类中的常用断言方法：

断言方法 说明 
notNull(Object object)  当 object 不为 null 时抛出异常，notNull(Object object, String message) 方法允许您通过 message 定制异常信息。和 notNull() 方法断言规则相反的方法是 isNull(Object object)/isNull(Object object, String message)，它要求入参一定是 null； 
isTrue(boolean expression) / isTrue(boolean expression, String message)  当 expression 不为 true 抛出异常； 
notEmpty(Collection collection) / notEmpty(Collection collection, String message)  当集合未包含元素时抛出异常。notEmpty(Map map) / notEmpty(Map map, String message) 和 notEmpty(Object[] array, String message) / notEmpty(Object[] array, String message) 分别对 Map 和 Object[] 类型的入参进行判断； 
hasLength(String text) / hasLength(String text, String message)  当 text 为 null 或长度为 0 时抛出异常； 
hasText(String text) / hasText(String text, String message)  text 不能为 null 且必须至少包含一个非空格的字符，否则抛出异常； 
isInstanceOf(Class clazz, Object obj) / isInstanceOf(Class type, Object obj, String message)  如果 obj 不能被正确造型为 clazz 指定的类将抛出异常； 
isAssignable(Class superType, Class subType) / isAssignable(Class superType, Class subType, String message)  subType 必须可以按类型匹配于 superType，否则将抛出异常； 

使用 Assert 断言类可以简化方法入参检测的代码，如 InputStream getData(String file) 在应用 Assert 断言类后，其代码可以简化为以下的形式：

public InputStream getData(String file){
    Assert.hasText(file,"file入参不是有效的文件地址"); 
    ① 使用 Spring 断言类进行方法入参检测
…
}
 


可见使用 Spring 的 Assert 替代自编码实现的入参检测逻辑后，方法的简洁性得到了不少的提高。Assert 不依赖于 Spring 容器，您可以大胆地在自己的应用中使用这个工具类

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

★ 数组转Collection

使用Apache Jakarta Commons Collections：


import org.apache.commons.collections.CollectionUtils;    
   
String[] strArray = {"aaa", "bbb", "ccc"};    
List strList = new ArrayList();    
Set strSet = new HashSet();    
CollectionUtils.addAll(strList, strArray);    
CollectionUtils.addAll(strSet, strArray);   

CollectionUtils.addAll()方法的实现很简单，只是循环使用了Collection的add()方法而已。

如果只是想将数组转换成List，可以用JDK中的java.util.Arrays类：


import java.util.Arrays;    
   
String[] strArray = {"aaa", "bbb", "ccc"};    
List strList = Arrays.asList(strArray);   

不过Arrays.asList()方法返回的List不能add对象，因为该方法的实现是使用参数引用的数组的大小来new的一个ArrayList。


★ Collection转数组

直接使用Collection的toArray()方法，该方法有两个重载版本：

Object[] toArray();    
   
T[] toArray(T[] a);   


★ Map转Collection

直接使用Map的values()方法。


★ List和Set转换

List list = new ArrayList(new Hashset());// Fixed-size list 
List list = Arrays.asList(array);// Growable 
list list = new LinkedList(Arrays.asList(array));// Duplicate elements are discarded 
Set set = new HashSet(Arrays.asList(array));

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1.   概述

       第一次接触BeanUtils是在学习Struts的过程中，在Struts中它被大量用于处理FormBean。

BeanUtils主要提供了对于JavaBean进行各种操作，

       BeanUtils一共分4个包：

Ø         org.apache.commons.beanutils

Ø         org.apache.commons.beanutils.converters

Ø         org.apache.commons.beanutils.locale

Ø         org.apache.commons.beanutils.locale.converters

其中上面两个是BeanUtils的默认实现，它没有针对本地化的任何处理，这个可以提高执行效率。但是若你的程序对于本地化有要求的话，那还是使用下面2个包比较安全。

 

2.   org.apache.commons.beanutils

       这个包主要提供用于操作JavaBean的工具类，Jakarta-Common-BeanUtils的主要功能都在这个包里实现。

    下面分别介绍几个主要的工具类：

2.1.BeanUtil

1、首先，我先定义一个JavaBean作为之后例子的操作对象。

    public class Company

    {

      private String name;

      private HashMap address = new HashMap();

      private String[] otherInfo;

      private ArrayList product;

      private ArrayList employee;

      private HashMap telephone;

 

      public Company(){}

 

      public String getName()

      {

        return name;

      }

      public void setName(String name)

      {

        this.name = name;

      }

 

      public String getAddress(String type)

      {

        return address.get(type).toString();

      }

      public void setAddress(String type, String address)

      {

        this.address.put(type,address);

      }

 

      public String[] getOtherInfo()

      {

        return otherInfo;

      }

      public void setOtherInfo(String[] otherInfo)

      {

        this.otherInfo = otherInfo;

      }

 

      public ArrayList getProduct()

      {

        return product;

      }

      public void setProduct(ArrayList product)

      {

        this.product = product;

      }

 

      public ArrayList getEmployee()

      {

        return employee;

      }

      public void setEmployee(ArrayList employee)

      {

        this.employee = employee;

      }

 

      public HashMap getTelephone()

      {

        return telephone;

      }

      public void setTelephone(HashMap telephone)

      {

        this.telephone = telephone;

      }

    }

2、BeanUtils可以直接get和set一个属性的值。它将property分成3种类型：

       Simple——简单类型，如Stirng、Int……

       Indexed——索引类型，如数组、arrayList……

       Maped——这个不用说也该知道，就是指Map啦，比如HashMap……

       访问不同类型的数据可以直接调用函数getProperty和setProperty。它们都只有2个参数，第一个是JavaBean对象，第二个是要操作的属性名。

Company c = new Company();

c.setName("Simple");

 

对于Simple类型，参数二直接是属性名即可

//Simple

    System.out.println(BeanUtils.getProperty(c, "name"));

    对于Map类型，则需要以“属性名（key值）”的形式

//Map

    System.out.println(BeanUtils.getProperty(c, "address (A2)"));

    HashMap am = new HashMap();

    am.put("1","234-222-1222211");

    am.put("2","021-086-1232323");

    BeanUtils.setProperty(c,"telephone",am);

    System.out.println(BeanUtils.getProperty(c, "telephone (2)"));

    对于Indexed，则为“属性名[索引值]”，注意这里对于ArrayList和数组都可以用一样的方式进行操作。

//index

    System.out.println(BeanUtils.getProperty(c, "otherInfo[2]"));

    BeanUtils.setProperty(c, "product[1]", "NOTES SERVER");

    System.out.println(BeanUtils.getProperty(c, "product[1]"));

 

       当然这3种类也可以组合使用啦！

    //nest

    System.out.println(BeanUtils.getProperty(c, "employee[1].name"));

 

3、此外，还有一个很重要的方法copyProperty，可以直接进行Bean之间的clone。

       Company c2 = new Company();

        BeanUtils.copyProperties(c2, c);

       但是这种copy都是浅拷贝，复制后的2个Bean的同一个属性可能拥有同一个对象的ref，这个在使用时要小心，特别是对于属性为自定义类的情况。

4、最后还有populate，它用于将一个map的值填充到一个bean中，其函数原型如下：

public void populate(java.lang.Object bean,

                java.util.Map properties)

              throws java.lang.IllegalAccessException,

                     java.lang.reflect.InvocationTargetException

在struts中这个函数被用于从http request中取得参数添加到FormBean，目前好像我也没有看到这个函数还有什么其他的用途？！以后想到再说吧：P

 

2.2.LazyDynaBean

       它实现一个动态的Bean，可以直接往里面加入属性，作为一个JavaBean一样使用，也可以用上面的BeanUtils或get/set方法进行操作，而不用事先定义一个标准的JavaBean类啦：）

记得在J2ee设计模式中有一种Value Object的模式，用于在MVC各层之间传递数据，避免直接传递大业务对象引起的性能问题，为了避免在项目中出现很多Bean类，在书中提供了一个动态Value Object的实现（通过扩展Map）。这里LazyDynaBean则可以作为一种更加成熟、稳定的实现来使用。呵呵，原来曾打算自己写一个类似的value object类的，现在看来可以直接用这个啦：P

       言归正传，LazyBean的确提供了一个很不错的DynaBean的实现。而且就像它的名字中表述的那样，它的确是为我这样的懒人考虑的很周到，用起来几乎不需要写什么多余的代码^_^，下面就看看使用的例子吧！

         //这里使用LazyDynaMap，它是LazyBean的一个轻量级实现

      LazyDynaMap dynaBean1 = new LazyDynaMap();

 

      dynaBean1.set("foo", "bar");                  // simple

      dynaBean1.set("customer", "title", "Mr");        // mapped

      dynaBean1.set("address", 0, "address1");         // indexed

      System.out.println(dynaBean1.get("address",0));

 

      Map myMap = dynaBean1.getMap();           // retrieve the Map

      System.out.println(myMap.toString());

       上面的例子可以看到，它可以在set时自动增加bean的property（既赋值的同时增加Bean中的property），同时也支持3中类型的property，并且LazyDynaMap还可以导出为map。

       对于这个类还有两个重要的Field要注意：

       returnnull——指定在get方法使用了一个没有定义过的property时，DynaBean的行为。

         //取的字段的信息

      dynaBean1.setReturnNull(true);//设为ture。若Bean中没有此字段，返回null

                                //默认为false。若Bean中没有此字段，自动增加一个：）

      System.out.println(dynaBean1.get("aaa"));//此时返回null

       Restricted——指定是否允许改变这个bean的property。

//MutableDynaClass.setRestricted设为true后，字段不可再增删和修改.

      //默认为false，允许增删和修改

      dynaBean1.setRestricted(true);

      dynaBean1.set("test","error");//这里会出错！

       通过设置这两个属性，可以防止意外修改DynaBean的property。在设计架构时，你可以在后台从数据表或xml文件自动产生DynaBean，在传到控制层和表示层之前设置上述属性使其Bean结构不允许修改，如此就不可能无意中修改Bean包含的属性……这样既可以享用它的便利，有可以防止由此引入的错误可能，设计者实在深得偷懒的精髓啊！！！！！

 

3.   其他

3.1.BeanUtils和PropertyUtils

       这两个类几乎有一摸一样的功能，唯一的区别是：BeanUtils在对Bean赋值是会进行类型转化。举例来说也就是在copyProperty时只要属性名相同，就算类型不同，BeanUtils也可以进行copy；而PropertyBean则可能会报错！！

       针对上面的例子，新建一个Company2的类，其中代码与Company一样，只是将otherinfo从String[]改为String。

      Company c = init();

      Company2 c2 = new Company2();

      

      BeanUtils.copyProperties(c2,c);

//      PropertyUtils.copyProperties(c2,c); 这句会报错！！

      System.out.println(c2.getOtherInfo());

    当然2个Bean之间的同名属性的类型必须是可以转化的，否则用BeanUtils一样会报错。

       若实现了org.apache.commons.beanutils.Converter接口则可以自定义类型之间的转化。

由于不做类型转化，用PropertyUtils在速度上会有很大提高！

此外，不作类型转化还有一个好处，如下面的代码：

      //test data type convert

//      ArrayList a1 = BeanUtils.getProperty(c,"product"); //BeanUtils返回的是String

      System.out.println("--" + BeanUtils.getProperty(c,"product"));     //取出后直接被转为String

      ArrayList a = (ArrayList)PropertyUtils.getProperty(c,"product");//PropertyUtils返回的是Object

      System.out.println("--" + a.get(1));

用BeanUtils无法返回一个对象（除非自己写一个Converter），它会自动进行类型转化，然后返回String。对于想返回java类或自定义类的话，还是不要老它大驾转化了。

 

3.2.Utils类

       所有的XXXUtils类都提供的是静态方法，可以直接调用，其主要实现都在相应的XXXUtilsBean中：

BeanUtils     ——> BeanUtilsBean

       ConvertUtils  ——> ConvertUtilsBean

    PropertyUtils ——> PropertyUtilsBean

 

其意思看类名也应该知道的差不多了，我就不再废话啦！当然你也可以直接调用那些XXXUtilsBean，功能都一样！

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1.Jakarta StringUtils

标准的JAVA应用编程接口能够支持字符串操作，但是更多的时候，仅仅支持是不够的。Commons Lang的StringUtils包加入到类路径中。StringUtils类中有不计其数的有用的方法。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师