Spring事务原理
统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatus
spring提供了几个关于事务处理的类：
TransactionDefinition //事务属性定义
TranscationStatus //代表了当前的事务，可以提交，回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。
一般事务定义步骤：
TransactionDefinition td = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try
{ //do sth
https://www.doczj.com/doc/3310022299.html,mit(ts);
}
catch(Exception e){transactionManager.rollback(ts);}
spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。
编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.
void add()
{
transactionTemplate.execute( new TransactionCallback(){
pulic Object doInTransaction(TransactionStatus ts)
{ //do sth}
}
}
声明式：
使用TransactionProxyFactoryBean:
围绕Poxy的动态代理能够自动的提交和回滚事务
org.springframework.transaction.interceptor.TransactionProxyFactoryBean
PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。
Spring 事务管理创造性的解决了很多以前要用重量级的应用服务器才能解决的事务问题，那么其实现原理一定很深奥吧？可是如果读者仔细研究了Spring事务管理的代码以后就会发现，事务管理其实也是如此简单的事情。这也印证了在本书开头的一句话“重剑无锋、大巧不工”，Spring并没有使用什么特殊的API，它运行的原理就是事务的原理。下面是DataSourceTransactionManager的启动事务用的代码（经简化）：protected void doBegin(Object transaction, TransactionDefinition definition)
{
DataSourceTransactionObject txObject =
(DataSourceTransactionObject) transaction;
Connection con = null;
try
{
if (txObject.getConnectionHolder() == null)
{
Connection newCon = this.dataSource.getConnection();
txObject.setConnectionHolder(
new ConnectionHolder(newCon), true);
}
txObject.getConnectionHolder()
.setSynchronizedWithTransaction(true);
con = txObject.getConnectionHolder().getConnection();
Integer previousIsolationLevel = DataSourceUtils
.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel);
if (con.getAutoCommit())
{
txObject.setMustRestoreAutoCommit(true);
con.setAutoCommit(false);
}
txObject.getConnectionHolder().setTransactionActive(true);
// Bind the session holder to the thread.
if (txObject.isNewConnectionHolder())
{
TransactionSynchronizationManager.bindResource(
getDataSource(),txObject.getConnectionHolder());
}
}
catch (SQLException ex)
{
DataSourceUtils.releaseConnection(con, this.dataSource);
throw new CannotCreateTransactionException(
"Could not open JDBC Connection for transaction", ex);
}
}
本文出自：https://www.doczj.com/doc/3310022299.html,
在调用一个需要事务的组件的时候，管理器首先判断当前调用（即当前线程）有没有一个事务，如果没有事务则启动一个事务，并把事务与当前线程绑定。Spring使用TransactionSynchronizationManager的bindResource方法将当前线程与一个事务绑定，采用的方式就是ThreadLocal，这可以从TransactionSynchronizationManager类的代码看出。
public abstract class TransactionSynchronizationManager
{
……
private static final ThreadLocal currentTransactionName = new ThreadLocal();
private static final ThreadLocal currentTransactionReadOnly = new ThreadLocal();
private static final ThreadLocal actualTransactionActive = new ThreadLocal(); ……
}
从doBegin的代码中可以看到在启动事务的时候，如果Connection是的自动提交的（也就是getAutoCommit()方法返回true）则事务管理就会失效，所以首先要调用setAutoCommit(false)方法将其改为非自动提交的。setAutoCommit(false)这个动作在有的JDBC驱动中会非常耗时，所以最好在配置数据源的时候就将“autoCommit”属性配置为true。
首先,为什么要进行事务,接下来说说spring是怎样进行事务管理的.
①Spring事务策略
Spring事务策略,也就是spring事务管理的实现方式.它有一个统一的抽象是由实现下面这个接口完成的.
org.springframework.transaction.PlatformTransactionManager
此接口的内容如下:
Public interfacePlatformTransactionManager()...{
TransactionStatue getTransaction(TransactionDefinition definition) throws TransactionException;
Void commit(TransactionStatus status) throws TransactionException;
Void rollback(TransactionStatus status) throws TransactionException;
}
不管是声明式的还是编程式的事务管理都需要此抽象来完成.
解释一下这个接口,这样可以更好的理解spring的事务控制的原理.
getTransaction()根据类型为TransactionDefinition的参数返回一个TransactionStatus 对象.返回的TransactionStatus对象可能代表一个新的或已经存在的事务(如果在当前调用堆栈有一个符合条件的事务).如同J2EE事务上下文,一个TransactionStatus也是和执行的线程关联的.
同时,在框架中还存在TransactionDefinition接口,即上边的参数类型.此接口指定了事务隔离程度、事务传播、事务超时、只读状态。
另外，还有TransactionStatus接口。这个接口为处理事务提供简单的控制事务执行和查询事务状态的方法。
②两种事务管理方式：编程式、声明式。
Spring提供两种方式的编程式事务管理，分别是：使用TransactionTemplate和直接使用PlatformTransactionManager。
ⅰ. TransactionTempale采用和其他Spring模板，如JdbcTempalte和HibernateTemplate一样的方法。它使用回调方法，把应用程序从处理取得和释放资源中解脱出来。如同其他模板，TransactionTemplate 是线程安全的。
代码片段：
Object result =tt.execute(newTransactionCallback()...{
publicObject doTransaction(TransactionStatus status)...{
updateOperation();
returnresultOfUpdateOperation();
}
});
使用TransactionCallback()可以返回一个值。
如果使用TransactionCallbackWithoutResult则没有返回值。
ⅱ. 也可以使用PlatformTransactionManager直接管理事务。简单地通过一个bean引用给你的bean 传递一个你使用的PlatformTransaction对象。然后，使用TransactionDefinition和TransactionStatus对象就可以发起、回滚、提交事务。
如下片段：
DefaultTransactionDefinition def=newDefaultTransactionDefinition(); //new 一个事务
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); //初始化事务,参数定义事务的传播类型;
TransactionStatus status =transactionManager.getTransaction(def); //获得事务状态
try...{
……………..
https://www.doczj.com/doc/3310022299.html,mit(status); //提交事务;
}catch(…..)...{
transactionManager.rollback(status); //回滚事务;
}
Spring也提供声明式事务管理。这是通过AOP实现的。
大多数Spring用户选择声明式事务管理，这是最少影响应用代码的选择，因而这是和非侵入性的轻量级容器的观念是一致的。
①通常通过TransactionProxyFactoryBean设置Spring事务代理。需要一个目标对象包装在事务代理中。这个目标对象一般是一个普通Javabean。当我们定义TransactionProxyFactoryBean时，必须提供一个相关的PlatformTransactionManager的引用和事务属性。事务属性含有事务定义。例如: PROPAGATION_REQUIRED,-MyCheckedException
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED,readOnly
事务代理会实现目标对象的接口:这里是属性名是target的引用。id是transactionServiceControl。(●使用CGLIB也可以实现具体类的代理。只要设置proxyTargetClass属性为true即可。如果目标对象没有实现任何接口，这将自动设置该属性为true。通常，我们希望面向接口编程。) ●使用proxyInterfaces属性来限定事务代理来代理指定接口也是可以。●也可以通过从org.springframework.aop.framework.ProxyConfig继承或所有AOP代理工厂共享的属性来定制TransactionProxyFactoryBean行为。
然后，说说属性名是transactionAttributes意义：
这里的transactionAttributes属性是定义在https://www.doczj.com/doc/3310022299.html,MathTransactionAttributeSource 中的属性格式设置。这个包括通配符的方法名称映射是很直观的，如”insert*”。注意insert*的映射的值包括回滚规则。”-MyCheckException”指定如果方法抛出MyCheckException或它的子类，事务会自动回滚。可以用逗号分隔多个回滚规则。“-”前缀强制回滚，“+”前缀指定提交(这允许即使抛出unchecked异常时也可以提交事务)。“PROPAGATION_REQUIRED” 指定事务传播范围。
TransactionProxyFactoryBean允许你通过“preInterceptors”和“postInterceptors”属性设置前或后的拦截操作。可以设置任意数量的前和后通过，它们的类型可以是Advistor(切入点)，MethodInterceptor或被当前Spring配置支持的通知类型。例如：ThrowAdvice，AfterReturningAdvice或BeforeAdvice。这些通知必须支持实例共享模式。如果你需要高级AOP特性操作事务，通过org.springframework.aop.framework.ProxyFactoryBean，而不是TransactionProxyFactory实用代理创建者。
②另一种声明方式：BeanNameAutoProxyCreator
使用TransactionProxyFactoryBean当事务代理包装对象，你可以完全控制代理。如果需要用一致方式包装大量bean。使用一个BeanFactoryPostProcessor的一个实现，BeanNameAutoProxyCreator，可以提供另外一种方法。(Spring中，一旦ApplicationContext读完它的初始化信息，它将初始化所有实现BeanPostProcessor接口的bean，并且让它们后处理ApplicationContext中所有其他的bean。所以使用这种机制，正确配置的BeanNameAutoProxyCreator可以用来后处理所有ApplicationContext中所有其他的bean),并且把它们用事务代理包装起来。真正生成的事务代理和使用TransactionProxyFactoryBean生成的基本一致。
Spring的事务管理的大致实现如下：
关键类和方法:
org.springframework.transaction.interceptor.TransactionInterceptor.invoke
org.springframework.transaction.interceptor.TransactionAspectSupport.createTransactionIfNecessary org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction
事务管理只有一个interceptor，那就是TransactionInterceptor。它在对象调用的每个方法之前都会检查一下是否有必要新建一个transaction
createTransactionIfNecessary用来检查是否有必要新建一个transaction。
步骤如下：
寻找transactionAttributes中是否定义有匹配的方法名,匹配包括完全匹配和正则匹配.(优先寻找完全匹配) 1。如果发现定义中有匹配的定义，则
2。从ThreadLocal中找到connectionHoler对象，该对象是在DataSourceUtil.getConnection(DataSource)中获得的。这就是为什么要使用DataSourceUtil.getConnection(DataSource)
的原因。一个connectionHolder对象里边记录了被请求的次数。
3。检查当前的Transaction是否存在？即查找ThreadLocal里边的connectionHolder是否存在，如果存在，表示Transaction已经存在，直接返回。
4。如果当前的Transaction在ThreadLocal中不存在，那么调用DataSourceTransactionManager.doBegin()方法。来新建一个transaction.
Spring事务配置的五种方式
前段时间对Spring的事务配置做了比较深入的研究，在此之间对Spring的事务配置虽说也配置过，但是一直没有一个清楚的认识。通过这次的学习发觉Spring的事务配置只要把思路理清，还是比较好掌握的。
总结如下：
Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager 的实现为HibernateTransactionManager。
具体如下图：
根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：第一种方式：每个Bean都有一个代理
xmlns:xsi="https://www.doczj.com/doc/3310022299.html,/2001/XMLSchema-instance" xmlns:context="https://www.doczj.com/doc/3310022299.html,/schema/context" xmlns:aop="https://www.doczj.com/doc/3310022299.html,/schema/aop" xsi:schemaLocation="https://www.doczj.com/doc/3310022299.html,/schema/beans https://www.doczj.com/doc/3310022299.html,/schema/beans/spring-beans-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/context https://www.doczj.com/doc/3310022299.html,/schema/context/spring-context-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/aop https://www.doczj.com/doc/3310022299.html,/schema/aop/spring-aop-2.5.xsd"> class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> value="org.hibernate.cfg.AnnotationConfiguration"/> class="org.springframework.orm.hibernate3.HibernateTransactionManager"> class="org.springframework.transaction.interceptor.TransactionProxyFactor yBean"> value="com.bluesky.spring.dao.GeneratorDao"/>
第二种方式：所有Bean共享一个代理基类
xmlns:xsi="https://www.doczj.com/doc/3310022299.html,/2001/XMLSchema-instance" xmlns:context="https://www.doczj.com/doc/3310022299.html,/schema/context" xmlns:aop="https://www.doczj.com/doc/3310022299.html,/schema/aop" xsi:schemaLocation="https://www.doczj.com/doc/3310022299.html,/schema/beans https://www.doczj.com/doc/3310022299.html,/schema/beans/spring-beans-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/context https://www.doczj.com/doc/3310022299.html,/schema/context/spring-context-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/aop https://www.doczj.com/doc/3310022299.html,/schema/aop/spring-aop-2.5.xsd"> class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> value="org.hibernate.cfg.AnnotationConfiguration"/> class="org.springframework.orm.hibernate3.HibernateTransactionManager"> class="org.springframework.transaction.interceptor.TransactionProxyFact oryBean" lazy-init="true" abstract="true">
第三种方式：使用拦截器
xmlns:xsi="https://www.doczj.com/doc/3310022299.html,/2001/XMLSchema-instance" xmlns:context="https://www.doczj.com/doc/3310022299.html,/schema/context" xmlns:aop="https://www.doczj.com/doc/3310022299.html,/schema/aop" xsi:schemaLocation="https://www.doczj.com/doc/3310022299.html,/schema/beans https://www.doczj.com/doc/3310022299.html,/schema/beans/spring-beans-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/context https://www.doczj.com/doc/3310022299.html,/schema/context/spring-context-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/aop https://www.doczj.com/doc/3310022299.html,/schema/aop/spring-aop-2.5.xsd"> class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> value="org.hibernate.cfg.AnnotationConfiguration"/> class="org.springframework.orm.hibernate3.HibernateTransactionManager"> class="org.springframework.transaction.interceptor.TransactionInterceptor" > class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreat or">
第四种方式：使用tx标签配置的拦截器
xmlns:xsi="https://www.doczj.com/doc/3310022299.html,/2001/XMLSchema-instance" xmlns:context="https://www.doczj.com/doc/3310022299.html,/schema/context" xmlns:aop="https://www.doczj.com/doc/3310022299.html,/schema/aop" xmlns:tx="https://www.doczj.com/doc/3310022299.html,/schema/tx" xsi:schemaLocation="https://www.doczj.com/doc/3310022299.html,/schema/beans https://www.doczj.com/doc/3310022299.html,/schema/beans/spring-beans-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/context https://www.doczj.com/doc/3310022299.html,/schema/context/spring-context-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/aop https://www.doczj.com/doc/3310022299.html,/schema/aop/spring-aop-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/tx https://www.doczj.com/doc/3310022299.html,/schema/tx/spring-tx-2.5.xsd"> class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> value="org.hibernate.cfg.AnnotationConfiguration"/> class="org.springframework.orm.hibernate3.HibernateTransactionManager"> expression="execution(* com.bluesky.spring.dao.*.*(..))"/> pointcut-ref="interceptorPointCuts"/>
第五种方式：全注解
xmlns:xsi="https://www.doczj.com/doc/3310022299.html,/2001/XMLSchema-instance" xmlns:context="https://www.doczj.com/doc/3310022299.html,/schema/context" xmlns:aop="https://www.doczj.com/doc/3310022299.html,/schema/aop" xmlns:tx="https://www.doczj.com/doc/3310022299.html,/schema/tx" xsi:schemaLocation="https://www.doczj.com/doc/3310022299.html,/schema/beans https://www.doczj.com/doc/3310022299.html,/schema/beans/spring-beans-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/context https://www.doczj.com/doc/3310022299.html,/schema/context/spring-context-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/aop https://www.doczj.com/doc/3310022299.html,/schema/aop/spring-aop-2.5.xsd https://www.doczj.com/doc/3310022299.html,/schema/tx https://www.doczj.com/doc/3310022299.html,/schema/tx/spring-tx-2.5.xsd"> class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> value="org.hibernate.cfg.AnnotationConfiguration"/> class="org.springframework.orm.hibernate3.HibernateTransactionManager">
此时在DAO上需加上@Transactional注解，如下：
package com.bluesky.spring.dao;
import java.util.List;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport; import https://www.doczj.com/doc/3310022299.html,ponent;
import https://www.doczj.com/doc/3310022299.html,er;
@Transactional
@Component("userDao")
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
public List
return this.getSession().createQuery("from User").list();
}
}
spring+hibernate实现事务回滚及其他
对于J2EE 应用程序而言，事务的处理一般有两种模式：
1．依赖特定事务资源的事务处理
这是应用开发中最常见的模式，即通过特定资源提供的事务机制进行事务管理。
如通过JDBC、JTA 的rollback、commit方法；Hibernate Transaction 的rollback、commit方法等。这种方法大家已经相当熟悉。2．依赖容器的参数化事务管理
通过容器提供的集约式参数化事务机制，实现事务的外部管理，如EJB 中的事务管理模式。
如，下面的EJB事务定义中，将SessionBean MySession的doService方
法定义为Required。也就是说，当MySession.doServer 方法被某个线程调用时，容器将此线程纳入事务管理容器，方法调用过程中如果发生异常，当前事务将被容器自动回滚，如果方法正常结束，则容器将自动提交当前事务。
容器管理的参数化事务为程序开发提供了相当的灵活性，同时因为将事务委托给容器进行管理，应用逻辑中无需再编写事务代码，大大节省了代码量（特别是针对需要同时操作多个事务资源的应用），从而提高了生产率。然而，使用EJB 事务管理的代价相当高昂，撇开
EJB 容器不菲的价格，EJB的学习成本，部署、迁移、维护难度，以及容器本身带来的性能开销（这往往意味着需要更高的硬件配置）都给我们带来了相当的困惑。此时事务管理所带来的优势往往还不能抵消上面这些负面影响。
Spring事务管理能给我们带来什么?
下面这段xml配置片断展示了Spring中的事务设定方式：
class="https://www.doczj.com/doc/3310022299.html,mons.dbcp.BasicDataSource" destroy-method="close">
class="org.springframework.jdbc.datasource.DataSourceTr ansactionManager">
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
class="org.springframework.transaction.interceptor.Tran sactionProxyFactoryBean"> PROPAGATION_REQUIRED,readOnly
配置中包含了dataSource，transactionManager 等资源定义。这些资源都为一个名为userDAOProxy 的TransactionProxyFactoryBean 服务，而userDAOProxy 则对包含实际数据逻辑的userDAO进行了事务性封装。
可以看到，在userDAOProxy 的"transactionAttributes"属性中，我们定义了针对userDAO 的事务策略，即将所有名称以insert 开始的方法（如UserDAO.insertUser方法）纳入事务管理范围。如果此方法中抛出异常，则Spring
将当前事务回滚，如果方法正常结束，则提交事务。而对所有名称以get 开始的方法（如UserDAO.getUser 方法）则以只读的事务处理机制进行处理。（设为只读型事务，可以使持久层尝试对数据操作进行优化，如对
于只读事务Hibernate将不执行flush操作，而某些数据库连接池和JDBC 驱动也对只读型操作进行了特别化。）结合上面这段申明带来的感性认知，看看Spring 的事务管理机制与EJB 中事务管理有何不同，或者有何优势。这里自然有许多方面可以比较，不过，笔者认为其中最为关键的两点是：
1．Spring可以将任意Java Class 纳入事务管理
这里的UserDAO只是我们编写的一个普通Java Class，其中包含了一些基本的数据应用逻辑。通过Spring，我们即可简单的实现事务的可配置化。也就是说，我们可以随意为某个类的某个方法指定事务管理机制。与之对比，如果使用EJB容器提供的事务管理功能，我们不得不按照EJB规范编将UserDAO 进行改造，将其转换为一个标准的EJB。
2．Spring事务管理并不依赖特定的事务资源。
EJB 容器必须依赖于JTA 提供事务支持。而Spring 的事务管理则支持JDBC、JTA 等多种事务资源。这为我们提供了更多的选择，从而也使得我们的系统部署更加灵活。
对Spring事务管理机制进行简单分析之后，我们将结合持久层封装的具体事务应用机制，对Spring中的事务管理进行更具实效的探讨。
持久层封装
JDBC
Spring对JDBC进行了良好的封装，通过提供相应的模板和辅助类，在相当程度上降低了JDBC操作的复杂性。并且得益于Spring良好的隔离设计，JDBC封装类库可以脱离Spring Context独立使用，也就是说，即使系统并没有采用Spring作为结构性框架，我们也可以单独使用Spring的JDBC部分（spring-dao.jar）来改善我们的代码。作为对比，首先让我们来看一段传统的JDBC代码：Connection conn =null;
Statement stmt = null;
try {
conn = dataSource.getConnection();
stmt = con.createStatement();
stmt.executeUpdate("UPDATE user SET age = 18 WHERE id = 'erica'");
} finally {
if (stmt != null) {
try {
stmt.close();
} catch (SQLException ex) {
logger.warn("Exception in closing JDBC Statement", ex);
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException ex) {
logger.warn("Exception in closing JDBC Connection", ex);
}
}
}
类似上面的代码非常常见。为了执行一个SQL语句，我们必须编写22行代码，而其中21行与应用逻辑并无关联，并且，这样的代码还会在系统其他地方（也许是每个需要数据库访问的地方）重复出现。
于是，大家开始寻找一些设计模式以改进如此的设计，Template模式的应用是其中一种典型的改进方案。Spring的JDBC封装，很大一部分就是借助Template模式实现，它提供了一个优秀的JDBC模板库，借助这个工具，我们可以简单有效的对传统的JDBC编码方式加以改进。下面是借助Spring JDBC Template修改过的代码，这段代码完成了与上面代码相同的功能。
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.update("UPDATE user SET age = 10 WHERE id = 'erica'");
可以看到，两行代码完成了上面需要19行代码实现的功能。所有冗余的代码都通过合理的抽象汇集到了JdbcTemplate中。无需感叹，借助Template模式，我们大致也能实现这样一个模板，不过，Spring的设计
者已经提前完成了这一步骤。org.springframework.jdbc.core.JdbcTemplate中包含了这个模板实现的代码，经过Spring设计小组精心设计，这个实现可以算的上是模板应用的典范。特别是回调（CallBack）的使用，使得整个模板结构清晰高效。值得一读。
Tips:实际开发中，可以将代码中硬编码的SQL语句作为Bean的一个String类型属性，借助DI机制在配置文件中定义，从而实现SQL 的参数化配置。
再对上面的例子进行一些改进，通过PrepareStatement执行update操作以避免SQL
Injection 漏洞9：
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate
.update(
"UPDATE user SET age = ? WHERE id = ?",
new PreparedStatementSetter() {
public void setValues(PreparedStatementSetter ps)
throws SQLException {
ps.setInt(1, 18);
ps.setString(2, "erica");
}
}
);
可以看到，上面引用了update方法的另一个版本，传入的参数有两个，第一个用于创建
PreparedStatement的SQL。第二个参数是为PreparedStatement设定参数的PreparedStatementSetter。
第二个参数的使用方法比较独到，我们动态新建了一个PreparedStatementSetter类，并实现了这个抽象类的setValues方法。之后将这个类的引用作为参数传递给update。update接受参数之后，即可调用第二个参数提供的方法完成PreparedStatement的初始化。Spring JDBC Template中大量使用了这样的Callback机制，这带来了极强的灵活性和扩展性。
上面演示了update方法的使用（同样的操作适用于update、insert、delete）。下面是一个查询的示例。
final List userList = new ArrayList();
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate
.query(
"SELECT name, sex, address FROM user WHERE age > 18",
9 SQL Injection：SQL语句中直接引入参数值而导致的系统漏洞，具体请参见以下论文：
https://www.doczj.com/doc/3310022299.html,/articles/SQLInjectionModesofAttackDefenceandWhyItMatters.php
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
User user = new User();
user.setId(rs.getString("name"));
user.setSex(rs.getString("sex"));
user.setAddress(rs.getString("address"));
userList.add(product);
}
}
);
这里传入query方法的有两个参数，第一个是Select查询语句，第二个是一个RowCallbackHandler实例，我们通过RowCallbackHandler 对Select语句得到的每行记录进行解析，并为其创建一个User数据对象。实现了手动的OR映射。此外，我们还可以通过JdbcTemplate.call 方法调用存储过程。query、update方法还有其他很多不同参数版本的实现，具体调用方法请参见SpringJavaDoc。
JdbcTemplate与事务
上例中的JdbcTemplate操作采用的是JDBC默认的AutoCommit模式，也就是说我们还无法保证数据操作的原子性（要么全部生效，要么全部无效），如：
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.update("UPDATE user SET age = 10 WHERE id = 'erica'");
jdbcTemplate.update("UPDATE user SET age = age+1 WHERE id = 'erica'");
由于采用了AutoCommit模式，第一个update操作完成之后被自动提交，数据库中”erica”对应的记录已经被更新，如果第二个操作失败，我们无法使得整个事务回滚到最初状态。对于这个例子也许无关紧要，但是对于一个金融帐务系统而言，这样的问题将导致致命错误。为了实现数据操作的原子性，我们需要在程序中引入事务逻辑，在JdbcTemplate中引入事务机制，在Spring中有两种方式：
1．代码控制的事务管理
2．参数化配置的事务管理
下面就这两种方式进行介绍。
u 代码控制的事务管理
首先，进行以下配置，假设配置文件为（Application-Context.xml）：
SpringFrameWork Developer’s Guide Version 0.6 spring配置文件各个属性详解 分类：spring 2012-08-09 11:25 9316人阅读评论(2) 收藏举报springaophibernateattributesxhtmlwebsphere 目录(?)[+]一、引用外部属性文件 Springmvc框架配置步骤 小弟是个新手，有不对的地方请tell me，一起研究探讨。谢谢。 1062140832@https://www.doczj.com/doc/3310022299.html, 配置springmvc框架其实不是很难，要现有一个总体的认识，确定要分几步，每一步主要是干什么，不要太盲目。 以为web.xml是项目的入口，所以所有的配置文件，都必须引入到wem.xml中，不然，配置了等于没用。所以，要先从入口入手。 配置web.xml 1、首先引入springmvc-servlet.xml文件 给你详细讲一下SSH框架的事物管理，希望对你有帮助。 Struts+hibernate+spring整合开发web应用是相当流行的，只需要简单的配置就能轻松的对数据库进行crud操作，下面就hibernate＋spring 的配置做一下剖析，一边与大家一起分享经验： 1、准备工作： 可以利用hibernate tools生成相关映射文件已经po对象、dao对象，dao 也可以自己手动编写，无非就是实现crud，如果通过继承hibernate提供的HibernateDaoSupport,则可以更轻松的实现 关键就在于配置文件，下面看一个样例： Spring分布式事务实现 分布式事务是指操作多个数据库之间的事务，spring的org.springframework.transaction.jta.JtaTransactionManager，提供了分布式事务支持。如果使用WAS的JTA支持，把它的属性改为WebSphere对应的TransactionManager。 在tomcat下，是没有分布式事务的，不过可以借助于第三方软件jotm（Java Open Transaction Manager ）和AtomikosTransactionsEssentials实现，在spring中分布式事务是通过jta（jotm，atomikos）来进行实现。 1、https://www.doczj.com/doc/3310022299.html,/ 2、https://www.doczj.com/doc/3310022299.html,/Main/TransactionsEssentials 一、使用JOTM例子 (1) Dao及实现 GenericDao接口： ? 1 2 3 4 public interface GenericDao { public int save(String ds, String sql, Object[] obj) throws Exception; public intfindRowCount(String ds, String sql); } GenericDaoImpl实现：? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 public class GenericDaoImpl implements GenericDao{ private JdbcTemplatejdbcTemplateA; private JdbcTemplatejdbcTemplateB; public void setJdbcTemplateA(JdbcTemplatejdbcTemplate) { this.jdbcTemplateA = jdbcTemplate; } public void setJdbcTemplateB(JdbcTemplatejdbcTemplate) { this.jdbcTemplateB = jdbcTemplate; } public int save(String ds, String sql, Object[] obj) throws Exception{ if(null == ds || "".equals(ds)) return -1; try{ if(ds.equals("A")){ return this.jdbcTemplateA.update(sql, obj); }else{ return this.jdbcTemplateB.update(sql, obj); } }catch(Exception e){ e.printStackTrace(); throw new Exception("执行" + ds + "数据库时失败！"); } } public intfindRowCount(String ds, String sql) { 开始之前 关于本教程 本教程将深入讲解Spring 简单而强大的事务管理功能，包括编程式事务和声明式事务。通过对本教程的学习，您将能够理解Spring 事务管理的本质，并灵活运用之。 先决条件 本教程假定您已经掌握了Java 基础知识，并对Spring 有一定了解。您还需要具备基本的事务管理的知识，比如：事务的定义，隔离级别的概念，等等。 本文将直接使用这些概念而不做详细解释。另外，您最好掌握数据库的基础知识，虽然这不是必须。 系统需求 要试验这份教程中的工具和示例，硬件配置需求为：至少带有512MB 内存（推荐1GB）的系统。需要安装以下软件： ?Sun JDK 或更新版本或IBM Developer Kit for the Java 5 platform 版本。?Spring framework 。本教程附带的示例代码已经在Spring 上测试过。?MySQL 或更新版本。 ? Spring 事务属性分析 事务管理对于企业应用而言至关重要。它保证了用户的每一次操作都是可靠的，即便出现了异常的访问情况，也不至于破坏后台数据的完整性。就像银行的自助取款机，通常都能正常为客户服务，但是也难免遇到操作过程中机器突然出故障的情况，此时，事务就必须确保出故障前对账户的操作不生效，就像用户刚才完全没有使用过取款机一样，以保证用户和银行的利益都不受损失。 在Spring 中，事务是通过TransactionDefinition 接口来定义的。该接口包含与事务属性有关的方法。具体如清单1所示： 清单1. TransactionDefinition 接口中定义的主要方法 public interface TransactionDefinition{ int getIsolationLevel(); int getPropagationBehavior(); int getTimeout(); boolean isReadOnly(); spring 年编著的《Expert one to one J2EE design and development Spring Logo 书中，对Java EE正统框架臃肿、低效、脱离现实的种种现状提出了质疑，并积极寻求探索革新之道。以此书为指导思想，他编写了interface21框架，这是一个力图冲破Java EE传统开发的困境，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。同年他又推出了一部堪称经典的力作《Expert one-to-one J2EE Development without EJB》，该书在Java世界掀起了轩然大波，不断改变着Java开发者程序设计和开发的思考方式。在该书中，作者根据自己多年丰富的实践经验，对EJB的各种笨重臃肿的结构进行了逐一的分析和否定，并分别以简洁实用的方式替换之。至此一战功成，Rod Johnson成为一个改变Java世界的大师级人物。 传统J2EE应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件，独立于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事务等。 Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而是与它们无缝地整合。 编辑本段简介 Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 ◆目的：解决企业应用开发的复杂性 ◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 ◆范围：任何Java应用 简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 ◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB 多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。 ◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC 与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 ◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。 ◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。 spring事务传播机制实例讲解 Java代码1、 [DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [https://www.doczj.com/doc/3310022299.html,erService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT 2、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')] 3、 [DEBUG,DataSourceTransactionManager,main] Suspending current transaction, creating new transaction with name [com.zx.spring.BookService.addBook] 4、 [DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')] 5、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit 6、 [DEBUG,DataSourceTransactionManager,main] Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1b7ae22] 7、[DEBUG,DataSourceTransactionManager,main] Resuming suspended transaction after completion of inner transaction 8、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit 9、 spring的@Transactional注解详细用法 各位读友大家好！你有你的木棉，我有我的文章，为了你的木棉，应读我的文章！若为比翼双飞鸟，定是人间有情人！若读此篇优秀文，必成天上比翼鸟！ spring的@Transactional注解详细用法Spring Framework对事务管理提供了一致的抽象，其特点如下：为不同的事务API 提供一致的编程模型，比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成事务管理方式spring支持编程式事务管理和声明式事务管理两种方式。编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。显然声明式事务管理要优于编程式事务管理，这正是spring 1. (单选题)下列关于Spring配置文件的说法不正确的是 o A. Spring默认是读取/WEB-INF/配置文件 o B. Spring的配置文件可以配置在类路径下，并可以重命名，但是需要在文件中指定 o C. 把文件放到src目录下，Spring也可以读到 o D. 可以通过在中的 正确答案：A IOC是来完成相互依赖的对象的创建、协调工作。 3. (单选题)下列关于Spring的装配模式（default-autowire）描述不正确的是 o A. Spring中，至少有两种装配模式，按“类型”和“名字” o B. Spring中默认是按名字进行装配的 o C. 可以用default-autowire=”byType”配置按类型装配 o D. 一旦在一个Spring配置文件中配置了default-autowire=”byType”，其它的配置文件也是按此种装配方式进行装配 正确答案：D 在 Spring事务原理 统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatus spring提供了几个关于事务处理的类： TransactionDefinition //事务属性定义 TranscationStatus //代表了当前的事务，可以提交，回滚。 PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 一般事务定义步骤： TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth https://www.doczj.com/doc/3310022299.html,mit(ts); } catch(Exception e){transactionManager.rollback(ts);} spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。 编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象. void add() { transactionTemplate.execute( new TransactionCallback(){ pulic Object doInTransaction(TransactionStatus ts) { //do sth} } } 声明式： 使用TransactionProxyFactoryBean: 浅析Spring提供的事务管理方法 Spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；而声明式的比编程式的更灵活方便。本文将讨论这两种事务管理的区别。 传统的JDBC事务管理 以往使用JDBC进行数据操作时，一般采用DataSource,从数据源中得到Connection,我们知道数据源是线程安全的，而连接不是线程安全的，所以对每个请求都是从数据源中重新取出一个连接。一般的数据源由容器进行管理，包括连接池。例如TOMCAT，WEBSPHERE，WEBLOGIC等这些J2EE商业容器都提供了这个功能。 以往的我们使用JDBC在写代码时，事务管理可能会是这样： Connection conn = null; try { conn = DBConnectionFactory.getConnection; conn.setAutoCommit(false); //do something https://www.doczj.com/doc/3310022299.html,mit(); //commit transcation } catch(Exception e) { conn.rollback(); //do sth } finally { try { conn.close(); catch(SQLException se){ //do sth.} //close ResultSet,PreparedStatement,Connection //notice:Maybe ocurr Exception when u close rs,pstmt,conn } 按照以往的思路来写代码，代码量比较长，而且容易疏忽，忘掉一些try/catch，引发一些异常无法catch，虽然有时候我们会写DBTool类，来关闭这些资源，并且保证在关闭这些资源时，不向外抛异常。 Spring提供的编程式的事务处理 Spring提供了几个关于事务处理的类： ?TransactionDefinition //事务属性定义 ?TranscationStatus //代表了当前的事务，可以提交，回滚。 ?PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 我们使用编程式的事务管理流程可能如下： 1 声明数据源 2 声明一个事务管理类，例如DataSourceTransactionManager,HibernateTransactionManger,JTATransactionManager等 3 在我们的代码中加入事务处理代码： TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth https://www.doczj.com/doc/3310022299.html,mit(ts); } catch(Exception e){transactionManager.rollback(ts);} 使用spring提供的事务模板TransactionTemplate void add() 简介 框架由开发，2004年发布了框架的第一版。是一个从实际开发中抽取出来的框架，因此它完成了大量开发中的通用步骤，留给开发者的仅仅是与特定应用相关的部分，从而大大提高了企业应用的开发效率。 总结起来优点如下： ?低侵入式设计，代码的污染极低。 ?独立于各种应用服务器，基于框架的应用，可以真正实现，的承诺。 ?的容器降低了业务对象替换的复杂性，提高了组件之间的解耦。 ?的支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用。 ?的和提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。 ?的高度开放性，并不强制应用完全依赖于，开发者可自由选用框架的部分或全部。 框架的组成结构图如下所示： 的核心机制 管理 程序主要是通过容器来访问容器中的，是容器最常用的接口，该接口有如下两个实现类：?: 从类加载路径下搜索配置文件，并根据配置文件来创建容器。 ?: 从文件系统的相对路径或绝对路径下去搜索配置文件，并根据配置文件来创建容器。 使用 在等工具中，用户可以自建，然后把的包都放入其中，当然也可以将包直接放在项目的目录下，但是如果使用，在项目发布时，需要将用户库所引用的文件随应用一起发布，就是将所使用的复制到目录下，这是因为对于一个应用，部署应用时不会将用户库的文件复制到下，需要手动复制。 依赖注入 框架的核心功能有两个： ?容器作为超级大工厂，负责创建、管理所有的对象，这些对象被称为。 ?容器管理容器中之间的依赖关系，使用一种被称为"依赖注入"的方式来管理之间的依赖关系。 使用依赖注入，不仅可以为注入普通的属性值，还可以注入其他的引用。依赖注入是一种 优秀的解耦方式，其可以让以配置文件组织在一起，而不是以硬编码的方式耦合在一起。理解依赖注入 是第一个高度重视以配置文件来管理实例的协作关系的人，他给这种方式起了一个名字：控制反转（，）。后来为这种方式起了另一个名称：依赖注入（），因此不管是依赖注入，还是控制反转，其含义完全相同。当某个对象（调用者）需要调用另一个对象（被依赖对象）的方法时，在传统模式下通常有两种做法： 1.原始做法: 调用者主动创建被依赖对象，然后再调用被依赖对象的方法。 2.简单工厂模式: 调用者先找到被依赖对象的工厂，然后主动通过工厂去获取被依赖对象，最后再调 用被依赖对象的方法。 在spring中如何配代码的事务管理 在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：org.springframework.web.context.ContextLoaderListener ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring 配置文件的位置。示例 使用”org.springframework.jdbc.datasource.DriverManagerDataSou rce”数据源来配置数据库驱动。示例如下：org.hsqldb.jdbcDriver jdbc:hsqldb:db/appfuse sa spring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransac 在context中定义DataSource，创建SessionFactoy，设置参 数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter 或OpenSessionInViewIntercepto 一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C 的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC 的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的 Spring基础知识汇总简介年发布了框架的第一版。是一个从实际开发中抽取出来的框架，因此开发，2004框架由 它完成了大量开发中的通用步骤，留给开发者的仅仅是与特定应用相关的部分，从而大大提高了企业应用的开发效率。总结起来优点如下：?低侵入式设计，代码的污染极低。?的承诺。，独立于各种应用服务器，基于框架的应用，可以真正实现 ?的容器降低了业务对象替换的复杂性，提高了组件之间的解耦。?的支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用。?的和提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。?的高度开放性，并不强制应用完全依赖于，开发者可自由选用框架的部分或全部。框架的组成结构图如下所示： 的核心机制 1 / 10 Spring基础知识汇总管理程序主要是通过容器来访问容器中的，是容器最常用的接口，该接口有如下两个实现类：? : 从类加载路径下搜索配置文件，并根据配置文件来创建容器。? : 从文件系统的相对路径或绝对路径下去搜索配置文件，并根据配置文件来创建容器。 使用，然后把的包都放入其中，当然也可以将包直接放在项目的在等工具中，用户可以 自建，在项目发布时，需要将用户库所引用的文件随应用一起发布，目录下，但是如果使用所使用的复制到目录下，这是因为对于一个应用，部署应用时不会将用户库的文件就是将复制到 下，需要手动复制。依赖注入框架的核心功能有两个：?容器作为超级大工厂，负责创建、管理所有的对象，这些对象被称为。?的方式来管理之间的依赖关系。依赖注入容器管理容器中之间的依赖关系，使 用一种被称为使用依赖注入，不仅可以为注入普通的属性值，还可以注入其他的引用。依赖注入是一种优秀的解耦方式，其可以让以配置文件组织在一起，而不是以硬编码的方式耦合在一起。理解依赖注入是第一个高度重视以配置文件来管理实例的协作关系的人，他给这种方式起了一个名字：），因此不管是依赖注为这种方式起了另一个名称：依赖注入（，）。后来控制反转（入，还是控制反转，其含义完全相同。当某个对象（调用者）需要调用另一个对象（被依赖对象）的方法时，在传统模式下通常有两种做法：主动创建被依赖对象，然后再调用被依赖对象的方法。原始做法1. : 调用者通过工厂去获取被依赖对象，最后再调主动调用者先找到被依赖对象的工厂，然后简单工厂模式2. : 用被依赖对象的方法。2 / 10 基础知识汇总Spring二字，这必然会导致调用者与被依赖对象实现类的硬编码耦合，非常不利主动注意上面的接被动于项目升级的维护。使用框架之后，调用者无需主动获取被依赖对象，调用者只要受容器为调用者的成员变量赋值即可，由此可见，使用后，调用者获取被依赖对象的方式称之为控制反转。由原来的主动获取，变成了被动接受——所以 相当于为调另外从容器的角度来看，容器负责将被依赖对象赋值给调用者的成员变量——用者注入它依赖的实例，因此称之为依赖注入。 设值注入设值注入是指容器通过成员变量的方法来注入被依赖对象。这种注入方式简单、直观，因而在的依赖注入里大量使用。构造注入利用构造器来设置依赖关系的方式，被称为构造注入。通俗来说，就是驱动在底层以反射方式执行带指定参数的构造器，当执行带参数的构造器时，就可利用构造器参数对成员变这就是构造注入的本质。量执行初始化——两种注入方式的对比设值注入有如下优点：?与传统的的写法更相似，程序开发人员更容易理解、接受。通过方法设定依赖关系显得更加直观、自然。?对于复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，难以阅读。在创建实例时，需要同时实例化其依赖的全部实例，因而导致性能下降。而使用设值注入，则能避免这些问题。?尤其在某些成员变量可选 的情况下，多参数的构造器更加笨重。构造注入优势如下：?构造注入可以在构造器中决定依赖关系的注入顺序，优先依赖的优先注入。?对于依赖关系无需变化的，构造注入更有用处。因为没有方法，所有的依赖关系全部在构造器内设定，无须担心后续的代码对依赖关系产生破坏。?依赖关系只能在构造器中设定，则只有组件的创建者才能 改变组件的依赖关系，对组件的调用者而言，组件内部的依赖关系完全透明，更符合高内聚的原则。注意： 建议采用设值注入为主，构造注入为辅的注入策略。对于依赖关系无须变化的注入，尽量采用构造注入；而其他依赖关系的注入，则考虑采用设值注入。3 / 10 Spring基础知识汇总容器中的对于开发者来说，开发者使用框架主要是做两件事：①开发；②配置。对于框架来说，它这就是所谓依赖注入——要做的就是根据配置文件来创建实例，并调用实例的方法完成的本质。容器中的作用域当通过容器创建一个实例时，不仅可以完成实例的实例化，还可以为指定特定的作用域。支持如下五种作用域：容器中，作用域的将只生成一个实例。1. : 单例模式，在整个方法获取作用域的时，都将产生一个新的实例。2.: 每次通过容器的()对于一次请求，作用域的将只生成一个实例，这意味着，在同一次请求内，程序每次请求该，得: 3. 到的总是同一个实例。只有在应用中使用时，该作用域才真正有效。对于一次会话，作用域的将只生成一个实例，这 意味着，在同一次会话内，程序每次请求该，得4. 到的总是同一个实例。只有在应用中使用时，该作用域才真正有效。 的时候有效，同样只在应用中有效。对应一个实例。在典型的情况下，仅在使用5. : 每个全局的 如果不指定的作用域，默认使用作用域。作用域的的创建、销毁代价比较大。而作用域的实例 spring,mybatis事务管理配置与@Transactional注解使用 [转] spring,mybatis事务管理配置与@Transactional注解使用 概述 事务管理对于企业应用来说是至关重要的，即使出现异常情况，它也可以保证数据的一致性。 Spring Framework对事务管理提供了一致的抽象，其特点如下： 为不同的事务API提供一致的编程模型，比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成 事务管理方式 spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。 声明式事务管理建立在AOP之上的。其本质是对方法前后 进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于 @Transactional注解的方式)，便可以将事务规则应用到业 务逻辑中。 显然声明式事务管理要优于编程式事务管理，这正是spring 倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。 声明式事务管理也有两种常用的方式，一种是基于tx和aop 名字空间的xml配置文件，另一种就是基于@Transactional 注解。显然基于注解的方式更简单易用，更清爽。 自动提交(AutoCommit)与连接关闭时的是否自动提交 自动提交 默认情况下，数据库处于自动提交模式。每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则spring配置文件各个属性详解
SpringMVC配置的基本步骤
S详细讲解SH中Spring事务流程
Spring分布式事务实现
全面分析 Spring 的编程式事务管理及声明式事务管理
Spring简介
spring事务传播机制实例讲解
spring的@Transactional注解详细用法
Spring考试
Spring事务配置的五种方式
计算机软件,spring中事务管理器的配置
浅析Spring提供的事务管理方法
Spring基础知识汇总
在spring中如何配代码的事务管理
Spring基础知识汇总
spring,mybatis事务管理配置与@Transactional注解使用[转]
相关主题
文本预览