亚洲在成人网在线看,亚洲福利在线视频,久久精品国产亚洲av麻豆色欲

[转脓]SSH2 - Struts2+Hibernate+Spring��目��结

Fri, 26 Dec 2008 05:45:00 GMT

原文地址�Q�http://www.wajava.com/bbs/viewthread_thread,51

1、在web.xml中加载Spring的配�|�文�?br />

contextConfigLocation

classpath*:spring/*.xml

org.springframework.web.context.ContextLoaderListener

2、配�|�属性文�?br />
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

classpath*:config/ct-db-c3p0.properties
classpath*:config/mail.properties

3、配�|�数据源

....bean.AddressBook
.......

org.hibernate.dialect.Oracle9Dialect
false
false
auto
true
org.hibernate.cache.EhCacheProvider
true

4、依赖注入配�|?br />

注：对beans的设�|?br /> ...

5、Spring怎样注入Class�Q�泛型类型对象）�Q?br /> 在事务配�|�时�Q�将proxy-target-class讄��为false卛_��。不能�ؓtrue�Q�因��针对接口代理�?br /> 如：

6、Spring中采用构造方法注入注意要点：
在配�|�文件中昑ּ�书写注入的参数。如�Q?br /> id="retJobService">

多个参数的构造函数示�?br /> id="typeService">

false

7、Spring 2.0 �l�合AspectJ pointcut语法配置AOP详解
Spring参考文�?7.3 chema-based AOP support 提供了aspect,advisor,advide三种�l�装�Ҏ��的解释，其中aspect是aspectJ原装�Q�但�E�复杂，

以上几句定义使用cglib创徏Proxy, 为BookManager的save()和remove()加上lowStockBookFlushingAdvice�Q��ؓ BookStockChecker.getLowStockBooks加上lowStockBookCachingAdvice.

execution(* *..BookManager.save(..))
�W�一�? 代表ret-type-pattern �q�回值可��L��Q?br /> *..BookManager 代表��L��Pacakge里的BookManager�c�R�?br /> 如果写成com.xyz.service.* 则代表com.xyz.service下的��L��c?br /> com.xyz.service..* com.xyz.service则代表com.xyz.service及其子package下的��L��c?br /> save代表save�Ҏ��Q�也可以写save* 代表saveBook()�{�方�?br /> (..) 匚w��0个参数或者多个参数的�Q��Q意类�?br /> (x,..) �W�一个参数的�c�d��必须是X
(x,*,*,s,..) 匚w��臛_��4个参敎ͼ��W�一个参数必��L��x�c�d��Q�第二个和第三个参数可以��L��Q�第四个必须是s�c�d��?br />
8、事务配�|�的不同形式
事务配置一�Q?br />

pointcut="execution(* ....recruitment.service.impl..*.*(..)) || execution(* ....employeeinfo.service.impl..*Service.*(..))"
advice-ref="txAdvice" />

事务配置二：

pointcut="execution(* ....employeeinfo.service.impl..*Service.*(..))"
advice-ref="txAdvice" />

pointcut="execution(* ....recruitment.service.impl..*.*(..)) "
advice-ref="txAdviceRet" />

......

transaction-manager="transactionManager">

.........

事务配置三：�Q�在java文�g中配�|�）
需要单独配�|�事务的�c�d��前配�|�事务开�?br /> @Transactional(propagation = Propagation.SUPPORTS)
需要��用事务的�Ҏ��前配�|�开启事务的信息
@Transactional(propagation = Propagation.REQUIRED)
如：
@Transactional(propagation = Propagation.SUPPORTS)
public class ApplierService extends BaseService implements
IApplierService {
@Transactional(propagation = Propagation.REQUIRED)
public void addOrModify(Applier t) {
applierDao.saveOrUpdate(toDBValue(t));
}
}

9、正��配�|�重写父�c�L��法时事务
参阅�Q?a target="_blank">http://aumy2008.javaeye.com/admin/blogs/152928

10、spring中bean的作用域详解
bean属性scope的选取�Q�prototype、request、session、global session�Q�：
class="....CompanyAction" scope="prototype"/>
s:datetimepicker录入框提交正常�?br /> prototype作用域部�|�的bean�Q�每一�ơ请求（��其注入到另一个bean中，或者以�E�序的方式调用容器的getBean()�Ҏ��Q?br /> 都会产生一个新的bean实例�Q�相当一个new的操作，对于prototype作用域的bean�Q�有一炚w��帔R��要，
那就是Spring不能对一个prototype bean的整个生命周期负责，
容器在初始化、配�|�、装饰或者是装配完一个prototype实例后，��它交给客户端，
随后��对该prototype实例不闻不问了。不��何�U�作用域�Q�容器都会调用所有对象的初始化生命周期回调方法，
而对prototype而言�Q��Q何配�|�好的析构生命周期回调方法都��不会被调用�?br /> 清除prototype作用域的对象�q��放�Q何prototype bean所持有的昂贵资源，都是客户端代码的职责�?br /> �Q�让Spring容器释放被singleton作用域bean占用资源的一�U�可行方式是�Q�通过使用bean的后�|�处理器�Q?br /> 该处理器持有要被清除的bean的引用。）

request、session、global session使用的时候首先要在web.xml中做如下配置�Q?br /> 如果你��用的是Servlet 2.4及以上的web容器�Q�那么你仅需要在web应用的XML声明文�gweb.xml中增加下�q�ContextListener卛_��Q?br />

org.springframework.web.context.request.RequestContextListener

class="....action.CompanyAction" scope="request"/>
s:datetimepicker录入框提交正常�?br />
class="....action.CompanyAction" scope="session"/>
s:datetimepicker录入框不能正常提交�?br />
class="....action.CompanyAction" scope="global session"/>
java.lang.IllegalStateException: No Scope registered for scope 'global session'
分析�Q�global session作用域类��g��标准的HTTP Session作用域，不过它仅仅在��Z��portlet的web应用中才有意义�?br />
Spring中bean的作用域相关�|�站�Q?br /> http://doc.javanb.com/spring-framework-reference-zh-2-0-5/ch03s04.html

一叶笑�?/a> 2008-12-26 13:45 发表评论

Wed, 24 Dec 2008 06:30:00 GMT

原文地址�Q?a >http://www.ilina.cn/cto/p278/J27834217.shtml

Hibernate 的jar包说明（转）

Hibernate一共包括了23个jar包，令�h��D��~��ؕ。下载Hibernate�Q�例�?.0.3�E�_��版本�Q�解压羃�Q�可以看��C��个hibernate2.jar和lib目录下有22个jar包：

�Q?�Q�hibernate2.jar:

　　Hibernate的库�Q�没有什么可说的�Q�必��M��用的jar�?

�Q?�Q�cglib-asm.jar:

　　CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库�Q�必��M��用的jar�?

�Q?�Q�dom4j.jar:

　　dom4j是一个Java的XML API�Q�类��g��jdom�Q�用来读写XML文�g的。dom4j是一个非帔R��怼��U�的Java XML API�Q�具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的��Y�Ӟ��可以在SourceForge上找到它。在IBM developerWorks上面可以扑ֈ�一��文章，对主��的Java XML API�q�行的性能、功能和易用性的评测�Q�dom4j无论在那个方面都是非常出色的。我早在��近两年之前��开始��用dom4j�Q�直到现在。如今你可以看到��来��多的Java软�g都在使用dom4j来读写XML�Q�特别值得一提的是连Sun的JAXM也在用dom4j。这是必��M��用的jar包，Hibernate用它来读写配�|�文件�?

�Q?�Q�odmg.jar:

　　ODMG是一个ORM的规范，Hibernate实现了ODMG规范�Q�这是一个核心的库，必须使用的jar包�?

�Q?�Q�commons-collections.jar�Q?

　　Apache Commons包中的一个，包含了一些Apache开发的集合�c�，功能比java.util.*强大。必��M��用的jar包�?

�Q?�Q�commons-beanutils.jar�Q?

　　Apache Commons包中的一个，包含了一些Bean工具�cȝ��。必��M��用的jar包�?

�Q?�Q�commons-lang.jar:

　　Apache Commons包中的一个，包含了一些数据类型工��L��Q�是java.lang.*的扩展。必��M��用的jar包�?

�Q?�Q�commons-logging.jar:

　　Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本��n包含了一个Simple Logger�Q�但是功能很弱。在�q�行的时候它会先在CLASSPATH找log4j�Q�如果有�Q�就使用log4j�Q�如果没有，��找JDK1.4带的java.util.logging�Q�如果也找不到就用Simple Logger。commons-logging.jar的出现是一个历史的的遗留的遗憾�Q�当初Apache极力游说Sun把log4j加入JDK1.4�Q�然而JDK1.4��目��组已经接近发布JDK1.4产品的时间了�Q�因此拒�l�了Apache的要求，使用自己的java.util.logging�Q�这个包的功能比log4j差的很远�Q�性能也一般�?/p>

　　后来Apache��开发出来了commons-logging.jar用来兼容两个logger。因此用commons-logging.jar写的log�E�序�Q�底层的Logger是可以切换的�Q�你可以选择log4j�Q�java.util.logging或者它自带的Simple Logger。不�q�我仍然强烈��使用log4j�Q�因为log4j性能很高�Q�log输出信息旉��几乎�{�于System.out�Q�而处理一条log�q�_��只需�?us。你可以在Hibernate的src目录下找到Hibernate已经��Z��准备好了的log4j的配�|�文�Ӟ��你只需要到Apache �|�站��M��载log4j��可以了。commons-logging.jar也是必须的jar包�?

使用Hibernate必须的jar包就是以上的�q�几个，剩下的都是可选的�?

　　ant.jar:

　　Ant�~�译工具的jar包，用来�~�译Hibernate源代码的。如果你不准备修改和�~�译Hibernate源代码，那么��没有什么用�Q�可选的jar�?

　　optional.jar�Q?

　　Ant的一个辅助包�?

　　c3p0.jar�Q?

　　C3PO是一个数据库�q�接池，Hibernate可以配置��Z��用C3PO�q�接池。如果你准备用这个连接池�Q�就需要这个jar包�?

　　proxool.jar�Q?

　　也是一个连接池�Q�同上�?

　　commons-pool.jar, commons-dbcp.jar:

　　DBCP数据库连接池�Q�Apache的Jakarta�l�织开发的�Q�Tomcat4的连接池也是DBCP�?

　　实际上Hibernate自己也实��C��一个非帔R��常简单的数据库连接池�Q�加上上�?个，你实际上可以在Hibernate上选择4�U�不同的数据库连接池�Q�选择哪一个看个�h的偏好，不过DBCP可能更通用一些。另外强调一点，如果在EJB中��用Hibernate�Q�一定要用App Server的连接池�Q�不要用以上4�U�连接池�Q�否则容器管理事务不起作用�?

　　connector.jar:

　　JCA 规范�Q�如果你在App Server上把Hibernate配置为Connector的话�Q�就需要这个jar。不�q�实际上一般App Server肯定会带上这个包�Q�所以实际上是多余的包�?

　　jaas.jar:

　　JAAS是用来进行权限验证的�Q�已�l�包含在JDK1.4里面了。所以实际上是多余的包�?

　　jcs.jar�Q?

　　如果你准备在Hibernate中��用JCS的话�Q�那么必��d��括它�Q�否则就不用�?

　　jdbc2_0-stdext.jar:

　　JDBC2.0的扩展包�Q�一般来说数据库�q�接池会用上它。不�q�App Server都会带上�Q�所以也是多余的�?

　　jta.jar�Q?

　　JTA规范�Q�当Hibernate使用JTA的时候需要，不过App Server都会带上�Q�所以也是多余的�?

　　junit.jar:

　　Junit包，当你�q�行Hibernate自带的测试代码的时候需要，否则��׃��用�?

　　xalan.jar, xerces.jar, xml-apis.jar:

　　Xerces是XML解析器，Xalan是格式化器，xml-apis实际上是JAXP。一般App Server都会带上�Q�JDK1.4也包含了解析器，不过不是Xerces�Q�是Crimson�Q�效率比较差�Q�不�q�Hibernate用XML只不�q�是��d��配置文�g�Q�性能没什么紧要的�Q�所以也是多余的�?/p>

ant-1.63.jar

http://ant.apache.org/

Ant 的核心包,在构建Hibernate 时会用到

antlr-2.7.5H3.jar

http://www.antlr.org/

语言转换�?Hibernate利用它实�?HQL �?SQL的�{�?/p>

asm.jar/asm-attrs.jar

http://asm.objectweb.org/

ASM 字节转换�?/p>

c3p0-0.8.5.2.jar

http://sourceforge.net/projects/c3p0

C3PO JDBC �q�接池工�?/p>

cglib-2.1.jar

http://cglib.sourceforge.net/

高效的代码生成工�? Hibernate用它在运行时扩展 Java�c�d��实现 Java 接口

commons-collections-2.1.1.jar

http://jakarta.apache.org/commons/collections

Apache 的工具集,用来增强Java寚w��合的处理能力

commons-logging-1.0.4.jar

http://jakarta.apache.org/commons/logging/

Apache 软�g基我�l�所提供的日志工�?/p>

concurrent-1.3.2.jar

http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html

�U�程同步工具,在��用JBoss 的树状缓存时需要用�?/p>

connector.jar

http://java.sun.com/j2ee/connector/

用连接多个应用服务器的标准连接器

dom4j-1.6.jar

http://dom4.j.org/

dom4j XML 解析�?/p>

ehcache-1.1.jar

http://sourceforge.net/projects/echache

�~�存工具.在没有提供其他缓存工��h��,�q�个�~�存工具是必不可��的

jaas.jar

http://java.sun.com/products/jass/

标准�?Java 权限和认证服务包

jaxen-1.1-beta-4.jar

http:jaxen.org/

通用�?XPath 处理引擎

jboss-cache.jar

http://www.jboss.com/products/jbosscache

JBoss 的一�U�树状缓存实现工�?/p>

jboss-common.jar

http://jboss.org/

Jboss 的基��?在��?JBoss 的树状缓存时必须有此�?/p>

jboss-jmx.jar

http://jboss.org/

JBoss �?JMX 实现�?/p>

jboss-system.jar

http://jboss.org/

JBoss 的核�?包括服务器和部��v引擎

jdbc2_0-stdext.jar

http://java.sun.com/products/jdbc/download.html#spec

标准�?JDBC 2.0 扩展API

jgroups2.2.7.jar

http://www.jgroups.org/

�|�络通信工具�?/p>

jta.jar

http://java.sun.com/products/jta

标准�?JAVA 事务处理接口

junit-3.8.1.jar

http://www.junit.org/

JUnit ��试框架

log4.j-1.2.9.jar

http://logging.apache.org/log4j/

log4j �?Apache 的日志工�?/p>

oscache-2.1.jar

http://www.opensymphony.com/oscache/

Java 对象的缓存工�?/p>

proxool-0.8.3.jar

http://proxool.sourceforge.net/

Proxool JDBC �q�接池工�?/p>

swarmcache-1.0rc2.jar

http://swarmcache.sourceforge.net/

Hibernate 可以使用的一�U�缓存工�?/p>

versioncheck.jar

版本��查工具包,用于在构建Hibernate 的时候检查辅�?jar 包文件的版本

xerces-2.6.2.jar

http://xml.apache.org/xerces2-j/

SAX XML 解析�?/p>

xml-apis.jar

http://xml.apache.org/xerces2-j/

Java语言中标准的XML 解析�?/p>

一叶笑�?/a> 2008-12-24 14:30 发表评论

Wed, 24 Dec 2008 06:27:00 GMT

原文地址�Q�http://blog.163.com/panyonglong_917/blog/static/179474552008728112039503/

Struts相关jar包简�?nbsp;

commons-beanutils.jar

Commons-Beanutils �q�个是jakarta commons��目中的一个子��目。这个项目开发的目的是帮助开发者动态的获取/讑ր�Java Bean的属性，同时解决每次都要写getXXX和setXXX的麻烦�?

commons-digester.jar

Digester本来仅仅是Jakarta Struts中的一个工��P��用于处理struts-config.xml配置文�g。显�Ӟ��XML文�g转换成相应的Java对象是一��很通用的功能，�q�个工具理应��h��更广泛的用途，所以很快它��在Jakarta Commons��目(用于提供可重用的Java�l��g�?中有了一席之地�?

在内部， Struts 使用来自于Jakarta Commons[ASF, Commons] ��目的Digester 来解析Struts配置文�g。Digester 使用struts-config DTD 来校验文档的格式�Q��ƈ且创建文档所描述的Java对象。如果XML文�g包含了非正式文档化的元素�Q�或者以非正式文档化的方式��用了元素�Q�Digester ��不会处理这个文件�?

commons-fileupload.jar

Commons-FileUpload FileUpload 使得在你可以在应用和Servlet中容易的加入强大和高性能的文件上传能力struts中上传文件要用到�?/div>

struts的验证框架依赖以下的两个包：

commons-validator.jar

(校验�Ҏ��)和校验规则。支持校验规则的和错误消息的国际化�?struts使用它对表单�q�行验证�?

jakarta-oro.jar

Commons-EL Commons-Jexl Search Jakarta ORO Jakarta ORO一套文本处理工�?能提供perl5.0兼容的正则表辑ּ�,AWK-like正则表达�? glob表达式。还提供替换,分割,文�g名过虑等功能�?/div>

struts.jar

struts核心包�?/div>

其他的一下jar�?/div>

commons-collections.jar

扩展了标准的Java Collection框架�Q�提供了额外的Map、List 和Set实现以及多个有用的工��L��库。功能比java.util.*强大�?/div>

commons-logging.jar:

Apache Commons包中的一个，包含了日志功能。这个包本��n包含了一个Simple Logger�Q�但是功能很弱。在�q�行的时候它会先在CLASSPATH找log4j�Q�如果有�Q�就使用log4j�Q�如果没有，��找JDK1.4带的 java.util.logging�Q�如果也找不到就用Simple Logger。commons-logging.jar的出现是一个历史的的遗留的遗憾�Q�当初Apache极力游说Sun把log4j加入JDK1.4�Q�然而JDK1.4��目��组已经接近发布JDK1.4产品的时间了�Q�因此拒�l�了Apache的要求，使用自己的java.util.logging�Q�这个包的功能比log4j差的很远�Q�性能也一般�?/div>

后来Apache��开发出来了commons-logging.jar用来兼容两个 logger。因此用commons-logging.jar写的log�E�序�Q�底层的Logger是可以切换的�Q�你可以选择 log4j�Q�java.util.logging或者它自带的Simple Logger。不�q�我仍然强烈��使用log4j�Q�因为log4j性能很高�Q�log输出信息旉��几乎�{�于System.out�Q�而处理一条log�q�_��只需�?us。你可以在Hibernate的src目录下找到Hibernate已经��Z��准备好了的log4j的配�|�文�Ӟ��你只需要到Apache �|�站��M��载log4j��可以了。commons-logging.jar也是必须的jar包�?/div>

一叶笑�?/a> 2008-12-24 14:27 发表评论

Wed, 24 Dec 2008 06:22:00 GMT

原文位置�Q�http://blog.163.com/panyonglong_917/blog/static/179474552008728112259392/

spring jar 包详�?br /> spring.jar是包含有完整发布的单个jar包，spring.jar中包含除�?spring-mock.jar里所包含的内容外其它所有jar包的内容�Q�因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试，正式应用�pȝ��中是用不得这些类的。　　除了spring.jar文�g�Q�Spring�q�包括有其它13个独立的jar包，各自包含着对应的Spring�l��g�Q�用户可以根据自��q��需要来选择�l�合自己的jar包，而不必引入整个spring.jar的所有类文�g�?br /> (1) spring-core.jar �q�个jar文�g包含Spring框架基本的核心工��L��Q�Spring其它�l��g要都要��用到�q�个包里的类�Q�是其它�l��g的基本核心，当然你也可以在自��q��应用�pȝ��中��用这些工��L��?br /> (2) spring-beans.jar �q�个jar文�g是所有应用都要用到的�Q�它包含讉K��配置文�g、创建和��理bean以及�q�行Inversion of Control / Dependency Injection�Q�IoC/DI�Q�操作相关的所有类。如果应用只需基本的IoC/DI支持�Q�引入spring-core.jar及spring- beans.jar文�g��可以了�?
(3) spring-aop.jar �q�个jar文�g包含在应用中使用Spring的AOP�Ҏ��时所需的类。��用基于AOP的Spring�Ҏ��，如声明型事务��理�Q�Declarative Transaction Management�Q�，也要在应用里包含�q�个jar包�?br /> (4) spring-context.jar 　　�q�个jar文�g为Spring核心提供了大量扩展。可以找��C��用Spring ApplicationContext�Ҏ��时所需的全部类�Q�JDNI所需的全部类�Q�UI斚w��的用来与模板�Q�Templating�Q�引擎如 Velocity、FreeMarker、JasperReports集成的类�Q�以及校验Validation斚w��的相关类�?
(5) spring-dao.jar 　　�q�个jar文�g包含Spring DAO、Spring Transaction�q�行数据讉K��的所有类。�ؓ了��用声明型事务支持�Q�还需在自��q��应用里包含spring-aop.jar�?
(6) spring-hibernate.jar 　　�q�个jar文�g包含Spring对Hibernate 2及Hibernate 3�q�行��装的所有类�?
(7) spring-jdbc.jar 　　�q�个jar文�g包含对Spring对JDBC数据讉K��q�行��装的所有类�?br /> (8) spring-orm.jar 　　�q�个jar文�g包含Spring对DAO�Ҏ��集�q�行了扩展，使其支持 iBATIS、JDO、OJB、TopLink�Q�因为Hibernate已经独立成包了，现在不包含在�q�个包里了。这个jar文�g里大部分的类都要依赖 spring-dao.jar里的�c�，用这个包时你需要同时包含spring-dao.jar包�?br /> (9) spring-remoting.jar 　　�q�个jar文�g包含支持EJB、JMS、远�E�调用Remoting�Q�RMI、Hessian、Burlap、Http Invoker、JAX-RPC�Q�方面的�c�R�?
(10) spring-support.jar 　　�q�个jar文�g包含支持�~�存Cache�Q�ehcache�Q�、JCA、JMX、邮件服务（Java Mail、COS Mail�Q�、�Q务计划Scheduling�Q�Timer、Quartz�Q�方面的�c�R�?br /> (11) spring-web.jar 　　�q�个jar文�g包含Web应用开发时�Q�用到Spring框架时所需的核心类�Q�包括自动蝲入WebApplicationContext�Ҏ��的�c�R�?Struts与JSF集成�c�R��文件上传的支持�c�R��Filter�c�d��大量工具辅助�c�R�?br /> (12) spring-webmvc.jar 　　�q�个jar文�g包含Spring MVC框架相关的所有类。包含国际化、标�{�、Theme、视囑ֱ�现的FreeMarker、JasperReports、Tiles、Velocity�?XSLT相关�c�R��当�Ӟ��如果你的应用使用了独立的MVC框架�Q�则无需�q�个JAR文�g里的��M��c�R�?
(13) spring-mock.jar 　　�q�个jar文�g包含Spring一整套mock�c�L��辅助应用的测试。Spring��试套�g使用了其中大量mock�c�，�q�样��试��更加简单。模�?HttpServletRequest和HttpServletResponse�c�d��Web应用单元��试是很方便的。　　
如何选择�q�些发布包，军_��选用哪些发布包其实相当简单。如果你正在构徏Web应用�q�将全程使用Spring�Q�那么最好就使用单个全部�?spring.jar文�g�Q�如果你的应用仅仅用到简单的Inversion of Control / Dependency Injection�Q�IoC/DI�Q�容器，那么只需spring-core.jar与spring-beans.jar卛_��Q�如果你对发布的大小要求很高�Q�那么就得精挑细选了�Q�只取包含自己所需�Ҏ��的jar文�g了。采用独立的发布包你可以避免包含自己的应用不需要的全部�c�R��当然你可以采用其它的一些工��h��设法令整个应用包变小�Q�节省空间的重点在于准确地找��己所需的Spring依赖�c�，然后合�ƈ所需的类与包��可以了。Eclispe有个插�g�?ClassPath Helper可以帮你找找所依赖的类�?

Spring包依赖说�?
1) spring-core.jar需commons-collections.jar�Q�spring-core.jar是以下其它各个的基本�?br /> 2) spring-beans.jar需spring-core.jar�Q�cglib-nodep-2.1_3.jar
3) spring-aop.jar需spring-core.jar�Q�spring-beans.jar�Q�cglib-nodep- 2.1_3.jar�Q�aopalliance.jar
4) spring-context.jar需spring-core.jar�Q�spring-beans.jar�Q�spring- aop.jar�Q�commons-collections.jar�Q�aopalliance.jar
5) spring-dao.jar需spring-core.jar�Q�spring-beans.jar�Q�spring-aop.jar�Q�spring- context.jar
6) spring-jdbc.jar需spring-core.jar�Q�spring-beans.jar�Q�spring-dao.jar
7) spring-web.jar需spring-core.jar�Q�spring-beans.jar�Q�spring-context.jar
8) spring-webmvc.jar需spring-core.jar/spring-beans.jar/spring-context.jar /spring-web.jar
9) spring -hibernate.jar需spring-core.jar�Q�spring-beans.jar�Q�spring-aop.jar�Q�spring- dao.jar�Q�spring-jdbc.jar�Q�spring-orm.jar�Q�spring-web.jar�Q�spring-webmvc.jar
10) spring-orm.jar需spring-core.jar�Q�spring-beans.jar�Q�spring-aop.jar�Q�spring- dao.jar�Q�spring-jdbc.jar�Q�spring-web.jar�Q�spring-webmvc.jar
11) spring -remoting.jar需spring-core.jar�Q�spring-beans.jar�Q�spring-aop.jar�Q�spring- dao.jar�Q�spring-context.jar�Q�spring-web.jar�Q�spring-webmvc.jar
12) spring-support.jar需spring-core.jar�Q�spring-beans.jar�Q�spring- aop.jar�Q�spring-dao.jar�Q�spring-context.jar�Q�spring-jdbc.jar
13) spring-mock.jar需spring-core.jar�Q�spring-beans.jar�Q�spring-dao.jar�Q�spring- context.jar�Q�spring-jdbc.jar

一叶笑�?/a> 2008-12-24 14:22 发表评论

[转脓]Spring JTA应用之Atomikos配置

Tue, 23 Dec 2008 07:47:00 GMT

原文地址�Q?a >http://tom-duan.javaeye.com/blog/147599

Atomikos,是一个基于Java的开源事务管理器�Q�提供了事务��理和连接池�Q�不需要应用服务器支持�Q�支持JDBC和JMS事务�Q�能提供对Spring�Q�Hibernate的集成，有兴��多了解的可以直接参考说明文当，有详�l�的介绍和��用说明�?

Atomikos可以到http://www.atomikos.com/products.html#ate下蝲,最新版本是3.2.0

首先,仍然是一个相关的配置文�g�Q�用来设�|�相关的环境,打开解压�~�后Atomikos根目�?拯��jta.properties到classpath中，�q�修改�ؓ如下内容
jta.properties

Java代码

com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory
com.atomikos.icatch.console_file_name = tm.out
com.atomikos.icatch.log_base_name = tmlog
com.atomikos.icatch.tm_unique_name = com.atomikos.spring.jdbc.tm
com.atomikos.icatch.console_log_level = INFO

com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory
com.atomikos.icatch.console_file_name = tm.out
com.atomikos.icatch.log_base_name = tmlog
com.atomikos.icatch.tm_unique_name = com.atomikos.spring.jdbc.tm
com.atomikos.icatch.console_log_level = INFO

随后�Q�是Spring上下文配�|�，建立一个名为ApplicationContext-atomikos.xml的Spring上下�?

ApplicationContext-atomikos.xml

Java代码

"1.0" encoding="UTF-8"?>
"http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
"datasource1" class="com.atomikos.jdbc.SimpleDataSourceBean" init-method="init" destroy-method="close">
"uniqueResourceName">
mysql/main
"xaDataSourceClassName">
com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
"xaDataSourceProperties">
URL=jdbc:mysql://localhost:3306/test;user=root;password=admin
"exclusiveConnectionMode">
true
"connectionPoolSize">
3
"validatingQuery">
SELECT 1
"datasource2" class="com.atomikos.jdbc.SimpleDataSourceBean" init-method="init" destroy-method="close">
"uniqueResourceName">
mysql/news
"xaDataSourceClassName">
com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
"xaDataSourceProperties">
URL=jdbc:mysql://localhost:3306/test2;user=root;password=admin
"exclusiveConnectionMode">
true
"connectionPoolSize">
3
"validatingQuery">
SELECT 1
"template1" class="org.springframework.jdbc.core.JdbcTemplate">
"dataSource" ref="datasource1" />
"template2" class="org.springframework.jdbc.core.JdbcTemplate">
"dataSource" ref="datasource2" />
"atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close">
"forceShutdown">true
"atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
"transactionTimeout" value="300"/>
"springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
"transactionManager">"atomikosTransactionManager" />
"userTransaction">"atomikosUserTransaction" />
"dao1" class="com.xa.dao.UserDao1">
"jdbcTemplate">
"template1">
"dao2" class="com.xa.dao.UserDao2">
"jdbcTemplate">
"template2">
"userServiceTarget" class="com.xa.service.UserServiceImpl">
"dao1" ref="dao1"/>
"dao2" ref="dao2"/>
"userTest" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
"transactionManager">
"springTransactionManager"/>
"target">
"userServiceTarget"/>
"transactionAttributes">
"insert*">PROPAGATION_REQUIRED,-Exception






mysql/main


com.mysql.jdbc.jdbc2.optional.MysqlXADataSource


URL=jdbc:mysql://localhost:3306/test;user=root;password=admin


true


3


SELECT 1




mysql/news


com.mysql.jdbc.jdbc2.optional.MysqlXADataSource


URL=jdbc:mysql://localhost:3306/test2;user=root;password=admin


true


3


SELECT 1









true
































PROPAGATION_REQUIRED,-Exception

看上下文中的代码�Q�很大部分和JOTM的相��|��atomikos使用com.atomikos.jdbc.SimpleDataSourceBean�c�L��创徏datasource bean�Q�这里需要特别注�?

Java代码

"uniqueResourceName">
mysql/main


mysql/main

Java代码

"uniqueResourceName">
mysql/news


mysql/news

上面的代码�ؓ每个Datasource配置了一个唯一的名�U�ͼ�名称不允许相同，否则��会使用同一个datasource�Q�而不会出现异常�?

另外在配�|�文件中定义了Atomikos的事务管理器�Q��ƈ在Spring的JtaTransactionManager中引�?

Java代码

"atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close">
"forceShutdown">true
"atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
"transactionTimeout" value="300"/>
"springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
"transactionManager">"atomikosTransactionManager" />
"userTransaction">"atomikosUserTransaction" />


true

其它的代码没什么特别，和JOTM配置基本相同�Q�JdbcTemplate�Q�DAO�Q�Service�Q�事务代理等�{?...

仍然使用TestXa.java�Q�修�Ҏ��引用ApplicationContext-atomikos.xml的上下文配置

Java代码

protected String[] getConfigLocations() {
//return new String[] { "classpath:ApplicationContext-jotm.xml" };
return new String[] { "classpath:ApplicationContext-atomikos.xml" };
}

protected String[] getConfigLocations() {
//return new String[] { "classpath:ApplicationContext-jotm.xml" };
return new String[] { "classpath:ApplicationContext-atomikos.xml" };
}

�q�行test�Q�然后查看数据库状态，
然后修改�Ҏ��参数使其不违反数据库�U�束�Q�再�q�行Test观察数据�?�Q�）�?

一叶笑�?/a> 2008-12-23 15:47 发表评论

[转脓]Spring JTA应用之JOTM配置

Tue, 23 Dec 2008 07:44:00 GMT

原文地址�Q�http://tom-duan.javaeye.com/blog/147594

JOTM(Java Open Transaction Manager)是ObjectWeb的一个开源JTA实现�Q�本�w�也是开源应用程序服务器JOnAS(Java Open Application Server)的一部分�Q��ؓ其提供JTA分布式事务的功能。Spring对JOTM提供了较好的支持�Q�提供了一个org.springframework.transaction.jta.JotmFactoryBean的支持类�Q�在Spring2.0中也包含了JOTM相关的一些library�?

jotm的下载地址为http://jotm.objectweb.org,最新版本�ؓ2.0.10.

下蝲完成后解压羃�Q�然后打开jotm下面conf文�g夹，拯��carol.properties文�g到classpath中，�q�修改这个文件如�?
carol.properties

Java代码

# do not use CAROL JNDI wrapper
carol.start.jndi=false
# do not start a name server
carol.start.ns=false
# Naming Factory
carol.jndi.java.naming.factory.url.pkgs=org.apache.naming

# do not use CAROL JNDI wrapper
carol.start.jndi=false
# do not start a name server
carol.start.ns=false
# Naming Factory
carol.jndi.java.naming.factory.url.pkgs=org.apache.naming

上面配置文�g的目的是不��用JNDI的方式来加蝲JOTM的配�|�，当然也可以根据需要选择其它的一些配�|�，例如JTOM所提供的默认配�|��?

然后开始在Spring上下文中配置JOTM�Q�在classpath中徏立一个ApplicationContext-jotm.xml�Q�配�|�如�?

ApplicationContext-jotm.xml

Java代码

"1.0" encoding="UTF-8"?>
"http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
"jotm" class="org.springframework.transaction.jta.JotmFactoryBean"/>
"txManager" class="org.springframework.transaction.jta.JtaTransactionManager">
"userTransaction" ref="jotm" />
"ds1" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">
"dataSource">
class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">
"transactionManager" ref="jotm" />
"driverName" value="com.mysql.jdbc.Driver" />
"url" value="jdbc:MySQL://localhost:3306/test" />
"user" value="root" />
"password" value="admin" />
"ds2" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">
"dataSource">
class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">
"transactionManager" ref="jotm" />
"driverName" value="com.mysql.jdbc.Driver" />
"url" value="jdbc:MySQL://localhost:3306/test2" />
"user" value="root" />
"password" value="admin" />
"template1" class="org.springframework.jdbc.core.JdbcTemplate">
"dataSource" ref="ds1" />
"template2" class="org.springframework.jdbc.core.JdbcTemplate">
"dataSource" ref="ds2" />
"dao1" class="com.xa.dao.UserDao1">
"jdbcTemplate">
"template1">
"dao2" class="com.xa.dao.UserDao2">
"jdbcTemplate">
"template2">
"userServiceTarget" class="com.xa.service.UserServiceImpl">
"dao1" ref="dao1"/>
"dao2" ref="dao2"/>
"userTest" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
"transactionManager">
"txManager"/>
"target">
"userServiceTarget"/>
"transactionAttributes">
"insert*">PROPAGATION_REQUIRED,-Exception


























































PROPAGATION_REQUIRED,-Exception

上面是一个完整的Spring上下文配�|�，可以看第一个bean “jotm”�Q�实际上引用了Spring内部所提供的对JOTM支持的工厂类�Q�参考下面的配置代码�D?

Java代码

"jotm" class="org.springframework.transaction.jta.JotmFactoryBean"/>

随后�Q�配�|�了JTA事务��理器，�q�且在管理器中��用上面所配置的jotm�Q�如下面的代�?

Java代码

"txManager" class="org.springframework.transaction.jta.JtaTransactionManager">
"userTransaction" ref="jotm" />

再接下来��是配置多个数据源了�Q��用jotm提供的org.enhydra.jdbc.pool.StandardXAPoolDataSource�c�，�Ҏ��c�d��可以明确地看出它是用以配�|�多个数据源的啦,配置的代码如�?

Java代码

"ds1" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">
"dataSource">
class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">
"transactionManager" ref="jotm" />
"driverName" value="com.mysql.jdbc.Driver" />
"url" value="jdbc:MySQL://localhost:3306/test" />
"user" value="root" />
"password" value="admin" />
"ds2" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">
"dataSource">
class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">
"transactionManager" ref="jotm" />
"driverName" value="com.mysql.jdbc.Driver" />
"url" value="jdbc:MySQL://localhost:3306/test2" />
"user" value="root" />
"password" value="admin" />

�q�里配置的两个数据源都连接到本地的mysql�Q�实际上可以�q�接��C��同的db server和不同类型的数据库，已经�l�过��试�Q�这里�ؓ了方便，在本地徏立了两个不同的数据库(test,test2)做测试�?

随后的配�|�基本上和普通的Spring上下文配�|�相同了�Q�根据不同的数据源配�|�两个jdbcTemplate�Q�两个dao分别引用不同的jdbcTemplate, ��两个dao注入到UserService�? 最后将service�U�_��事务��理,�q�在事务代理配置中配�|�回滚规�?意思�ؓ如遇异常�Q�则强制回滚内容。配�|�如下所�C?

Java代码

"transactionAttributes">
"insert*">PROPAGATION_REQUIRED,-Exception



PROPAGATION_REQUIRED,-Exception

�q�样�Q�一个��用JOTM JTA事务的简单应用算大致成型了，最后，写一个JUnit�Q�来��试一下结�?
TestXa.java

Java代码

package com.xa;
import org.springframework.context.ApplicationContext;
import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
import com.xa.service.UserService;
public class TestXa extends AbstractDependencyInjectionSpringContextTests
{
protected String[] getConfigLocations() {
return new String[] { "classpath:ApplicationContext-jotm.xml" };
}
public void testInsertBothDatabase() {
ApplicationContext ctx = this.getApplicationContext();
UserService ut = (UserService)ctx.getBean("userTest");
try {
ut.insertBothDatabase("1", null);
}
catch (Exception e) {
e.printStackTrace();
}
}
}

package com.xa;
import org.springframework.context.ApplicationContext;
import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
import com.xa.service.UserService;
public class TestXa extends AbstractDependencyInjectionSpringContextTests
{
protected String[] getConfigLocations() {
return new String[] { "classpath:ApplicationContext-jotm.xml" };
}
public void testInsertBothDatabase() {
ApplicationContext ctx = this.getApplicationContext();
UserService ut = (UserService)ctx.getBean("userTest");
try {
ut.insertBothDatabase("1", null);
}
catch (Exception e) {
e.printStackTrace();
}
}
}

在test中，调用了UserService的insertBothDatabase�Ҏ��Q�有两个参数�Q�userId和UserName�Q�另外在�Ҏ��的实��C��调用了两个��用不同数据源dao�Q�分别向两个不同的数据库插入输入�Q�而test2数据库的xa_test表中�Q�name字段是不允许为空的，因此�Q�在插入test2数据库时会失�?

�q�行�q�个test�Q�然后察看数据库�l�果�Q�）�Q�test和test2数据库中都没有插入成功，看serviceImpl中的代码可以知道�Q�逻辑上dao1会先于dao2执行�Q�但是由于JTA事务�Q�在dao2插入数据出现异常时整个事务被回滚�Q�由于事务被配置在service层，dao1和dao2都被�U�_��一个事务进行管理，呵呵。修改一下方法的参数�Q�修改�ؓ

Java代码

ut.insertBothDatabase("1", "name1");

ut.insertBothDatabase("1", "name1");

然后再试试test看数据库�l�果�Q�如何？

一叶笑�?/a> 2008-12-23 15:44 发表评论

使用AutowiringRequestProcessor整合struts和Spring2.0

Mon, 22 Dec 2008 05:55:00 GMT

原文位置�Q�http://downpour.javaeye.com/blog/24239

论坛中用Struts�Q�Spring的�h不少�Q�以前的帖子也有问过Struts�Q�Spring的整合方式。前面的帖子中ReadOnly老大曄��提到�q�Spring2.0新增加的一个整合方式。今天简单把�q�几�U�整合方式小�l�一下�?

在这之前�Q�别忘了用一下Google大法�Q�一般早有�h会对�c�M��的问题做�q�回�{�，果然�Q�在ibm developworks上有一��文章，一下子�늛�了三�U�整合方式，有兴��的xdjm可以参考下面的链接�Q�http://www-128.ibm.com/developerworks/cn/java/j-sr2.html�?

下面着重谈一下Spring2.0新增的一个整个方式，我感觉挺不错�Q�可以完全将Struts的配�|�和Spring的配�|�分��R��具体步骤如下：
1. �~�写Spring的配�|�文件applicationContext.xml�Q�简单�v见，仅仅定义一个Service对象�?

引用

�q�看上去��和普通的Spring配置文�g没有��M��分别�?
2. �~�写Struts的配�|�文件struts-config.xml�Q�注意其中的controller的配�|�，用到了Spring2.0的新�Ҏ��?

引用

PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_2.dtd"
>

type="com.bearingpoint.gdc.zero.action.user.AddUser"
scope="request"
>

3. 然后��Z��的Struts的Action注入你需要的Service

引用

private UserService userService;

public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
User user = new User();
userService.addUser(user);
return mapping.findForward("success");
}

/**
* @param userService
* The userService to set.
*/
public void setUserService(UserService userService) {
this.userService = userService;
}

看上��M��好像啥都没做�Q�而事实上�Q�注入工作已�l�由AutowiringRequestProcessor自动完成�?

4. �~�写web.xml�q�行��试�?

引用

?xml version="1.0" ?>

contextConfigLocation

/WEB-INF/classes/applicationContext.xml

org.springframework.web.context.ContextLoaderListener

struts

org.apache.struts.action.ActionServlet

config

/WEB-INF/classes/struts-config.xml

detail

validate

true

struts

*.do

index.jsp

最后，启动Jetty�q�行��试�Q�顺利运行通过�Q?

看上��d��此简单，配置��h��也没有什么很特别的地方，只是按照常规来写你的Spring和Struts的配�|�文件就好了�?

不过在这里还是说一下其中的要注意两个问题：
1. �q�种autowire的注入支持两�U�不同的方式�Q�分别是byName和byType�Q�默认是byType。我惌��对于�l�大多数开发者来说是够了�?
2. 鉴于在http://www.javaeye.com/topic/15057中所提到的OpenSessionInView模式的失效的问题。我仔细看了一下Spring的源码。对于这�U�autowire的整合方式，不推荐在struts-config.xml文�g中配�|�ContextLoaderPlugIn�Q�而是采用web.xml中的ContextLoaderListener来加载Spring的初始化配置。否则，你的OpenSessionInView模式可能会失效�?

一叶笑�?/a> 2008-12-22 13:55 发表评论

Mon, 22 Dec 2008 05:49:00 GMT

原文位置�Q�http://www-128.ibm.com/developerworks/cn/java/j-sr2.html

使用 Spring 更好地处�?Struts 动作

三种整合 Struts 应用�E�序�?Spring 的方�?/em>

�U�别�Q?中��

George Franciscus (george.franciscus@nexcel.ca), 负责�? Nexcel

2005 �q?10 �?11 �?/p>

Struts Recipes 的合著�?George Franciscus ��介�l�另一个重大的 Struts 整合�H�门 —�?�q�次是将 Struts 应用�E�序导入 Spring 框架。请跟随 George�Q�他��向您展�C�如何改�?Struts 动作�Q��得管�?Struts 动作��像��理 Spring beans 那样。结果是一个增强的 web 框架�Q�这个框架可以方便地利用 Spring AOP 的优�ѝ�?/blockquote>
您肯定已�l�听说过控制反�{ (IOC) 设计模式�Q�因为很长一�D�|��间以来一直在��传关于它的信息。如果您在�Q何功能中使用�q?Spring 框架�Q�那么您��q��道其原理的作用。在本文中，我利用这一原理把一�?Struts 应用�E�序注入 Spring 框架�Q�您��亲�w�体会到 IOC 模式的强大�?/p>
��一�?Struts 应用�E�序整合�q?Spring 框架��h��多方面的优点。首先，Spring 是�ؓ解决一些关�?JEE 的真实世界问题而设计的�Q�比如复杂性、低性能和可��试性，�{�等。第二，Spring 框架包含一�?AOP 实现�Q�允许您��面向方面技术应用于面向对象的代码。第三，一些�h可能会说 Spring 框架只有处理 Struts �?Struts 处理自己好。但是这是观炚w��题，我演�C�Z��U�将 Struts 应用�E�序整合�?Spring 框架的方法后�Q�具体由您自己决定��用哪一�U��?/p>
我所演示的方法都是执行�v来相对简单的�Q�但是它们却��h��明显不同的优炏V��我为每一�U�方法创��Z��一个独立而可用的例子�Q�这��h��可以完全理解每�U�方法。请参阅下蝲部分获得完整例子源代码。请参阅参考资�?/a>�Q�下�?Struts MVC �?Spring 框架�?/p>
��Z��?Spring �q�么了不��P��

Spring 的创立�?Rod Johnson 以一�U�批判的眼光看待 Java™ 企业软�g开发，�q�且提议很多企业��N��都能够通过战略��C��?IOC 模式�Q�也�U�C��依赖注入�Q�来解决。当 Rod 和一个具有奉献精��的开放源码开发者团队将�q�个理论应用于实跉|��Q�结果就产生�?Spring 框架。简�a�之，Spring 是一个轻型的容器�Q�利用它可以使用一个外�?XML 配置文�g方便地将对象�q�接在一赗��每个对象都可以通过昄��一�?JavaBean 属性收��C��个到依赖对象的引用，留给您的��单�Q务就只是在一�?XML 配置文�g中把它们�q�接好�?/p>

IOC �?Spring

IOC 是一�U��应用�E�序逻辑外在化的设计模式�Q�所以它是被注入而不是被写入客户��Z��码中。将 IOC 与接口编�E�应用结合，��像 Spring 框架那样�Q��生了一�U�架构，�q�种架构能够减少客户机对特定实现逻辑的依赖。请参阅参考资�?/a> 了解更多关于 IOC �?Spring 的信息�?/p>

依赖注入是一个强大的�Ҏ��，但是 Spring 框架能够提供更多�Ҏ��。Spring 支持可插拔的事务��理器，可以�l�您的事务处理提供更�q�泛的选择范围。它集成了领先的持久性框�Ӟ��q�且提供一个一致的异常层次�l�构。Spring �q�提供了一�U��用面向方面代码代替正常的面向对象代码的简单机制�?/p>
Spring AOP 允许您��?em>拦截�?/em> 在一个或多个执行点上拦截应用�E�序逻辑。加强应用程序在拦截器中的日志记录逻辑会��生一个更可读的、实用的代码基础�Q�所以拦截器�q�泛用于日志记录。您很快��׃��看到�Q��ؓ了处理横切关注点�Q�Spring AOP 发布了它自己的拦截器�Q�您也可以编写您自己的拦截器�?/p>

回页�?/strong>

整合 Struts �?Spring

�?Struts �怼��Q�Spring 可以作�ؓ一�?MVC 实现。这两种框架都具有自��q��优点和缺点，��管大部分�h同意 Struts �?MVC 斚w��仍然是最好的。很多开发团队已�l�学会在旉��紧迫的时候利�?Struts 作�ؓ构造高品质软�g的基��。Struts ��h��如此大的推动力，以至于开发团队宁愿整�?Spring 框架的特性，而不愿意转换�?Spring MVC。没必要�q�行转换�Ҏ��来说是一个好消息。Spring 架构允许您将 Struts 作�ؓ Web 框架�q�接到基�?Spring 的业务和持久层。最后的�l�果��是现在一切条仉��具备了�?/p>
在接下来的小�H�门中，您将会了解到三种��?Struts MVC 整合�?Spring 框架的方法。我��揭�C�每�U�方法的�~�陷�q�且�Ҏ��它们的优炏V�?一旦您了解到所有三�U�方法的作用�Q�我��会向您展示一个��o人兴奋的应用�E�序�Q�这个程序��用的是这三种�Ҏ��中我最喜欢的一�U��?/p>

回页�?/strong>

三个��窍�?/span>

接下来的每种整合技术（或者窍门）都有自己的优点和特点。我偏爱其中的一�U�，但是我知道这三种都能够加深您�?Struts �?Spring 的理解。在处理各种不同情况的时候，�q�将�l�您提供一个广阔的选择范围。方法如下：

使用 Spring �?ActionSupport �c�L��?Structs
使用 Spring �?DelegatingRequestProcessor 覆盖 Struts �?RequestProcessor
��?Struts Action ��理委托�l?Spring 框架

装蝲应用�E�序环境

无论您��用哪�U�技术，都需要��?Spring �?ContextLoaderPlugin �?Struts �?ActionServlet 装蝲 Spring 应用�E�序环境。就像添加�Q何其他插件一��P��单地向您�?struts-config.xml 文�g��d��该插�Ӟ��如下所�C�：
                        
                        
                        
前面已经提到�q�，�?下蝲部分�Q�您能够扑ֈ��q�三个完全可使用的例子的完整源代码。每个例子都��Z��个书�c�搜索应用程序提供一�U�不同的 Struts �?Spring 的整合方法。您可以在这里看��C��子的要点�Q�但是您也可以下载应用程序以查看所有的�l�节�?/p>

回页�?/strong>

�H�门 1. 使用 Spring �?ActionSupport

手动创徏一�?Spring 环境是一�U�整�?Struts �?Spring 的最直观的方式。�ؓ了��它变得更��单，Spring 提供了一些帮助。�ؓ了方便地获得 Spring 环境�Q?code>org.springframework.web.struts.ActionSupport �c�L��供了一�?getWebApplicationContext() �Ҏ��。您所做的只是�?Spring �?ActionSupport 而不�?Struts Action �c�L��展您的动作，如清�?1 所�C�：

清单 1. 使用 ActionSupport 整合 Struts
package ca.nexcel.books.actions;
                        import java.io.IOException;
                        import javax.servlet.ServletException;
                        import javax.servlet.http.HttpServletRequest;
                        import javax.servlet.http.HttpServletResponse;
                        import org.apache.struts.action.ActionError;
                        import org.apache.struts.action.ActionErrors;
                        import org.apache.struts.action.ActionForm;
                        import org.apache.struts.action.ActionForward;
                        import org.apache.struts.action.ActionMapping;
                        import org.apache.struts.action.DynaActionForm;
                        import org.springframework.context.ApplicationContext;
                        import org.springframework.web.struts.ActionSupport;
                        import ca.nexcel.books.beans.Book;
                        import ca.nexcel.books.business.BookService;
                        public class SearchSubmit extends ActionSupport {   |(1)
                        public ActionForward execute(
                        ActionMapping mapping,
                        ActionForm form,
                        HttpServletRequest request,
                        HttpServletResponse response)
                        throws IOException, ServletException {
                        DynaActionForm searchForm = (DynaActionForm) form;
                        String isbn = (String) searchForm.get("isbn");
                        //the old fashion way
                        //BookService bookService = new BookServiceImpl();
                        ApplicationContext ctx =
                        getWebApplicationContext();    |(2)
                        BookService bookService =
                        (BookService) ctx.getBean("bookService");   |(3)
                        Book book = bookService.read(isbn.trim());
                        if (null == book) {
                        ActionErrors errors = new ActionErrors();
                        errors.add(ActionErrors.GLOBAL_ERROR,new ActionError
                        ("message.notfound"));
                        saveErrors(request, errors);
                        return mapping.findForward("failure") ;
                        }
                        request.setAttribute("book", book);
                        return mapping.findForward("success");
                        }
                        }
                        
让我们快速思考一下这里到底发生了什么。在 (1) 处，我通过�?Spring �?ActionSupport �c�而不�?Struts �?Action �c�进行扩展，创徏了一个新�?Action。在 (2) 处，我��?getWebApplicationContext() �Ҏ��获得一�?ApplicationContext。�ؓ了获得业务服务，我��用在 (2) 处获得的环境�?(3) 处查找一�?Spring bean�?/p>
�q�种技术很��单�ƈ且易于理解。不�q�的是，它将 Struts 动作�?Spring 框架耦合在一赗��如果您��x��换掉 Spring�Q�那么您必须重写代码。�ƈ且，�׃�� Struts 动作不在 Spring 的控制之下，所以它不能获得 Spring AOP 的优�ѝ��当使用多重独立�?Spring 环境�Ӟ��q�种技术可能有用，但是在大多数情况下，�q�种�Ҏ��不如另外两种�Ҏ��合适�?/p>

回页�?/strong>

�H�门 2. 覆盖 RequestProcessor

��?Spring �?Struts 动作中分��L��一个更巧妙的设计选择。分��ȝ��一�U�方法是使用 org.springframework.web.struts.DelegatingRequestProcessor �c�L��覆盖 Struts �?RequestProcessor 处理�E�序�Q�如清单 2 所�C�：

清单 2. 通过 Spring �?DelegatingRequestProcessor �q�行整合
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                         |(1)
                        
                        
                        
                        
                        
                        
                        
                        
我利用了标记来用 DelegatingRequestProcessor 覆盖默认�?Struts RequestProcessor。下一步是在我�?Spring 配置文�g中注册该动作�Q�如清单 3 所�C�：

清单 3. �?Spring 配置文�g中注册一个动�?/strong>

|(1)

注意�Q�在 (1) 处，我��用名�U�属性注册了一�?bean�Q�以匚w�� struts-config 动作映射名称�?code>SearchSubmit 动作揭示了一�?JavaBean 属性，允许 Spring 在运行时填充属性，如清�?4 所�C�：

清单 4. ��h�� JavaBean 属性的 Struts 动作

package ca.nexcel.books.actions; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.Action; import org.apache.struts.action.ActionError; import org.apache.struts.action.ActionErrors; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import org.apache.struts.action.DynaActionForm; import ca.nexcel.books.beans.Book; import ca.nexcel.books.business.BookService; public class SearchSubmit extends Action { private BookService bookService; public BookService getBookService() { return bookService; } public void setBookService(BookService bookService) { | (1) this.bookService = bookService; } public ActionForward execute( ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { DynaActionForm searchForm = (DynaActionForm) form; String isbn = (String) searchForm.get("isbn"); Book book = getBookService().read(isbn.trim()); |(2) if (null == book) { ActionErrors errors = new ActionErrors(); errors.add(ActionErrors.GLOBAL_ERROR,new ActionError("message.notfound")); saveErrors(request, errors); return mapping.findForward("failure") ; } request.setAttribute("book", book); return mapping.findForward("success"); } }

在清�?4 中，您可以了解到如何创徏 Struts 动作。在 (1) 处，我创��Z��一�?JavaBean 属性�?code>DelegatingRequestProcessor自动地配�|�这�U�属性。这�U�设计�� Struts 动作�q�不知道它正�?Spring ��理�Q��ƈ且��您能够利�?Sping 的动作管理框架的所有优炏V��由于您�?Struts 动作注意不到 Spring 的存在，所以您不需要重写您�?Struts 代码��可以��用其他控制反转容器来替换�?Spring�?/p>
DelegatingRequestProcessor �Ҏ��的确比第一�U�方法好�Q�但是仍然存在一些问题。如果您使用一个不同的 RequestProcessor�Q�则需要手动整�?Spring �?DelegatingRequestProcessor。添加的代码会造成�l�护的麻烦�ƈ且将来会降低您的应用�E�序的灵�z�L��。此外，�q�有�q�一些��用一�p�d��命��o来代�?Struts RequestProcessor 的传闅R�?�q�种改变��会对这�U�解��x��法的使用寿命造成负面的媄响�?/p>

回页�?/strong>

�H�门 3. ��动作管理委托给 Spring

一个更好的解决�Ҏ��是将 Strut 动作��理委托�l?Spring。您可以通过�?struts-config 动作映射中注册一个代理来实现。代理负责在 Spring 环境中查�?Struts 动作。由于动作在 Spring 的控制之下，所以它可以填充动作�?JavaBean 属性，�q��ؓ应用诸如 Spring �?AOP 拦截器之�cȝ��Ҏ��带来了可能�?

清单 5 中的 Action �c�M��清单 4 中的相同。但�?struts-config 有一些不同：

清单 5. Spring 整合的委托方�?/strong>

|(1) input="/searchEntry.do" validate="true" name="searchForm">

清单 5 是一个典型的 struts-config.xml 文�g�Q�只有一个小��的差别。它注册 Spring 代理�cȝ��名称�Q�而不是声明动作的�c�d��Q�如�Q?�Q�处所�C�。DelegatingActionProxy �c�M��用动作映��名�U�查�?Spring 环境中的动作。这��是我们使用 ContextLoaderPlugIn 声明的环境�?/p>
��一�?Struts 动作注册��Z��?Spring bean 是非常直观的�Q�如清单 6 所�C�。我利用动作映射使用标记的名�U�属性（在这个例子中�?"/searchSubmit"�Q�简单地创徏了一�?bean。这个动作的 JavaBean 属性像��M�� Spring bean 一栯��填充�Q?

清单 6. �?Spring 环境中注册一�?Struts 动作

回页�?/strong>

动作委托的优�?/span>

动作委托解决�Ҏ��是这三种�Ҏ��中最好的。Struts 动作不了�?Spring�Q�不对代码作��M��改变��可用于�?Spring 应用�E�序中�?code>RequestProcessor 的改变不会媄响它�Q��ƈ且它可以利用 Spring AOP �Ҏ��的优点�?

动作委托的优点不止如此。一旦让 Spring 控制您的 Struts 动作�Q�您��可以��?Spring �l�动作补充更强的�z�d��。例如，没有 Spring 的话�Q�所有的 Struts 动作都必��L��U�程安全的。如果您讄�� 标记�?singleton 属性�ؓ“false”�Q�那么不��用何种�Ҏ��Q�您的应用程序都��在每一个请求上有一个新生成的动作对象。您可能不需要这�U�特性，但是把它攑֜�您的工具��׃��也很好。您也可以利�?Spring 的生命周期方法。例如，当实例化 Struts 动作�Ӟ�� 标记�?init-method 属性被用于�q�行一个方法。类似地�Q�在从容器中删除 bean 之前�Q�destroy-method 属性执行一个方法。这些方法是��理昂贵对象的好办法�Q�它们以一�U�与 Servlet 生命周期相同的方式进行管理�?/p>

回页�?/strong>

拦截 Struts

前面提到�q�，通过��?Struts 动作委托�l?Spring 框架而整�?Struts �?Spring 的一个主要的优点是：您可以将 Spring �?AOP 拦截器应用于您的 Struts 动作。通过��?Spring 拦截器应用于 Struts 动作�Q�您可以用最��的代�h处理横切��x��炏V�?/p>
虽然 Spring 提供很多内置拦截器，但是我将向您展示如何创徏自己的拦截器�q�把它应用于一�?Struts 动作。�ؓ了��用拦截器�Q�您需要做三�g事：

创徏拦截器�?
注册拦截器�?
声明在何处拦截代码�?

�q�看��h��非常��单的几句话却非常强大。例如，在清�?7 中，我�ؓ Struts 动作创徏了一个日志记录拦截器�?�q�个拦截器在每个�Ҏ��调用之前打印一句话�Q?/p>
清单 7. 一个简单的日志记录拦截�?/strong>

package ca.nexcel.books.interceptors; import org.springframework.aop.MethodBeforeAdvice; import java.lang.reflect.Method; public class LoggingInterceptor implements MethodBeforeAdvice { public void before(Method method, Object[] objects, Object o) throws Throwable { System.out.println("logging before!"); } }

�q�个拦截器非常简单�?code>before() �Ҏ��在拦截点中每个方法之前运行。在本例中，它打印出一句话�Q�其实它可以做您惛_��的�Q何事。下一步就是在 Spring 配置文�g中注册这个拦截器�Q�如清单 8 所�C�：

清单 8. �?Spring 配置文�g中注册拦截器

|(1) |(2) /searchSubmit|(3) logger |(4)

您可能已�l�注意到了，清单 8 扩展�?清单 6 中所�C�的应用�E�序以包含一个拦截器。具体细节如下：

�?(1) 处，我注册了�q�个拦截器�?
�?(2) 处，我创��Z��一�?bean 名称自动代理�Q�它描述如何应用拦截器。还有其他的�Ҏ��定义拦截点，但是�q�种�Ҏ��常见而简�ѝ�?
�?(3) 处，我将 Struts 动作注册为将被拦截的 bean。如果您惌��拦截其他�?Struts 动作�Q�则只需要在 "beanNames" 下面创徏附加�? 标记�?
�?(4) 处，当拦截发生时�Q�我执行了在 (1) 处创建的拦截�?bean 的名�U�。这里列出的所有拦截器都应用于“beanNames”�?

��是�q�样。就像这个例子所展示的，��您�?Struts 动作�|�于 Spring 框架的控制之下，为处理您�?Struts 应用�E�序提供了一�p�d��全新的选择。在本例中，使用动作委托可以��L��地利�?Spring 拦截器提�?Struts 应用�E�序中的日志记录能力�?/p>

回页�?/strong>

�l�束�?/span>

在本文中�Q�您已经学习了将 Struts 动作整合�?Spring 框架中的三种�H�门。��?Spring �?ActionSupport 来整�?Struts�Q�第一�U�窍门中��是�q�样做的�Q�简单而快��P��但是会将 Struts 动作�?Spring 框架耦合在一赗��如果您需要将应用�E�序�U�L��C��个不同的框架�Q�则需要重写代码。第二种解决�Ҏ��通过委托 RequestProcessor 巧妙地解开代码的耦合�Q�但是它的可扩展性不强，�q�且�?Struts �?RequestProcessor 变成一�p�d��命��o�Ӟ��q�种�Ҏ��持�l�不了很长时间。第三种�Ҏ��是这三种�Ҏ��中最好的�Q�将 Struts 动作委托�l?Spring 框架可以使代码解耦，从而��您可以在您的 Struts 应用�E�序中利�?Spring 的特性（比如日志记录拦截器）�?/p>
三种 Struts-Spring 整合�H�门中的每一�U�都被实现成一个完整可用的应用�E�序。请参阅下蝲部分仔细研究它们�?/p>

一叶笑�?/a> 2008-12-22 13:49 发表评论

转脓�Q?解惑 spring 嵌套事务

Mon, 15 Dec 2008 03:15:00 GMT

原文出处�Q?a >http://www.javaeye.com/topic/35907

在所有��?spring 的应用中, 声明式事务管理可能是使用率最高的功能�? 但是, 从我观察到的情况�?
�l�大多数人�ƈ不能深刻理解事务声明中不同事务传播属性配�|�的的含�? 让我们来看一�?TransactionDefinition 接口中的定义

Java代码

/**
* Support a current transaction, create a new one if none exists.
* Analogous to EJB transaction attribute of the same name.
*
This is typically the default setting of a transaction definition.
*/
int PROPAGATION_REQUIRED = 0;
/**
* Support a current transaction, execute non-transactionally if none exists.
* Analogous to EJB transaction attribute of the same name.
*
Note: For transaction managers with transaction synchronization,
* PROPAGATION_SUPPORTS is slightly different from no transaction at all,
* as it defines a transaction scopp that synchronization will apply for.
* As a consequence, the same resources (JDBC Connection, Hibernate Session, etc)
* will be shared for the entire specified scope. Note that this depends on
* the actual synchronization configuration of the transaction manager.
* @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization
*/
int PROPAGATION_SUPPORTS = 1;
/**
* Support a current transaction, throw an exception if none exists.
* Analogous to EJB transaction attribute of the same name.
*/
int PROPAGATION_MANDATORY = 2;
/**
* Create a new transaction, suspend the current transaction if one exists.
* Analogous to EJB transaction attribute of the same name.
*
Note: Actual transaction suspension will not work on out-of-the-box
* on all transaction managers. This in particular applies to JtaTransactionManager,
* which requires the javax.transaction.TransactionManager to be
* made available it to it (which is server-specific in standard J2EE).
* @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
*/
int PROPAGATION_REQUIRES_NEW = 3;
/**
* Execute non-transactionally, suspend the current transaction if one exists.
* Analogous to EJB transaction attribute of the same name.
*
Note: Actual transaction suspension will not work on out-of-the-box
* on all transaction managers. This in particular applies to JtaTransactionManager,
* which requires the javax.transaction.TransactionManager to be
* made available it to it (which is server-specific in standard J2EE).
* @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
*/
int PROPAGATION_NOT_SUPPORTED = 4;
/**
* Execute non-transactionally, throw an exception if a transaction exists.
* Analogous to EJB transaction attribute of the same name.
*/
int PROPAGATION_NEVER = 5;
/**
* Execute within a nested transaction if a current transaction exists,
* behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB.
*
Note: Actual creation of a nested transaction will only work on specific
* transaction managers. Out of the box, this only applies to the JDBC
* DataSourceTransactionManager when working on a JDBC 3.0 driver.
* Some JTA providers might support nested transactions as well.
* @see org.springframework.jdbc.datasource.DataSourceTransactionManager
*/
int PROPAGATION_NESTED = 6;

/** * Support a current transaction, create a new one if none exists. * Analogous to EJB transaction attribute of the same name. *

This is typically the default setting of a transaction definition. */ int PROPAGATION_REQUIRED = 0; /** * Support a current transaction, execute non-transactionally if none exists. * Analogous to EJB transaction attribute of the same name. *

Note: For transaction managers with transaction synchronization, * PROPAGATION_SUPPORTS is slightly different from no transaction at all, * as it defines a transaction scopp that synchronization will apply for. * As a consequence, the same resources (JDBC Connection, Hibernate Session, etc) * will be shared for the entire specified scope. Note that this depends on * the actual synchronization configuration of the transaction manager. * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization */ int PROPAGATION_SUPPORTS = 1; /** * Support a current transaction, throw an exception if none exists. * Analogous to EJB transaction attribute of the same name. */ int PROPAGATION_MANDATORY = 2; /** * Create a new transaction, suspend the current transaction if one exists. * Analogous to EJB transaction attribute of the same name. *

Note: Actual transaction suspension will not work on out-of-the-box * on all transaction managers. This in particular applies to JtaTransactionManager, * which requires the javax.transaction.TransactionManager to be * made available it to it (which is server-specific in standard J2EE). * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager */ int PROPAGATION_REQUIRES_NEW = 3; /** * Execute non-transactionally, suspend the current transaction if one exists. * Analogous to EJB transaction attribute of the same name. *

Note: Actual transaction suspension will not work on out-of-the-box * on all transaction managers. This in particular applies to JtaTransactionManager, * which requires the javax.transaction.TransactionManager to be * made available it to it (which is server-specific in standard J2EE). * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager */ int PROPAGATION_NOT_SUPPORTED = 4; /** * Execute non-transactionally, throw an exception if a transaction exists. * Analogous to EJB transaction attribute of the same name. */ int PROPAGATION_NEVER = 5; /** * Execute within a nested transaction if a current transaction exists, * behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB. *

Note: Actual creation of a nested transaction will only work on specific * transaction managers. Out of the box, this only applies to the JDBC * DataSourceTransactionManager when working on a JDBC 3.0 driver. * Some JTA providers might support nested transactions as well. * @see org.springframework.jdbc.datasource.DataSourceTransactionManager */ int PROPAGATION_NESTED = 6;

我们可以看到, �?spring 中一共定义了六种事务传播属�? 如果你觉得看��h��不够直观, 那么我来转脓一个满大街都有的翻�?

引用

PROPAGATION_REQUIRED -- 支持当前事务�Q�如果当前没有事务，��新��Z��个事务。这是最常见的选择�?
PROPAGATION_SUPPORTS -- 支持当前事务�Q�如果当前没有事务，��׃��非事务方式执行�?
PROPAGATION_MANDATORY -- 支持当前事务�Q�如果当前没有事务，��抛出异常�?
PROPAGATION_REQUIRES_NEW -- 新徏事务�Q�如果当前存在事务，把当前事务挂赗��?
PROPAGATION_NOT_SUPPORTED -- 以非事务方式执行操作�Q�如果当前存在事务，��把当前事务挂�v�?
PROPAGATION_NEVER -- 以非事务方式执行�Q�如果当前存在事务，则抛出异常�?
PROPAGATION_NESTED -- 如果当前存在事务�Q�则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED�c�M��的操作�?
前六个策略类��g��EJB CMT�Q�第七个�Q�PROPAGATION_NESTED�Q�是Spring所提供的一个特�D�变量�?
它要求事务管理器或者��用JDBC 3.0 Savepoint API提供嵌套事务行�ؓ�Q�如Spring的DataSourceTransactionManager�Q?

在我所见过的误解中, 最常见的是下面�q�种:

引用

假如有两个业务接�?ServiceA �?ServiceB, 其中 ServiceA 中有一个方法实现如�?

/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
// 调用 ServiceB 的方�?
ServiceB.methodB();
}

那么如果 ServiceB �?methodB 如果配置了事�? ��必��配�|��ؓ PROPAGATION_NESTED

�q�种��x��可能害了不少�? 认�ؓ Service 之间应该避免互相调用, 其实�Ҏ��不用担心�q�点�Q�PROPAGATION_REQUIRED 已经说得很明�?
如果当前�U�程中已�l�存在事�? �Ҏ��调用会加入此事务, 果当前没有事务，��新��Z��个事�? 所�?ServiceB#methodB() 的事务只要遵循最普通的规则配置�?PROPAGATION_REQUIRED 卛_��, 如果 ServiceB#methodB (我们�U�C��为内部事�? ��Z��文打下基��) 抛了异常, 那么 ServiceA#methodA(我们�U�C��为外部事�? 如果没有�Ҏ��配置此异常时事务提交 (�?+MyCheckedException的用�?, 那么整个事务是一定要 rollback �? 什�?Service 只能�?Dao 之类的言论纯属无�E�之�? spring 只负责配�|�了事务属性方法的拦截, 它怎么知道你这个方法是�?Service �q�是 Dao �??

说了�q�么半天, 那到底什么是真正的事务嵌套呢, 解释之前我们来看一�?nbsp; Juergen Hoeller 的原�?

Juergen Hoeller 写道

PROPAGATION_REQUIRES_NEW starts a new, independent "inner" transaction for the given scope. This transaction will be committed or rolled back completely independent from the outer transaction, having its own isolation scope, its own set of locks, etc. The outer transaction will get suspended at the beginning of the inner one, and resumed once the inner one has completed.

Such independent inner transactions are for example used for id generation through manual sequences, where the access to the sequence table should happen in its own transactions, to keep the lock there as short as possible. The goal there is to avoid tying the sequence locks to the (potentially much longer running) outer transaction, with the sequence lock not getting released before completion of the outer transaction.

PROPAGATION_NESTED on the other hand starts a "nested" transaction, which is a true subtransaction of the existing one. What will happen is that a savepoint will be taken at the start of the nested transaction. íf the nested transaction fails, we will roll back to that savepoint. The nested transaction is part of of the outer transaction, so it will only be committed at the end of of the outer transaction.

Nested transactions essentially allow to try some execution subpaths as subtransactions: rolling back to the state at the beginning of the failed subpath, continuing with another subpath or with the main execution path there - all within one isolated transaction, and not losing any previous work done within the outer transaction.

For example, consider parsing a very large input file consisting of account transfer blocks: The entire file should essentially be parsed within one transaction, with one single commit at the end. But if a block fails, its transfers need to be rolled back, writing a failure marker somewhere. You could either start over the entire transaction every time a block fails, remembering which blocks to skip - or you mark each block as a nested transaction, only rolling back that specific set of operations, keeping the previous work of the outer transaction. The latter is of course much more efficient, in particular when a block at the end of the file fails.

Juergen Hoeller 写道

Rolling back the entire transaction is the choice of the demarcation code/config that started the outer transaction.

So if an inner transaction throws an exception and is supposed to be rolled back (according to the rollback rules), the transaction will get rolled back to the savepoint taken at the start of the inner transaction. The immediate calling code can then decide to catch the exception and proceed down some other path within the outer transaction.

If the code that called the inner transaction lets the exception propagate up the call chain, the exception will eventually reach the demarcation code of the outer transaction. At that point, the rollback rules of the outer transaction decide whether to trigger a rollback. That would be a rollback of the entire outer transaction then.

So essentially, it depends on your exception handling. If you catch the exception thrown by the inner transaction, you can proceed down some other path within the outer transaction. If you let the exception propagate up the call chain, it's eventually gonna cause a rollback of the entire outer transaction.

    也就是说, 最�Ҏ��弄�؜淆的其实�?PROPAGATION_REQUIRES_NEW �?PROPAGATION_NESTED, 那么�q�两�U�方式又有何区别�? 我简单的��译一�?Juergen Hoeller 的话 :

    PROPAGATION_REQUIRES_NEW 启动一个新�? 不依赖于环境�?"内部" 事务. �q�个事务��被完全 commited �?rolled back 而不依赖于外部事�? 它拥有自��q��隔离范围, 自己的锁, �{�等. 当内部事务开始执行时, 外部事务��被挂�v, 内务事务�l�束�? 外部事务��l�执�?

    另一斚w��, PROPAGATION_NESTED 开始一�?"嵌套�? 事务, 它是已经存在事务的一个真正的子事�? 潜套事务开始执行时, 它将取得一�?savepoint. 如果�q�个嵌套事务��p�|, 我们��回滚到�?savepoint. 潜套事务是外部事务的一部分, 只有外部事务�l�束后它才会被提�?

    由此可见, PROPAGATION_REQUIRES_NEW �?PROPAGATION_NESTED 的最大区别在�? PROPAGATION_REQUIRES_NEW 完全是一个新的事�? �?PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 潜套事务也会�?commit, �q�个规则同样适用�?roll back.


    那么外部事务如何利用嵌套事务�?savepoint �Ҏ��呢, 我们用代码来说话

Java代码

ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
ServiceB.methodB();
}
}
ServiceB {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRES_NEW
*/
void methodB() {
}
}

	ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
ServiceB.methodB();
}
}
ServiceB {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRES_NEW
*/
void methodB() {
}
}

�q�种情况�? 因�ؓ ServiceB#methodB 的事务属性�ؓ PROPAGATION_REQUIRES_NEW, 所以两者不会发生�Q何关�p? ServiceA#methodA �?ServiceB#methodB 不会因�ؓ�Ҏ��的执行情况而媄响事务的�l�果, 因�ؓ它们�Ҏ��是两个事务, �?ServiceB#methodB 执行�?ServiceA#methodA 的事务已�l�挂起了 (关于事务挂�v的内容已�l�超��Z��本文的讨��? 有时间我会再写一些挂��L��文章) .

那么 PROPAGATION_NESTED 又是怎么回事�? �l�箋看代�?

Java代码

ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
ServiceB.methodB();
}
}
ServiceB {
/**
* 事务属性配�|��ؓ PROPAGATION_NESTED
*/
void methodB() {
}
}

	ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
ServiceB.methodB();
}
}
ServiceB {
/**
* 事务属性配�|��ؓ PROPAGATION_NESTED
*/
void methodB() {
}
}

现在的情况就变得比较复杂�? ServiceB#methodB 的事务属性被配置�?PROPAGATION_NESTED, 此时两者之间又��如何协作呢? �?Juergen Hoeller 的原话中我们可以扑ֈ��{�案, ServiceB#methodB 如果 rollback, 那么内部事务(�?ServiceB#methodB) ��回滚到它执行前�?SavePoint(注意, �q�是本文中第一�ơ提到它, 潜套事务中最核心的概�?, 而外部事�?�?ServiceA#methodA) 可以有以下两�U�处理方�?

1. 改写 ServiceA 如下

Java代码

ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
try {
ServiceB.methodB();
} catch (SomeException) {
// 执行其他业务, �?nbsp;ServiceC.methodC();
}
}
}

	ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
try {
ServiceB.methodB();
} catch (SomeException) {
// 执行其他业务, �?ServiceC.methodC();
}
}
}

�q�种方式也是潜套事务最有�h值的地方, 它�v��C��分支执行的效�? 如果 ServiceB.methodB ��p�|, 那么执行 ServiceC.methodC(), �?ServiceB.methodB 已经回滚到它执行之前�?SavePoint, 所以不会��生脏数据(相当于此�Ҏ��从未执行�q?, �q�种�Ҏ��可以用在某些特�D�的业务�? �?PROPAGATION_REQUIRED �?PROPAGATION_REQUIRES_NEW 都没有办法做到这一�? (题外�?: 看到�q�种代码, ��g��似曾相识, 惌��v�?prototype.js 中的 Try 函数 )

2. 代码不做��M��修改, 那么如果内部事务(�?ServiceB#methodB) rollback, 那么首先 ServiceB.methodB 回滚到它执行之前�?SavePoint(在�Q何情况下都会如此),
   外部事务(�?ServiceA#methodA) ��根据具体的配置军_��自己�?commit �q�是 rollback (+MyCheckedException).


上面大致讲述了潜套事务的使用场景, 下面我们来看如何�?spring 中��?PROPAGATION_NESTED, 首先来看 AbstractPlatformTransactionManager

Java代码

/**
* Create a TransactionStatus for an existing transaction.
*/
private TransactionStatus handleExistingTransaction(
TransactionDefinition definition, Object transaction, boolean debugEnabled)
throws TransactionException {
... 省略
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
if (!isNestedTransactionAllowed()) {
throw new NestedTransactionNotSupportedException(
"Transaction manager does not allow nested transactions by default - " +
"specify 'nestedTransactionAllowed' property with value 'true'");
}
if (debugEnabled) {
logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
}
if (useSavepointForNestedTransaction()) {
// Create savepoint within existing Spring-managed transaction,
// through the SavepointManager API implemented by TransactionStatus.
// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
DefaultTransactionStatus status =
newTransactionStatus(definition, transaction, false, false, debugEnabled, null);
status.createAndHoldSavepoint();
return status;
}
else {
// Nested transaction through nested begin and commit/rollback calls.
// Usually only for JTA: Spring synchronization might get activated here
// in case of a pre-existing JTA transaction.
doBegin(transaction, definition);
boolean newSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER);
return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);
}
}
}

	/**
* Create a TransactionStatus for an existing transaction.
*/
private TransactionStatus handleExistingTransaction(
TransactionDefinition definition, Object transaction, boolean debugEnabled)
throws TransactionException {
... 省略
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
if (!isNestedTransactionAllowed()) {
throw new NestedTransactionNotSupportedException(
"Transaction manager does not allow nested transactions by default - " +
"specify 'nestedTransactionAllowed' property with value 'true'");
}
if (debugEnabled) {
logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
}
if (useSavepointForNestedTransaction()) {
// Create savepoint within existing Spring-managed transaction,
// through the SavepointManager API implemented by TransactionStatus.
// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
DefaultTransactionStatus status =
newTransactionStatus(definition, transaction, false, false, debugEnabled, null);
status.createAndHoldSavepoint();
return status;
}
else {
// Nested transaction through nested begin and commit/rollback calls.
// Usually only for JTA: Spring synchronization might get activated here
// in case of a pre-existing JTA transaction.
doBegin(transaction, definition);
boolean newSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER);
return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);
}
}
}

一目了�?

1. 我们要设�|?transactionManager �?nestedTransactionAllowed 属性�ؓ true, 注意, 此属性默认�ؓ false!!!

再看 AbstractTransactionStatus#createAndHoldSavepoint() �Ҏ��

Java代码

/**
* Create a savepoint and hold it for the transaction.
* @throws org.springframework.transaction.NestedTransactionNotSupportedException
* if the underlying transaction does not support savepoints
*/
public void createAndHoldSavepoint() throws TransactionException {
setSavepoint(getSavepointManager().createSavepoint());
}

	/**
* Create a savepoint and hold it for the transaction.
* @throws org.springframework.transaction.NestedTransactionNotSupportedException
* if the underlying transaction does not support savepoints
*/
public void createAndHoldSavepoint() throws TransactionException {
setSavepoint(getSavepointManager().createSavepoint());
}

可以看到 Savepoint �?SavepointManager.createSavepoint 实现�? 再看 SavepointManager 的层�ơ结�? 发现
�?Template 实现�?JdbcTransactionObjectSupport, 常用�?DatasourceTransactionManager, HibernateTransactionManager
中的 TransactonObject 都是它的子类 :

JdbcTransactionObjectSupport 告诉我们必须要满��两个条件才�?createSavepoint :

2. java.sql.Savepoint 必须存在, �?jdk 版本�?1.4+
3. Connection.getMetaData().supportsSavepoints() 必须�?true, �?jdbc drive 必须支持 JDBC 3.0

��保以上条�g都满��_��, 你就可以��试使用 PROPAGATION_NESTED �? (全文�?

一叶笑�?/a> 2008-12-15 11:15 发表评论

Thu, 14 Aug 2008 08:59:00 GMT

原文地址�Q�http://www.uusam.com/uu/blog/article.asp?id=60

EHCache 是一个纯java的，在Hibernate2.1充当可插入的的在�q�程中的�~�存�Q�它��h��以下�~�存�Q�最��的依赖性，全面的文�Ҏ��：快速，��单，丰富的文档和��试用例�?

    官方�|�站 http://ehcache.sourceforge.net/

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
�Q�－�Q�－�Q�－�Q�－�Q�－使用��介－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br /> �Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
    ehcache-1.2 cacheNames 列表的取得；

    �Ҏ��一�Q?br />         CacheManager.create();
        String[] cacheNames = CacheManager.getInstance().getCacheNames();

    �Ҏ��二：
        CacheManager manager = new CacheManager();
        String[] cacheNames = manager.getCacheNames();

    �Ҏ��三：
        CacheManager manager1 = new CacheManager("src/config/ehcache1.xml");
        CacheManager manager2 = new CacheManager("src/config/ehcache2.xml");
        String[] cacheNamesForManager1 = manager1.getCacheNames();
        String[] cacheNamesForManager2 = manager2.getCacheNames();

    ehcache-1.2 ��理器各�U�徏立的�Ҏ��Q?br />
    �Ҏ��一�Q?br />          CacheManager manager = new CacheManager();

    �Ҏ��二：
        CacheManager manager = new CacheManager("src/config/ehcache.xml");

    �Ҏ��三：
        URL url = getClass().getResource("/anotherconfigurationname.xml");
        CacheManager manager = new CacheManager(url);

    �Ҏ��四：
        InputStream fis = new FileInputStream(new File("src/config/ehcache.xml").getAbsolutePath());
        try {
            CacheManager manager = new CacheManager(fis);
        } finally {
            fis.close();
        }

    ��d��和删除缓存元�?br />
        讄��一个名为test 的新cache,test属性�ؓ默认
        CacheManager singletonManager = CacheManager.create();
        singletonManager.addCache("testCache");
        Cache test = singletonManager.getCache("testCache");

        讄��一个名为test 的新cache,�q�定义其属�?
        CacheManager singletonManager = CacheManager.create();
        Cache memoryOnlyCache = new Cache("testCache", 5000, false, false, 5, 2);
        manager.addCache(memoryOnlyCache);
        Cache test = singletonManager.getCache("testCache");

        Cache 属性说明：

            构造函敎ͼ�
            public Cache(java.lang.String name,
                         int maxElementsInMemory,
                         boolean overflowToDisk,
                         boolean eternal,
                         long timeToLiveSeconds,
                         long timeToIdleSeconds)

            参数说明�Q?br />             name                          - 元素名字�?br />                 maxElementsInMemory           - 讑֮�内存中创建对象的最大倹{�?br />                 overflowToDisk                - 讄��当内存中�~�存辑ֈ� maxInMemory 限制时元素是否可写到��盘
                                                       上�?br />                 eternal                       - 讄��元素�Q�译注：内存中对象）是否�怹��ȝ��。如果是�Q�将忽略��?br />                                                       旉��制且元素�怸�消亡�?br />                 timeToIdleSeconds             - 讄��某个元素消亡前的停顿旉��?br />                                                       也就是在一个元素消亡之前，两次讉K��旉��的最大时间间隔倹{�?br />                                                       �q�只能在元素不是�怹��ȝ��时有效（译注�Q�如果对象永恒不灭，�?br />                                                       讄��该属性也无用�Q��?br />                                                       如果该值是 0 ��意味着元素可以停顿无穷长的旉��?br />                 timeToLiveSeconds             - 为元素设�|�消亡前的生存时间�?br />                                                        也就是一个元素从构徏到消亡的最大时间间隔倹{�?br />                                                        �q�只能在元素不是�怹��ȝ��时有效�?br />
        删除�~�存元素�Q?br />         CacheManager singletonManager = CacheManager.create();
        singletonManager.removeCache("test");

    关闭�~�存��理�?CacheManager

        CacheManager.getInstance().shutdown();

    对于�~�存对象的操作：
        攑օ�一个简单的对象到缓存元素；
        Cache cache = manager.getCache("sampleCache1");
        Element element = new Element("key1", "value1");
        cache.put(element);

        得到一个序列化后的对象属性��|��
        Cache cache = manager.getCache("sampleCache1");
        Element element = cache.get("key1");
        Serializable value = element.getValue();

        得到一个没有序列化后的对象属性��|��
        Cache cache = manager.getCache("sampleCache1");
        Element element = cache.get("key1");
        Object value = element.getObjectValue();

        删除一个对象从元素�Q?br />         Cache cache = manager.getCache("sampleCache1");
        Element element = new Element("key1", "value1"
        cache.remove("key1");

    对于永固性磁盘存储，立即存储到磁盘：

        Cache cache = manager.getCache("sampleCache1");
        cache.flush();

    获得�~�存大小�Q?br />         得到�~�存的对象数量；
        Cache cache = manager.getCache("sampleCache1");
        int elementsInMemory = cache.getSize();

        得到�~�存对象占用内存的数�?br />         Cache cache = manager.getCache("sampleCache1");
        long elementsInMemory = cache.getMemoryStoreSize();

        得到�~�存对对象占用磁盘的数量
        Cache cache = manager.getCache("sampleCache1");
        long elementsInMemory = cache.getDiskStoreSize();

    关于�~�存的读取和丢失的记�?br />         得到�~�存��d��的命中次敎ͼ�
        Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getHitCount();

        得到内存中缓存读取的命中�ơ数�Q?br />         Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getMemoryStoreHitCount();

        得到��盘中缓存读取的命中�ơ数�Q?br />         Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getDiskStoreCount();

        得到�~�存��d��的丢失次敎ͼ�
        Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getMissCountNotFound();

        得到�~�存��d��的已�l�被销毁的对象丢失�ơ数�Q?br />         Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getMissCountExpired();

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
�Q�－�Q�－�Q�－�Q�－�Q�－��单例子－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br /> �Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－

    实战�Q?br />         XML文�g格式:





                                         maxElementsInMemory="10000"
                        eternal="false"
                        timeToIdleSeconds="120"
                        timeToLiveSeconds="120"
                        overflowToDisk="true"
                        diskPersistent="false"
                        diskExpiryThreadIntervalSeconds="120"
                        memoryStoreEvictionPolicy="LRU"
                        />

                                        maxElementsInMemory="10000"
                       eternal="false"
                       overflowToDisk="true"
                       timeToIdleSeconds="2"
                       timeToLiveSeconds="3"
                       memoryStoreEvictionPolicy="LFU"
                        />



    源码�Q?br />
        import java.io.Serializable;

        import net.sf.ehcache.Cache;
        import net.sf.ehcache.CacheManager;
        import net.sf.ehcache.Element;

        /**
         #############################################################################
         # DESCRIBE ehcache �~�存操作DEMO
         # AUTHOR   悠～�?br />          # DATE     2006-7-10
         # COMPANY  FLX
         # PORJECT  ehcache-demo
         #############################################################################
         */

        public class Demo {

            static CacheManager manager= new CacheManager();

            /**
             *##############################################################################
             *
             * @DESCRIBE
             * @param args
             * @throws InterruptedException
             *
             *##############################################################################
             */
            public static void main(String[] args) throws InterruptedException {

                String[] cacheNames = manager.getCacheNames();
                System.out.println("��d��的缓存列表�ؓ�Q?);
                for(int i=0;i                     System.out.println("-- "+(i+1)+" "+cacheNames[i]);
                }

                Cache cache = manager.getCache("cache1");
                Element element = new Element("key1", "value1");
                cache.put(element);

                element = cache.get("key1");
                Serializable value = element.getValue();
                System.out.println("序列化后的��gؓ�Q?+value.toString());

                element = cache.get("key1");
                Object value1 = element.getObjectValue();
                System.out.println("未序列化的��gؓ�Q?+value1.toString());

                int elementsInMemory = cache.getSize();
                System.out.println("得到�~�存的对象数量："+elementsInMemory);

                long elementsInMemory1 = cache.getMemoryStoreSize();
                System.out.println("得到�~�存对象占用内存的数量："+elementsInMemory1);

                long elementsInMemory2 = cache.getDiskStoreSize();
                System.out.println("得到�~�存对对象占用磁盘的数量�Q?+elementsInMemory2);

                int hits = cache.getHitCount();
                System.out.println("得到�~�存��d��的命中次敎ͼ�"+hits);

                int hits1 = cache.getMemoryStoreHitCount();
                System.out.println("得到内存中缓存读取的命中�ơ数�Q?+hits1);

                int hits2 =cache.getDiskStoreHitCount();
                System.out.println("得到��盘中缓存读取的命中�ơ数�Q?+hits2);

                int hits3 = cache.getMissCountNotFound();
                System.out.println("得到�~�存��d��的丢失次敎ͼ�"+hits3);

                int hits4 = cache.getMissCountExpired();
                System.out.println("得到�~�存��d��的已�l�被销毁的对象丢失�ơ数�Q?+hits4);
            }

        }

一叶笑�?/a> 2008-08-14 16:59 发表评论

亚洲在成人网在线看,亚洲福利在线视频,久久精品国产亚洲av麻豆色欲

[转脓]SSH2 - Struts2+Hibernate+Spring��目���结

[转脓]Spring JTA应用之Atomikos配置

[转脓]Spring JTA应用之JOTM配置

使用AutowiringRequestProcessor整合struts和Spring2.0

原文位置�Q�http://www-128.ibm.com/developerworks/cn/java/j-sr2.html

使用 Spring 更好地处�?Struts 动作

转脓�Q?解惑 spring 嵌套事务

[转脓]SSH2 - Struts2+Hibernate+Spring��目��结