因?yàn)檫@些對象將和所有層交互，這也許是一個開始編碼的好地方。這個簡單的領(lǐng)域模型將包括一個代表一份訂單的對象和一個代表一個訂單項(xiàng)的對象。訂單對象將和一組訂單項(xiàng)對象有一對多的關(guān)系。例子代碼在領(lǐng)域?qū)佑袃蓚€簡單的對象：

　　com.meagle.bo.Order.java: 包括一份訂單的概要信息；
　　com.meagle.bo.OrderLineItem.java: 包括一份訂單的詳細(xì)信息；

　　考慮一下為你的對象選擇包名，它將反映你的應(yīng)用程序是怎樣分層的。例如：簡單應(yīng)用的領(lǐng)域?qū)ο罂梢苑胚M(jìn)com.meagle.bo包。更多專門的領(lǐng)域?qū)ο髮⒎湃朐赾om.meagle.bo下面的子包里。業(yè)務(wù)邏輯在com.meagle.service包里開始打包，DAO對象放進(jìn)com.meagle.service.dao.hibernate包。對于forms和actions的表現(xiàn)類分別放入com.meagle.action 和 com.meagle.forms包。準(zhǔn)確的包命名為你的類提供的功能提供一個清楚的區(qū)分，使當(dāng)故障維護(hù)時更易于維護(hù)，和當(dāng)給應(yīng)用程序增加新的類或包時提供一致性。

　　持久層配置

　　用Hibernate設(shè)置持久層涉及到幾個步驟。第一步是進(jìn)行配置持久化我們的領(lǐng)域業(yè)務(wù)對象。因?yàn)槲覀冇糜陬I(lǐng)域?qū)ο蟪志没腍ibernate和POJOs一起工作，因此，訂單和訂單項(xiàng)對象包括的所有的字段的都需要提供getter和setter方法。訂單對象將包括像ID、用戶名、合計、和訂單項(xiàng)這樣一些字段的標(biāo)準(zhǔn)的JavaBean格式的setter和getter方法。訂單項(xiàng)對象將同樣的用JavaBean的格式為它的字段設(shè)置setter和getter方法。

　　Hibernate在XML文件里映射領(lǐng)域?qū)ο蟮疥P(guān)系數(shù)據(jù)庫。訂單和訂單項(xiàng)對象將有兩個映射文件來表達(dá)這種映射。有像XDoclet這樣的工具來幫助這種映射。Hibernate將映射領(lǐng)域?qū)ο蟮竭@些文件：

　　Order.hbm.xml
　　OrderLineItem.hbm.xml

　　你可以在WebContent/WEB-INF/classes/com/meagle/bo目錄里找到這些生成的文件。配置Hibernate SessionFactory使它知道是在和哪個數(shù)據(jù)庫通信，使用哪個數(shù)據(jù)源或連接池，加載哪些持久對象。SessionFactory提供的Session對象是Java對象和像選取、保存、更新、刪除對象這樣一些持久化功能間的翻譯接口。我們將在后面的部分討論Hibernate操作Session對象需要的SessionFactory配置。

　　業(yè)務(wù)層配置

　　既然我們已經(jīng)有了領(lǐng)域?qū)ο螅覀冃枰袠I(yè)務(wù)服務(wù)對象來執(zhí)行應(yīng)用邏輯、執(zhí)行向持久層的調(diào)用、獲得從用戶接口層的請求、處理事務(wù)、處理異常。為了將所有這些連接起來并且易于管理，我們將使用Spring框架的bean管理方面。Spring使用“控制反轉(zhuǎn)”,或者“setter依賴注入”來把這些對象連好，這些對象在一個外部的XML文件中被引用。“控制反轉(zhuǎn)”是一個簡單的概念，它允許對象接受其它的在一個高一些的層次被創(chuàng)建的對象。使用這種方法，你的對象從必須創(chuàng)建其它對象中解放出來并降低對象耦合。

　　這兒是個不使用IoC的對象創(chuàng)建它的從屬對象的例子，這導(dǎo)致緊的對象耦合：

　　圖２：沒有使用IoC的對象組織。對象Ａ創(chuàng)建對象Ｂ和Ｃ。

　　這兒是一個使用IoC的例子，它允許對象在一個高一些層次被創(chuàng)建和傳進(jìn)另外的對象，所以另外的對象能直接使用現(xiàn)成的對象·［譯者注：另外的對象不必再親自創(chuàng)建這些要使用的對象］：

圖３：對象使用IoC組織。對象Ａ包含setter方法，它們接受到對象Ｂ和Ｃ的接口。這也可以用對象Ａ里的接受對象Ｂ和Ｃ的構(gòu)建器完成。

　　建立我們的業(yè)務(wù)服務(wù)對象

　　我們將在我們的業(yè)務(wù)對象中使用的setter方法接受的是接口，這些接口允許對象的松散定義的實(shí)現(xiàn)，這些對象將被設(shè)置或者注入。在我們這個例子里我們將使我們的業(yè)務(wù)服務(wù)對象接受一個DAO去控制我們的領(lǐng)域?qū)ο蟮某志没．?dāng)我們在這篇文章的例子中使用Hibernate，我們可以容易的轉(zhuǎn)換到一個不同的持久框架的實(shí)現(xiàn)，通知Spring使用新的實(shí)現(xiàn)的DAO對象。你能明白編程到接口和使用“依賴注入”模式是怎樣寬松耦合你的業(yè)務(wù)邏輯和你的持久化機(jī)制的。

　　這兒是業(yè)務(wù)服務(wù)對象的接口，它是一個DAO對象依賴的樁。

public interface IOrderService { 　public abstract Order saveNewOrder(Order order) 　　throws OrderException, 　　　　　 OrderMinimumAmountException; 　public abstract List findOrderByUser( 　　　　　　　　　　　　　　　　　　 String user) 　　　　　　　　　　　　　 throws OrderException; 　public abstract Order findOrderById(int id) 　　　　　　　　　　　　　 throws OrderException; 　public abstract void setOrderDAO( 　　　　　　　　　　　　　　 IOrderDAO orderDAO); }

　　注意上面的代碼有一個為DAO對象準(zhǔn)備的setter方法。這兒沒有一個getOrderDAO方法因?yàn)樗皇潜匾模驗(yàn)椴惶袕耐饷嬖L問連著的OrderDAO對象的需要。DAO對象將被用來和我們的持久層溝通。我們將用Spring把業(yè)務(wù)服務(wù)對象和DAO對象連在一起。因?yàn)槲覀兙幋a到接口，我們不會緊耦合實(shí)現(xiàn)。

　　下一步是寫我們的DAO實(shí)現(xiàn)對象。因?yàn)镾pring有內(nèi)建的對Hibernate的支持，這個例子DAO將繼承HibernateDaoSupport類，這使得我們?nèi)菀兹〉靡粋€到HibernateTemplate類的引用，HibernateTemplate是一個幫助類，它能簡化Hibernate Session的編碼和處理HibernateExceptions。這兒是DAO的接口：

public interface IOrderDAO { 　public abstract Order findOrderById( 　　　　　　　　　　　　　　　　　　final int id); 　public abstract List findOrdersPlaceByUser( 　　　　　　　　　　　　　 final String placedBy); 　public abstract Order saveOrder( 　　　　　　　　　　　　　　　 final Order order); }

　　我們還有兩個對象要和我們的業(yè)務(wù)層連在一起。這包括HibernateSessionFactory和一個TransactionManager對象。這在Spring配置文件里直接完成。Spring提供一個HibernateTransactionManager，它將從工廠綁定一個Hibernate Session到一個線程來支持事務(wù)。這兒是HibernateSessionFactory和HibernateTransactionManager的Spring配置。

<bean id="mySessionFactory" 　　　 class="org.springframework.orm.hibernate. 　　　　　　　LocalSessionFactoryBean"> 　<property name="mappingResources"> 　　<list> 　　　<value> 　　　　com/meagle/bo/Order.hbm.xml 　　　</value> 　　　<value> 　　　　com/meagle/bo/OrderLineItem.hbm.xml 　　　</value> 　　</list> 　</property> 　<property name="hibernateProperties"> 　　<props> 　　　<prop key="hibernate.dialect"> 　　　　net.sf.hibernate.dialect.MySQLDialect 　　　</prop> 　　　<prop key="hibernate.show_sql"> 　　　　false 　　　</prop> 　　　<prop key="hibernate.proxool.xml"> 　　　　C:/MyWebApps/.../WEB-INF/proxool.xml 　　　</prop> 　　　<prop key="hibernate.proxool.pool_alias"> 　　　　　spring 　　　</prop> 　　</props> 　</property> </bean> <!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) --> <bean id="myTransactionManager" 　　　　 class="org. 　 　　　　　　 springframework. 　　　　　　　　orm. 　　　　　　　　hibernate. 　　　　　　　　HibernateTransactionManager"> 　<property name="sessionFactory"> 　　<ref local="mySessionFactory"/> 　</property> 　</bean>

　　每一個對象能被Spring配置里的一個<bean>標(biāo)記引用。在這個例子里，bean “mySessionFactory”代表一個HibernateSessionFactory，bean “myTransactionManager”代表一個Hibernate transaction manager。注意transactionManger bean有一個叫作sessionFactory的屬性元素。HibernateTransactionManager有一個為sessionFactory準(zhǔn)備的setter和getter方法，它們是用來當(dāng)Spring容器啟動時的依賴注入。sessionFactory屬性引用mySessionFactory bean。這兩個對象現(xiàn)在當(dāng)Spring容器初始化時將被連在一起。這種連接把你從為引用和創(chuàng)建這些對象而創(chuàng)建singleton對象和工廠中解放出來，這減少了你應(yīng)用程序中的代碼維護(hù)。mySessionFactory bean有兩個屬性元素,它們翻譯成為mappingResources 和 hibernatePropertes準(zhǔn)備的setter方法。通常，如果你在Spring之外使用Hibernate,這個配置將被保存在hibernate.cfg.xml文件中。不管怎樣,Spring提供了一個便捷的方式--在Spring配置文件中合并Hibernate的配置。

　　既然我們已經(jīng)配置了我們的容器服務(wù)beans和把它們連在了一起，我們需要把我們的業(yè)務(wù)服務(wù)對象和我們的DAO對象連在一起。然后，我們需要把這些對象連接到事務(wù)管理器。

　　這是在Spring配置文件里的樣子：

<!-- ORDER SERVICE --> <bean id="orderService" 　class="org. 　　　　 springframework. 　　　　 transaction. 　　　　 interceptor. 　　　　 TransactionProxyFactoryBean"> 　<property name="transactionManager"> 　　<ref local="myTransactionManager"/> 　</property> 　<property name="target"> 　　<ref local="orderTarget"/> 　</property> 　<property name="transactionAttributes"> 　　<props> 　　　<prop key="find*"> 　　PROPAGATION_REQUIRED,readOnly,-OrderException 　　　</prop> 　　　<prop key="save*"> 　　PROPAGATION_REQUIRED,-OrderException 　　 </prop> 　　</props> 　</property> </bean> <!-- ORDER TARGET PRIMARY BUSINESS OBJECT: Hibernate implementation --> <bean id="orderTarget" 　　　　 class="com. 　　　　　　　　meagle. 　　　　　　　　service. 　　　　　　　　spring. 　　　　　　　　OrderServiceSpringImpl"> 　<property name="orderDAO"> 　　<ref local="orderDAO"/> 　</property> </bean> <!-- ORDER DAO OBJECT --> <bean id="orderDAO" 　　　　 class="com. 　　　　　　　　meagle. 　　　　　　　　service. 　　　　　　　　dao. 　　　　　　　　hibernate. 　　　　　　　　OrderHibernateDAO"> 　<property name="sessionFactory"> 　　<ref local="mySessionFactory"/> 　</property> </bean>

　　圖４是我們已經(jīng)連在一起的東西的一個概覽。它展示了每個對象是怎樣相關(guān)聯(lián)的和怎樣被Spring設(shè)置進(jìn)其它對象中。把這幅圖和示例應(yīng)用中的Spring配置文件對比查看它們之間的關(guān)系。

圖４：這是Spring怎樣將在這個配置的基礎(chǔ)上裝配beans。

　　這個例子使用一個TransactionProxyFactoryBean，它有一個為我們已經(jīng)定義了的事務(wù)管理者準(zhǔn)備的setter方法。這是一個有用的對象，它知道怎樣處理聲明的事務(wù)操作和你的服務(wù)對象。你可以通過transactionAttributes屬性定義事務(wù)怎樣被處理，transactionAttributes屬性為方法名定義模式和它們怎樣參與進(jìn)一個事務(wù)。

　　TransactionProxyFactoryBean類也有一個為一個target準(zhǔn)備的setter,target將是一個到我們的叫作orderTarget的業(yè)務(wù)服務(wù)對象的引用。 orderTarget bean定義使用哪個業(yè)務(wù)服務(wù)對象并有一個指向setOrderDAO()的屬性。orderDAO bean將居于這個屬性中，orderDAO bean是我們的和持久層交流的DAO對象。

　　還有一個關(guān)于Spring和bean要注意的是bean能以兩種模式工作。這兩種模式被定義為singleton和prototype。一個bean默認(rèn)的模式是singleton，意味著一個共享的bean的實(shí)例將被管理。這是用于無狀態(tài)操作--像一個無狀態(tài)會話bean將提供的那樣。當(dāng)bean由Spring提供時，prototype模式允許創(chuàng)建bean的新實(shí)例。你應(yīng)當(dāng)只有在每一個用戶都需要他們自己的bean的拷貝時才使用prototype模式。

　　提供一個服務(wù)定位器

　　既然我們已經(jīng)把我們的服務(wù)和我們的DAO連起來了，我們需要把我們的服務(wù)暴露給其它層。通常是一個像使用Struts或Swing這樣的用戶接口層里的代碼來使用這個服務(wù)。一個簡單的處理方法是使用一個服務(wù)定位器模式的類從一個Spring上下文中返回資源。這也可以靠引用bean ID通過Spring來直接完成。

　　這兒是一個在Struts Action中怎樣配置一個服務(wù)定位器的例子：

public abstract class BaseAction extends Action { 　private IOrderService orderService; 　public void setServlet(ActionServlet 　　　　　　　　　　　　　　　　 actionServlet) { 　　super.setServlet(actionServlet); 　　ServletContext servletContext = 　　　　　　　 actionServlet.getServletContext(); 　　WebApplicationContext wac = 　　　WebApplicationContextUtils. 　　　　 getRequiredWebApplicationContext( 　　　　　　　　　　　　　　　　 servletContext); 　　　this.orderService = (IOrderService) 　　　　　　　　　　 wac.getBean("orderService"); 　} 　protected IOrderService getOrderService() { 　　return orderService; 　} }

　　用戶接口層配置

　　示例應(yīng)用的用戶接口層使用Struts框架。這兒我們將討論當(dāng)為一個應(yīng)用分層時和Struts相關(guān)的部分。讓我們從在struts-config.xml文件里檢查一個Action配置開始。

<action path="/SaveNewOrder" 　　type="com.meagle.action.SaveOrderAction" 　　name="OrderForm" 　　scope="request" 　　validate="true" 　　input="/NewOrder.jsp"> 　<display-name>Save New Order</display-name> 　<exception key="error.order.save" 　　path="/NewOrder.jsp" 　　scope="request" 　　type="com.meagle.exception.OrderException"/> 　<exception key="error.order.not.enough.money" 　　path="/NewOrder.jsp" 　　scope="request" 　　type="com. 　　meagle. 　　exception. 　　OrderMinimumAmountException"/> 　<forward name="success" path="/ViewOrder.jsp"/> 　<forward name="failure" path="/NewOrder.jsp"/> </action>

　　SaveNewOrder Action被用來持久化一個用戶從用戶接口層提交的訂單。這是一個典型的Struts Action；然而，注意這個action的異常配置。這些Exceptions為我們的業(yè)務(wù)服務(wù)對象也在Spring 配置文件中配置了。當(dāng)這些異常被從業(yè)務(wù)層擲出我們能在我們的用戶接口里恰當(dāng)?shù)奶幚硭鼈儭５谝粋€異常，OrderException，當(dāng)在持久層里保存訂單對象失敗時將被這個action使用。這將引起事務(wù)回滾和通過業(yè)務(wù)對象傳遞把異常傳回給Struts層。OrderMinimumAmountException，在業(yè)務(wù)對象邏輯里的一個事務(wù)因?yàn)樘峤坏挠唵芜_(dá)不到最小訂單數(shù)量而失敗也將被處理。然后，事務(wù)將回滾和這個異常能被用戶接口層恰當(dāng)?shù)奶幚怼?

　　最后一個連接步驟是使我們的表現(xiàn)層和我們的業(yè)務(wù)層交互。這已經(jīng)通過使用前面討論的服務(wù)定位器來完成了。服務(wù)層充當(dāng)一個到我們的業(yè)務(wù)邏輯和持久層的接口。這兒是 Struts中的SaveNewOrder Action可能怎樣使用一個服務(wù)定位器調(diào)用一個業(yè)務(wù)方法：

public ActionForward execute( 　ActionMapping mapping, 　ActionForm form, 　javax.servlet.http.HttpServletRequest request, 　javax.servlet.http.HttpServletResponse response) 　throws java.lang.Exception { 　OrderForm oForm = (OrderForm)form; 　// Use the form to build an Order object that 　// can be saved in the persistence layer. 　// See the full source code in the sample app. 　// Obtain the wired business service object 　// from the service locator configuration 　// in BaseAction. 　// Delegate the save to the service layer and 　// further upstream to save the Order object. 　getOrderService().saveNewOrder(order); 　oForm.setOrder(order); 　ActionMessages messages = new ActionMessages(); 　messages.add( 　　　ActionMessages.GLOBAL_MESSAGE, new ActionMessage( 　　　"message.order.saved.successfully")); 　saveMessages(request, messages); 　return mapping.findForward("success"); }

　　結(jié)論

　　這篇文章按照技術(shù)和架構(gòu)覆蓋了許多話題。從中而取出的主要思想是怎樣更好的給你的應(yīng)用程序分層：用戶接口層、持久邏輯層、和其它任何你需要的應(yīng)用層。這樣可以解耦你的代碼，允許添加新的代碼組件，使你的應(yīng)用在將來更易維護(hù)。這里覆蓋的技術(shù)能很好的解決這類的問題。不管怎樣，使用這樣的構(gòu)架可以讓你用其他技術(shù)代替現(xiàn)在的層。例如，你也許不想使用Hibernate持久化。因?yàn)槟阍谀愕腄AO對象中編碼到接口，你能怎樣使用其它的技術(shù)或框架，比如 iBATIS，作為一個替代是顯而易見的。或者你可能用不同于Struts的框架替代你的UI層。改變UI層的實(shí)現(xiàn)不會直接影響你的業(yè)務(wù)邏輯層或者你的持久層。替換你的持久層不會影響你的UI邏輯或業(yè)務(wù)服務(wù)層。集成一個web應(yīng)用其實(shí)也不是一件煩瑣的工作，靠解耦你的各應(yīng)用層和用適當(dāng)?shù)目蚣芙M成它，它能變得更容易處理。

二、比較

http://qxndl.blog.sohu.com/905950.html

struts+spring+hibernate之間的關(guān)系與差別

三、整合

先說說《Wiring Your Web Application with Open Source Java by Mark Eagle》這個示例，網(wǎng)上有這個的中英文文章。在后續(xù)的說明中我會將文章的部分內(nèi)容引用進(jìn)來。我使用的開發(fā)工具是 Eclipse3.1 + MyEclipse4.0M2。

針對一個簡單或者復(fù)雜的 Web 應(yīng)用程序，我們需要考慮諸如是怎樣建立用戶接口？在哪里處理業(yè)務(wù)邏輯？怎樣持久化的數(shù)據(jù)？而針對這三個層次，每個層次我們都要仔細(xì)考慮：各個層該使用什么技術(shù)？ 怎樣的設(shè)計能松散耦合還能靈活改變？ 怎樣替換某個層而不影響整體構(gòu)架？應(yīng)用程序如何做各種級別的業(yè)務(wù)處理（比如事務(wù)處理）？等等。

對于這個示例我們采用當(dāng)前流行的三種框架來做到 Web 應(yīng)用程序的松散耦合：表示層我們用 Struts；業(yè)務(wù)層我們用 Spring；而持久層則用 Hibernate。

Struts 負(fù)責(zé)管理用戶的請求，做出響應(yīng)；提供控制器，委派調(diào)用業(yè)務(wù)邏輯；處理異常；UI 驗(yàn)證等。
Spring 負(fù)責(zé)處理應(yīng)用程序的業(yè)務(wù)邏輯和業(yè)務(wù)校驗(yàn)；管理事務(wù)；提供與其它層相互作用的接口；管理業(yè)務(wù)層級別的對象的依賴等。
Hibernate 負(fù)責(zé)存儲、更新、刪除數(shù)據(jù)庫記錄等。

這篇文章舉例說明如何使用這三個框架整合開發(fā)，并揭示一個請求是如何貫穿于各個層的。（從用戶的加入一個Order到數(shù)據(jù)庫，顯示；進(jìn)而更新、刪除）。 

1. 首先創(chuàng)建一組對象，這些對象有的需要持久化，有的提供業(yè)務(wù)邏輯，有的是顯示接口的設(shè)計。Hibernate 允許你將數(shù)據(jù)庫中的信息存放入對象，可以在連接斷開的情況下把這些數(shù)據(jù)顯示到UI層。而那些對象也可以返回給持續(xù)層，從而在數(shù)據(jù)庫里更新。

使用 myeclipse 的 Web  Project 新建一個項(xiàng)目 SSHTest：

創(chuàng)建 Order 類：

利用 eclipse 生成 Getters 和 Setters。

同樣創(chuàng)建 OrderLineItem 類。

com.ivan.ssh.bo.Order 包含一個訂單的主要信息：訂單號，訂單總價，訂單客戶名。
com.ivan.ssh.bo.OrderLineItem 包含訂單的詳細(xì)信息：訂單單項(xiàng)號，單價，描述。一個訂單對應(yīng)于多個訂單項(xiàng)。

Order 與 OrderLineItem 的關(guān)系是一對多的關(guān)系，這里為它們建立雙向一對多的關(guān)系。
在類中我們需要分別為 Order 和 OrderLineItem 添加屬性 orderLineItems(java.util.Set 類型) 和 order(Order 類型)及其 getter 和 setter 方法。

2. 配置持久層，Hibernate 通過 XML 文件來映射 (OR) 對象，以下兩個 xml 文件分別映射了Order 和 OrderItem 對象。
Order.hbm.xml:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class
        name="com.meagle.bo.Order"
        table="Orders"
        dynamic-update="false"
        dynamic-insert="false">

        <id
            name="id"
            column="Order_ID"
            type="int"
            unsaved-value="0">
            <generator class="native">
            </generator>
        </id>

        <set
            name="orderLineItems"
            table="OrderLineItem"
            lazy="true"
            inverse="true"
            cascade="save-update"
            sort="unsorted">
              <key column="Order_ID"/>
              <one-to-many class="com.meagle.bo.OrderLineItem"/>
        </set>

        <property
            name="userName"
            type="string"
            update="true"
            insert="true"
            column="UserName"
            not-null="true"
            unique="false"/>
        <property
            name="total"
            type="double"
            update="true"
            insert="true"
            column="Total"
            not-null="false"
            unique="false"/>
    </class>
</hibernate-mapping>

OrderLineItem.hbm.xml：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class
        name="com.meagle.bo.OrderLineItem"
        table="OrderLineItem"
        dynamic-update="false"
        dynamic-insert="false">

        <id
            name="id"
            column="OrderLineItem_ID"
            type="int"
            unsaved-value="0">
            <generator class="native">
            </generator>
        </id>

        <many-to-one
            name="order"
            class="com.meagle.bo.Order"
            cascade="none"
            outer-join="auto"
            update="true"
            insert="true"
            column="Order_ID"/>

        <property
            name="description"
            type="string"
            update="true"
            insert="true"
            column="Description"
            not-null="false"
            unique="false"/>

        <property
            name="lineItemPrice"
            type="double"
            update="true"
            insert="true"
            column="LineItemPrice"
            not-null="false"
            unique="false"/>
    </class>
</hibernate-mapping>

稍后我們介紹怎樣配置 SessionFactory 和 Session，前者說明與哪個數(shù)據(jù)庫通信，使用哪個連接池或使用了 DataSource，加載哪些持久對象，后者用來完成查找、保存、刪除和更新這些操作。

3. 配置業(yè)務(wù)層，這里要創(chuàng)建業(yè)務(wù)服務(wù)對象(Business Service Object)，用他們來執(zhí)行程序的邏輯，調(diào)用持久層，得到 UI 層的 requests，處理 transactions，并且控制 exceptions。為了將這些連接起來并且易于管理，我們將使用面向方面的 SpringFramework。Spring 提供了控制倒置(Inversion of Control)和注射依賴設(shè)置(Setter Dependency Injection) 這些方式（可供選擇），用 XML 文件將對象連接起來。IoC 是一個簡單概念（它允許一個對象在上層接受其他對象的創(chuàng)建），用 IoC 這種方式讓你的對象從創(chuàng)建中釋放了出來，降低了偶合度。

我們將用一個 business service object 接收一個 DAO，用它來控制 domain objects 的持久化。 由于在這個例子中使用了 Hibernate，我們可以很方便的用其他持久框架實(shí)現(xiàn)同時通知 Spring 有新的 DAO 可以使用了。在面向接口的編程中，你會明白 “注射依賴”模式是怎樣松散耦合你的業(yè)務(wù)邏輯和持久機(jī)制的。

public interface IOrderService {
  public abstract Order saveNewOrder(Order order)
     throws OrderException, OrderMinimumAmountException;
  public abstract List findOrderByUser(String user) throws OrderException;
  public abstract Order findOrderById(int id) throws OrderException;
  public abstract void setOrderDAO(IOrderDAO orderDAO);
}

注意到這段代碼里有一個 setOrderDao()，它就是一個DAO Object設(shè)置方法（注射器）。

其實(shí)現(xiàn)類：
public class OrderServiceSpringImpl implements IOrderService {

 private static final double ORDER_MINIMUM = 100.0;

 private IOrderDAO orderDAO;

 public Order saveNewOrder(Order order)
  throws OrderException, OrderMinimumAmountException {

  // do some business logic
  if (order != null && order.getTotal() == 0) {

   double total = 0.0;

   Set items = order.getOrderLineItems();
   Iterator iter = items.iterator();
   while (iter.hasNext()) {
    OrderLineItem item = (OrderLineItem) iter.next();
    total += item.getLineItemPrice();
   }

   if (total < OrderServiceSpringImpl.ORDER_MINIMUM) {
    throw new OrderMinimumAmountException("Order did not exceed the order minimum");
   } else {
    order.setTotal(total);
   }
  }

  Order savedOrder = null;
  try {
   savedOrder = getOrderDAO().saveOrder(order);
  } catch (RuntimeException e) {
   throw new OrderException("Could not save order " + e.toString());
  }

  return savedOrder;
 }

 public List findOrderByUser(String user) throws OrderException {

  List orders = null;
  try {
   orders = getOrderDAO().findOrdersPlaceByUser(user);
  } catch (RuntimeException e) {
   // should really use a logger instead of System.out
   System.out.println(
    "Could not locate order by user " + e.getMessage());
   throw new OrderException(
    "Could not locate order by user " + e.getMessage());
  }
  return orders;
 }

 public Order findOrderById(int id) throws OrderException {

  Order order = null;
  try {
   order = getOrderDAO().findOrderById(id);
  } catch (RuntimeException e) {
   // should really use a logger instead of System.out
   System.out.println(
    "Could not locate order by ID " + e.getMessage());
   throw new OrderException(
    "Could not locate order by ID " + e.getMessage());
  }
  return order;
 }

 public IOrderDAO getOrderDAO() {
  return orderDAO;
 }

 public void setOrderDAO(IOrderDAO orderDAO) {
  this.orderDAO = orderDAO;
 }
}

接下去對 DAO 的實(shí)現(xiàn)類進(jìn)行編碼。既然 Spring 已經(jīng)有對 Hibernate 的支持，那這個例子就直接繼承 HibernateDaoSupport類了，這個類很有用，我們可以參考 HibernateTemplate（它主要是針對 HibernateDaoSupport 的一個用法，具體可以查看 Spring 的 API）。

public interface IOrderDAO {
 public  Order findOrderById(final int id);
 public abstract List findOrdersPlaceByUser(final String placedBy);
 public abstract Order saveOrder(final Order order);
}

此接口的實(shí)現(xiàn)類：
public class OrderHibernateDAO
 extends HibernateDaoSupport
 implements IOrderDAO {

 public OrderHibernateDAO() {
  super();
 }

 public Order findOrderById(final int id) {

  Order order = (Order) getHibernateTemplate().load(Order.class, new Integer(id));
   
  if(order.getOrderLineItems().size() > 0){
   // collection initialized. 
  }   
  return order;
 }

 public List findOrdersPlaceByUser(final String placedBy) {

  return getHibernateTemplate().executeFind(new HibernateCallback() {
   public Object doInHibernate(Session session)
    throws HibernateException, SQLException {

    StringBuffer sb = new StringBuffer(100);
    sb.append("select distinct order ");
    sb.append("from Order order ");
    sb.append("join order.lineItems lineItems ");
    sb.append("where order.placedBy = :placedBy");

    sb.append("order by order.id");

    Query query = session.createQuery(sb.toString());
    query.setString("placedBy", placedBy);

    List list = query.list();

    return list;
   }
  });
 }

 public Order saveOrder(final Order order) {
  getHibernateTemplate().save(order);
  return order;
 }

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