Spring的AOP的注解开发，基于AspectJ的注解开发

一、Spring的基于ApsectJ的注解的AOP开发

1、创建项目引入jar

（1）引入spring开发的jar

（2）引入spring开发的配置文件

• 在src下创建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
</beans>

（3)编写目标类和配置目标类

将两个类交给Spring管理，然后在增强类当中设置识别切面类的注解，和将增强类当中方法设置为前置增强方法，并设置路径规定对应增强的是那个类的方法

• 编写目标类

package com.itzheng.spring.demo1;
public class OrderDao {
	public void save() {
		System.out.println("保存订单。。。。。。");
	}
	public void update() {
		System.out.println("修改订单。。。。。。");
	}
	public void delete() {
		System.out.println("删除订单。。。。。。");
	}
	public void find() {
		System.out.println("查询订单。。。。。。");
	}
}

• 配置目标类在applicationContext.xml当中
  

（4)编写切面类并配置

• 编写切面类

package com.itzheng.spring.demo1;
/*
 - 切面类：注解的切面类
 */
public class MyAspectAnno {
	public void before() {
		System.out.println("前置增强==========");
	}
}

• 配置切面类
  

（5)使用注解的AOP对象目标类进行前置增强

• 在applicationContext配置文件当中打开注解的AOP开发（自动产生代理）。
  
• 在切面类上使用注解@Aspect后Spring就会把这个修饰的类，识别为切面类。
• 前置增强，在切面类当中的方法上用@Before注解修饰，并设置对应的路径的方法，表示在这个路径上的方法上设置当前方法为前置增强的方法。

package com.itzheng.spring.demo1;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
/*
 - 切面类：注解的切面类
 */
@Aspect
public class MyAspectAnno {
	@Before(value = "execution(* com.itzheng.spring.demo1.OrderDao.save(..))")
	public void before() {
		System.out.println("前置增强==========");
	}
}

（6)编写测试类

package com.itzheng.spring.demo1;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/*
 - Spring的AOP的注解开发
 */
@RunWith(SpringJUnit4ClassRunner.class) // 引入Spring整合单元测试
@ContextConfiguration("classpath:applicationContext.xml") // 加载配置文件
public class SpringDemo1 {
	@Resource(name = "orderDao")//注入对象
	private OrderDao orderDao;
	@Test
	public void demo1() {
		orderDao.save();
		orderDao.update();
		orderDao.delete();
		orderDao.find();
	}
}

二、Spring的注解订单AOP的通知类型以及使用

1、@Before:前置通知（前置增强）：在目标方法执行前实现

上面的案例就是前置增强

2、@AfterReturning:后置通知（后置增强）：在目标方法执行后执行

• （1）在MyAspectAnno类当中创建后置增强的方法：并设置注解：@AfterReturning(value = "execution(* com.itzheng.spring.demo1.OrderDao.delete(..))")

//后置通知
	@AfterReturning(value = "execution(* com.itzheng.spring.demo1.OrderDao.delete(..))")
	public void afterReturning() {
		System.out.println("后置增强==========");
	}

• 运行测试方法
  
• （1）在MyAspectAnno类当中创建后置增强的方法：得到返回值
• 修改OrderDao类当中delete方法

public String delete() {
	System.out.println("删除订单。。。。。。");
	return "删除成功";
}

• （2）在MyAspectAnno当中修改后置通知的方法：在@AfterReturning当中设置returning = “result”)其中result必须和afterReturning方法的参数Object result名称相同

//后置通知
	@AfterReturning(value = "execution(* com.itzheng.spring.demo1.OrderDao.delete(..))",returning = "result")
	public void afterReturning(Object result) {
		System.out.println("后置增强=========="+result);
	}

• 测试方法
  

3、@Around:环绕通知（环绕增强）

• 在MyAspectAnno类当中创建around方法并在方法上设置ProceedingJoinPoint链接点参数，通过连接点joinPoint.proceed()执行@Around注解对应的方法

//环绕通知
	@Around(value = "execution(* com.itzheng.spring.demo1.OrderDao.update(..))")
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {//ProceedingJoinPoint链接点
		System.out.println("环绕前增强==========");
		Object object = joinPoint.proceed();//执行目标方法
		System.out.println("环绕后增强==========");
		return object;
	}

• 执行测试方法
  

3、AfterThrowing:异常抛出通知（异常抛出增强）

（1）异常抛出增强案例（不捕获异常）

• 在MyAspectAnno类当中创建afterThrowing方法并设置@AfterThrowing注解设置对应路径方法

//异常抛出通知
	@AfterThrowing(value = "execution(* com.itzheng.spring.demo1.OrderDao.find(..))")
	public void afterThrowing() {
		System.out.println("异常抛出通知=======");
	}

• 修改OrderDao类当中的find方法设置异常

public void find() {
		int i = 1/0;
		System.out.println("查询订单。。。。。。");
	}

• 测试
  

（2）异常抛出增强案例（捕获异常）

• 在MyAspectAnno类当中@AfterReturning注解上设置throwing = "e"属性

//异常抛出通知
	@AfterThrowing(value = "execution(* com.itzheng.spring.demo1.OrderDao.find(..))",throwing = "e")
	public void afterThrowing(Throwable e) {		
		System.out.println("异常抛出通知======="+e);
	}

• 测试并捕获异常
  

4、After :最终通知（最终增强）

• 在MyAspectAnno类当中创建after方法，设置@After注解在目标类的find方法

//最终通知
	@After(value = "execution(* com.itzheng.spring.demo1.OrderDao.find(..))")
	public void after() {
		
		System.out.println("最终通知======================");
	}

• 在有异常的情况下也会执行
  

三、Spring的AOP的注解的切入点的注解

1、创建MyAspectAnno类当中创建切入点注解以及对应的方法：Pointcut

//配置切入点注解
	@Pointcut(value="execution(* com.itzheng.spring.demo1.OrderDao.find(..))")
	private void printcut1() {}

2、在其他方法上使用@Pointcut当中路径对应的目标方法的路径

• 当前类名称.@Pointcut修饰切入点地方方法
  
• 测试正常运行
  
• 注意当实习类没有使用接口Spring的底层的动态代理使用的是