第三章 AOP 面向切面的编程

作者: 水墨九 | 来源:发表于2022-01-02 16:11 被阅读0次

3.1 增加功能，导致的一些问题

1、源代码中、业务方法中增加的功能
1）源代码改动的比较多
2）重复代码比较多
3）代码难以维护

3.2 AOP概念

3.2.1 什么是AOP

AOP(Aspect Orient Programming):面向切面编程

Aspect:表示切面，给业务方法增加功能，叫做切面。切面一般都是非业务功能，而且切面功能一般都是可以复用的。例如：日志、事务、权限检查、参数检查、统计信息等
Orient:面向、对着
Programming:编程
怎么理解面向切面编程？（以切面为核心，设计开发你的应用）
设计项目的时候，找出切面的功能。
安排切面的执行时间、位置

3.2.2 AOP的作用

1）让切面功能复用
2）让开发人员专注于业务逻辑、提高开发效率
3）实现业务功能和非业务功能解耦合
4）给存在的业务方法增加功能，不用修改原来的代码

3.2.3 AOP中的一些术语

1） Aspect：切面，给业务方法增加的功能
2）JoinPoint:连接点，连接切面的业务方法，在这个业务方法执行时，同时执行这个切面的功能
3）PointCut:是一个或多个连接点的集合，表示这些方法执行时，都能去增加切面的功能。表示切面执行的位置
4）target:目标对象，给哪个对象增加切面方法，这个对象就是目标对象
5）Advice:通知（IT术语：增强），表示切面的执行时间，在目标方法之前执行切面，还是在目标方法之后执行。
AOP中三个重要的要素：
Aspect、PointCut、Advice。这个概念的理解是：在Advice的时间，在PointCut的位置执行Aspect
AOP是一个动态的思想，在程序执行期间，创建代理（ServiceProxy），使用代理执行方法时，增加切面的功能，这个代理对象时存在内存中的

3.2.4 什么时候用AOP

你要给某些方法，增加一些相同的功能，源代码不能改，给业务方法增加非业务功能。

3.2.5 AOP技术思想的实现

使用框架实现AOP，实现AOP的框架很多，比较著名的有两个：
1）Spring:Spring框架实现AOP思想中的部分功能，Spring框架实现AOP的操作比较繁琐、比较重
2）AspectJ:一个独立的框架，专门做AOP的。属于Eclipse基金会的

3.3 使用AspectJ框架实现AOP

Aspectj框架可以使用注解和xml配置文件两种方式实现AOP

3.3.1 通知

Aspectj表示起么的执行时间，用的通知（Advice)。这个通知可以用注解表示.
讲5个注解，表示切面的5个执行时间，这些注解叫做通知注解
@Before:前置通知
@AfterReturning:后置通知
@Aroud:环绕通知
@AfterThrowing:异常通知
@After：最终通知

3.3.2 PointCut 位置

PointCut用来表示切面执行的位置，使用AspectJ中切入点表达式
切入点表达式语法：execution(访问权限方法的返回值方法声明（参数）异常类型)

3.3.3 @Before 前置通知

 /**
     * 切面类中的通知方法，是可以有参数的
     * JointPoint必须是他
     * JointPoint：表示正在执行的业务方法，相当于反射中的Method
     *      使用要求：必须是参数列表中的第一个
     *      作用：获取方法执行时的信息，例如：方法的名称、参数集合（如果想要在切面类中，获取方法的信息，则需要加这个）
     */
    @Before(value = "execution(* *..SomeServiceImpl.do*(..) )" )
    public void  myBefore2(JoinPoint joinPoint){
        //获取方法的定义
        System.out.println("前置通知中，获取目标方法的定义："+joinPoint);
        System.out.println("前置通知中，获取目标方法的名称："+joinPoint.getSignature().getName());

        Object args[] = joinPoint.getArgs();
        for (Object arg : args) {
            System.out.println("获取方法执行时候的参数："+arg);
        }


        String methodName = joinPoint.getSignature().getName();
        if ("doSome".equals(methodName)){
            System.out.println("doSome=========");
        }else if ("doOther".equals(methodName)){
            System.out.println("doOther========");
        }

    }

3.3.4 后置通知@AfterReturning

@AfterReturning：在目标方法之后执行

 /**
     * 后置通知方法的定义：
     *  1)方法是public的
     *  2）方法是void
     *  3)方法名称自定义
     *  4）方法有参数，推荐使用object类型
     */
    /**
     * @AfterReturning:后置通知
     *      属性：
     *          value:切入点表达式
     *          returning：自定义的变量，表示目标方法的返回值
     *                     自定义变量名称必须和通知方法的形参名一样
     *      特点：
     *      1、在目标方法之后执行
     *      2、能获取到目标方法的执行结果
     *      3、不会影响目标方法的执行
     *  方法的参数：
     *  Object res：表示目标方法的返回值，使用res接收方法的调用结果
     *
     *  后置通知的执行顺序
     *  Object res = SomeServiceImpl.doOther(..);
     *  myAfterReturning(res)
     *
     * 方法返回的是String、Integer、Long等基本类型，在后置通知中，修改返回，是不会影响目标方法的最后调用结果的
     * 如果返回的是对象类型，例如：Student,在后置方法中，修改这个Student对象的属性值，会影响最后的调用结果
     */
    @AfterReturning(value = "execution(* *..SomeServiceImpl.do*(..))",returning = "res")
    public void myAfterReturning(JoinPoint jp,Object res){
        System.out.println("后置通知，在目标方法之后执行的，能拿到执行结果:"+res);
        //Object res有什么用，可以根据返回值得不同，做不同的增强功能
        if (null != res){
            res = "Hello";
        }
        System.out.println("后置通知，在目标方法之后执行的，拿到执行的结果："+res);
    }

3.3.5 @Around环绕通知

@Around(value="切入点表达式")
使用环绕通知时，就是调用我们切面类中的通知方法

package com.wh.ch09aspectaround.handle;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

import java.util.Date;

/**
 * @Author :wanghui
 * @Date 2022/1/2 - 9:35
 */
@Aspect
public class MyAspect {
    /**
     * 焕荣通知设置：
     * 1、方法是public
     * 2、方法必须有返回值，推荐使用Object类型
     * 3、方法名称自定义
     * 4、方法必须有ProceedingJoinPoint参数
     */
    /**
     * @Around:环绕通知
     * 属性：
     *  value:切入点表达式
     *  位置：方法定义的上面
     *返回值：Object:表示调用目标方法，期望的执行结果，但是这个结果不一定是目标方法自己的返回值
     *参数：ProceedingJoinPoint,相当于反射中的method
     *     作用：执行目标方法的，等于Method.invoke()
     * 特点：
     * 1、在目标方法的前和后，都能增强功能
     * 2、控制目标方法是否执行
     * 3、可以修改目标方法的执行结果
     *
     */
    @Around("execution(* *..SomeServiceImpl.doFirst(..))")
    public Object myAroud(ProceedingJoinPoint pjp) throws Throwable {

        //执行目标方法
        Object methodReturn = null;
        System.out.println("执行了环绕通知的MyAround方法,在目标方法之前，输出日志时间==="+new Date());
        methodReturn =   pjp.proceed();//method invoke,表示执行doFirst()方法本身
        System.out.println("环绕通知，在目标方法之后，输出日志时间："+new Date());

        //返回目标方法的执行结果
        return  methodReturn;
    }
}

能否说一个前置通知+一个后置通知就等于一个环绕呢？
答案是不可以的
环绕可以控制方法的返回值，而前置、后置没法。可以模拟在方法前后加返回值。

3.3.6 @AfterThrowing异常通知

语法：@AafterThrowing(value="切入点表达式",throwing="自定义变量")

package com.wh.ch09aspectaround.handle;


import org.aspectj.lang.ProceedingJoinPoint;
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 java.util.Date;

/**
 * @Author :wanghui
 * @Date 2022/1/2 - 9:35
 */
@Aspect
public class MyAspect{
    /**
     * 异常通知方法的定义：
     * 1、方法是public
     * 2、方法是没有返回值的，是void的
     * 3、方法名称自定义
     * 4、方法有参数是Exception
     */
    /**
     * @AfterThrowing:是异常通知’
     * 属性：value:切入点表达式
     *      throwing:自定义变量，表示目标方法抛出的异常，变量名必须和通知方法的形参名一样
     * 位置：在方法的上面
     *
     * 特点：
     * 1、在目标方法抛出异常后执行的，没有异常不执行
     * 2、能够获取目标方法的异常信息
     * 3、不是异常处理程序，可以得到发生异常的通知，可以发送邮件、短信等通知开发人员
     *    可以看做是目标方法的监控程序
     * 异常通知的执行
     * try{
     *     SomeServiceImpl.doSecond(..)
     * }catch(Exception e){
     *      myAfterThrowing(e)
     * }
     */
    @AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",throwing="ex")
    public void myAfterThrowing(Exception ex){
        System.out.println("异常通知，在目标方法抛出异常时候执行的，异常原因为："+ex.getMessage());
        /**
         * 异常发生时：
         * 1、记录异常发生的时间、位置等信息
         * 2、发送邮件、短信等通知开发人员
         */

    }
}

3.3.7@After 最终通知

语法：@After（value="切入点表达式"）

package com.wh.ch11after.handle;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

import java.util.Date;

/**
 * @Author :wanghui
 * @Date 2022/1/2 - 9:35
 */
@Aspect
public class MyAspect{
    /**
     * 最终通知方法的定义：
     * 1、方法是public
     * 2、方法是没有返回值的，是void的
     * 3、方法名称自定义
     * 4、方法有参数是Exception
     */

    /**
     * @After:最终通知
     * 属性：value:切入点表达式
     * 位置：在方法的上边
     *
     * 特点：
     * 1、在目标方法之后执行的
     * 2、总是会被执行
     * 3、可用用来做程序最后的收尾工作，例如：清楚临时数据、变量、清理内存
     *
     * 最终通知
     * try{
     *     业务方法
     * }finally{
     *     myAfter
     * }
     */
    @After(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public void myAfter(){
        System.out.println("最终通知，总是会被执行");
    }
}

3.3.8 @Pointcut

定义和管理切入点的注解
@PointCcut(value="切入点表达式")

package com.wh.handle;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

import java.util.Date;

/**
 * @Author :wanghui
 * @Date 2022/1/2 - 9:35
 */
@Aspect
public class MyAspect{

    @Before(value = "mypt()")
    public void myBefore(){
        System.out.println("前置方法=========");
    }

    @After(value = "mypt()")
    public void myAfter(){
        System.out.println("最终通知，总是会被执行");
    }

    /**
     * @pointcut:管理和定义切入点的，不是通知注解
     * 属性：value,切入点表达式
     * 位置，在一个自定义方法的上面，这个方法看做是切入点表达式的别名
     * 其他的通知注解中，可以使用方法别名，就表示使用这个切入点表达式了
     */

    @Pointcut("execution(* *..SomeServiceImpl.doThird(..))")
    public void mypt(){
        //无需代码
    }

}

3.4 AOP 总结

AOP是一种动态的思想，目的是实现业务功能和非业务功能的解耦合。业务功能是独立的模块，其他功能也是独立的模块。例如事务功能，日志功能等等。让这些事务、日志功能是可以被复用的。

当目标方法需要一些功能时，可以在不修改、不能修改源代码的情况下，使用AOP技术，在程序执行期间，生成代理对象，通过代理执行我们的业务方法，同时增加功能。