三木之Spring事务注解实现

AOP底层实现原理

动态代理

（

什么是动态代理

1.代理对象,不需要实现接口

2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)

3.动态代理也叫做:JDK代理,接口代理

）

 

AOP编程应用场景

日志记录，性能统计，安全控制，事务处理，异常处理

 

事务注解实现代码

pom.xml

		
		
			org.springframework
			spring-core
			3.0.6.RELEASE
		
		
			org.springframework
			spring-context
			3.0.6.RELEASE
		
		
			org.springframework
			spring-aop
			3.0.6.RELEASE
		
		
			org.springframework
			spring-orm
			3.0.6.RELEASE
		
		
			org.aspectj
			aspectjrt
			1.8.9
		
		
		
		    org.aspectj
		    aspectjweaver
		    1.8.9
		

		
			cglib
			cglib
			2.1_2
		

		
		
			com.mchange
			c3p0
			0.9.5.2
		
		
		
			mysql
			mysql-connector-java
			5.1.37
		
	

spring.xml

实现自定义注解

元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解：
1.@Target

@Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。

1. CONSTRUCTOR:用于描述构造器
2. FIELD:用于描述域
3. LOCAL_VARIABLE:用于描述局部变量
4. METHOD:用于描述方法
5. PACKAGE:用于描述包
6. PARAMETER:用于描述参数
7. TYPE:用于描述类、接口(包括注解类型) 或enum声明

2.@Retention

表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效）

// 事务注解 设置传播行为
@Target({ ElementType.METHOD }) //只能用在方法上
@Retention(RetentionPolicy.RUNTIME)//
public @interface ExtTransaction {
		//int userId() default 0;

		//String userName() default "默认名称";

		//String[]arrays();
}

 

自定义事务注解

UserServiceImpl.java(使用到自定义事务注解的类)

@Service
public class UserServiceImpl implements UserService {
	@Autowired
	private UserDao userDao;
	//@Autowired
	//private TransactionUtils transactionUtils;
	
	@Override
	//@Transactional
	@ExtTransaction
	public void add() {
		// TODO Auto-generated method stub
		userDao.add("wangmazi", 27);
		int i = 1 / 0;
		System.out.println("我是add方法");
		userDao.add("zhangsan", 16);
	}

	/*public void add() {
		TransactionStatus transactionStatus = null;
		try {
			transactionStatus = transactionUtils.begin();
			userDao.add("wangmazi", 27);
			int i = 1 / 0;
			System.out.println("我是add方法");
			userDao.add("zhangsan", 16);
			transactionUtils.commit(transactionStatus);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("报错了，事务回滚");
		} finally {
			if (transactionStatus != null) {
				transactionStatus.setRollbackOnly();
				//transactionUtils.rollback();
			}
		}

	}*/

}

 TransactionUtils.java (通用事务工具类)

// 编程事务（需要手动begin 手动回滚 手都提交）
@Component
@Scope("prototype") // 每个事务都是新的实例 目的解决线程安全问题 多例子
public class TransactionUtils {

	// 全局接受事务状态
	private TransactionStatus transactionStatus;
	// 获取事务源
	@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;

	// 开启事务
	public TransactionStatus begin() {
		System.out.println("开启事务");
		transactionStatus = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
		return transactionStatus;
	}

	// 提交事务
	public void commit(TransactionStatus transaction) {
		dataSourceTransactionManager.commit(transaction);
	}

	// 回滚事务
	public void rollback() {
		System.out.println("回滚事务...");
		if(transactionStatus!=null){
			dataSourceTransactionManager.rollback(transactionStatus);
		}
	}

}

AopExtTransaction.java(切面)

@Component
@Aspect
public class AopExtTransaction {
	// 一个事务实例子 针对一个事务
	@Autowired
	private TransactionUtils transactionUtils;
	
	private ExtTransaction extTransaction=null;
	
	@Pointcut("execution(* com.transaction.service.*.*.*(..))")
	public void pointout(){}

	// 环绕通知 在方法之前和之后处理事情
	@Around("pointout()")
	public void around(ProceedingJoinPoint pjp) throws Throwable {
		//未加上自定义注解
		/*TransactionStatus transactionStatus = transactionUtils.begin();
		pjp.proceed();
		transactionUtils.commit(transactionStatus);*/
		
		//加上自定义注解
		
		//1.通过切入点，获取代理对象的方法,获取该方法上是否有该注解
		extTransaction = getDeclaredAnnotation(pjp);
		TransactionStatus transactionStatus = null;
		
		//2.如果extTransaction不为空(即使用了该注解) ，开启事务
		if(extTransaction!= null){
			 transactionStatus = transactionUtils.begin();
		}else {
			System.out.println("该方法上没有注解@ExtTransaction");
		}
		
		//3.调用目标代理对象方法
		pjp.proceed();
		
		//4.如果使用了该注解 ，提交事务
		if(extTransaction!=null){
			transactionUtils.commit(transactionStatus);
		}
	}
	
	/**
	 *  使用异常通知进行 回滚事务
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 */
	@AfterThrowing("pointout()")
	public void afterThrowing() throws NoSuchMethodException, SecurityException {
		// 获取当前事务进行回滚
		// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
		
		// 判断该代理对象方法上是否存在该注解
		if (extTransaction != null) {
			transactionUtils.rollback();
		}
	}
	
	/**
	 * 通过切入点，获取代理对象的方法
	 * @param pjp
	 * @return
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 */
	public ExtTransaction getDeclaredAnnotation(ProceedingJoinPoint pjp) throws NoSuchMethodException, SecurityException{
		// 获取方法名称
		String methodName = pjp.getSignature().getName();
		// 获取目标对象
		Class classTarget = pjp.getTarget().getClass();
		// 获取目标对象类型
		Class[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
		// 获取目标对象方法
		Method objMethod = classTarget.getMethod(methodName, par);
		return objMethod.getDeclaredAnnotation(ExtTransaction.class);
	}
}

 

总结：

实现自定义事务注解原理：

1.先实现一个@ExtTransaction 自定义注解

2.使用spring.xml 配置事务源

3.实现 通用事务工具类TransactionUtils，并且设置为多例（每个事务开启都创建一个新的实例，保证线程安全问题）

4.通过切面类，实现事务开启，提交或回滚；

     （1）通过切入点，获取代理对象的方法,获取该方法上是否有该注解

     （2）判断，如果extTransaction不为空(即使用了该注解) ，开启事务

     （3）调用目标代理对象方法

     （4）如果使用了该注解 ，提交事务   /  若发生异常，则异常通知进行 回滚事务