]]>
Hibernate的Lazy初始化1:n關系時，你必須保證是在同一個Session內部使用這個關系集合，不然Hiernate將拋出例外。
另外，你不愿意你的DAO測試代碼每次都打開關系Session，因此，我們一般會采用OpenSessionInView模式。
OpenSessionInViewFilter解決Web應用程序的問題
如果程序是在正常的Web程序中運行，那么Spring的OpenSessionInViewFilter能夠解決問題，它：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配置
OpenSessionInViewFilter配置
很多人在使用OpenSessionInView過程中提及一個錯誤：
看看OpenSessionInViewFilter里的幾個方法
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);
}
}
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);
}
可以看到OpenSessionInViewFilter在getSession的時候,會把獲取回來的session的flush mode 設為FlushMode.NEVER。然后把該sessionFactory綁定到 TransactionSynchronizationManager，使request的整個過程都使用同一個session，在請求過后再接除該 sessionFactory的綁定，最后closeSessionIfNecessary根據該 session是否已和transaction綁定來決定是否關閉session。在這個過程中，若HibernateTemplate 發現自當前session有不是readOnly的transaction，就會獲取到FlushMode.AUTO Session，使方法擁有寫權限。
TransactionSynchronizationManager.hasResource(sessionFactory)) {
也即是，如果有不是readOnly的transaction就可以由Flush.NEVER轉為Flush.AUTO,擁有insert, update,delete操作權限，如果沒有transaction，并且沒有另外人為地設flush model的話，則doFilter的整個過程都是Flush.NEVER。所以受transaction保護的方法有寫權限，沒受保護的則沒有。
采用spring的事務聲明,使方法受transaction控制
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>
對 于上例，則以save,add,update,remove開頭的方法擁有可寫的事務，如果當前有某個方法，如命名為importExcel()，則因沒 有transaction而沒有寫權限，這時若方法內有insert,update,delete操作的話，則需要手動設置flush model為Flush.AUTO,如
-
session.setFlushMode(FlushMode.AUTO);
-
session.save(user);
-
session.flush();
盡管Open Session In View看起來還不錯，其實副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal方法代碼，這個方法 實際上是被父類的doFilter調用的，因此，我們可以大約了解的OpenSessionInViewFilter調用流程: request(請求)->open session并開始transaction->controller->View(Jsp)->結束transaction并 close session.
一切看起來很正確，尤其是在本地開發測試的時候沒出現問題，但試想下如果流程中的某一步被阻塞的話，那在這期間connection就一直被占用而不釋 放。最有可能被阻塞的就是在寫Jsp這步，一方面可能是頁面內容大，response.write的時間長，另一方面可能是網速慢，服務器與用戶間傳輸時 間久。當大量這樣的情況出現時，就有連接池連接不足，造成頁面假死現象。
Open Session In View是個雙刃劍，放在公網上內容多流量大的網站請慎用。
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 網頁本身就是一個文本型結構化文檔，如果直接將這些包含了 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 字符：
- ' ：\'
- " ：\"
- \ ：\\
- 走紙換頁： \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>
|
應該說，您即使沒有處理 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 容器，您可以大膽地在自己的應用中使用這個工具類。
|
|
本文介紹了一些常用的 Spring 工具類，其中大部分 Spring 工具類不但可以在基于 Spring 的應用中使用，還可以在其它的應用中使用。
對于 Web 應用來說，由于有很多關聯的腳本代碼，如果這些代碼通過拼接字符串的方式動態產生，就需要對動態內容中特殊的字符進行轉義處理，否則就有可能產生意想不到的后果。Spring 為此提供了 HtmlUtils 和 JavaScriptUtils 工具類，只要將動態內容在拼接之前使用工具類進行轉義處理，就可以避免類似問題的發生了。如果您不介意引入一個第三方類包，那么 jakarta commons lang 通用類包中的 StringEscapeUtils 工具類可能更加適合，因為它提供了更加全面的轉義功能。
最后我們還介紹了 Spring 的 Assert 工具類，Assert 工具類是通用性很強的工具類，它使用面向對象的方式解決方法入參檢測的問題，您可以在自己的應用中使用 Assert 對方法入參進行檢查。
]]>
(1) spring下載包中doc目錄下的MVC-step-by-step和sample目錄下的例子都是比較好的spring開發的例子。
(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（中文版，未全部翻譯）
還有就是多實踐吧
]]>