SpringAOP和Spring事物管理

Spring AOP :

Pointcut表达式:   designators-指示器   wildcards-通配符   operators-操作符
wildcards:  * -- 匹配任意数量的字符
			+ -- 匹配制定类及其子类
			..-- 一般用于匹配任意数的子包或参数
operator: && || !
Wildcards(通配符)
	* 匹配任意数量的字符
	+ 匹配指定类及其子类
	.. 一般用于匹配任意数的子包或参数

Pointcut :切面表达式
		designators:指示器,描述通过什么方式去匹配Java的那些方法
			execution():匹配方法
			匹配注解
				@target()
				@args()
				@within()
				@annotation()
			within():匹配包/类型
			this()/bean()/target():匹配对象
			args():匹配参数
			
		wildcards:通配符(*:匹配任意数量的字符;+匹配指定类及其子类;..:一般用于匹配任意数的子包或参数)
		operators: 运算符(&&:与操作符;||或;!:非)
		
匹配包/类型 : 
	// 匹配ProductService类里头的所有方法
	@Pointcut("within(com.imooc.service.ProductService)")
	public void matchType() {
	}
	
	// 匹配com.imooc包及子包下所有类的方法
	@Pointcut("within(com.imooc..*)")
	public void matchPackage(){}
		
匹配对象:
	1:this(包名):匹配AOP对象的目标对象指定类型的方法;
	2:target(包名):匹配实现接口的目标对象的方法(不是AOP代理后的对象);
	3:bean(包名):匹配所有以Service结尾的bean里头的方法;	

	/**	
		public class DemoDao implements IDao{}
	*/	
	// 匹配AOP对象的目标对象为指定类型的方法,即DemoDao的aop代理对象的方法
	@Pointcut("this(com.imooc.DemoDao)")
	public void thisDemo() {}
	
	// 匹配实现IDao接口的目标对象(而不是aop代理后的对象)的方法,这里即DemoDao的方法
	@Pointcut("target(com.iommc.IDao)")
	public void targetDemo() {}
	
	// 匹配所有以Service结尾的bean里头的方法
	@Pointcut("bean(*Service)")
	public void beanDemo() {}

匹配参数
	// 匹配任何以find开头而且只有一个Long参数的方法
	@Pointcut("execution(* * ..find*(Long))")
	public void argsDemo1() {}
	
	// 匹配任何只有一个Long参数的方法
	@Pointcut("args(Long)")
	public void argsDemo2() {}
	
	// 匹配任何find开头的而且第一个参数为Long型的方法
	@Pointcut("execution(* *..find*(Long,..)")
	public void argsDemo3() {}

	// 匹配第一个参数为Long型的方法
	@Pointcut("args(Long,..)")
	public void argsDemo4() {}
	
匹配注解:
	1:匹配方法级别的;
	2:匹配类级别的;
	3:匹配参数级别的;	
			
	@annotion:匹配方法级别的注解方法;
	@within:匹配标注有Beta的类底下的方法;
	@target:匹配标注有Repository的类底下的方法;
	@args:匹配传入的参数类标注有Repository注解的方法;	
	
	示例 : 
		1: // 匹配方法标注有AdminOnly的注解的方法
		@Pointcut("@annotation(com.imooc.demo.security.AdminOnly)")
		public void annoDemo(){}
		
		2: // 匹配标注有Beta的类地下的方法,要求的anntation的RetentionPolity级别的CLASS
		@Pointcut("@within(com.google.common.annotations.Beta)")
		public void annoWithDemo(){}
		
		3: // 匹配标注有Repository的类地下的方法,要求的annotation的RetentionPolicy级别为RUNTIME
		@Pointcut("@target(org.springframework.stereotype.Repository)")
		public void annoTargetDemo() {}
		
		4: //匹配传入的参数类标注有Repository注解的方法;
		@Pointcut("@args(org.springframework.stereotype.Repository)")
		public void annoArgsDemo(){}
		
@Before,表示在切点之前执行的插入的逻辑;
@Aspect切面类,标注界面类;
@Component,标注在类上,表示这个类交给spring托管;	
execution表达式:
拦截方法:
@Pointcut("execution(public * com.imooc.service.*.*(..))");
拦截抛出的异常:
@Pointcut("exection(public * com.imooc.service.*.*(..) throws java.lang.IllegalAccessException)");	
//匹配任何公共方法
 @Pointcut("execution(public * com.imooc.service.*.*(..))")

 //匹配com.imooc包及子包下Service类中无参方法
 @Pointcut("execution(* com.imooc..*Service.*())")

 //匹配com.imooc包及子包下Service类中的任何只有一个参数的方法
 @Pointcut("execution(* com.imooc..*Service.*(*))")

 //匹配com.imooc包及子包下任何类的任何方法
 @Pointcut("execution(* com.imooc..*.*(..))")

 //匹配com.imooc包及子包下返回值为String的任何方法
 @Pointcut("execution(String com.imooc..*.*(..))")

 //匹配异常
 execution(public * com.imooc.service.*.*(..) throws java.lang.IllegalAccessException)
 
 5种Advice:
	1:@Before,前置通知;
	2:@After(finally),后置通知,方法执行完成之后;
	3:@AfterReturning,返回通知,成功执行之后执行;
	4:@AfterThrowing,异常通知,抛出异常之后执行
	5: @Around : 环绕通知
	
原理概述 : 织入的时机
	1: 编译期(Aspectj)
	2: 类加载时(Aspectj 5+)
	3: 运行时(Spring AOP)
运行时织入:
1:静态代理与动态代理;
2:基于接口代理与基于继承代理;	

代理模式;
	组成:调用者,统一的接口、真实对象、代理者;
	原理:通过接口,实现这样一个过程,在调用真实对象的时候,调用者并不直接与真实对象打交道,而是通过一个代理者与真实对象通信,代理者能够负责真实
	对象的非业务逻辑,如日志管理、访问控制 、异常处理等,使得真实对象专注于业务逻辑的实现,不受非业务逻辑的干扰。
代理对象会把正真的业务逻辑委托给实际对象 而代理对象只会进行一写边缘的附加操作  这就是aop的实现原理.
代理对象调用目标对象的方法产生的异常需要抛出去,不能处理,因为代理对象的作用是对目标对象进行增强,不会对目标对象进行改变.

静态代理就是一个代理类根据被代理类的情况,被代理类有几个方法,代理类就需要有几个方法,每个方法都要对被代理类进行代理,这样会出现代码重复的情况,
如多个被代理方法其实前后需要执行的逻辑是一样的,但是静态代理还是需要为每个方法写一个代理方法,造成代码重复。动态代理根据放射得到被代理类执行的方
法和参数,避免了代码的重复。
静态代理的代码,静态代理的弊端:代理的对象越多.
JDK实现要点:
	1类:java.lang.reflect.Proxy;
	2接口:InvoctionHandler;
	3只能基于接口进行动态代理.
动态代理实现时,需要的接口,InvocationHandler接口。
	注意:在捕获异常之后,执行插入程序,然后还需要将异常在catch代码块内抛出去!	
			
jdk运行期动态代理源码解析:其实就是真实类实现一个接口,我们再写一个类似于切面的类,实现invocationhandler接口且实现invoke方法,同时要保存真实类对象,
初始化时赋值对象,invoke方法中反射方式调用真是对象方法,在方法前后可以加上定制的逻辑,这个方法其实是动态代理对象调用的,动态代理对象是客户端通过动
态代理类实例化的,而动态代理类是真实对象方法执行前的运行期生成的.class类,这个类实现了和真实对象一样的接口,所以也有真实对象的方法,调用代理对象方
法时也就可以传入参数,然后代理对象再将方法和参数传递给invocationhandler的实例对象。	

通过System.setProperties()可以设置保存jdk动态代理生成的字节码文件.

JDK与Cglib代理对比:
	1:JDK只能针对有接口的类的接口方法进行动态代理;
	2:Cglib基于继承来实现代理,无法对static、final类进行代理;
	3:Cglib基于继承来实现代理,无法对private、static方法进行代理。	
	
Cglib实现:
	1:生成指定类对象的子类,也就是重写类中的业务函数。
	2:执行回调函数,加入intercept()函数。
	3:创建这个类的子类对象。
	-----------------------------------------
	反射技术实现;
	methodProxy.invokeSuper();	
JDK通过接口代理,所以只能代理实现接口的类的方法,而cglib通过继承实现代理,所以不能代理final类,也无法代理private和static方法.
无法对final类进行代理,因为final类不能被继承
关于Cglib无法对static类和方法进行代理:
单一的类是没有static修饰符的,只有静态类内部可以用static修饰;
对于static方法,它是属于类的,子类在不重写的情况下,是可以调用的,但是一旦重写了就无法调用了,普通的public方法可以通过super.method()调用,但是
static方法不行.

Spring如何创建代理bean?
	JDK动态代理与Cglib代理是如何选用的?
	-----------------------------
	1:如果目标对象实现了接口,则默认采用JDK动态代理;
	2:如果目标对象没有实现接口,则采用Cglib进行动态代理;
	3:如果目标对象实现了接口,且强制Cglib代理,则使用Cglib代理;
			
继承JPARepository对数据操作实现自己的事务控制,@transactional会在子事务外层加一层事务控制,对事务整体进行控制,在方法执行前后判断事务需要进行回滚操作。
SpringBoot对缓存的一个控制:
1、引入依赖:
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>
2、使用注解:
@Cacheable(cacheNames={"menu"})
public List<String> getMenuList(){
	   System.out.println("看看是不是只有第一次被调用");
	   return Arrays.asList("java","C++","PHP");
}	
			
使用SpringAop的注意事项/坑
	1: 不宜把重要的业务逻辑放到aop中处理;
	2: 无法拦截static,final方法,private方法;
	3: 无法拦截内部方法调用.
			
实现AOP的方法被方法内部调用时是不会走AOP的织入逻辑的,因为内部调用AOP方法的调用对象是this,而this不是增强的代理对象,所以不会走织入代码,解决方法
就是用ApplicationContent获取到增强的代理对象的bean,然后用这个bean来执行AOP方法,就可以走织入的代码逻辑了.			
Spring Aop 的坑,无法拦截方法内部调用,因为内部调用是this调用的,而不是代理类调用的.
无法拦截内部调用的原因:aop通过代理实现的,而省略的this是指该对象,而不是代理后的对象
解决aop无法内部调用的问题:通过spring的ApplicationContext获取该类的对象,就是代理对象,使用代理对象去调用内部方法.
解决方法:通过ApplicationContext来获取代理bean,通过代理bean调用方法。

课程总结:

	1.面向切面编程是对面向对象编程的补充,主要用于日志记录,权限验证,事务配置等功能。

	2.使用aspectJ实现aop,aspectJ是一个面向切面的框架,它扩展了Java语言。

	3.主要注解:

	@Aspect 标注说明Java类是切面配置的类 由@Pointcut和@Advice组成 

	@Pointcut 描述在哪些类的哪些方法植入代码  

	@Advice表达在Pointcut表达式的什么时间执行

	4. pointcut中的通配符,运算符,指示器(通过什么方式匹配植入的方法)

	通配符:* 匹配任意数量的字符  +匹配指定类及其子类  ..一般用于匹配任意数的子包或参数

	运算符:&&与操作符  || 或操作符  !非操作符

	指示器:

	a. @within 匹配包/类型 

	@Pointcut("within(com.imooc.service.ProductService")) //匹配ProductService类里的所有方法

	@Pointcut("within(com.imooc..*)") //匹配com.imooc包及子包下所有类的方法

	b. execution  表达式:方法的修饰符 返回值 包名.类名.方法(参数)

	@Pointcut("execution(public * com.imooc.service.*Service.*(..))")//表示com.imooc.service包下以Service字符结尾的类中任意参数的所有方法

	5.Advice 注明要在哪个切点执行什么操作,有几种方式

	@Before("")  //意思是在切点执行前执行

	@After("")  //意思是在切点执行前执行

	@Around("") //表明在切点方法的前后都要执行该处理器方法	

Spring事务 : Spring事务管理接口: PlatformTransactionManager:事务管理器 TransactionDefinition:事务定义信息(事务隔离级别、传播行为)(隔离、传播、超时、只读) TransactionStatus:事务具体运行状态

	事务管理器PlatformTransactionManager
		Spring为不同的持久化框架提供了不同PlatformTransactionManager接口实现;
		org.springframework.jdbc.datasource.DataSourceTransactionManager : 使用Spring JDBC或iBatis进行持久化数据时使用.
		org.springframework.orm.hibernate3.HibernateTransactionManager : 使用Hibernate3.0版本进行持久化数据时使用.
		org.springframework.orm.jpa.JpaTransactionManager : 使用JPA进行持久化时使用
		org.springframework.jdo.JdoTransactionManager : 当持久化机制是Jdo时使用
		org.springframework.transaction.jta.JtaTransactionManager : 使用一个JTA实现管理事务,在一个事务跨越多个资源时必须使用.
	TransactionDefinition定义事务隔离级别
	如果不考虑隔离性,会引发如下的安全问题:
	1.脏读。
	一个事务读取了另一个事务改写但还未提交的数据,如果这些数据被回滚,则读到的数据是无效的。
	2.不可重复读。
	在同一个事务中,多次读取同一数据返回的结果有所不同。
	3.幻读。
	一个事务读取了几行记录后,另一个事务插入一些记录,幻读就发生了。再后来的查询中,第一个事务就会发现有些原来没有的记录。


	隔离级别的出现就是为了解决以上问题的。

	数据库提供的事务的隔离级别(四种):
	1.READ_UNCOMMITED;
	允许你读取还未提交的改变了的数据,可能导致脏,幻,不可重复读。
	2.READ_COMMINTED:
	允许在并发事务已经提交后读取,可防止脏读,但幻读和不可重复读还是有可能发生。
	3.REPEATABLE_READ:
	对相同字段的多次读取是一致的,除非数据被事务本身改变,可防止脏读,不可重复读,但幻读仍有可能出现。
	4.SERILIZABLE:
	完全服从ACID的隔离级别,确保不发生脏读,幻读,不可重复读,这在所有的隔离级别中是最慢的,它是典型的完全通过锁定在事务中涉及的数据表来完成的。

	除了以上的数据库提供的事务隔离级别,spring提供了Default隔离级别,该级别表示spring使用后端数据库默认的隔离级别。

	MySQL默认事务隔离级别:REPATABLE_READ(可能出现幻读)
	Oracle默认:READ_COMMITTED(可能出现不可重复读和幻读)
			
	propagation_required:a存在事务,则b与a同一事务,如果a没有事务,则b新起事务
	propagation_supported:a存在事务,则b与a同事务,如果a没有事务,则b也没有事务
	propagation_mondatary:a存在事务,则b与a同事务,如果a没有事务,则抛异常
	propagation_required_new:如果a存在事务,b新起事务
	propagation_not_supported:如果a存在事务,b不已事务运行
	propagation_never:如果出现事务,直接抛出异常
	propagation_nested:a事务运行结束后,会有保存点,这边可以自定事务,b出错,a可以回滚或者就到a的保存点		
			
	TransactionDefinition定义事务之事务的传播行为(002)<br>
	<br>
	事务的传播行为有七种,这七种行为可以分为三类,图中前三个分为一类(让aaa()和bbb()操作在同一事务里),中间三个为一类(保证aaa()和bbb()操作在不同一事务里),最后为一类(aaa()执行完成后,设置一个保存点,如果bbb()发生异常,将回滚到保存点或初始状态)。<br>
	<br>
	重点记住PROPAGATION_REQUIRED, PROPAGATION_REQUIRES_NEW, PROPAGATION_NESTED		
			
	相关代码(公共1):
	//package cn.muke.spring.demo1;
	@AccountDao.java
	/**
	 * 转账案例的DAO层的接口
	 */
	public interface AccountDao {
	/**
	 * out	:转出账号
	 * money:转出金额
	 */
	public void outMoney(String out,Double money);
		
	/**
	 * in	:转入账号
	 * money:转入金额
	 */
	public void inMoney(String in,Double money);
	}

	@AccountService.java
	/**
	 * 转账案例的业务层接口
	 */
	public interface AccountService {
	/**
	 * out	:转出账号
	 * in	:转入账号
	 * money:转账金额
	 */
	public void transfer(String out,String in,Double money);
	}

	@AccountDaoImpl.java
	/**
	 * 转账案例的DAO层的实现类
	 */
	public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
	/**
	 *  out	 :转出账号
	 *  money:转出金额
	 */
	public void outMoney(String out, Double money) {
	String sql="update account set money=money-? where name=?";
	this.getJdbcTemplate().update(sql,money,out);
	}

		/**
		 *  in	 :转入账号
		 *  money:转入金额
		 */
		public void inMoney(String in, Double money) {
			String sql="update account set money=money+? where name=?";
			this.getJdbcTemplate().update(sql,money,in);
		}
	}		
事务的传播行为和隔离级别[transaction behavior and isolated level]

Spring中事务的定义: 一、Propagation :   key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用: PROPAGATION_REQUIRED–支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS–支持当前事务,如果当前没有事务,就以非事务方式执行。 PROPAGATION_MANDATORY–支持当前事务,如果当前没有事务,就抛出异常。 PROPAGATION_REQUIRES_NEW–新建事务,如果当前存在事务,把当前事务挂起。 PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。 PROPAGATION_NEVER–以非事务方式执行,如果当前存在事务,则抛出异常。

很多人看到事务的传播行为属性都不甚了解,我昨晚看了j2ee without ejb的时候,看到这里也不了解,甚至重新翻起数据库系统的教材书,但是也没有找到对这个的分析。今天搜索,找到一篇极好的分析文章,虽然这篇文章是重点分析PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRED_NESTED的 解惑 spring 嵌套事务 TransactionDefinition 接口定义***********

 int PROPAGATION_REQUIRED = 0;   




 int PROPAGATION_SUPPORTS = 1;   

 int PROPAGATION_MANDATORY = 2;   




 int PROPAGATION_REQUIRES_NEW = 3;   



 int PROPAGATION_NOT_SUPPORTED = 4;   


 int PROPAGATION_NEVER = 5;   



 int PROPAGATION_NESTED = 6;   

*************************************************************************
在这篇文章里,他用两个嵌套的例子辅助分析,我这里直接引用了。
********************sample***********************
ServiceA {   
	   
	   
	 void methodA() {   
		 ServiceB.methodB();   
	 }   
  
}   
  
ServiceB {   
	   
		 
	 void methodB() {   
	 }   
	   
}      
*************************************************
我们这里一个个分析吧
1: PROPAGATION_REQUIRED 
加入当前正要执行的事务不在另外一个事务里,那么就起一个新的事务
比如说,ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候,
		 ServiceA.methodA已经起了事务,这时调用ServiceB.methodB,ServiceB.methodB看到自己已经运行在ServiceA.methodA
的事务内部,就不再起新的事务。而假如ServiceA.methodA运行的时候发现自己没有在事务中,他就会为自己分配一个事务。
这样,在ServiceA.methodA或者在ServiceB.methodB内的任何地方出现异常,事务都会被回滚。即使ServiceB.methodB的事务已经被
提交,但是ServiceA.methodA在接下来fail要回滚,ServiceB.methodB也要回滚
2:   PROPAGATION_SUPPORTS
如果当前在事务中,即以事务的形式运行,如果当前不再一个事务中,那么就以非事务的形式运行
这就跟平常用的普通非事务的代码只有一点点区别了。不理这个,因为我也没有觉得有什么区别
3:   PROPAGATION_MANDATORY
必须在一个事务中运行。也就是说,他只能被一个父事务调用。否则,他就要抛出异常。
4:   PROPAGATION_REQUIRES_NEW
这个就比较绕口了。 比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED,ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW,
那么当执行到ServiceB.methodB的时候,ServiceA.methodA所在的事务就会挂起,ServiceB.methodB会起一个新的事务,等待ServiceB.methodB的事务完成以后,
他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务,那么就是存在
两个不同的事务。如果ServiceB.methodB已经提交,那么ServiceA.methodA失败回滚,ServiceB.methodB是不会回滚的。如果ServiceB.methodB失败回滚,
如果他抛出的异常被ServiceA.methodA捕获,ServiceA.methodA事务仍然可能提交。
5:   PROPAGATION_NOT_SUPPORTED 
当前不支持事务。比如ServiceA.methodA的事务级别是PROPAGATION_REQUIRED ,而ServiceB.methodB的事务级别是PROPAGATION_NOT_SUPPORTED ,
那么当执行到ServiceB.methodB时,ServiceA.methodA的事务挂起,而他以非事务的状态运行完,再继续ServiceA.methodA的事务。
6:   PROPAGATION_NEVER 
不能在事务中运行。假设ServiceA.methodA的事务级别是PROPAGATION_REQUIRED, 而ServiceB.methodB的事务级别是PROPAGATION_NEVER ,
那么ServiceB.methodB就要抛出异常了。
7:   PROPAGATION_NESTED 
理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是,PROPAGATION_REQUIRES_NEW另起一个事务,将会与他的父事务相互独立,
而Nested的事务和他的父事务是相依的,他的提交是要等和他的父事务一块提交的。也就是说,如果父事务最后回滚,他也要回滚的。
而Nested事务的好处是他有一个savepoint。
*****************************************
ServiceA {   
	   
	   
	 void methodA() {   
		 try {
	  //savepoint   
			 ServiceB.methodB();    //PROPAGATION_NESTED 级别
		 } catch (SomeException) {   
			 // 执行其他业务, 如 ServiceC.methodC();   
		 }   
	 }   
  
}   
********************************************
也就是说ServiceB.methodB失败回滚,那么ServiceA.methodA也会回滚到savepoint点上,ServiceA.methodA可以选择另外一个分支,比如
ServiceC.methodC,继续执行,来尝试完成自己的事务。
但是这个事务并没有在EJB标准中定义。

二、Isolation Level(事务隔离等级):
1、Serializable:最严格的级别,事务串行执行,资源消耗最大;

2、REPEATABLE READ:保证了一个事务不会修改已经由另一个事务读取但未提交(回滚)的数据。避免了“脏读取”和“不可重复读取”的情况,但是带来了更多的性能损失。

3、READ COMMITTED:大多数主流数据库的默认事务等级,保证了一个事务不会读到另一个并行事务已修改但未提交的数据,避免了“脏读取”。该级别适用于大多数系统。

4、Read Uncommitted:保证了读取过程中不会读取到非法数据。
隔离级别在于处理多事务的并发问题。
我们知道并行可以提高数据库的吞吐量和效率,但是并不是所有的并发事务都可以并发运行,这需要查看数据库教材的可串行化条件判断了。
这里就不阐述。
我们首先说并发中可能发生的3中不讨人喜欢的事情
1:   Dirty reads--读脏数据。也就是说,比如事务A的未提交(还依然缓存)的数据被事务B读走,如果事务A失败回滚,会导致事务B所读取的的数据是错误的。

2:   non-repeatable reads--数据不可重复读。比如事务A中两处读取数据-total-的值。在第一读的时候,total是100,然后事务B就把total的数据改成200,事务A再读一次,结果就发现,total竟然就变成200了,造成事务A数据混乱。

3:   phantom reads--幻象读数据,这个和non-repeatable reads相似,也是同一个事务中多次读不一致的问题。但是non-repeatable reads的不一致是因为他所要取的数据集被改变了(比如total的数据),但是phantom reads所要读的数据的不一致却不是他所要读的数据集改变,而是他的条件数据集改变。比如Select account.id where account.name="ppgogo*",第一次读去了6个符合条件的id,第二次读取的时候,由于事务b把一个帐号的名字由"dd"改成"ppgogo1",结果取出来了7个数据。
						  Dirty reads          non-repeatable reads            phantom reads
Serializable                     不会                   不会                           不会
REPEATABLE READ           不会                   不会                            会
READ COMMITTED            不会                    会                             会
Read Uncommitted            会                     会                             会

三、readOnly
事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务。这是一个最优化提示。在一些情况下,一些事务策略能够起到显著的最优化效果,例如在使用Object/Relational映射工具(如:Hibernate或TopLink)时避免dirty checking(试图“刷新”)。
四、Timeout
	   在事务属性中还有定义“timeout”值的选项,指定事务超时为几秒。在JTA中,这将被简单地传递到J2EE服务器的事务协调程序,并据此得到相应的解释。			
			
事务的API介绍

一、简介
PlatformTransactionManager - 平台事务管理器,真正用来管理事务的接口,包含事务的提交,回滚等信息
TransactionDefinition - 事务定义信息(隔离级别、传播行为、是否超时、设置只读)
TransactionStatus - 事务具体的运行状态(是否已经提交,是否有保存点,是不是一个新的事务等等这些状态)

关系:
首先会根据TransactionDefinition事务定义的信息(比如定义了什么样的隔离级别,定义什么样的传播行为),由PlatformTransactionManager对事务进行管理,进行事务管理的过程中,事务会产生一些相应的状态,这些状态在TransactionStatus中

二、PlatformTransactionManager 接口
1. DataSourceTransactionManager
	 使用Spring JDBC 或iBatis进行持久化数据时使用
2. HibernateTransactionManager
	 使用Hibernate3.0版本进行持久化数据时使用

三、TransactionDefinition
1.事务隔离级别
解决脏读、不可重复读、幻读等安全问题

事务隔离级别(四种):
DEFAULT
READ_UNCOMMITED
READ_COMMITED
REPEATABLE_READ
SERIALIZABLE

2.事务的传播行为
解决业务层的方法之间的相互调用的问题(在调用方法的过程中,事务是如何传递的)

事务的传播行为有七种,又分为三类:
第一类共同点:A和B方法在同一个事务中。
*PROPAGATION_REQUIRED
PROPAGATION_SUPPORTS
PROPAGATION_MANDATORY

第二类共同点:A 方法和 B 方法不在同一个事务里面。
*PROPAGATION_REQUIRES_NEW
PROPAGATION_NOT_SUPPORTED
PROPAGATION_NEVER

第三类:如果 A 方法有的事务执行完,设置一个保存点,如果 B 方法中事务执行失败,可以滚回保存点或初始状态。
*PROPAGATION_NESTED

四、TransactionStatus	

TransactionStatus接口用来记录事务的状态

该接口定义了一组方法,用来获取或判断事务的相应状态信息.

平台事务管理器(PlatformTransactionManager)会根据TransactionDefinition中定义的事务信息(包括隔离级别、传播行为)来进行事务的管理,在管理的过程中事务可能
产生了保存点或事务是新的事务等情况,那么这些信息都会记录在TransactionStatus的对象中.	
TransactionStatus记录事务的状态信息(刷新、是否有保存点、是否完成、是否是一个新事务、是否只回滚、设置只回滚)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券