使用struts+spring+hibernate组装你的web应用架构.docx
《使用struts+spring+hibernate组装你的web应用架构.docx》由会员分享，可在线阅读，更多相关《使用struts+spring+hibernate组装你的web应用架构.docx（16页珍藏版）》请在冰豆网上搜索。
使用struts+spring+hibernate组装你的web应用架构
使用struts+spring+hibernate组装你的web应用架构
其实，就算用Java建造一个不是很烦琐的web应用，也不是件轻松的事情。
在构架的一开始就有很多事情要考虑。
从高处看，摆在开发者面前有很多问题：
要考虑是怎样建立用户接口？
在哪里处理业务逻辑？
怎样持久化的数据。
而这三层构架中，每一层都有他们要仔细考虑的。
各个层该使用什么技术？
怎样的设计能松散耦合还能灵活改变？
怎样替换某个层而不影响整体构架？
应用程序如何做各种级别的业务处理（比如事务处理）？
构架一个Web应用需要弄明白好多问题。
幸运的是，已经有不少开发者已经遇到过这类问题，并且建立了处理这类问题的框架。
一个好框架具备以下几点：
减轻开发者处理复杂的问题的负担（"不重复发明轮子"）；内部有良好的扩展；并且有一个支持它的强大的用户团体。
好的构架一般有针对性的处理某一类问题，并且能将它做好（DoOneThingwell）。
然而，你的程序中有几个层可能需要使用特定的框架，已经完成的UI（用户接口）并不代表你也可以把你的业务逻辑和持久逻辑偶合到你的UI部分。
举个例子，你不该在一个Controller（控制器）里面写JDBC代码作为你的业务逻辑，这不是控制器应该提供的。
一个UI控制器应该委派给其它给在UI范围之外的轻量级组件。
好的框架应该能指导代码如何分布。
更重要的是，框架能把开发者从编码中解放出来，使他们能专心于应用程序的逻辑（这对客户来说很重要）。
这篇文章将讨论怎样结合几种著名的框架来使得你的应用程序做到松弛耦合。
如何建立你的架构，并且怎样让你的各个应用层保持一致。
？
如何整合框架以便让每个层在以一种松散偶合的方式彼此作用而不用管低层的技术细节？
这对我们来说真是一种挑战。
这里讨论一个整合框架的策略（使用3种受欢迎的开源框架）：
表示层我们用Struts；业务层我们用Spring；而持久层则用Hibernate。
你也可以用其他FrameWork替换只要能得到同样的效果。
见图1（框架组合示意图）
应用程序的分层
大部分的Web应用在职责上至少能被分成4层。
这四层是：
presentation（描述），persistence（持久），business（业务）和domainmodel（域模块）。
每个层在处理程序上都应该有一项明确的责任,而不应该在功能上与其它层混合，并且每个层要与其它层分开的，但要给他们之间放一个通信接口。
我们就从介绍各个层开始，讨论一下这些层应该提供什么，不应该提供什么。
表示层（ThePresentationLayer）
一般来讲，一个典型的Web应用的的末端应该是表示层。
很多Java发者也理解Struts所提供的。
象业务逻辑之类的被打包到org.apache.struts.Action.，因此，我们很赞成使用Struts这样的框架。
下面是Struts所负责的：
*管理用户的请求,做出相应的响应。
*提供一个Controller,委派调用业务逻辑和其它上层处理。
*处理异常，抛给StrutsAction
*为显示提供一个模型
*UI验证。
以下条款，不该在Struts显示层的编码中经常出现。
它们与显示层无关的。
*直接的与数据库通信，例如JDBC调用。
*与你应用程序相关联的业务逻辑以及校验。
*事物管理。
在表示层引入这些代码，则会带来高偶合和麻烦的维护。
持久层（ThePersistenceLayer）
典型的Web应用的另一个末端是持久层。
这里通常是程序最容易失控的地方。
开发者总是低估构建他们自己的持久框架的挑战性。
系统内部的持续层不但需要大量调试时间，而且还经常缺少功能使之变得难以控制，这是持久层的通病。
还好有几个ORM开源框架很好的解决了这类问题。
尤其是Hibernate。
Hibernate为java提供了OR持久化机制和查询服务,它还给已经熟悉SQL和JDBCAPI的Java开发者一个学习桥梁，他们学习起来很方便。
Hibernate的持久对象是基于POJO和Javacollections。
此外，使用Hibernate并不妨碍你正在使用的IDE。
请看下面的条目，你在持久层编码中需要了解的。
*查询对象的相关信息的语句。
Hibernate通过一个OO查询语言（HQL）或者正则表达的API来完成查询。
HQL非常类似于SQL--只是把SQL里的table和columns用Object和它的fields代替。
你需要学习一些新的HQL语言；不管怎样，他们容易理解而文档也做的很好。
HQL是一种对象查询的自然语言，花很小的代价就能学习它。
*如何存储，更新，删除数据库记录。
*象Hibernate这类的高级ORM框架支持大部分主流数据库，并且他们支持Parent/child关系，事物处理，继承和多态。
业务层（TheBusinessLayer）
一个典型Web应用的中间部分是业务层或者服务层。
从编码的视角来看，这层是最容易被忽视的一层。
而我们却往往在UI层或持久层周围看到这些业务处理的代码，这其实是不正确的，因为它导致了程序代码的紧密偶合，这样一来，随着时间推移这些代码很难维护。
幸好，针对这一问题有好几种Frameworks存在。
最受欢迎的两个框架是Spring和PicoContainer。
这些为也被称为microcontainers，他们能让你很好的把对象搭配起来。
这两个框架都着手于‘依赖注射'（dependencyinjection）（还有我们知道的‘控制反转'InversionofControl=IoC）这样的简单概念。
这篇文章将关注于Spring的注射（译注：
通过一个给定参数的Setter方法来构造Bean,有所不同于Factory）,Spring还提供了SetterInjection（type2），ConstructorInjection（type3）等方式供我们选择。
Spring把程序中所涉及到包含业务逻辑和Dao的Objects——例如transactionmanagementhandler（事物管理控制）、ObjectFactoris（对象工厂）、serviceobjects（服务组件）——都通过XML来配置联系起来。
后面我们会举个例子来揭示一下Spring是怎样运用这些概念。
业务层所负责的如下：
*处理应用程序的业务逻辑和业务校验
*管理事物
*允许与其它层相互作用的接口
*管理业务层级别的对象的依赖。
*在显示层和持久层之间增加了一个灵活的机制，使得他们不直接的联系在一起。
*通过揭示从显示层到业务层之间的Context来得到businessservices。
*管理程序的执行（从业务层到持久层）。
域模块层（TheDomainModelLayer）
既然我们致力于的是一个不是很复杂的Web的应用，我们需要一个对象集合，让它在不同层之间移动的。
域模块层由实际需求中的业务对象组成比如,OrderLineItem,Product等等。
开发者在这层不用管那些DTOs，仅关注domainobject即可。
例如，Hibernate允许你将数据库中的信息存放入对象（domainobjects），这样你可以在连接断开的情况下把这些数据显示到UI层。
而那些对象也可以返回给持续层，从而在数据库里更新。
而且，你不必把对象转化成DTOs（这可能似的它在不同层之间的在传输过程中丢失），这个模型使得Java开发者能很自然运用OO，而不需要附加的编码。
一个简单例子
既然我们已经从全局上理解这些组件。
现在就让我们开始实践吧。
我们还是用Struts，Spring和Hibernate。
这三个框架已经被描述够多了，这里就不重复介绍了。
这篇文章举例指导你如何使用这三个框架整合开发,并向你揭示一个请求是如何贯穿于各个层的。
（从用户的加入一个Order到数据库，显示；进而更新、删除）。
从这里可以下载到程序程序原代码（download）
既然每个层是互相作用的，我们就先来创建domainobjects。
首先，我们要在这些Object中要确定那些是需要持久化的，哪些是提供给businesslogic，那些是显示接口的设计。
下一步，我们将配置我们的持久层并且定义好Hibernate的ORmappings。
然后定义好BusinessObjects。
有了这些组成部分之后，我们将使用Spring把这些连接起来。
最后，我们提供给Spring一个持久层，从这个持久层里我们可以知道它是如何与业务逻辑层（businessservicelayer）通信的，以及它是怎样处理其他层抛出的异常的。
。
域对象层（DomainObjectLayer）
这层是编码的着手点，我们的编码就从这层开始。
例子中Order与OrderItem是一个One—To—Many的关系。
下面就是DomainObjectLayer的两个对象：
·com.meagle.bo.Order.java:
包含了一个Order的概要信息
·com.meagle.bo.OrderLineItem.java:
包含了Order的详细信息
好好考虑怎你的package命名,这反应出了你是怎样分层的。
例如domainobjects在程序中可能打包在com.meagle.bo内。
更详细一点将打包在com.meagle.bo的子目录下面。
businesslogic应该从com.meagle.serice开始打包，而DAO对象应该位于com.meagle.service.dao.hibernate。
反应Forms和Actions的持久对象（presentationclasses）应该分别放在com.meagle.action和com.meagle.forms包。
准确的给包命名使得你的classes很好分割并且易于维护，并且在你添加新的classes时，能使得程序结构上保持上下一致。
持久层的配置（PersistenceLayerConfiguration）
建立Hibernate的持久层需要好几个步骤。
第一步让我们把BO持久化。
既然Hibernate是通过POJO工作的，因此Order和OrderLineItem对象需要给所有的fileds加上getter,setter方法。
Hibernate通过XML文件来映射（OR）对象，以下两个xml文件分别映射了Order和OrderItem对象。
（这里有个叫XDoclet工具可以自动生成你的XML影射文件）
-Order.hbm.xml
-OrderLineItem.hbm.xml
你可以在WebContent/WEB-INF/classes/com/meagle/bo目录下找到这些xml文件。
Hibernate的[urlhttp:
//www.hibernate.org/hib_docs/api/net/sf/hibernate/SessionFactory.html]SessionFactory[/url]是用来告诉程序应该与哪个数据库通信，该使用哪个连接池或使用了DataSource，应该加载哪些持久对象。
而Session接口是用来完成Selecting，Saving，Delete和Updating这些操作。
后面的我们将讲述SessionFactory和Session是怎样设置的。
业务层的配置（BusinessLayerConfiguration）
既然我们已经有了domainobjects，接下来我们就要businessserviceobjects了，用他们来执行程序的logic,调用持久层，得到UI层的requests,处理transactions，并且控制exceptions。
为了将这些连接起来并且易于管理，我们将使用面向方面的SpringFramework。
Spring提供了控制倒置（inversionofcontrol0==IoC）和注射依赖设置（setterdependencyinjection）这些方式（可供选择），用XML文件将对象连接起来。
IoC是一个简单概念（它允许一个对象在上层接受其他对象的创建），用IoC这种方式让你的对象从创建中释放了出来，降低了偶合度。
这里是一个没有使用IoC的对象创建的例子，它有很高偶合度。
图2.没有使用IoC.A创建了B和C
而这里是一个使用IoC的例子，这种方式允许对象在高层可以创建并进入另外一个对象，所以这样可以直接被执行。
图3.对象使用了IoC。
A包含了接受B,C的setter方法,这同样达到了由A创建B,C的目的。
建立我们的业务服务对象（BuildingOurBusinessServiceObjects）
BusinessObject中的Setter方法接受的是接口，这样我们可以很松散的定义对象实现，然后注入。
在我们的案例中，我们将用一个businessserviceobject接收一个DAO,用它来控制domainobjects的持久化。
由于在这个例子中使用了Hibernate，我们可以很方便的用其他持久框架实现同时通知Spring有新的DAO可以使用了。
在面向接口的编程中，你会明白"注射依赖"模式是怎样松散耦合你的业务逻辑和持久机制的：
）。
下面是一个接口businessserviceobject，DAO代码片段：
代码:
publicinterfaceIOrderService{
publicabstractOrdersaveNewOrder（Orderorder）
throwsOrderException,
OrderMinimumAmountException;
publicabstractListfindOrderByUser（
Stringuser）
throwsOrderException;
publicabstractOrderfindOrderById（intid）
throwsOrderException;
publicabstractvoidsetOrderDAO（
IOrderDAOorderDAO）;
}
注意到这段代码里有一个setOrderDao（），它就是一个DAOObject设置方法（注射器）。
但这里并没有一个getOrderDao的方法，这不必要，因为你并不会在外部访问这个orderDao。
这个DAOObjecte将被调用，和我们的persistencelayer通信。
我们将用Spring把DAOObject和businessserviceobject搭配起来的。
因为我们是面向接口编程的，所以并不需要将实现类紧密的耦合在一起。
接下去我们开始我们的DAO的实现类进行编码。
既然Spring已经有对Hibernate的支持，那这个例子就直接继承HibernateDaoSupport类了，这个类很有用，我们可以参考HibernateTemplate（它主要是针对HibernateDaoSupport的一个用法，译注：
具体可以查看Srping的API）。
下面是这个DAO接口代码：
代码:
publicinterfaceIOrderDAO{
publicabstractOrderfindOrderById（
finalintid）;
publicabstractListfindOrdersPlaceByUser（
finalStringplacedBy）;
publicabstractOrdersaveOrder（
finalOrderorder）;
}
我们仍然要给我们持久层组装很多关联的对象，这里包含了HibernateSessionFactory和TransactionManager。
Spring提供了一个HibernateTransactionManager，他用线程捆绑了一个HibernateSession，用它来支持transactions（请查看ThreadLocal）。
下面是HibernateSessionFactory和HibernateTransactionManager:
的配置：
代码:
class="org.springframework.orm.hibernate.
LocalSessionFactoryBean">
com/meagle/bo/Order.hbm.xml
com/meagle/bo/OrderLineItem.hbm.xml
net.sf.hibernate.dialect.MySQLDialect
false
C:
/MyWebApps/.../WEB-INF/proxool.xml
spring
--TransactionmanagerforasingleHibernate
SessionFactory（alternativetoJTA）-->
class="org.
springframework.
orm.
hibernate.
HibernateTransactionManager">
可以看出：
每个对象都可以在Spring配置信息中用标签引用。
在这里，mySessionFactory引用了HibernateSessionFactory，而myTransactionManager引用了HibernateTransactionManage。
注意代码中myTransactionMangerBean有个sessionFactory属性。
HibernateTransactionManager有个sessionFactorysetter和getter方法，这是用来在Spring启动的时候实现"依赖注入"（dependencyinjection）的。
在sessionFactory属性里引用mySessionFactory。
这两个对象在Spring容器初始化后就被组装了起来了。
这样的搭配让你从单例（singletonobjects）和工厂（factories）中解放了出来，降低了代码的维护代价。
mySessionFactory.的两个属性，分别是用来注入mappingResources和hibernatePropertes的。
通常，如果你在Spring之外使用Hibernate,这样的设置应该放在hibernate.cfg.xml中的。
不管怎样,Spring提供了一个便捷的方式-----在Spring内部配置中并入了Hibernate的配置。
如果要得到更多的信息，可以查阅SpringAPI。
既然我们已经组装配置好了ServiceBeans，就需要把BusinessServiceObject和DAO也组装起来，并把这些对象配到一个事务管理器（transactionmanager）里。
在Spring中的配置信息：
代码:
--ORDERSERVICE-->
class="org.
springframework.
transaction.
interceptor.
TransactionProxyFactoryBean">
升级会员 