AOP自学自讲

AOP

参考来源

B站up主java学习者的教学视频

概念及作用

AOP(Aspect Orient Programming)，面向切面编程，从动态角度考虑程序运行过程，可通过运行期动态代理实现程序重要功能的统一维护的一种技术。
利用AOP可以对业务逻辑的各个部分进行隔离，降低耦合度，提高重用性和开发效率。

给业务方面增加的功能，叫做Aspect(切面)，一般为非业务功能，且可复用的。例如日志功能，事务功能，权限检查，参数检查，统计信息等等。

编程思路

1. 找出需要可当作切面来处理的功能
2. 安排切面实行的时间、位置、顺序。

相关术语

1. Aspect:切面，给业务方法增加的功能
2. JoinPoint:连接点，连接切面的业务方法，在这个业务方法执行时，会同时执行切面的功能
3. PointCut:切入点，是一个或多个连接点集合。表示这些方法执行时，都能增加切面的功能。表示切面执行的位置
4. target:目标对象，给哪个对象增加切面功能，哪个就是目标对象
5. Advice:通知（增强），表示切面的执行时间，在目标方法之前还是之后。

AOP中重要的三个要素

Aspect,PointCut,Advice
连起来就是，在Advice的时间，在PointCut的位置，执行Aspect。

AOP是一种动态的思想。在程序运行期间，创建代理（ServiceProxy），使用代理执行方法时，增加功能。
这个代理对象是存在内存中的。

使用AspectJ框架实现AOP

AspectJ是独立的框架，专门做AOP这方面。
有注解和xml配置文件两种方式实现
我们这里是用注解来实现

Advice 通知

表示执行时间，五个注解
@Before:前置通知，方法执行前执行
@After:后置通知，方法执行后执行
@Around:环绕通知，围绕着方法执行
@AfterThrowing:异常通知，方法抛出异常之后执行
@AfterReturning:返回通知，方法返回结果后执行

PointCut 切入点

表示执行位置，使用切入点表达式
语法：execution(方法的定义)
方法的定义包括

1. 访问权限类型
2. 返回值类型
3. 包名类名
4. 方法名（所有参数类型和个数）
5. 抛出异常类型

之间空格分开，加粗代表必须写

以下三"."的地方均为两“.”

符号	意义
*	0至多个任意字符
…	用在方法参数中，表示任意多个参数用在包名后，表示当前包及其子包路径
+	用在类名后，表示当前类及其子类，用在接口后，表示当前接口及其实现类

execution(public * *(…))
指定切入点为：任意公共方法。

第一个 * 代表返回值，第二个 * 代表方法名，…代表任意参数类型及个数

execution(* set*(…))
指定切入点为：任意以“set”开始的方法。

execution(* com.blumson.service… * .*(…))
指定切入点为：定义在service包或者子包里的任意类的任意方法。

“…”出现在类名中是，后面必须跟“*”，表示包、子包下的所有类。

execution(* …service..*(…))
指定切入点为：所有包下的service子包下的所有类（接口）中所有方法

实现通知步骤

以前置通知为例

项目结构如图

1. 新建maven项目

2. 修改pom.xml 加入依赖（spring-aspects依赖，junit）

<dependencies>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.5.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-aspectsartifactId>
            <version>5.2.5.RELEASEversion>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.11version>
            <scope>testscope>
        dependency>
    dependencies>

3. 创建业务接口和实现类

实现类SomeServiceImpl.java

public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String name, Integer age) {
        System.out.println("业务方法doSome(),创建商品订单");
    }
}

4. 创建一个叫做切面类的普通类

1）在类的上面加入@Aspect，表示当前类为一个切面类
2）在类中定义方法，方法表示切面的功能。

/*
前置通知方法的定义：
1）方法权限是public
2）返回值是void
3）名称自定义
4）可以有参数，为JoinPoint，也可以没有
*/

3）在方法的上面加入AspectJ框架中的通知注解，例如@Before(value=“切入点表达式”)

@Aspect
public class MyAspect {
    @Before(value = "execution(void com.blumson.service.impl.SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(){
        System.out.println("切面前置通知，"+new Date()+"执行");
    }
}

5. 创建spring配置文件

1）声明目标对象
2）声明切面类对象
3）声明自动代理生成器
applicationContext.xml

    <bean id="someService" class="com.blumson.service.impl.SomeServiceImpl"/>

    
    <bean id="myAspect" class="com.blumson.controller.MyAspect"/>

    
    <aop:aspectj-autoproxy />

6. 创建测试类，测试目标方法执行时，增加切面的功能

MyTest.java

public class MyTest {
    @Test
    public void text1(){
        String config = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        SomeService service = (SomeService) applicationContext.getBean("someService");
        //代理对象，调用方法，切面功能增强
        service.doSome("smallHe",19);
    }
}

得到代理对象（service）

测试结果

如果添加很多个前置通知方法，这些方法之间的顺序不确定

JoinPoint

用于在通知方法中获取目标方法的的相关信息

@Aspect
public class MyAspect {
    @Before(value = "execution(void com.blumson.service.impl.SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("切面前置通知，"+new Date()+"执行");
        System.out.println("获取目标方法定义："+joinPoint.getSignature());
        System.out.println("获取目标方法名称："+joinPoint.getSignature().getName());
        Object args []= joinPoint.getArgs();
        for (Object object:args){
            System.out.println("获取目标方法参数"+object);
        }
    }
}

输出结果

于是可以在execution用通配符，对应多个方法时进行筛选不同的方法执行不同的增强功能。
在MyAspect.java中

//可以利用这点对不同目标方法进行筛选
    String methodName = joinPoint.getSignature().getName();
    if("doSome".equals(methodName)){
        System.out.println("切面前置通知，"+new Date()+"执行");
    }

@AfterReturning返回通知

属性：

• value：切入点表达式
• returning：自定义的变量，表示目标方法的返回值，名称必须与通知方法的形参名一样，推荐参数类型为Object。

这个参数就是目标方法的返回值。
1.如果这个返回值是基本类型，在通知方法中修改了这个返回值，不会影响目标方法的返回值。
2.如果这个返回值是对象类型，在通知方法中修改了这个返回值，会影响目标方法的返回值。

证明一下第二条
someServiceImpl.java添加了如下目标方法

public User doReturn() {
        System.out.println("业务方法doReturn(),添加用户信息");
        User user = new User();
        user.setId(1);
        user.setUsername("smallHe");
        user.setPassword("123456");
        return user;
    }

MyAspect.java添加了如下通知方法

@AfterReturning(value = "execution(* com.blumson.service.impl.SomeServiceImpl.doReturn())",returning="ret")
    public void myReturn(Object ret){
        User user = (User)ret;
        user.setPassword("123");
        System.out.println("执行了返回通知");
        System.out.println("修改了返回值为："+user.getPassword());
    }

MyTest.java添加了如下测试方法

@Test
    public void test2(){
        String config = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        SomeService service = (SomeService) applicationContext.getBean("someService");
        User user = service.doReturn();
        System.out.println("test02中调用方法的结果："+user.getPassword());
    }

测试结果如图所示，由此可证

我们可以对返回值进行判断，来执行不同的增强功能。
还有一点需要注意，就是通知方法要用到JoinPoint 时，它必须是通知方法的第一个参数。不然会报错。
其余和@Before用法类似。

@Around环绕通知（最重要）

该通知方法必须有返回值，有ProceedingJoinPoint参数

它只有value属性，可省略value=

• 返回值类型：Object
  表示调用目标方法希望得到的执行结果（不一定是目标方法自己的返回值）
• ProceedingJoinPoint参数：
  相当于反射中Method，作用是执行目标方法，等同于Method.invoke()

ProceedingJoinPoint类继承自JoinPoint类，有继承JoinPoint类的方法，可实现JoinPoint有的功能。

• 环绕通知作用：

1. 在目标方法的前和后都能增强功能
2. 控制目标方法是否执行
3. 修改目标方法的执行结果

代理对象调用的目标方法=调用通知方法本身->得到的返回值是通知方法的返回值

如果想要执行真正的目标方法本身，就需要用到ProceedingJoinPoint类型参数的proceed()方法

• 这个方法的返回值可以用Object接收，如果通知方法return这个Object对象的话，返回的是真正目标方法本身的返回值。
• 于是可以通过目标方法的返回值来进行判定是否执行一些增强功能，以及更改返回值。
• 并且可以通过是否执行proceed()方法来控制目标方法是否执行。

我们来用代码证明一下以上内容
SomeServiceImpl.java添加如下方法

@Override
    public User doAround() {
        System.out.println("业务方法doAround()");
        User user = new User();
        user.setId(1);
        user.setUsername("smallHe");
        user.setPassword("123456");
        return user;
    }

MyAspect.java添加如下方法

@Around("execution(* com.blumson.service.impl.SomeServiceImpl.doAround())")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕在前");
        User user1 = new User();
        if("doAround".equals(proceedingJoinPoint.getSignature().getName())){
            user1 = (User) proceedingJoinPoint.proceed();//在方法名为doAround时执行目标方法
        }else {
            System.out.println("方法不符");
        }
        System.out.println("环绕在后");
        User user = new User();
        user.setId(2);
        user.setUsername("bigHe");
        user.setPassword("123");
        return user;
//        return user1;
//        返回目标方法的返回对象
    }

MyText.java

@Test
    public void test3(){
        String config = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        SomeService service = (SomeService) applicationContext.getBean("someService");
        User user = service.doAround();
        System.out.println("id="+user.getId()+"\n"+"username="+user.getUsername()+"\n"+"password="+user.getPassword());
    }

MyAspect.java中添加方法返回的是user时测试结果

MyAspect.java中添加方法返回的是user1时测试结果

由测试结果得证。

@AfterThrowing异常通知（了解）

• 基本语法格式：@AfterThrowing(value=“切入点表达式”,throwing=“自定义变量”)

自定义变量表示目标方法抛出的异常，变量名需要与通知方法形参名一样

• 方法无返回值，是void
• 方法有参数，是Exception
• 作用：

1. 在目标方法抛出异常后执行，无异常不执行
2. 能获取到目标方法的异常信息
3. 非异常处理程序。可得到发生异常的通知，发送邮件、短信通知开发人员，看作是目标方法的监控程序

类似于
try{目标方法}catch(Exception e){异常通知方法(e)}

@After最终通知（了解）

特点：

• 可以用来做程序收尾工作。例如清除临时数据，变量，清理内存
• 方法无参数
• 在目标方法之后执行，且总是会被执行（有异常也会被执行）

类似于
try{目标方法}finally{最终通知方法}

其余和@Before差不多

@Pointcut定义切入点

定义和管理切入点，不是通知注释

• 属性：value=“该方法的切入点表达式”
• 位置：在一个自定义方法上面，这个方法的名称（例：doget()）将看作是它对应的切入点表达式的别名，在通知注解中就能直接写这个别名来对应目标方法。
  这个自定义方法需要和通知方法在同一个类里面。

    @AfterReturning(value = "doRet()",returning="ret")
    public void myReturn(Object ret){
        User user = (User)ret;
        user.setPassword("123");
        System.out.println("执行了返回通知");
        System.out.println("修改了返回值为："+user.getPassword());
    }
    @Pointcut("execution(* com.blumson.service.impl.SomeServiceImpl.doReturn())")
    public void doRet(){
        //无需代码
    }