spring事务配置详解

合集下载

spring MVC原理及配置

spring MVC原理及配置springmvc原理及配置springmvc原理及配置1.springmvc详述：springmvc就是spring提供更多的一个强悍而有效率的web框架。

借助注释，springmvc提供更多了几乎就是pojo的研发模式，使控制器的研发和测试更加直观。

这些控制器通常不轻易处置命令，而是将其委托给spring上下文中的其他bean，通过spring的倚赖转化成功能，这些bean被转化成至控制器中。

springmvc主要由dispatcherservlet、处理器映射、处理器(控制器)、视图解析器、视图组成。

他的两个核心是两个核心：处理器映射：选择使用哪个控制器来处理请求视图解析器：选择结果应该如何渲染通过以上两点，springmvc确保了如何挑选掌控处置命令和如何挑选视图展现出输入之间的松耦合。

2.springmvc运行原理这里写图片描述(2)找寻处理器：由dispatcherservlet控制器查阅一个或多个handlermapping，找出处置命令的controller。

(3)调用处理器：dispatcherservlet将请求提交到controller。

(4)(5)调用业务处置和回到结果：controller调用业务逻辑处置后，回到modelandview。

3.springmvc接口解释（1）dispatcherservlet接口：spring提供的前端控制器，所有的请求都有经过它来统一分发。

在dispatcherservlet将请求分发给springcontroller 之前，需要借助于spring提供的handlermapping定位到具体的controller。

（2）handlermappingUSB：能够完成客户请求到controller映射。

（3）controller接口：须要为mammalian用户处置上述命令，因此同时实现controllerUSB时，必须确保线程安全并且可以器重。

Spring+Hibernate+Atomikos配置JTA事务

Spring+Hibernate+Atomikos配置JTA事务例子1.依赖jar包2.配置文件(1)数据源、JTA事务配置文件src/applicationContext-common.xml<?xml version="1.0" encoding="GBK"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/tx/schema/tx/spring-tx-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="oracleDataSource"class="com.atomikos.jdbc.AtomikosDataSourceBean"><property name="uniqueResourceName"><value>chh</value></property><propertyname="xaDataSourceClassName"><value>oracle.jdbc.xa.client.OracleXADat aSource</value></property><property name="xaProperties"><props><prop key="user">chh</prop><prop key="password">chh</prop><prop key="URL">jdbc:oracle:thin:@127.0.0.1:1521:chh</prop></props></property><property name="poolSize"><value>1</value></property><property name="borrowConnectionTimeout"><value>60</value></property> </bean><bean id="oracleDataSource1"class="com.atomikos.jdbc.AtomikosDataSourceBean"><property name="uniqueResourceName"><value>chh1</value></property><propertyname="xaDataSourceClassName"><value>oracle.jdbc.xa.client.OracleXADat aSource</value></property><property name="xaProperties"><props><prop key="user">chh1</prop><prop key="password">chh1</prop><prop key="URL">jdbc:oracle:thin:@127.0.0.1:1521:chh</prop></props></property><property name="poolSize"><value>1</value></property><property name="borrowConnectionTimeout"><value>60</value></property> </bean><bean id="chhSessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="configLocation"value="classpath:hibernate-jtatest1.cfg.xml" /><property name="dataSource" ref="oracleDataSource"></property></bean><bean id="chh1SessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"value="classpath:hibernate-jtatest2.cfg.xml" /><property name="dataSource" ref="oracleDataSource1"></property></bean><bean id="atomikosTransactionManager"class="erTransactionManager"init-method="init" destroy-method="close"><property name="forceShutdown"><value>true</value></property></bean><bean id="atomikosUserTransaction"class="erTransactionImp"><property name="transactionTimeout"><value>300</value></property> </bean><bean id="springTransactionManager"class="org.springframework.transaction.jta.JtaTransactionManager"><property name="transactionManager"><refbean="atomikosTransactionManager" /></property><property name="userTransaction"><ref bean="atomikosUserTransaction" /></property><property name="allowCustomIsolationLevels" value="true"/></bean><tx:advice id="txAdvice"transaction-manager="springTransactionManager"><tx:attributes><tx:method name="delete*" rollback-for="Exception"/><tx:method name="save*" rollback-for="Exception"/><tx:method name="update*" rollback-for="Exception"/><tx:method name="*" read-only="true" rollback-for="Exception"/></tx:attributes></tx:advice><aop:config><aop:pointcut id="point"expression=" execution(* com.zte.jta.serviceImp.*.*(..))" /><aop:advisor advice-ref="txAdvice" pointcut-ref="point" /></aop:config></beans>(2) 业务配置文件src/applicationContext-service.xml<?xml version="1.0" encoding="GBK"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/tx/schema/tx/spring-tx-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="biz" class="impl"><property name="productDao" ref="productDao" /><property name="userDao" ref="userDao" /></bean><bean id="userDao" class="erDaoimpl"><property name="sessionFactory" ref="chhSessionFactory" /></bean><bean id="productDao" class="com.zte.jta.daoImp.ProductDaoimpl"><property name="sessionFactory" ref="chh1SessionFactory" /></bean></beans>(3)数据源1 hibernate 配置文件src/hibernate-jtatest1.cfg.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><propertyname="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop erty><property name="show_sql">true</property><mapping resource="com/zte/jta/test/Users.hbm.xml" /></session-factory></hibernate-configuration>(3) 数据源2 hibernate 配置文件src/hibernate-jtatest2.cfg.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><propertyname="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop erty><property name="show_sql">true</property><mapping resource="com/zte/jta/test/Product.hbm.xml" /></session-factory></hibernate-configuration>(4)对象映射关系数据配置文件src/com/zte/jta/test/Product.hbm.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="com.zte.jta.test.Product" table="product" ><id name="id" type="ng.Integer"><column name="id" /><generator class="sequence" ><param name="sequence">SEQ_product</param></generator></id><property name="price" type="ng.Float"><column name="price" precision="53" scale="0" not-null="true" /></property></class></hibernate-mapping>(5)对象映射关系数据配置文件src/com/zte/jta/testUsers.hbm.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="ers" table="tusers" ><id name="id" type="ng.Integer"><column name="id" /><generator class="sequence" ><param name="sequence">SEQ_tusers</param></generator></id><property name="name" type="ng.String"><column name="name" length="100" not-null="true" /> </property></class></hibernate-mapping>3.Java代码(1)src/com/zte/jta/dao/ProductDao.javapackage com.zte.jta.dao;import com.zte.jta.test.Product;public interface ProductDao {public abstract void save(Product p);}(2)src/com/zte/jta/dao/UserDao.javapackage com.zte.jta.dao;import ers;public interface UserDao {public abstract void save(Users u);}(3)src/com/zte/jta/daoImp/ProductDaoimpl.javapackage com.zte.jta.daoImp;importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;import com.zte.jta.dao.ProductDao;import com.zte.jta.test.Product;public class ProductDaoimpl extends HibernateDaoSupport implements ProductDao {public void save(Product p){this.getHibernateTemplate().save(p);}}(4)src/com/zte/jta/daoImp/UserDaoimpl.javapackage com.zte.jta.daoImp;importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;import erDao;import ers;public class UserDaoimpl extends HibernateDaoSupport implements UserDao {public void save(Users u){this.getHibernateTemplate().save(u);}}(5)src/com/zte/jta/service/Biz.javapackage com.zte.jta.service;import com.zte.jta.test.Product;import ers;public interface Biz {public void save(Product p, Users u);}(6)src/com/zte/jta/serviceImp/Bizimpl.javapackage com.zte.jta.serviceImp;import com.zte.jta.dao.ProductDao;import erDao;import ;import com.zte.jta.test.Product;import ers;public class Bizimpl implements Biz {private ProductDao productDao = null;private UserDao userDao = null;public void save(Product p, Users u) {productDao.save(p);userDao.save(u);}public void setProductDao(ProductDao productDao) {this.productDao = productDao;}public void setUserDao(UserDao userDao) {erDao = userDao;}}4.数据库建对象create user chh identified by chh;create user chh identified by chh1;grant dba,resource,connect to chh;grant dba,resource,connect to chh1;grant select on sys.dba_pending_transactions to chh;grant select on sys.pending_trans$to chh;grant select on sys.dba_2pc_pending to chh;grant execute on sys.dbms_system to chh;grant select on sys.dba_pending_transactions to chh1; grant select on sys.pending_trans$to chh1;grant select on sys.dba_2pc_pending to chh1;grant execute on sys.dbms_system to chh1;create sequence chh.SEQ_tusersminvalue 1maxvalue 10000000000000000start with 1increment by 1cache 20order;create sequence chh1.SEQ_productminvalue 1maxvalue 10000000000000000start with 1increment by 1cache 20order;create table chh.TUSERS(ID INTEGER not null,NAME VARCHAR2(50)not null)tablespace MAPpctfree 10initrans 1maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);alter table TUSERSadd primary key(ID)using indextablespace MAPpctfree 10initrans 2maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);create table CHH1.PRODUCT (ID INTEGER not null, PRICE NUMBER not null)tablespace MAPpctfree 10initrans 1maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);alter table CHH1.PRODUCT add primary key(ID) using indextablespace MAPpctfree 10initrans 2maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);5.测试方法public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext-common.xml","applicationContext-service.xml"});BeanFactory bf = context;Biz biz = (Biz) bf.getBean("biz");Product p = new Product();p.setPrice(10f);Users u = new Users();u.setName(null); //非空字段插入一个空试试，再给个值试试 "aaa"biz.save(p, u);}。

Spring事务配置的五种方式

Spring事务原理统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatusspring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。

PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤：TransactionDefinition td = new TransactionDefinition();TransactionStatus ts = transactionManager.getTransaction(td);try{ //do sthmit(ts);}catch(Exception e){transactionManager.rollback(ts);}spring提供的事务管理可以分为两类：编程式的和声明式的。

编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。

省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.void add(){transactionTemplate.execute( new TransactionCallback(){pulic Object doInTransaction(TransactionStatus ts){ //do sth}}}声明式：使用TransactionProxyFactoryBean:<bean id="userManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><property name="transactionManager"><ref bean="transactionManager"/></property><property name="target"><ref local="userManagerTarget"/></property><property name="transactionAttributes"><props><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="*">PROPAGATION_REQUIRED,readOnly</prop></props></property></bean>围绕Poxy的动态代理能够自动的提交和回滚事务org.springframework.transaction.interceptor.TransactionProxyFactoryBeanPROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。

【SpringFramework】Spring入门教程（三）使用注解配置

【SpringFramework】Spring⼊门教程（三）使⽤注解配置本⽂主要介绍四个⽅⾯：(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置，⼤家脑海⾥⾸先得有⼀个认知，即注解配置和xml配置要实现的功能都是⼀样的，都是要降低模块间的耦合度。

仅仅只是配置的形式不⼀样。

关于实际的开发中到底使⽤xml还是注解，每家公司有着不同的使⽤习惯。

所以这两种配置⽅式我们都需要掌握。

基于注解配置的⽅式也已经逐渐代替xml配置。

所以我们必须要掌握使⽤注解的⽅式配置Spring。

配置步骤注意：如果使⽤Eclipse需要先安装了STS插件，或者使⽤STS开发⼯具创建项⽬。

本⽂使⽤IDEA进⾏演⽰。

1.2.1. 第⼀步：拷贝必备jar包到⼯程的lib⽬录。

注意：在基于注解的配置中，我们还要多拷贝⼀个aop的jar包。

如下图：1.2.2. 第⼆步：在类的根路径下创建⼀个任意名称的xml⽂件（不能是中⽂）注意：基于注解整合时，Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步：创建⼀个服务类创建⼀个测试的服务类，并且加⼊使⽤@Component注解，声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时，需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步：测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果，如果可以调⽤服务⽅法，测试成功。

详解SpringBoot中JdbcTemplate的事务控制

详解SpringBoot中JdbcTemplate的事务控制⽬录前⾔原⽣Jdbc的事务控制Spring的声明式事务控制尝试JdbcTemplate的事务控制TransactionTemplate的编程式事务控制前⾔JdbcTemplate是spring-jdbc提供的数据库核⼼操作类，那对JdbcTemplate进⾏事务控制呢？我的环境：spring-boot-2.1.3，druid-1.1.3。

原⽣Jdbc的事务控制即，批处理+⾃动提交的控制⽅式，public static void demo(String[] args) throws SQLException, ClassNotFoundException {String url = "jdbc:mysql://10.1.4.16:3306/szhtest";String username = "ababab";String password = "123456";String sql1 = "insert xx";String sql2 = "insert xx";Class.forName("com.mysql.jdbc.Driver");Connection conn = DriverManager.getConnection(url, username, password);Statement statement = conn.createStatement();// 获取到原本的⾃动提交状态boolean ac = conn.getAutoCommit();// 批处理多条sql操作statement.addBatch(sql1);statement.addBatch(sql2);// 关闭⾃动提交conn.setAutoCommit(false);try {// 提交批处理statement.executeBatch();// 若批处理⽆异常，则准备⼿动commitmit();} catch (Exception e) {e.printStackTrace();// 批处理抛异常，则rollbacktry {conn.rollback();} catch (SQLException ex) {ex.printStackTrace();}} finally {// 恢复到原本的⾃动提交状态conn.setAutoCommit(ac);if (statement != null) {try {statement.close();} catch (SQLException e) {e.printStackTrace();}}if (conn != null) {try {conn.close();} catch (SQLException e) {e.printStackTrace();}}}}Spring的声明式事务控制Bean的类或⽅法上加@Transactional，事务控制粒度较⼤，只能控制在⽅法级别，不能控制到代码粒度级别。

SpringBoot事务注解详解

SpringBoot事务注解详解SpringBoot事务注解详解@Transactionalspring 事务注解1.简单开启事务管理@EnableTransactionManagement // 启注解事务管理，等同于xml配置⽅式的 <tx:annotation-driven />2.事务注解详解默认遇到throw new RuntimeException(“…”);会回滚需要捕获的throw new Exception(“…”);不会回滚指定回滚@Transactional(rollbackFor=Exception.class)public void methodName() {// 不会回滚throw new Exception("...");}指定不回滚@Transactional(noRollbackFor=Exception.class)public ItimDaoImpl getItemDaoImpl() {// 会回滚throw new RuntimeException("注释");}如果有事务,那么加⼊事务,没有的话新建⼀个(不写的情况下)@Transactional(propagation=Propagation.REQUIRED)容器不为这个⽅法开启事务@Transactional(propagation=Propagation.NOT_SUPPORTED)readOnly=true只读,不能更新,删除@Transactional (propagation = Propagation.REQUIRED,readOnly=true)设置超时时间@Transactional (propagation = Propagation.REQUIRED,timeout=30)设置数据库隔离级别@Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)3.指定事务管理器spring Boot 使⽤事务⾮常简单，⾸先使⽤注解 @EnableTransactionManagement 开启事务⽀持后，然后在访问数据库的Service⽅法上添加注解 @Transactional 便可。

Spring声明式事务注解之@EnableTransactionManagement解析

Spring声明式事务注解之@EnableTransactionManagement解析Spring声明式事务注解之@EnableTransactionManagement1. 说明@EnableTransactionManagement声明在主配置类上，表⽰开启声明式事务，其原理是通过@Import导⼊TransactionManagementConfigurationSelector组件，然后⼜通过TransactionManagementConfigurationSelector导⼊组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration；2. 原理分析@EnableTransactionManagement代码实现如下：@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented// 通过@Import导⼊TransactionManagementConfigurationSelector组件@Import(TransactionManagementConfigurationSelector.class)public @interface EnableTransactionManagement {boolean proxyTargetClass() default false;AdviceMode mode() default AdviceMode.PROXY;int order() default Ordered.LOWEST_PRECEDENCE;}@EnableTransactionManagement通过@Import导⼊TransactionManagementConfigurationSelector；TransactionManagementConfigurationSelector的实现如下：public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {/*** {@inheritDoc}* @return {@link ProxyTransactionManagementConfiguration} or* {@code AspectJTransactionManagementConfiguration} for {@code PROXY} and* {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()}, respectively*/@Overrideprotected String[] selectImports(AdviceMode adviceMode) {switch (adviceMode) {case PROXY:// 根据@EnableTransactionManagement的固定值PROXY，这⾥会导⼊AutoProxyRegistrar组件和ProxyTransactionManagementConfiguration组件 return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};case ASPECTJ:return new String[] {TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};default:return null;}}}所以TransactionManagementConfigurationSelector⼜导⼊了组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration；3. AutoProxyRegistrar分析3.1 AutoProxyRegistrar继承关系InfrastructureAdvisorAutoProxyCreator--AbstractAdvisorAutoProxyCreator--AbstractAdvisorAutoProxyCreator--ProxyProcessorSupport--SmartInstantiationAwareBeanPostProcessor // 跟AOP是原理是⼀样的--InstantiationAwareBeanPostProcessor--BeanPostProcessor--BeanFactoryAware3.2 AutoProxyRegistrar的所⽤AutoProxyRegistrar的作⽤跟AOP中的AnnotationAwareAspectJAutoProxyCreator是⼀样的，利⽤后置处理器机制在对象创建以后，包装对象，返回⼀个代理对象（增强器），代理对象执⾏⽅法利⽤拦截器链进⾏调⽤；InfrastructureAdvisorAutoProxyCreator继承SmartInstantiationAwareBeanPostProcessor，跟AOP的原理是⼀样的，也是通过@Transactional作为⽅法拦截的标记，把有事务管理的类作为⽬标类，⽣成代理对象，然后增强@Transactional标记的⽅法，在使⽤⽬标⽅法的时候，从IOC容器中获取的其实是被增强的代理类，且事务⽅法会被代理，跟AOP原理⼀样的；4. ProxyTransactionManagementConfiguration分析ProxyTransactionManagementConfiguration是⼀个配置类，想IOC容器中导⼊事务增强器(BeanFactoryTransactionAttributeSourceAdvisor)，事务注解@Transactional的解析器(AnnotationTransactionAttributeSource)和事务⽅法拦截器(TransactionInterceptor)；package org.springframework.transaction.annotation;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Role;import org.springframework.transaction.config.TransactionManagementConfigUtils;import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;import org.springframework.transaction.interceptor.TransactionAttributeSource;import org.springframework.transaction.interceptor.TransactionInterceptor;@Configurationpublic class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {/**事务增强器(Advisor)，在事务类创建的时候，被AutoProxyRegistrar导⼊的组件InfrastructureAdvisorAutoProxyCreator拦截，InfrastructureAdvisorAutoProxyCreator拦截的逻就是增强事务类的事务⽅法，⽽BeanFactoryTransactionAttributeSourceAdvisor作为增强器，与需要增强的⽅法(这⾥是指被@Transactional标记的⽅法)进⾏匹配，匹配成功的增强器，最后转成拦截器(MethodInterceptor,就是下⾯的TransactionInterceptor)，然后与⽬标⽅法⼀起在拦截器链中被执⾏，达到⽅法增强的效果；BeanFactoryTransactionAttributeSourceAdvisor的继承关系如下：BeanFactoryTransactionAttributeSourceAdvisor--AbstractBeanFactoryPointcutAdvisor--AbstractPointcutAdvisor--PointcutAdvisor--AdvisorAOP中AspectJPointcutAdvisor的继承关系如下，与AbstractPointcutAdvisor⼀样，都实现PointcutAdvisor--AspectJPointcutAdvisor--PointcutAdvisor--Advisor*/@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();advisor.setTransactionAttributeSource(transactionAttributeSource());advisor.setAdvice(transactionInterceptor());advisor.setOrder(this.enableTx.<Integer>getNumber("order"));return advisor;}/**@Transactional注解的解析类；负责解析事务⽅法上@Transactional中的各个参数配置，解析的时机是在创建事务类之后被增强的时候，匹配事务⽅法的时候⼀起被解析了AnnotationTransactionAttributeSource的继承关系如下：AnnotationTransactionAttributeSource--AbstractFallbackTransactionAttributeSource--TransactionAttributeSource通过⽅法org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource.getTransactionAttribute(Method, Class<?>)解析出事务信息TransactionAttribute；AnnotationTransactionAttributeSource在⽅法findTransactionAttribute(Class<?>)中依赖于SpringTransactionAnnotationParser在解析事务类时，绑定事务⽅法与增强器的时候进⾏@Transactional注解解析；*/@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionAttributeSource transactionAttributeSource() {return new AnnotationTransactionAttributeSource();}/**被@Transactional标记的事务⽅法的拦截器，实际是⼀个MethodInterceptor保存了事务属性信息，事务管理器；在⽬标⽅法执⾏的时候；执⾏拦截器链；*/@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionInterceptor transactionInterceptor() {TransactionInterceptor interceptor = new TransactionInterceptor();interceptor.setTransactionAttributeSource(transactionAttributeSource());if (this.txManager != null) {interceptor.setTransactionManager(this.txManager);}return interceptor;}}在SpringTransactionAnnotationParser中parseTransactionAnnotation⽅法来解析@Transactional中的各个参数，其具体代码如下：protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();Propagation propagation = attributes.getEnum("propagation");rbta.setPropagationBehavior(propagation.value());Isolation isolation = attributes.getEnum("isolation");rbta.setIsolationLevel(isolation.value());rbta.setTimeout(attributes.getNumber("timeout").intValue());rbta.setReadOnly(attributes.getBoolean("readOnly"));rbta.setQualifier(attributes.getString("value"));ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<RollbackRuleAttribute>();Class<?>[] rbf = attributes.getClassArray("rollbackFor");for (Class<?> rbRule : rbf) {RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);rollBackRules.add(rule);}String[] rbfc = attributes.getStringArray("rollbackForClassName");for (String rbRule : rbfc) {RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);rollBackRules.add(rule);}Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");for (Class<?> rbRule : nrbf) {NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);rollBackRules.add(rule);}String[] nrbfc = attributes.getStringArray("noRollbackForClassName");for (String rbRule : nrbfc) {NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);rollBackRules.add(rule);}rbta.getRollbackRules().addAll(rollBackRules);return rbta;}spring 事务 @EnableTransactionManagement原理@EnableXXX原理：注解上有个XXXRegistrar，或通过XXXSelector引⼊XXXRegistrar，XXXRegistrar实现了ImportBeanDefinitionRegistrar的registerBeanDefinitions⽅法，给容器注册XXXCreator。

spring事务详解（基于注解和声明的两种实现方式）

spring事务详解（基于注解和声明的两种实现⽅式）Spring事务( Transaction )事务的概念事务是⼀些sql语句的集合，作为⼀个整体执⾏，⼀起成功或者⼀起失败。

使⽤事务的时机⼀个操作需要多天sql语句⼀起完成才能成功程序中事务在哪⾥说明加在业务类的⽅法上⾯（public⽅法上⾯），表⽰业务⽅法执⾏时，需要事务的⽀持。

不同的事务管理器不同的数据库访问技术，处理事务是不同的1. 使⽤jdbc访问数据库，事务处理public void updateAccount(){Connection con = .....;con.setAutoCommit(false);state.insert();state.update();mit();con.setAutoCommit(true);}2. MyBatis执⾏数据库，处理事务public void updateAccount(){SqlSession sqlSession = SqlSessionFactory.openSession(false);try{sqlSession.insert(...);sqlSession.update(...);mit();}catch(Exception e){sqlSession.rollback();}}spring统⼀管理事务，把不同的数据库访问技术的事务处理统⼀起来使⽤spring的事务管理器，管理不同数据库访问技术的事务处理。

开发⼈员只需要掌握spring的事务处理⼀个⽅案，就可以实现使⽤不同数据库访问技术的事务管理。

尽管事务⾯向的是spring，有spring管理事务，做事务提交和回滚。

spring事务管理器spring框架使⽤事务管理器对象，管理所有的事务。

事务管理器接⼝： PlatFormTransactionManager作⽤：定义了事务的操作，主要是commit() , rollback()事务管理器有很多的实现类：⼀种数据库访问计数有⼀个实现类。

Springboot中的数据库事务

Springboot中的数据库事务Springboot中的数据库事务对于⼀些业务⽹站⽽⾔，产品库存的扣减、交易记录以及账户都必须是要么同时成功，要么同时失败，这便是⼀种事务机制，⽽在⼀些特殊的场景下，如⼀个批处理，它将处理多个交易，但是在⼀些交易中发⽣了异常，这个时候则不能将所有的交易都回滚。

如果所有的交易都回渎，那么那些本能够正常处理的业务也⽆端地被回滚。

通过 Spring 的数据库事务传播⾏为，可以很⽅便地处理这样的场景。

⾸先配置数据库信息spring.datasource.url=jdbc:mysql://localhost:3306/demoername=rootspring.datasource.password=123456spring.datasource.driver=com.mysql.jdbc.Driverspring.datasource.tomcat.max-idle=10spring.datasource.tomcat.max-active=50spring.datasource.tomcat.max-wait=10000spring.datasource.tomcat.initial-size=5⼀、JDBC数据库事务package com.demo.servicee.impl@Servicepublic class JdbcServiceImpl implements JdbcService{@Autowiredprivate DataSource dataSource=null;@Overridepublic int insertUser(String name,String note){Connection conn=null;int result=0;try{//获取连接conn=dataSource.getConnection();//开启事务conn.setAutoCommit(false);//设置隔离级别conn.setTransactionIsolation(TransactionIsolationLevel.RRAD_COMMITED.getLevel());//执⾏SQLPreparedStatement ps=conn.prepareStatement("insert into t_user(user_name,note)values(?,?)");ps.setString(1,userName);ps,setString(2,note);result=ps.executeUpdate();//提交事务mit();}catch(Exception e){//回滚事务if（conn !=null）{try{conn.rollback();}catch(SqlException e1)e1.printStackTrace();}}e.printStackTrace();}finally{try{if(conn !=null && !conn.isClosed()){conn.close()}}catch(SQLException e){e.printStackTrace();}}return result;}}使⽤JDBC需要使⽤⼤量的try...catch...finally...语句，和关于连接的获取关闭，事务的提交和回滚。

spring配置详解

spring配置详解1.前⾔公司⽼项⽬的后台，均是基于spring框架搭建，其中还⽤到了log4j.jar等开源架包。

在新项⽬中，则是spring和hibernate框架均有使⽤，利⽤了hibernate框架，来实现持久化，简化sql操作等。

Hibernate配置⽂件可以有两种格式，⼀种是 hibernate.properties，另⼀种是hibernate.cfg.xml。

后者稍微⽅便⼀些，当增加hbm映射⽂件的时候，可以直接在 hibernate.cfg.xml ⾥⾯增加，不必像 hibernate.properties 必须在初始化代码中加⼊。

我们新项⽬中使⽤的是hibernate.cfg.xml格式。

不过在本⽂中不将细述，后续有机会再补上。

公司项⽬中，中间件主要有tomcat，webshpere，WebLogic。

以下，将对项⽬中spring基本配置，log4j的配置，还有中间件的相关参数配置做⼀个初步的介绍。

2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。

配置的实现是通过注记配置和XML配置来合作实现。

这⾥，我将按照Spring的配置流程，将其他⼏个⽅⾯的配置融合其中，来进⾏全⾯解析。

2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中，当中间件启动时，中间件会⾸先读取web.xml中的配置。

在web.xml中可以配置监听器，过滤器，servlet映射等等。

在Spring 框架中，我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。

在GISV13的web.xml中，我们定义了如下内容：InitGISConfigServlet定义了容器启动时，⾸先要运⾏这个⽅法。

然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Spring事务配置的五种方法2009-04-24 10:20总结如下：Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。

具体如下图：根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：第一种方式：每个Bean都有一个代理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDaoTarget" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDao"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <property name="transactionManager" ref="transactionManager"/><property name="target" ref="userDaoTarget"/><property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao"/><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>第二种方式：所有Bean共享一个代理基类<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="transactionBase"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true" abstract="true"><property name="transactionManager" ref="transactionManager"/><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><bean id="userDaoTarget" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDao" parent="transactionBase"><property name="target" ref="userDaoTarget"/></bean></beans>第三种方式：使用拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterceptor"> <property name="transactionManager" ref="transactionManager"/><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames"><list><value>*Dao</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><bean id="userDao" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory"/></bean></beans>第四种方式：使用tx标签配置的拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="configLocation"value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="*" propagation="REQUIRED"/></tx:attributes></tx:advice><aop:config><aop:pointcut id="interceptorPointCuts"expression="execution(* com.bluesky.spring.dao.*.*(..))"/> <aop:advisor advice-ref="txAdvice"pointcut-ref="interceptorPointCuts"/></aop:config></beans>第五种方式：全注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky"/><tx:annotation-driven transaction-manager="transactionManager"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean></beans>此时在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 ponent;import er;@Transactional@Component("userDao")public class UserDaoImpl extends HibernateDaoSupport implements UserDao {public List<User> listUsers() {return this.getSession().createQuery("from User").list();}}注意的几点:1 @Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional 也不会报错,但方法没有事务功能.2 默认情况下,一个有事务方法, 遇到RuntiomeException时会回滚 . 遇到受检查的异常是不会回滚的. 要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) .@Transactional 的所有可选属性如下:可以去看spring源码 : org.springframework.transaction.annotation.Isolation我的"隔离级别"相关文章有不明白的,可以去看看事务的传播属性,有如下可选可以去看spring源码 : org.springframework.transaction.annotation.Propagation。