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 切面类：就是切点与增强结合 * 前置增强 */@Aspectpublic 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.SpringJUnit4Cla***unner;/** * @author NOP * 自动方式代理没有切点切面的增强 */@RunWith(SpringJUnit4Cla***unner.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.SpringJUnit4Cla***unner;@RunWith(SpringJUnit4Cla***unner.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最终通知