跟我重温spring---AOP(3)

1、 AspectJ的注解方式AOP的开发

具体的开发步骤

    1. 步骤一：创建JavaWEB项目，引入具体的开发的jar包

        * 先引入Spring框架开发的基本开发包，还需要引入AOP的开发包（AOP联盟和AOP的开发包）

        * 再引入AspectJ的开发包

            * 引入AOP联盟的开发包                   --com.springsource.org.aopalliance-1.0.0.jar

            * 引入Spring框架传统的AOP的开发包     -- spring-aop-3.2.0.RELEASE.jar

            * aspectj 本身jar包                        --com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

            * spring支持aspectj的包                 --spring-aspects-3.2.0.RELEASE.jar

 

    2. 步骤二：创建Spring的配置文件，引入具体的AOP的schema约束（不要忘记配置提示）

        <beans xmlns="http://www.springframework.org/schema/beans"

              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

              xmlns:aop="http://www.springframework.org/schema/aop"

               xsi:schemaLocation="

                http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd

               http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">

 

    3. 步骤三：创建包结构，编写具体的实现类代码

        * com.spring.demo1

            * OrderDaoImpl

 

    4. 步骤四：将目标类配置到Spring中

        <!-- 目标类-->

        <bean id="orderDaoImpl"class="com.spring.spring.OrderDaoImpl"/>

 

    5. 步骤五：编写切面（切面 = 通知 + 切入点），所以需要先来了解通知的类型和切入点的表达式定义！！

        1. AspectJ的通知类型如下

            @Before                 -- 前置通知，相当于BeforeAdvice

            @AfterReturning         -- 后置通知，相当于AfterReturningAdvice

            @Around                 -- 环绕通知，相当于MethodInterceptor

            @AfterThrowing          -- 抛出通知，相当于ThrowAdvice

            @After                  -- 最终final通知，不管是否异常，该通知都会执行

 

        2. AspectJ的切入点表达式定义：就是用来限制哪些类的哪些方法需要进行增强！！

            * 如果想完成切入点的定义，需要大家来了解 execution(切入点表达式)的函数，括号中就是具体的表达式的写法

            * execution(切入点表达式)的函数的语法

 

        3. 编写切面代码

            @Aspect

            public class MyAspectAnno {

               @Before(value="execution(public *com.spring.demo1.OrderDaoImpl.save(..))")

                public void before(){

                    System.out.println("前置通知...");

                }

            }

 

            在核心的配置文件中，配置切面类

            <!-- 配置切面 -->

            <beanid="myAspectAnno"class="com.spring.demo1.MyAspectAnno"/>

 

    6. 步骤六：在核心的配置文件中开启AspectJ的注解的自动代理

        <!-- 开启自动代理-->

        <aop:aspectj-autoproxy/>

 

    7. 步骤七：编写测试代码

        @RunWith(SpringJUnit4ClassRunner.class)

       @ContextConfiguration("classpath:applicationContext.xml")

        public class Demo1 {

           @Resource(name="orderDaoImpl")

            private OrderDaoImpl orderDaoImpl;

            @Test

            public void run(){

                orderDaoImpl.save();

            }

        }

 

2、 注解方式通知类型的使用

AspectJ的注解方式完成AOP的开发

a. 前置通知:

    * @Before       -- 代表在目标方法之前执行增强.

    * 前置通知中有一个参数:Joinpoint:获得切入点信息.

 

b. 后置通知:

    * @AfterReturing        -- 代表在目标方法之后执行增强.

    * 可以获得到目标方法的返回值，需要在注解中添加returning="result"属性

    * 代码:

        // 后置通知:

        @AfterReturning(value="execution(*com.spring.spring.demo1.OrderDao.update(..))",returning="result")

        public void afterReturing(Objectresult){

            System.out.println("后置通知================"+result);

        }

 

c. 环绕通知:

    * @Around       -- 代表在目标方法之前和之后执行增强.

    * 用来阻止目标方法执行，需要使用ProceedingJoinPoint对象作为参数！！

    * 代码:

        // 环绕通知:

        @Around("execution(*com.spring.spring.demo1.OrderDao.delete(..))")

        public Object around(ProceedingJoinPointjoinPoint) throws Throwable{

            System.out.println("环绕前通知===============");

            // 执行目标方法:

            Object obj = joinPoint.proceed();

            System.out.println("环绕后通知===============");

            return obj;

        }

 

c. 异常抛出通知:

    * @AfterThrowing        -- 代表在目标方法出现异常的时候执行增强.

    * 获得到异常的信息.

    * 代码:

        // 异常抛出通知:

        @AfterThrowing(value="execution(*com.spring.spring.demo1.OrderDao.find(..))",throwing="e")

        public void afterThrowing(Throwable e){

            System.out.println("异常抛出通知=============="+e.getMessage());

        }

 

e. 最终通知

    * @After        -- 代表无论目标方法是否出现异常.这种通知总是会执行的.类似try{}catch(){}finally{}

    * 代码

        // 最终通知

        @After(value="execution(*com.spring.spring.demo1.OrderDao.find(..))")

        public void after(){

            System.out.println("最终通知================");

        }

 

3、 切入点的定义

1. 概述

    * 可以在切面的类中来定义切入点的方法，这样做的好处是在具体的通知方法中直接引入切入点，程序维护最简单！！

 

2. 相关的代码

    @Pointcut(value="execution(* com.spring.spring.demo1.OrderDao.find(..))")

    private void myPointcut(){}

 

3. 在通知的方法中引入切入点

    * @Around(value="切面类名.切入点的方法()")

    * 例如：@Around(value="MyAspectjAnno.myPointcut()")