另外，你不愿意你的DAO测试代码每次都打开关系Session，因此，我们一般会采用OpenSessionInView模式。

OpenSessionInViewFilter解决Web应用程序的问题

protected void doFilterInternal(HttpServletRequest request, 

HttpServletResponse response,

           FilterChain filterChain) throws ServletException, IOException {

      SessionFactory sessionFactory = lookupSessionFactory();

      logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");

      Session session = getSession(sessionFactory);

      TransactionSynchronizationManager.bindResource(sessionFactory, 

new SessionHolder(session));

      try {

            filterChain.doFilter(request, response);

      }

      finally {

            TransactionSynchronizationManager.unbindResource(sessionFactory);

            logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");

            closeSession(session, sessionFactory);

      }

}

为什么绑定以后，就可以防止每次不会新开一个Session呢？看看HibernateDaoSupport的情况：

public final void setSessionFactory(SessionFactory sessionFactory) {

this.hibernateTemplate = new HibernateTemplate(sessionFactory);

}

protected final HibernateTemplate getHibernateTemplate() {

return hibernateTemplate;

}

我们的DAO将使用这个template进行操作：

public abstract class BaseHibernateObjectDao

      extends HibernateDaoSupport

      implements BaseObjectDao {



      protected BaseEntityObject getByClassId(final long id) {

            BaseEntityObject obj =

                  (BaseEntityObject) getHibernateTemplate()

                        .execute(new HibernateCallback() {




                  public Object doInHibernate(Session session)

                        throws HibernateException {

                        return session.get(getPersistentClass(), 

new Long(id));

                  }




            });

            return obj;

      }






      public void save(BaseEntityObject entity) {

            getHibernateTemplate().saveOrUpdate(entity);

      }




      public void remove(BaseEntityObject entity) {

            try {




                  getHibernateTemplate().delete(entity);

            } catch (Exception e) {

                  throw new FlexEnterpriseDataAccessException(e);

            }

      }




      public void refresh(final BaseEntityObject entity) {

            getHibernateTemplate().execute(new HibernateCallback() {




                  public Object doInHibernate(Session session)

                        throws HibernateException {

                        session.refresh(entity);

                        return null;

                  }




            });

      }


      public void replicate(final Object entity) {

            getHibernateTemplate().execute(new HibernateCallback() {




                  public Object doInHibernate(Session session)

                        throws HibernateException {

                        session.replicate(entity, 

ReplicationMode.OVERWRITE);

                        return null;

                  }




            });

      }

public Object execute(HibernateCallback action) throws DataAccessException {

      Session session = (!this.allowCreate ?

            SessionFactoryUtils.getSession(getSessionFactory(), 

false) :

            SessionFactoryUtils.getSession(getSessionFactory(),

getEntityInterceptor(),

getJdbcExceptionTranslator()));

      boolean existingTransaction =  

TransactionSynchronizationManager.hasResource(getSessionFactory());

      if (!existingTransaction && getFlushMode() == FLUSH_NEVER) {

            session.setFlushMode(FlushMode.NEVER);

      }

      try {

            Object result = action.doInHibernate(session);

            flushIfNecessary(session, existingTransaction);

            return result;

      }

      catch (HibernateException ex) {

            throw convertHibernateAccessException(ex);

      }

      catch (SQLException ex) {

            throw convertJdbcAccessException(ex);

      }

      catch (RuntimeException ex) {

            // callback code threw application exception

            throw ex;

      }

      finally {

            SessionFactoryUtils.closeSessionIfNecessary(

session, getSessionFactory());

      }

}

public static void closeSessionIfNecessary(Session session, 

SessionFactory sessionFactory)   

throws CleanupFailureDataAccessException {

      if (session == null || 

         TransactionSynchronizationManager.hasResource(sessionFactory)) {

            return;

      }

      logger.debug("Closing Hibernate session");

      try {

            session.close();

      }

      catch (JDBCException ex) {

            // SQLException underneath

            throw new CleanupFailureDataAccessException(

            "Cannot close Hibernate session", ex.getSQLException());

      }

      catch (HibernateException ex) {

            throw new CleanupFailureDataAccessException(

            "Cannot close Hibernate session", ex);

      }

}

HibernateInterceptor和OpenSessionInViewInterceptor的问题

使用同样的方法，这两个Interceptor可以用来解决问题。但是关键的不同之处在于，它们的力度只能定义在DAO或业务方法上，而不是在我们的Test方法上，除非我们把它们应用到TestCase的方法上，但你不大可能为TestCase去定义一个接口，然后把Interceptor应用到这个接口的某些方法上。直接使用HibernateTransactionManager也是一样的。因此，如果我们有这样的测试：

Category parentCategory  = new Category ();

      parentCategory.setName("parent");

      dao.save(parentCategory);

      Category childCategory  = new Category();

childCategory.setName("child");




      parentCategory.addChild(childCategory);

      dao.save(childCategory);


      Category savedParent = dao.getCategory("parent");

      Category savedChild = (Category ) savedParent.getChildren().get(0);

      assertEquals(savedChild, childCategory);

• 每次DAO执行都会启动一个session和关闭一个session
• 如果我们定义了一个lazy的关系，那么最后的Category savedChild = (Category ) savedParent.getChildren().get(0);将会让hibernate报错。

解决方案

一种方法是对TestCase应用Interceptor或者TransactionManager，但这个恐怕会造成很多麻烦。除非是使用增强方式的AOP.我前期采用这种方法(Aspectwerkz)，在Eclipse里面也跑得含好。

另一种方法是在TestCase的setup和teardown里面实现和Filter完全一样的处理，其他的TestCase都从这个TestCase继承，这种方法是我目前所使用的。

    它有两种配置方式OpenSessionInViewInterceptor和OpenSessionInViewFilter(具体参看SpringSide)，功能相同，只是一个在web.xml配置，另一个在application.xml配置而已。

    Open Session In View在request把session绑定到当前thread期间一直保持hibernate session在open状态，使session在request的整个期间都可以使用，如在View层里PO也可以lazy loading数据，如 ${ company.employees }。当View 层逻辑完成后，才会通过Filter的doFilter方法或Interceptor的postHandle方法自动关闭session。

OpenSessionInViewInterceptor配置

    

    
<beans> 
    
    

    
  <bean name="openSessionInViewInterceptor" 
    
    

    
class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor"> 
    
    

    
    <property name="sessionFactory">
    
    

    
      <ref bean="sessionFactory"/>
    
    

    
    </property> 
    
    

    
  </bean> 
    
    

    
  <bean id="urlMapping" 
    
    

    
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> 
    
    

    
    <property name="interceptors"> 
    
    

    
      <list> 
    
    

    
        <ref bean="openSessionInViewInterceptor"/> 
    
    

    
      </list> 
    
    

    
    </property> 
    
    

    
    <property name="mappings"> 
    
    

    
    ... 
    
    

    
    </property> 
    
    

    
  </bean> 
    
    

    
... 
    
    

    
</beans> 
    

OpenSessionInViewFilter配置

    

    
<web-app> 
    
    

    
... 
    
    

    
  <filter> 
    
    

    
    <filter-name>hibernateFilter</filter-name> 
    
    

    
    <filter-class> 
    
    

    
      org.springframework.orm.hibernate3.support.OpenSessionInViewFilter 
    
    

    
    </filter-class> 
    
    

    
    <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
    
    

    
    <init-param> 
    
    

    
      <param-name>singleSession</param-name> 
    
    

    
      <param-value>true</param-value>
    
    

    
    </init-param>
    
    

    
  </filter> 
    
    

    
... 
    
    

    
  <filter-mapping> 
    
    

    
    <filter-name>hibernateFilter</filter-name> 
    
    

    
    <url-pattern>*.do</url-pattern> 
    
    

    
  </filter-mapping> 
    
    

    
... 
    
    

    
</web-app> 
    

    

    
org.springframework.dao.InvalidDataAccessApiUsageException: Write operations 
    
    

    
are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into 
    
    

    
FlushMode.AUTO or remove 'readOnly' marker from transaction definition 
    

    

    
protected void doFilterInternal(HttpServletRequest request, 

    HttpServletResponse response,FilterChain filterChain) 

    throws ServletException, IOException {

    　SessionFactory sessionFactory = lookupSessionFactory();

    logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");

    Session session = getSession(sessionFactory);

    TransactionSynchronizationManager.bindResource(

    　　sessionFactory, new SessionHolder(session));

    try {

    　　filterChain.doFilter(request, response);

    }

    　finally {

    　TransactionSynchronizationManager.unbindResource(sessionFactory);

    logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");

    closeSession(session, sessionFactory);

    }

    }

    

    

    

    

     
    
    

    
protected Session getSession(SessionFactory sessionFactory)

    throws DataAccessResourceFailureException {

    　Session session = SessionFactoryUtils.getSession(sessionFactory, true);

    session.setFlushMode(FlushMode.NEVER);

    return session;

    }
    
    


    protected void closeSession(Session session, SessionFactory sessionFactory)

    throws CleanupFailureDataAccessException {

    　SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);

    } 

    

    
public static void closeSessionIfNecessary(Session session, SessionFactory sessionFactory)
    
    

    
      throws CleanupFailureDataAccessException {
    
    

    
    if (session == null || 

    TransactionSynchronizationManager.hasResource(sessionFactory)) {
    
    

    
      return;
    
    

    
    }
    
    

    
    logger.debug("Closing Hibernate session");
    
    

    
    try {
    
    

    
      session.close();
    
    

    
    }
    
    

    
    catch (JDBCException ex) {
    
    

    
      // SQLException underneath
    
    

    
      throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex.getSQLException());
    
    

    
    }
    
    

    
    catch (HibernateException ex) {
    
    

    
      throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex);
    
    

    
    }
    
    

    
  } 
    

采用spring的事务声明,使方法受transaction控制

    

    
  <bean id="baseTransaction" 

    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" 

              abstract="true"> 

            <property name="transactionManager" ref="transactionManager"/> 

            <property name="proxyTargetClass" value="true"/> 

            <property name="transactionAttributes"> 

                <props> 

                    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop> 

                    <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop> 

                    <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop> 

                    <prop key="save*">PROPAGATION_REQUIRED</prop> 

                    <prop key="add*">PROPAGATION_REQUIRED</prop> 

                    <prop key="update*">PROPAGATION_REQUIRED</prop> 

                    <prop key="remove*">PROPAGATION_REQUIRED</prop> 

                </props> 

            </property> 

        </bean> 

    
    
    
    <bean id="userService" parent="baseTransaction"> 

            <property name="target"> 

                <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/> 

            </property> 

        </bean> 

    

        

        
 session.setFlushMode(FlushMode.AUTO); 
        
        

        
 session.save(user); 
        
        

        
 session.flush(); 
        
    
    

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1441664

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

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

特殊字符转义

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

• HTML 特殊字符；
• JavaScript 特殊字符；
• SQL 特殊字符；

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

HTML 特殊字符转义

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

• &：&amp;
• " ：&quot;
• < ：&lt;
• > ：&gt;

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

            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 提供了三个转义方法：

此外，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 代码片断：

            <%@ 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 完成这一工作：

            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 类中的常用断言方法：

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

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

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

回页首

小结

本文介绍了一些常用的 Spring 工具类，其中大部分 Spring 工具类不但可以在基于 Spring 的应用中使用，还可以在其它的应用中使用。

对于 Web 应用来说，由于有很多关联的脚本代码，如果这些代码通过拼接字符串的方式动态产生，就需要对动态内容中特殊的字符进行转义处理，否则就有可能产生意想不到的后果。Spring 为此提供了 HtmlUtils 和 JavaScriptUtils 工具类，只要将动态内容在拼接之前使用工具类进行转义处理，就可以避免类似问题的发生了。如果您不介意引入一个第三方类包，那么 jakarta commons lang 通用类包中的 StringEscapeUtils 工具类可能更加适合，因为它提供了更加全面的转义功能。

最后我们还介绍了 Spring 的 Assert 工具类，Assert 工具类是通用性很强的工具类，它使用面向对象的方式解决方法入参检测的问题，您可以在自己的应用中使用 Assert 对方法入参进行检查。

(2) AppFuse集成了目前最流行的几个开源轻量级框架或者工具Ant,XDoclet,Spring,Hibernate(iBATIS),JUnit,Cactus,StrutsTestCase,Canoo's WebTest,Struts Menu,Display Tag Library,OSCache,JSTL,Struts 。
你可以通过AppFuse源代码来学习spring。
AppFuse网站：http://raibledesigns.com/wiki/Wiki.jsp?page=AppFuse

(3)Spring 开发指南(夏昕)（http://www.xiaxin.net/Spring_Dev_Guide.rar）
一本spring的入门书籍,里面介绍了反转控制和依赖注射的概念，以及spring的bean管理，spring的MVC，spring和hibernte，iBatis的结合。

(4) spring学习的中文论坛
SpringFramework中文论坛(http://spring.jactiongroup.net)
Java视线论坛(http://forum.javaeye.com)的spring栏目

2、利用Spring框架编程，console打印出log4j:WARN Please initialize the log4j system properly？
说明你的log4j.properties没有配置。请把log4j.properties放到工程的classpath中，eclipse的classpath为bin目录，由于编译后src目录下的文件会拷贝到bin目录下，所以你可以把log4j.properties放到src目录下。
这里给出一个log4j.properties的例子：

log4j.rootLogger=DEBUG,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%F:%L) - %m%n

3、出现 java.lang.NoClassDefFoundError?
一般情况下是由于你没有把必要的jar包放到lib中。

比如你要采用spring和hibernate（带事务支持的话），你除了spring.jar外还需要hibernat.jar、aopalliance.jar、cglig.jar、jakarta-commons下的几个jar包。

http://www.springframework.org/download.html下载spring开发包，提供两种zip包
spring-framework-1.1.3-with-dependencies.zip和spring-framework-1.1.3.zip，我建议你下载spring-framework-1.1.3-with-dependencies.zip。这个zip解压缩后比后者多一个lib目录，其中有hibernate、j2ee、dom4j、aopalliance、jakarta-commons等常用包。

4、java.io.FileNotFoundException: Could not open class path resource [....hbm.xml],提示找不到xml文件？
原因一般有两个：
(1)该xml文件没有在classpath中。
(2)applicationContext-hibernate.xml中的xml名字没有带包名。比如：
<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="dataSource"><ref bean="dataSource"/></property>
<property name="mappingResources">
<list>
<value>User.hbm.xml</value> 错，改为： <value>com/yz/spring/domain/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect"> net.sf.hibernate.dialect.MySQLDialect </prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>

5、org.springframework.beans.NotWritablePropertyException: Invalid property 'postDao' of bean class？
出现异常的原因是在application-xxx.xml中property name的错误。
<property name="...."> 中name的名字是与bean的set方法相关的，而且要注意大小写。
比如
public class PostManageImpl extends BaseManage implements PostManage {
private PostDAO dao = null;
public void setPostDAO(PostDAO postDAO){
this.dao = postDAO;
}
}
那么xml的定义应该是：
<bean id="postManage" parent="txProxyTemplate">
<property name="target">
<bean class="com.yz.spring.service.implement.PostManageImpl">
<property name="postDAO"><ref bean="postDAO"/></property> 对
<property name="dao"><ref bean="postDAO"/></property> 错
</bean>
</property>
</bean>

6、Spring中如何实现事务管理？
首先，如果使用mysql，确定mysql为InnoDB类型。
事务管理的控制应该放到商业逻辑层。你可以写个处理商业逻辑的JavaBean，在该JavaBean中调用DAO，然后把该Bean的方法纳入spring的事务管理。

比如：xml文件定义如下：
<bean id="txProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager"><ref bean="transactionManager"/></property>
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="remove*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>

<bean id="userManage" parent="txProxyTemplate">
<property name="target">
<bean class="com.yz.spring.service.implement.UserManageImpl">
<property name="userDAO"><ref bean="userDAO"/></property>
</bean>
</property>
</bean>

com.yz.spring.service.implement.UserManageImpl就是我们的实现商业逻辑的JavaBean。我们通过parent元素声明其事务支持。

7、如何管理Spring框架下更多的JavaBean？
JavaBean越多，spring配置文件就越大，这样不易维护。为了使配置清晰，我们可以将JavaBean分类管理，放在不同的配置文件中。 应用启动时将所有的xml同时加载。
比如：
DAO层的JavaBean放到applicationContext-hibernate.xml中，商业逻辑层的JavaBean放到applicationContext-service.xml中。然后启动类中调用以下代码载入所有的ApplicationContext。

String[] paths = {"com/yz/spring/dao/hibernate/applicationContext-hibernate.xml",
"com/yz/spring/service/applicationContext-service.xml"};
ctx = new ClassPathXmlApplicationContext(paths);

8、web应用中如何加载ApplicationContext？
可以通过定义web.xml，由web容器自动加载。

<servlet>
<servlet-name>context</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext-hibernate.xml</param-value>
<param-value>/WEB-INF/applicationContext-service.xml</param-value>
</context-param>

9、在spring中如何配置的log4j?
在web.xml中加入以下代码即可。
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>/WEB-INF/log4j.properties</param-value>
</context-param>

10、Spring框架入门的编程问题解决了，我该如何更深地领会Spring框架呢？
这两本书你该去看看。这两本书是由Spring的作者Rod Johnson编写的。
Expert One on one J2EE Design and Development
Expert One on one J2EE Development Without EJB
你也该看看martinfowler的Inversion of Control Containers and the Dependency Injection pattern。
http://www.martinfowler.com/articles/injection.html

再好好研读一下spring的文档。
http://www.jactiongroup.net/reference/html/index.html（中文版，未全部翻译）

还有就是多实践吧