Spring事务配置管理

合集下载

spring配置文件各个属性详解

spring配置文件各个属性详解分类：spring 2012-08-09 11:25 9316人阅读评论(2) 收藏举报springaophibernateattributesxhtmlwebsphere目录(?)[+]一、引用外部属性文件<bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="locations"><list><value>classpath:mail.properties</value><value>classpath:jdbc.properties</value></list></property></bean>我们定义了一个PropertyPlaceholderConfigurer类的实例，并将其位置属性设置为我们的属性文件。

该类被实现为Bean工厂的后处理器，并将使用定义在文件中的属性来代替所有的占位符（${...}value）。

注意：而在spring2.5的版本中提供了一种更简便的方式，如：1.<context:property-placeholderlocation="classpath:config/jdbc.properties"/>这样以后要使用属性文件中的资源时，可以使用${属性名}来获得。

二、常用数据源的配置第一种是：DBCP数据源，（需要加入2个jar文件，在spring中的lib下jakarta-commons/commons-dbcp.jar和commons-pools.jar）主要配置如下：<bean id="dataSource"class="mons.dbcp.BasicDataSource"><property name="driverClassName"value="com.mysql.jdbc.Driver"></property><property name="url"value="${jdbc.url}"></property><property name="username" value="${ername}"></property><property name="password" value="${jdbc.password}"></property></bean>第二种是：c3p0数据源，跟第一种一个类型，需加入c3p0.jar包。

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

datasourcetransactionmanager用法

datasourcetransactionmanager用法DataSourcetransactionmanager 是Spring 框架中用于管理数据库事务的一种重要的机制。

通过DataSourceTransactionManager，开发人员可以在Spring 应用中使用声明式事务进行数据库操作。

在本文中，我们将详细介绍DataSourceTransactionManager 的用法，并逐步回答相关问题。

第一步：导入依赖在使用DataSourceTransactionManager 之前，首先需要在项目的构建配置文件（如pom.xml）中添加相应的依赖。

在Spring 中，DataSourceTransactionManager 是由Spring JDBC 模块提供的，因此我们需要添加相应的Spring JDBC 依赖。

xml<dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.10</version></dependency>第二步：配置数据源DataSourceTransactionManager 需要一个有效的数据源来管理事务。

在Spring 应用中，数据源可以通过Spring 的配置文件（如applicationContext.xml）进行配置。

例如，我们可以使用基于连接池的数据源，如Apache Commons DBCP 或HikariCP。

xml<bean id="dataSource"class="org.apachemons.dbcp2.BasicDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver" /><property name="url"value="jdbc:mysql:localhost:3306/mydatabase" /><property name="username" value="username" /><property name="password" value="password" /></bean>第三步：配置事务管理器配置事务管理器是使用DataSourceTransactionManager 的关键步骤。

高级Java工程师面试题及答案

高级Java工程师面试题选择题各2分共44分1.下列说法正确的是A. Java语言不区分大小写B. Java程序以类为基本单位C. JVM为Java虚拟机JVM的英文缩写D. 运行Java程序需要先安装JDK答案：B,C,D2.下列说法中错误的是A. Java语言是编译执行的B. Java中使用了多进程技术C. Java的单行注视以//开头D. Java语言具有很高的安全性答案：A,B3.下面不属于Java语言特点的一项是A. 安全性B. 分布式C. 移植性D. 编译执行答案：D4.下列语句中，正确的项是A . int $ e,a,b=10;B. char c,d=’a’;C. float e=0.0d;D. double c=0.0f;答案ABD5.一个int 类型的常量和一个byte类型常量做减法，结果的类型是A. intB. byteC. charD. float答案A6.下列程序段的输出结果是public class Expressions{void printExpr(){int x=3,y=4,z=5;System.out.println(x+y+z);}}A. xyzB. x+y+zC. 12D. 9答案C7.下列关于for循环和while循环的说法中哪些是不正确的？A. for循环能实现的操作，while循环也都能实现B. for循环判断条件一般是非程序结果C. while循环判断条件一般是程序结果D. 两种循环结构中都必须有循环体，循环体不能为空答案ABC8.以下程序段执行后的K值为int x=10; y=34;k=(x<y)?y:x;A. 10B. 34C. 10D. 44答案B9.下列不属于Java语言流程控制结构是A.分支语句B.条转语句C.循环语句D.赋值语句E.答案D10.设定义语句：int a[ ]={43,44,45};则下面对此语句的叙述正确的是A.定义一个名为a的一维数组B.a数组有3个元素C.a数组的元素的下标为1~3D.数组中的每一个元素都是整型E.答案ABD11.运行以下代码public class Person{int array[]=new int[10];public static void main(String args[]){System.out.println(array [1]);}}正确的是A.编译时将产生错误B.编译时正确，运行时将产生错误C.输出零D.输出空答案A12.执行完下面语句int[ ]x = new int[20]; 后，说法正确的是A.x[19]为0B.x[19]未定义C.x[20]为0D.x[0]为空答案A13.设tmp是一个数组类成员，以下声明并初始化一个4个元素的数组选项A.int tmp[]={1,2,3,4};B.int tmp[]=new int[5];C.int tmp[]=new int(5);D.int tmp[];答案A14.设定义：String s=”cake”，下面不合法的有A.s=s. toUpperCase();B.char c=s[1];C.int len=s.length;D.s=s.trim();答案BC15.设String s1=”Hello”;String s2=”World”;以下方法用来得到字符串“Hello World”有A.s2+s1;B.s1.concat(s2);C.s1.append(s2);D.s1.concate(s2);答案B16.下面哪一个是Java最基本的元素A. 接口B. 方法C. 包D. 对象答案：D17.如果Cake.java、Ball.java这两个类总共包含有8个方法，则编译后会产生多少个字节码文件A. 12B. 10C. 2D. 1答案：C18.下面关于抽象类的理解，错误的是A. 构造方法可以声明为抽象类型B. 抽象方法必须被子类的方法覆盖C. 不允许实现抽象方法D. 方法声明中，static 和abstract不能同时存在答案：A19.编译Java程序时编译器提示找不到要编译的代码，这种错误通常可能是A. 文件名拼写错误B. 没有导入相应的包C. 文件名不是.javaD. 源文件不在Java搜索路径中答案：A,C,D20.捕获异常应该使用下列哪个子句A. throwB. catchC. finallyD. throws答案：B21.下列哪一项不属于finally语句的工作A. 关闭数据库B. 释放资源C. 关闭文件D.分配资源答案：D22.下面哪些需要异常处理机制A. 编译出错B. 方法、类中抛出的异常C. 使系统从故障中恢复D. 程序因不可避免的原因产生错误答案：B,C,D简述题每题3分共18分(1)用final声明属性、方法和类时，被声明的属性、方法和类表现出哪些特性？下面的实例正确吗？如果不正确，请说明原因？实例：final Test t = new Test();t.setName(“Jack”);答：final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

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--支持当前事务，如果当前没有事务，就新建一个事务。

MyBatis-Spring-TransactionManager事务管理

<bean class="org.apache.ibatis.transaction.managed.ManagedTransactionFactory" />
</property>
</bean>
编程式事务管理
MyBatis 的 SqlSession 提供指定的方法来处理编程式的事务。但是当使用 MyBatis-Spring 时, bean 将会使用 Spring 管理的 SqlSession 或映射器来注入。那就是说 Spring 通常是处理事务的。
一旦事务创建之后,MyBatis-Spring 将会透明的管理事务。在你的 DAO 类中就不需要额外的代码了。
标准配置
要开启 Spring 的事务处理 , 在 Spring 的 XML 配置文件中简单创建一个 DataSourceTransactionManager 对象:
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = txManager.getTransaction(def);
</bean>
指定的 DataSource 一般可以是你使用 Spring 的任意 JDBC DataSource。这包含了连接池和通过 JNDI 查找获得的 DataSource。
要注意, 为事务管理器指定的 DataSource 必须和用来创建 SqlSessionFactoryBean 的是同一个数据源,否则事务管理器就无法工作了。

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。

transactional的rollbackfor参数 -回复

transactional的rollbackfor参数-回复什么是transactional的rollbackFor参数？为什么要使用它？如何正确地配置它？在实际开发中如何应用它？这些都是开发中常见的问题。

在本文中，我们将一步一步回答这些问题，以帮助读者更好地理解和应用transactional的rollbackFor参数。

当我们使用Spring Framework进行开发时，经常会涉及到数据库事务的处理。

数据库事务是一组数据库操作的有序执行，要么全部执行成功，要么全部回滚到事务开始的状态。

Spring的transactional注解就是用于管理数据库事务的关键之一。

在Spring的transactional注解中，rollbackFor参数是一个非常重要的配置项。

它用来指定在哪些异常发生时，事务应该进行回滚。

默认情况下，Spring只会对RuntimeException进行回滚，但是对于受检查异常（Checked Exceptions）默认不会回滚。

这时就需要使用rollbackFor 参数来指定我们想要回滚的异常类型。

首先，让我们来看看为什么我们需要使用rollbackFor参数。

在实际开发中，通常会遇到数据库操作异常或业务逻辑异常。

例如，当插入数据库时，由于某些原因，数据库连接断开，此时插入会抛出SQLException。

如果我们不配置rollbackFor参数，Spring默认不会回滚事务，导致插入的数据无效。

为了解决这个问题，我们可以在transactional注解中使用rollbackFor参数来指定回滚的异常类型。

通过配置该参数，当指定的异常发生时，Spring会自动回滚事务，防止数据失效。

在上述例子中，我们可以使用rollbackFor = SQLException.class来配置rollbackFor参数。

接下来，让我们来看看如何正确地配置rollbackFor参数。

正常情况下，我们只需要在transactional注解中指定rollbackFor参数的值即可。

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()事务管理器有很多的实现类：⼀种数据库访问计数有⼀个实现类。

enabletransactionmanagement原理

enabletransactionmanagement原理什么是enabletransactionmanagement •enabletransactionmanagement是一个用于开启事务管理功能的选项。

•在软件开发过程中，当需要对多个数据库操作进行组合或者保证一组操作的原子性时，可以开启事务管理。

•使用enabletransactionmanagement可以在程序中灵活地配置和管理事务。

事务管理的意义•事务是指一组数据库操作，要么全部成功执行，要么全部不执行。

•在并发环境下，多个用户同时进行数据库操作，可能会引发一些问题，如数据一致性、并发冲突等。

•事务管理的目的就是提供一种机制来保证多个操作的一致性和隔离性。

事务的ACID特性•ACID是指原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）。

•原子性指一个事务中的所有操作要么全部成功，要么全部失败。

•一致性指事务在执行前和执行后，数据库始终处于一致的状态。

•隔离性指并发执行的事务之间应该互相隔离，使它们感觉像是在串行执行。

•持久性指一旦事务提交后，其修改操作对数据库是永久性的。

enabletransactionmanagement的配置和使用1.在项目的配置文件中，开启事务管理功能。

2.在需要开启事务的方法或类上添加@Transactional注解。

3.配置事务的一些属性，如事务的传播行为、隔离级别、超时时间等。

配置文件的设置spring:datasource:url: jdbc:username: rootpassword: 123456jpa:hibernate:ddl-auto: updatejackson:date-format: yyyy-MM-dd HH:mm:ssprofiles:active: devmain:allow-bean-definition-overriding: truejpa:properties:hibernate:default_batch_fetch_size: 100show-sql: trueopen-in-view: trueservlet:multipart:enabled: truemax-file-size: 50MBmax-request-size: 50MB方法或类上的注解配置@Servicepublic class UserServiceImpl implements UserService {@Autowiredprivate UserRepository userRepository;@Transactionalpublic User createUser(String username, String passw ord) {User user = new User();user.setUsername(username);user.setPassword(password);return userRepository.save(user);}}事务属性的配置@Servicepublic class UserServiceImpl implements UserService {@Autowiredprivate UserRepository userRepository;@Transactional(propagation = Propagation.REQUIRED, i solation = Isolation.READ_COMMITTED, timeout = 10)public User createUser(String username, String passw ord) {User user = new User();user.setUsername(username);user.setPassword(password);return userRepository.save(user);}}enabletransactionmanagement的工作原理•当一个方法被@Transactional注解修饰时，Spring框架会通过AOP的方式来拦截方法的调用。

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所对应的加载配置⽂件的路径。

spring,mybatis事务管理配置与@Transactional注解使用[转]

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对象，只要加上注解就可以获得完全的事务支持。

和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

多数据源动态配置及事务控制

多数据源动态配置及事务控制1、动态数据源切换时，如何保证事务⽬前事务最灵活的⽅式，是使⽤spring的声明式事务，本质是利⽤了spring的aop，在执⾏数据库操作前后，加上事务处理。

spring的事务管理，是基于数据源的，所以如果要实现动态数据源切换，⽽且在同⼀个数据源中保证事务是起作⽤的话，就需要注意⼆者的顺序问题，即：在事务起作⽤之前就要把数据源切换回来。

举⼀个例⼦：web开发常见是三层结构：controller、service、dao。

⼀般事务都会在service层添加，如果使⽤spring的声明式事务管理，在调⽤service层代码之前，spring会通过aop的⽅式动态添加事务控制代码，所以如果要想保证事务是有效的，那么就必须在spring添加事务之前把数据源动态切换过来，也就是动态切换数据源的aop要⾄少在service上添加，⽽且要在spring声明式事务aop之前添加.根据上⾯分析:最简单的⽅式是把动态切换数据源的aop加到controller层，这样在controller层⾥⾯就可以确定下来数据源了。

不过，这样有⼀个缺点就是，每⼀个controller绑定了⼀个数据源，不灵活。

对于这种：⼀个请求，需要使⽤两个以上数据源中的数据完成的业务时，就⽆法实现了。

针对上⾯的这种问题，可以考虑把动态切换数据源的aop放到service层，但要注意⼀定要在事务aop之前来完成。

这样，对于⼀个需要多个数据源数据的请求，我们只需要在controller⾥⾯注⼊多个service实现即可。

但这种做法的问题在于，controller层⾥⾯会涉及到⼀些不必要的业务代码，例如：合并两个数据源中的list…此外，针对上⾯的问题，还可以再考虑⼀种⽅案，就是把事务控制到dao层，然后在service层⾥⾯动态切换数据源。

实例2、实例本例⼦中，对不同数据源分包（package）管理，同⼀包下的代码使⽤了同⼀数据源。

最全153道Spring全家桶面试题，你都碰到过哪些？（含答案解析）

最全153道Spring全家桶⾯试题，你都碰到过哪些？（含答案解析）前⾔Spring 框架⾃诞⽣以来⼀直备受开发者青睐，有⼈亲切的称之为：Spring 全家桶。

⽏庸置疑，Spring 早已成为 Java 后端开发的⾏业标准，⽆数的公司选择 Spring 作为基础的开发框架，⼤部分Java 后端程序员在⽇常⼯作中也会接触到 Spring。

很多研发⼈员把 Spring 看作⼼⽬中最好的 Java 项⽬，没有之⼀。

所以这是重点也是难点，⼯作中必须会，⾯试时肯定考。

Spring ⾯试题1、不同版本的 Spring Framework 有哪些主要功能？2、什么是 Spring Framework？3、列举 Spring Framework 的优点。

4、Spring Framework 有哪些不同的功能？5、Spring Framework 中有多少个模块，它们分别是什么？6、什么是 Spring 配置⽂件？7、Spring 应⽤程序有哪些不同组件？8、使⽤ Spring 有哪些⽅式？9、什么是 Spring IOC 容器？10、什么是依赖注⼊？11、可以通过多少种⽅式完成依赖注⼊？12、区分构造函数注⼊和 setter 注⼊。

13、spring 中有多少种 IOC 容器？14、区分 BeanFactory 和 ApplicationContext。

15、列举 IoC 的⼀些好处。

16、Spring IoC 的实现机制。

17、什么是 spring bean？18、spring 提供了哪些配置⽅式？19、spring ⽀持集中 bean scope？20、spring bean 容器的⽣命周期是什么样的？21、什么是 spring 的内部 bean？22、什么是 spring 装配23、⾃动装配有哪些⽅式？24、⾃动装配有什么局限？25、什么是基于注解的容器配置26、如何在 spring 中启动注解装配？27、@Component, @Controller, @Repository, @Service 有何区别？28、@Required 注解有什么⽤？29、@Autowired 注解有什么⽤？30、@Qualifier 注解有什么⽤？31、@RequestMapping 注解有什么⽤？32、spring DAO 有什么⽤？33、列举 Spring DAO 抛出的异常。

Spring事务管理及与mybatis整合的事务管理

数据访问事务处理in Spring+Mybatis3.0事务---保证了用户的每一次操作都是可靠的，即使出现了异常的访问，也不至于破坏后台数据的完整性;Java事务简介事务必须符合ISO/IEC所定制的ACID原则1)A(atomicity):原子性在事务执行的过程中,任何的失败就将导致事务的任何修改失效,2)C(consistency):一致性事务回滚时,事务所执行的内容必须恢复到初始状态,即事务执行前的状态3)I(isolation):隔离性事务执行过程中对数据的修改,在提交之前的数据对其他事务不可见4)D(durability):持久性已经提交的数据在事务执行失败时,数据的状态都是正确的.事务分类:全局事务(分布式事务):由应用服务器来管理(如JTA),同时可以用于多个事务性的资源;本地事务本地事务和资源相关,主要通过JDBC来实现在实际应用中,存在一种容器管理事务,容器事务主要是由javaEE应用服务器提供,容器事务大多给予JTA完成,事实上这是在容器中覆盖了JDBC和JTA事务.事务特性分析(use spring)TransactionDefinition 接口来定义事务属性。

Code:public interface TransactionDefinition{int getIsolationLevel();int getPropagationBehavior();int getTimeout();boolean isReadOnly();}事务机制a)事务隔离级别隔离级别是指若干个并发的事务之间的隔离程度。

TransactionDefinition 接口中定义了五个表示隔离级别的常量：TransactionDefinition.ISOLATION_DEFAULT(默认值)：表示使用底层数据库的默认隔离级别。

对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。