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

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

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

　　持久層配置

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

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

　　Order.hbm.xml
　　OrderLineItem.hbm.xml

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

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

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

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

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

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

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

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

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

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

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); }

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

　　下一步是寫我們的DAO實(shí)現(xiàn)對(duì)象。因?yàn)镾pring有內(nèi)建的對(duì)Hibernate的支持，這個(gè)例子DAO將繼承HibernateDaoSupport類，這使得我們?nèi)菀兹〉靡粋€(gè)到HibernateTemplate類的引用，HibernateTemplate是一個(gè)幫助類，它能簡(jiǎn)化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); }

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

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

　　既然我們已經(jīng)配置了我們的容器服務(wù)beans和把它們連在了一起，我們需要把我們的業(yè)務(wù)服務(wù)對(duì)象和我們的DAO對(duì)象連在一起。然后，我們需要把這些對(duì)象連接到事務(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)連在一起的東西的一個(gè)概覽。它展示了每個(gè)對(duì)象是怎樣相關(guān)聯(lián)的和怎樣被Spring設(shè)置進(jìn)其它對(duì)象中。把這幅圖和示例應(yīng)用中的Spring配置文件對(duì)比查看它們之間的關(guān)系。

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

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

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

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

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

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

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

　　最后一個(gè)連接步驟是使我們的表現(xiàn)層和我們的業(yè)務(wù)層交互。這已經(jīng)通過使用前面討論的服務(wù)定位器來完成了。服務(wù)層充當(dāng)一個(gè)到我們的業(yè)務(wù)邏輯和持久層的接口。這兒是 Struts中的SaveNewOrder Action可能怎樣使用一個(gè)服務(wù)定位器調(diào)用一個(gè)業(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對(duì)象中編碼到接口，你能怎樣使用其它的技術(shù)或框架，比如 iBATIS，作為一個(gè)替代是顯而易見的?；蛘吣憧赡苡貌煌赟truts的框架替代你的UI層。改變UI層的實(shí)現(xiàn)不會(huì)直接影響你的業(yè)務(wù)邏輯層或者你的持久層。替換你的持久層不會(huì)影響你的UI邏輯或業(yè)務(wù)服務(wù)層。集成一個(gè)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》這個(gè)示例，網(wǎng)上有這個(gè)的中英文文章。在后續(xù)的說明中我會(huì)將文章的部分內(nèi)容引用進(jìn)來。我使用的開發(fā)工具是 Eclipse3.1 + MyEclipse4.0M2。

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

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

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

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

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

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

創(chuàng)建 Order 類：

利用 eclipse 生成 Getters 和 Setters。

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

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

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

2. 配置持久層，Hibernate 通過 XML 文件來映射 (OR) 對(duì)象，以下兩個(gè) xml 文件分別映射了Order 和 OrderItem 對(duì)象。
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，前者說明與哪個(gè)數(shù)據(jù)庫通信，使用哪個(gè)連接池或使用了 DataSource，加載哪些持久對(duì)象，后者用來完成查找、保存、刪除和更新這些操作。

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

我們將用一個(gè) business service object 接收一個(gè) DAO，用它來控制 domain objects 的持久化。 由于在這個(gè)例子中使用了 Hibernate，我們可以很方便的用其他持久框架實(shí)現(xiàn)同時(shí)通知 Spring 有新的 DAO 可以使用了。在面向接口的編程中，你會(huì)明白 “注射依賴”模式是怎樣松散耦合你的業(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);
}

注意到這段代碼里有一個(gè) setOrderDao()，它就是一個(gè)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;
 }
}

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