Spring的AspectJ的AOP，基于注解(9)重点掌握

什么是AspectJ

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。 AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP

• AspectJ表达式: * 语法:execution(表达式) execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

    * execution(“* cn.itcast.spring3.demo1.dao.*(..)”)		---只检索当前包
    * execution(“* cn.itcast.spring3.demo1.dao..*(..)”)		---检索包及当前包的子包.
    * execution(* cn.itcast.dao.GenericDAO+.*(..))			---检索GenericDAO及子类
  

• AspectJ增强:

		@Before 前置通知，相当于BeforeAdvice
		@AfterReturning 后置通知，相当于AfterReturningAdvice
		@Around 环绕通知，相当于MethodInterceptor
		@AfterThrowing抛出通知，相当于ThrowAdvice
		@After 最终final通知，不管是否异常，该通知都会执行
		@DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

---

基于注解

• 第一步:引入相应jar包.

  • aspectj依赖aop环境.
  • spring-aspects-3.2.0.RELEASE.jar
  • com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

• 第二步:编写被增强的类:

  • UserDao

package cn.spring3.demo1;
/**
 * @author NOP
 * 被代理的对象
 */
public class UserDao {
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("添加客户");
	}
	public void delete() {
		// TODO Auto-generated method stub
		System.out.println("删除客户");
		int i=1/0;
	}
	public String find() {
		// TODO Auto-generated method stub
		System.out.println("查询客户");
		return "fanhuizhi";
	}
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("修改客户");
	}
}

• 第三步:使用AspectJ注解形式:

package cn.spring3.demo1;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
 * @author NOP 切面类：就是切点与增强结合
 * 前置增强
 */
@Aspect
public class MyAspect {
	@Before(value = "execution(* cn.spring3.demo1.UserDao.add(..))")//这里写表达式，写哪些类需要添加
	public void before(JoinPoint joinpoint) {
		System.out.println("前置增强..."+joinpoint);
	}

	@AfterReturning(value = "execution(* cn.spring3.demo1.UserDao.find(..))",returning="returnVal")//这里写表达式，写哪些类需要添加
	public void afterReturning(Object returnVal){
		System.out.println("后置增强..."+"方法的返回值"+returnVal);
	}
	
	@Around(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")//这里写表达式，写哪些类需要添加
	public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
		System.out.println("环绕前增强...");
		Object obj = proceedingJoinPoint.proceed();
		System.out.println("环绕后增强...");
		return obj;
	}
	
	@AfterThrowing(value = "execution(* cn.spring3.demo1.UserDao.delete(..))",throwing="ex")//这里写表达式，写哪些类需要添加
	public void afterThrowing(Throwable ex) throws Throwable{
		System.out.println("不跑了出异常了..."+ex.getMessage());
	}
	
	//@After(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")//这里写表达式，写哪些类需要添加
	@After("MyAspect.MyPointCut()")//类名.方法名
	public void after(){
		System.out.println("最终通知");//不管有没有异常都会通知
	}
	
	//仅是为了定义一个通用的表达式
	@Pointcut(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")
	private void MyPointCut(){
	}
}

• 第四步:创建applicationContext.xml

 xmlns:aop="http://www.springframework.org/schema/aop"
       
* 引入aop的约束:
*<!-- 自动生成代理  底层就是AnnotationAwareAspectJautoProxyCreator -->
	<aop:aspectj-autoproxy/>

	<bean id="userDao" class="cn.spring3.demo1.UserDao"/>
	
	<bean id="MyAspect" class="cn.spring3.demo1.MyAspect"/>

• 第五步，编写测试类

package cn.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author NOP
 * 自动方式代理没有切点切面的增强
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {
	@Autowired
	@Qualifier("userDao")
	private UserDao userDao;
	
	@Test
	public void demo1(){
		System.out.println("-----------------");
		userDao.add();
		System.out.println("-----------------");
		userDao.find();
		System.out.println("-----------------");
		userDao.delete();
		System.out.println("-----------------");
		userDao.update();
		System.out.println("-----------------");
	}
}
测试结果：
-----------------
前置增强...execution(void cn.spring3.demo1.UserDao.add())
添加客户
-----------------
查询客户
后置增强...方法的返回值fanhuizhi
-----------------
环绕前增强...
删除客户
最终通知
不跑了出异常了.../ by zero

• AspectJ的通知类型:
  • @Before 前置通知，相当于BeforeAdvice
    • 就在方法之前执行.没有办法阻止目标方法执行的.
  • @AfterReturning 后置通知，相当于AfterReturningAdvice
    • 后置通知,获得方法返回值.
  • @Around 环绕通知，相当于MethodInterceptor
    • 在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.
  • @AfterThrowing抛出通知，相当于ThrowAdvice
  • @After 最终final通知，不管是否异常，该通知都会执行
  • @DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)
• 切点的定义:
  • @Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))") private void myPointcut(){}

面试:

• Advisor和Aspect的区别?
  • Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.
  • Aspect:可以支持多个切点和多个通知的组合

---

基于XML

• 第一步:编写被增强的类:
  • ProductDao

package cn.spring3.demo2;

public class ProductDao {

	public void add() {
		// TODO Auto-generated method stub
		System.out.println("添加商品");
	}

	public void delete() {
		// TODO Auto-generated method stub
		System.out.println("删除商品");

	}

	public void find() {
		// TODO Auto-generated method stub
		System.out.println("查询商品");
		int i = 1 / 0;
	}

	public String update() {
		// TODO Auto-generated method stub
		System.out.println("修改商品");
		return "woshitest";
	}

}

• 第二步:定义切面

package cn.spring3.demo2;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * @author NOP
 * 切面类
 */
public class MyAspectXML {
	/*
	 * 
	 */
	public void before(){
		System.out.println("前置增强");
	}
	

	public void afterReturning(Object returnVal){
		System.out.println("后置增强"+returnVal);
	}
	

	public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
		System.out.println("环绕前增强");
		Object obj = proceedingJoinPoint.proceed();
		System.out.println("环绕后增强");
		return obj;
	}
	
	public void afterThrowing(Throwable ex){
		System.out.println("不跑了出异常了..."+ex.getMessage());
	}
	
	public void after(){
		System.out.println("最终通知");//不管有没有异常都会通知
	}
}

• 第三步:配置applicationContext.xml

<!-- 定义被增强的类 -->
	<bean id="productDao" class="cn.spring3.demo2.ProductDao"/>
	
	<!-- 定义切面 -->
	<bean id="myAspectXML" class="cn.spring3.demo2.MyAspectXML"/>
	
	<!-- 定义aop配置 -->
	<aop:config>
		<!-- 定义切点： -->
		<aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
		
		<!-- 定义切点： -->
		<aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.update(..))" id="mypointcutar"/>
		
		<!-- 定义切点： -->
		<aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.delete(..))" id="mypointcutaar"/>
		
		<!-- 定义切点： -->
		<aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.find(..))" id="mypointcutaat"/>
		
		<aop:aspect ref="myAspectXML">
			<!-- 前置通知-->
			<aop:before method="before" pointcut-ref="mypointcut"/> 
			
			<!-- 后置通知 -->
			<aop:after-returning method="afterReturning" pointcut-ref="mypointcutar" returning="returnVal"/>
			
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="mypointcutaar"/>
			
			<!-- 异常通知 -->
			<aop:after-throwing method="afterThrowing" throwing="ex" pointcut-ref="mypointcutaat"/>
			
			<!-- 最终通知//不管有没有异常都会通知 -->
			<aop:after method="after"  pointcut-ref="mypointcutaat"/>
		</aop:aspect>
	</aop:config>

• 第四步:编写测试类

package cn.spring3.demo2;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest2 {
	@Autowired
	@Qualifier("productDao")
	private ProductDao productDao;
	
	@Test
	public void demo1(){
		System.out.println("-----------------");
		productDao.add();
		System.out.println("-----------------");
		productDao.find();
		System.out.println("-----------------");
		productDao.delete();
		System.out.println("-----------------");
		productDao.update();
		System.out.println("-----------------");
	}
}

测试结果：
-----------------
前置增强
添加商品
-----------------
查询商品
不跑了出异常了.../ by zero
最终通知