面向切面:AOP

面向切面:AOP

大家好,今天本篇博客我们来了解Spring里边的另一个重要部分,叫做AOP,也就是我们说的面向切面编程。

1、场景模拟

首先第一部分,咱们做一个场景模拟。我们先写一个简单的例子,然后通过例子引出我们的问题。

咱们写一个简单的计算器的例子,就做一个加减乘除的功能。

然后把例子写完之后,在加减乘除的每个方法中分别添加上日志。

就是在你的方法之前,还有之后每个里边都加上日志。然后这个之后我们会看到代码中的问题,咱们分析问题,然后提出解决方案。

搭建子模块:spring6-aop

1.1 声明接口

声明计算器接口Calculator,包含加减乘除的抽象方法

package com.jie.aop.service;

/**
 * 计算器接口
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/10/30 4:16
 */
public interface CalculatorService {

    /**
     * 加法
     *
     * @param i
     * @param j
     * @return: int
     * @date: 2023/10/30 4:16
     */
    int add(int i, int j);

    /**
     * 减法
     *
     * @param i
     * @param j
     * @return: int
     * @date: 2023/10/30 4:16
     */
    int sub(int i, int j);

    /**
     * 乘法
     *
     * @param i
     * @param j
     * @return: int
     * @date: 2023/10/30 4:16
     */
    int mul(int i, int j);

    /**
     * 除法
     *
     * @param i
     * @param j
     * @return: int
     * @date: 2023/10/30 4:16
     */
    int div(int i, int j);

}

1.2 创建实现类

package com.jie.aop.service.impl;

import com.jie.aop.service.CalculatorService;

/**
 * 计算器接口实现类
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/10/30 4:24
 */
public class CalculatorServiceImpl implements CalculatorService {
    @Override
    public int add(int i, int j) {

        int result = i + j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int sub(int i, int j) {

        int result = i - j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int mul(int i, int j) {

        int result = i * j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int div(int i, int j) {

        int result = i / j;

        System.out.println("方法内部 result = " + result);

        return result;
    }
}

1.3 创建带日志功能的实现类

面向切面:AOP_第1张图片

package com.jie.aop.service.impl;

import com.jie.aop.service.CalculatorService;

/**
 * 带日志的计算器接口实现类
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/10/30 4:27
 */
public class CalculatorLogImpl implements CalculatorService {

    @Override
    public int add(int i, int j) {

        System.out.println("[日志] add 方法开始了,参数是:" + i + "," + j);

        int result = i + j;

        System.out.println("方法内部 result = " + result);

        System.out.println("[日志] add 方法结束了,结果是:" + result);

        return result;
    }

    @Override
    public int sub(int i, int j) {

        System.out.println("[日志] sub 方法开始了,参数是:" + i + "," + j);

        int result = i - j;

        System.out.println("方法内部 result = " + result);

        System.out.println("[日志] sub 方法结束了,结果是:" + result);

        return result;
    }

    @Override
    public int mul(int i, int j) {

        System.out.println("[日志] mul 方法开始了,参数是:" + i + "," + j);

        int result = i * j;

        System.out.println("方法内部 result = " + result);

        System.out.println("[日志] mul 方法结束了,结果是:" + result);

        return result;
    }

    @Override
    public int div(int i, int j) {

        System.out.println("[日志] div 方法开始了,参数是:" + i + "," + j);

        int result = i / j;

        System.out.println("方法内部 result = " + result);

        System.out.println("[日志] div 方法结束了,结果是:" + result);

        return result;
    }
}

1.4 提出问题

就以这个带日志这个代码为例,咱们现在来分析这个代码中它会有什么问题。

面向切面:AOP_第2张图片

①现有代码缺陷

各位注意,我刚才提到这两个输出代表的是不是日志功能,但是大家明确这个日志跟核心的业务是不是没有关系。

就是我现在可以这么理解,没有日志这功能是不是也能做,有日志之后可以让它信息输出的更完整,但是没有日志对我核心功能没有影响。

但是你看现在问题是什么?我的日志跟核心功能它们是不是混合到一起了?

不管你是加减乘除里边是不是都这么做的,那这个时候我们在写代码的时候会有一个问题,我们既要关心核心业务,也要关注这个日志的一个业务。但是它里边核心业务跟它因为混到一起了,所以造成里边维护起来是不是特别不方便。

那这个时候我们肯定想这么做,让我们的核心功能和核心代码跟我的日志要分离出来。但是目前没有分离,他们是整合到一起了,给它混到一起来写的。

这么做不管你是从代码的可维护性,还是代码的各方面来看,它肯定是特别混乱的。

②解决思路

所以我们对他要进行一个完善,那怎么完善呢?核心就是:解耦。

思路很明确,让核心业务或者核心代码和日志的功能给它分离出来。

③困难

现在这个日志具体到了我们的每个方法里边,每个方法中都做了日输出,都是在之前之后。

而这个时候如果按照普通方式,比如咱们写一个工具类,然后做这个过程,它好像并不能做到。

因为它是渗透到你的方法内部,在核心的方法业务的前后做这个过程。

所以咱要把它把核心业务和日志分离出来,用原始方式就没法做到了。

这个时候咱需要用到一个新的技术才能实现。那技术是什么呢?

2、代理模式

2.1、概念

①介绍

代理是一种二十三种设计模式中的一种,属于结构型模式。

它的作用是什么呢?

大家可以这么理解,我们提供一个代理类,让我们调用目标方法的时候,不是直接调用,而是通过代理类间接调用,这个过程就叫做代理模式。

那具体怎么理解?大家看这张图里面画的,这里没有使用代理模式。咱直接调方法。

面向切面:AOP_第3张图片

比如我现在我想做一个加的操作,直接调A的方法,想做减操作,想做乘,想做除,那就直接调这方法,这是我们的普通方式。

但是有了代理模式之后,咱们怎么来做?大家看这过程。

面向切面:AOP_第4张图片

我们调的时候并不是直接调你的具体方法,调什么?调你的代理对象。

通过代理对象或者代理类去间接调用咱们的目标方法,最终得到结果。

大家看这张图里边,咱们调用目标方法,比如说调这个加减乘除这个方法,那怎么做?先去经过你的代理,然后由代理返回,而内部由代理去调用他的目标方法,这个过程就叫代理模式。

②生活中的代理

  • 广告商找大明星拍广告需要经过经纪人
  • 合作伙伴找大老板谈合作要约见面时间需要经过秘书
  • 房产中介是买卖双方的代理

③相关术语

  • 代理:将非核心逻辑剥离出来以后,封装这些非核心逻辑的类、对象、方法。
  • 目标:被代理“套用”了非核心逻辑代码的类、对象、方法。

2.2 静态代理

静态你可以理解为它把里面部分都是写固定了。

创建静态代理类:

package com.jie.aop.service.impl;

import com.jie.aop.service.CalculatorService;

/**
 * 静态代理类
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/10/30 4:49
 */
public class CalculatorStaticProxy implements CalculatorService {
    
    @Override
    public int add(int i, int j) {
        return 0;
    }

    @Override
    public int sub(int i, int j) {
        return 0;
    }

    @Override
    public int mul(int i, int j) {
        return 0;
    }

    @Override
    public int div(int i, int j) {
        return 0;
    }
}

然后代理类之中要怎么做呢?我们刚才提到了,因为我代理类最终要调目标方法,所以我们把被代理的目标对象给他要传入进来,那怎么传呢,通过构造方法把它进行传递。

面向切面:AOP_第5张图片

下面在里边我们可以写这个具体过程。我们就以添加为例,在添加中怎么做?比如我现在我要加上我的日志,那咱们来做个实现。这个日志就是我们那个非核心功能。

面向切面:AOP_第6张图片

然后写完之后,大家看这个代码,虽然说咱们写完了,针对于我们这个目标对象确实做到了解耦操作。

就是这里边你看核心业务中没有什么干扰代码。

面向切面:AOP_第7张图片

然后把干扰代码都放到咱这个代理类中进行实现。但是它有一些致命的缺陷。

我这代码是不是写固定了,或者说写死了。

就拿日志来讲,这个日志,如果后面在其他的代码里也要用到,那是不是需要再加个代理类实现?

也就是说我这个日志功能其实并没有给它抽取出来。如果再有相关功能,那还要写代理类进行实现。所以这个方式它并不好,它里面就是并没有做到一个真正的灵活性。

提出进一步的需求:将日志功能集中到一个代理类中,将来有任何日志需求,都通过这一个代理类来实现。这就需要使用动态代理技术了。

2.3 动态代理

动态代理它是怎么一个过程呢?咱们把这张图先看一下,然后咱用代码具体把动态代理做个实现。

面向切面:AOP_第8张图片

首先我们肯定也是建个代理类,但是它跟静态代理的最大区别是什么呢?

我们不需要每个部分或者说每个功能中都建个静态代理类,咱只需要动态创建一个,不管你是什么目标或者目标对象,为它建这么一个代理类。

然后在里边把日志做统一管理,在操作前在操作后。而这个时候我们调方法的时候,不管你调什么方法,它都会在操作前操作后进行日志输出。

这就叫动态代理,实现了咱们达到的效果,把日志统一进行管理,不需要每个部分都建个代理类。然后他也做到了在方法前方法后进行日志的输出。

面我们用代码把这个具体做个实现。

package com.jie.aop.proxy;

import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 代理工厂类
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/10/30 6:43
 */
public class ProxyFactory {

    /**
     * 将被代理的目标对象声明为成员变量
     */
    private final Object target;

    /**
     * 通过构造器为目标对象赋值
     *
     * @param target 目标对象
     * @date: 2023/10/30 6:43
     */
    public ProxyFactory(Object target) {
        this.target = target;
    }

    /**
     * 通过动态代理创建代理对象
     *
     * @param
     * @return: java.lang.Object
     * @date: 2023/10/30 6:43
     */
    public Object getProxy() {

        /**
         * newProxyInstance():创建一个代理实例
         * 其中有三个参数:
         * 1、classLoader:加载动态生成的代理类的类加载器
         * 2、interfaces:目标对象实现的所有接口的class对象所组成的数组
         * 3、invocationHandler:设置代理对象实现目标对象方法的过程,即代理类中如何重写接口中的抽象方法
         */
        // 获取目标对象的类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        // 获取目标对象实现的所有接口的class对象所组成的数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
        // 设置代理对象实现目标对象方法的过程,即代理类中如何重写接口中的抽象方法
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy,
                                 Method method,
                                 Object[] args) {
                /**
                 * proxy:代理对象
                 * method:代理对象需要实现的方法,即其中需要重写的方法
                 * args:method所对应方法的参数
                 */
                Object result = null;
                try {
                    System.out.println("[动态代理][日志] " + method.getName() + ",参数:" + Arrays.toString(args));
                    // 调用目标对象的方法
                    result = method.invoke(target, args);
                    System.out.println("[动态代理][日志] " + method.getName() + ",结果:" + result);
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("[动态代理][日志] " + method.getName() + ",异常:" + e.getMessage());
                } finally {
                    System.out.println("[动态代理][日志] " + method.getName() + ",方法执行完毕");
                }
                return result;
            }
        };

        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
    }
}

动态代理测试:

import com.jie.aop.proxy.ProxyFactory;
import com.jie.aop.service.CalculatorService;
import com.jie.aop.service.impl.CalculatorLogImpl;
import org.junit.jupiter.api.Test;

/**
 *  动态代理测试类
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/10/30 6:54
 */
public class TestCal {

    @Test
    public void testDynamicProxy(){
        // 创建代理工厂
        ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl());
        // 获取代理对象
        CalculatorService proxy = (CalculatorService) factory.getProxy();
        // 调用方法
        proxy.add(1,0);
    }
}

面向切面:AOP_第9张图片

3、AOP概念及相关术语

3.1 概述

AOP(Aspect Oriented Programming)是一种设计思想,是软件设计领域中的面向切面编程,它是面向对象编程的一种补充和完善,它以通过预编译方式和运行期动态代理方式实现,在不修改源代码的情况下,给程序动态统一添加额外功能的一种技术。

利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

3.2 相关术语

①横切关注点

首先看第一个术语叫横切关注点。那这个什么意思呢?

给大家说明,比如我现在有很多模块,现在我各个模块中都想解决同样一个问题。比如说我这些模块中都想加日志,事务,用户验证。那这个时候这里边的用户验证,日志,事务就属于叫横切关注点。

就是我们从方法中抽取同样一类非核心业务,那这个业务就叫横切关注点。

②通知(增强)

然后再看第二个,通知或者叫增强。什么叫增强呢?通俗来说就是想要增强的功能。

比如说我想加一个用户的安全校验,想加一个事务,想加上一个日志等等,这个就是叫通知或者叫增强。

每一个横切关注点上要做的事情都需要写一个方法来实现,这样的方法就叫通知方法。

通知拥有5种类型:

  • 前置通知:在被代理的目标方法执行
  • 返回通知:在被代理的目标方法成功结束后执行(寿终正寝
  • 异常通知:在被代理的目标方法异常结束后执行(死于非命
  • 后置通知:在被代理的目标方法最终结束后执行(盖棺定论
  • 环绕通知:使用try…catch…finally结构围绕整个被代理的目标方法,包括上面四种通知对应的所有位置

面向切面:AOP_第10张图片

③切面

什么叫切面呢?就是我们封装通知方法的类。比如说我写个类,里面有前置、后置、什么返回等等,那这个类就叫做切面。

④目标

被代理的目标对象。

⑤代理

向目标对象应用通知之后创建的代理对象。

⑥连接点

什么叫连接点?我们看这张图里边,给大家说明连接点怎么去理解。

面向切面:AOP_第11张图片

我现在把方法排成一排,就是什么添加和其他方法,然后每个横切位置看成一个X轴,另外把方法从上到下的执行顺序看成一个Y轴,而X和Y轴的交叉点就叫连接点,这是我们从字面上的解释。

那通俗来说,什么叫连接点?你可以这么理解,就是spring里边允许你使用通知的地方就叫连接点

那大家想一下,这个使用通知地方就太多了,我在方法前,在方法后是不是都可以使用这个通知,所以这个就叫连接点,就是通俗说你允许使用通知的地方就叫连接点。

⑦切入点

什么叫切入点?

你可以理解为我们现在通过spring的AOP技术,可以直接定位到你的特定的连接点。

比如定位到我方法之前,定位到方法之后,然后这个时候通俗的说就是实际去增强的方法,那个地方就叫切入点。比如现在我想对A的方法做增强,想在A的之后进行输出,这个就叫切入点。

4、基于注解的AOP

下面我们用spring进行AOP的具体操作,在spring里面进行AOP操作,它也是基于两种方式,第一种基于注解实现,第二个基于XML配置文件实现。我们先知道基于注解该怎么去做。

4.1 技术说明

首先我们说第一个内容,动态代理的这个分类,然后它分成哪些呢?给大家说明它有两类。第一类叫做JDK的动态代理,然后还有第二部分叫做CG lib的动态代理,它有两个分类,那这两个具体什么意思,咱们来做一个说明。

大家看我这个图。

面向切面:AOP_第12张图片

它有两种情况。第一种情况,当你代理的这个对象是一个有接口情况,第二个是没有接口。

如果有接口的时候,那他用的一个叫JDK的动态代理。如果没有接口,用的是CG lib的动态代理。

首先第一个情况就是有接口。有接口的时候,它使用的是JDK的动态代理。然后它怎么做的呢?

比如说我现在这部分我们有一个接口和它的实现类。

面向切面:AOP_第13张图片

然后过程中比如现在我们想用动态代理来增强里面的方法,那怎么做呢?那

我们就要创建接口实现类的代理对象。说的简单点,我们的这个代理类也要实现这个接口。只是代理类不是直接new出来的,但是跟new出来的对象具有相同的效果。

面向切面:AOP_第14张图片

因为这个技术要求代理对象和目标对象实现同样的接口(兄弟两个拜把子模式)。

第二种情况。

如果说你没有接口,那这个时候使用就是CG lib的动态代理。

而这个是怎么做的呢?你可以理解为它继承了这个目标这个类,生成了一个子类代对象。

通过继承被代理的目标类(认干爹模式)实现代理,所以不需要目标类实现接口。

AspectJ:

这是个什么东西呢?

其实这个本身它也一个框架,它是一个AOP的这么一个框架,就是本身它不是spring一部分。

但是为什么这里面出现一个AspectJ 呢?给大家强调,因为AspectJ里边很多的方法特别的方便,它里面注解也特别强大,spring就是依赖于这个AspectJ的注解实现AOP的功能,所以spring用到里面的注解,最终可以很方便的实现AOP中的各种功能。

其实这个AspectJ 本质上是一个静态代理,它用代理逻辑“织入”被代理的目标类编译得到的字节码文件这个,所以它效果是一个动态的。但是本身是一个静态代理,spring只是借用里面的注解,最终实现了AOP的功能。

4.2 准备工作

①添加依赖

在IOC所需依赖基础上再加入下面依赖即可:

<dependencies>
    
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>6.0.2version>
    dependency>

    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-aopartifactId>
        <version>6.0.2version>
    dependency>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-aspectsartifactId>
        <version>6.0.2version>
    dependency>

    
    <dependency>
        <groupId>org.junit.jupitergroupId>
        <artifactId>junit-jupiter-apiartifactId>
        <version>5.3.1version>
    dependency>

    
    <dependency>
        <groupId>org.apache.logging.log4jgroupId>
        <artifactId>log4j-coreartifactId>
        <version>2.19.0version>
    dependency>
    <dependency>
        <groupId>org.apache.logging.log4jgroupId>
        <artifactId>log4j-slf4j2-implartifactId>
        <version>2.19.0version>
    dependency>
dependencies>

②准备被代理的目标资源

接口:

package com.jie.aop.annoaop.service;

/**
 * 计算器接口
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/10/30 4:16
 */
public interface CalculatorService {

    /**
     * 加法
     *
     * @param i
     * @param j
     * @return: int
     * @date: 2023/10/30 4:16
     */
    int add(int i, int j);

    /**
     * 减法
     *
     * @param i
     * @param j
     * @return: int
     * @date: 2023/10/30 4:16
     */
    int sub(int i, int j);

    /**
     * 乘法
     *
     * @param i
     * @param j
     * @return: int
     * @date: 2023/10/30 4:16
     */
    int mul(int i, int j);

    /**
     * 除法
     *
     * @param i
     * @param j
     * @return: int
     * @date: 2023/10/30 4:16
     */
    int div(int i, int j);

}

实现类:

package com.jie.aop.annoaop.service.impl;

import com.jie.aop.annoaop.service.CalculatorService;
import org.springframework.stereotype.Component;

/**
 * 带日志的计算器接口实现类
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/10/30 4:27
 */
@Component
public class CalculatorLogImpl implements CalculatorService {

    @Override
    public int add(int i, int j) {

        System.out.println("[日志] add 方法开始了,参数是:" + i + "," + j);

        int result = i + j;

        System.out.println("方法内部 result = " + result);

        System.out.println("[日志] add 方法结束了,结果是:" + result);

        return result;
    }

    @Override
    public int sub(int i, int j) {

        System.out.println("[日志] sub 方法开始了,参数是:" + i + "," + j);

        int result = i - j;

        System.out.println("方法内部 result = " + result);

        System.out.println("[日志] sub 方法结束了,结果是:" + result);

        return result;
    }

    @Override
    public int mul(int i, int j) {

        System.out.println("[日志] mul 方法开始了,参数是:" + i + "," + j);

        int result = i * j;

        System.out.println("方法内部 result = " + result);

        System.out.println("[日志] mul 方法结束了,结果是:" + result);

        return result;
    }

    @Override
    public int div(int i, int j) {

        System.out.println("[日志] div 方法开始了,参数是:" + i + "," + j);

        int result = i / j;

        System.out.println("方法内部 result = " + result);

        System.out.println("[日志] div 方法结束了,结果是:" + result);

        return result;
    }
}

4.3 创建切面类并配置

面向切面:AOP_第15张图片

下一步需要建一个配置文件,在配置文件中做一些相关配置包的扫描规则,以及配置AspectJ 的自动代理。

面向切面:AOP_第16张图片


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    
    <context:component-scan base-package="com.jie.aop.annoaop"/>

    
    <aop:aspectj-autoproxy/>
beans>

完成之后,最后我们来到这个切面类中,在里边做什么?设置你的切入点,还有我们那个通知的类型。

package com.jie.aop.annoaop.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 日志切面类
 *
 * @author 阿杰 [email protected]
 * @version 1.0
 * @date 2023/11/13 20:22
 */
@Aspect
@Component
public class LogAspect {

    /**
     * 前置通知 @Before(value = "切入点表达式配置切入点")
     *
     * @param joinPoint 连接点
     *                  JoinPoint 业务方法,要加入切面功能的业务方法
     *                  作用是:可以在通知方法中获取方法执行时的信息,例如方法名称,方法参数等
     *                  如果你的切面功能中需要用到方法的信息,就加入JoinPoint
     *                  这个JoinPoint参数的值是由框架赋予,必须是第一个位置的参数
     *                  通知方法是是spring框架调用的,不是我们调用的,我们只是配置
     *                  spring框架在调用通知方法时,会把这个连接点对象作为实参传递给通知方法
     */
    @Before("execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))")
    public void beforePrintLog(JoinPoint joinPoint) {
        // 获取方法名称
        String name = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        System.out.println("[日志] 前置通知 方法开始了,方法名称是:" + name + ",方法参数是:" + Arrays.toString(args));
    }

    /**
     * 后置通知 @AfterReturning(value = "切入点表达式配置切入点")
     */
    @AfterReturning(value = "execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))")
    public void afterReturningPrintLog(JoinPoint joinPoint) {
        // 获取方法名称
        String name = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        System.out.println("[日志] 后置通知 方法开始了,方法名称是:" + name + ",方法参数是:" + args);
    }

    /**
     * 异常通知 @AfterThrowing(value = "切入点表达式配置切入点")
     * throwing = "ex":指定通知方法中的参数名,用于接收异常信息
     */
    @AfterThrowing(value = "execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))", throwing = "ex")
    public void afterThrowingPrintLog(JoinPoint joinPoint, Throwable ex) {
        // 获取方法名称
        String name = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        System.out.println("[日志] 异常通知 方法开始了,方法名称是:" + name + ",方法参数是:" + args + ",异常信息是:" + ex);
    }

    /**
     * 最终通知 @After(value = "切入点表达式配置切入点")
     * 无论是否有异常,都会执行
     * returning = "result":指定通知方法中的参数名,用于接收返回值
     */
    @AfterReturning(value = "execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))", returning = "result")
    public void afterPrintLog(JoinPoint joinPoint, Object result) {
        // 获取方法名称
        String name = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        System.out.println("[日志] 最终通知 方法开始了,方法名称是:" + name + ",方法参数是:" + args + ",结果是:" + result);
    }

    /**
     * 环绕通知 @Around(value = "切入点表达式配置切入点")
     * proceedingJoinPoint:等同于Method
     */
    @Around("execution(* com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))")
    public Object aroundPrintLog(ProceedingJoinPoint proceedingJoinPoint) {
        Object result = null;
        try {
            // 获取方法名称
            String name = proceedingJoinPoint.getSignature().getName();
            // 获取方法参数
            Object[] args = proceedingJoinPoint.getArgs();
            System.out.println("[日志] 环绕通知 方法开始了,方法名称是:" + name + ",方法参数是:" + args);
            // 明确调用业务层方法(切入点方法)
            result = proceedingJoinPoint.proceed(args);
            System.out.println("[日志] 环绕通知 方法结束了,结果是:" + result);
        } catch (Throwable throwable) {
            System.out.println("[日志] 环绕通知 方法出现异常了,异常信息是:" + throwable);
            throwable.printStackTrace();
        } finally {
            System.out.println("[日志] 环绕通知 方法结束了");
        }
        return result;
    }
}

执行测试:

面向切面:AOP_第17张图片

面向切面:AOP_第18张图片

4.4 各种通知

  • 前置通知:使用@Before注解标识,在被代理的目标方法执行
  • 返回通知:使用@AfterReturning注解标识,在被代理的目标方法成功结束后执行(寿终正寝
  • 异常通知:使用@AfterThrowing注解标识,在被代理的目标方法异常结束后执行(死于非命
  • 后置通知:使用@After注解标识,在被代理的目标方法最终结束后执行(盖棺定论
  • 环绕通知:使用@Around注解标识,使用try…catch…finally结构围绕整个被代理的目标方法,包括上面四种通知对应的所有位置

各种通知的执行顺序:

  • Spring版本5.3.x以前:
    • 前置通知
    • 目标操作
    • 后置通知
    • 返回通知或异常通知
  • Spring版本5.3.x以后:
    • 前置通知
    • 目标操作
    • 返回通知或异常通知
    • 后置通知

4.5 切入点表达式语法

①作用

面向切面:AOP_第19张图片

②语法细节

  • 用 *** **号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限

  • 在包名的部分,一个“*”号只能代表包的层次结构中的一层,表示这一层是任意的。

    • 例如:*.Hello匹配com.Hello,不匹配com.atguigu.Hello
  • 在包名的部分,使用“ ***… **” 表示包名任意、包的层次深度任意

  • 在类名的部分,类名部分整体用*号代替,表示类名任意

  • 在类名的部分,可以使用*号代替类名的一部分

    • 例如:*Service匹配所有名称以Service结尾的类或接口
  • 在方法名部分,可以使用*号表示方法名任意

  • 在方法名部分,可以使用*号代替方法名的一部分

    • 例如:*Operation匹配所有方法名以Operation结尾的方法
  • 在方法参数列表部分,使用(…)表示参数列表任意

  • 在方法参数列表部分,使用(int,…)表示参数列表以一个int类型的参数开头

  • 在方法参数列表部分,基本数据类型和对应的包装类型是不一样的

    • 切入点表达式中使用 int 和实际方法中 Integer 是不匹配的
  • 在方法返回值部分,如果想要明确指定一个返回值类型,那么必须同时写明权限修饰符

    • 例如:execution(public int Service.(…, int)) 正确
      例如:execution(
      int *…Service.(…, int)) 错误

面向切面:AOP_第20张图片

4.6 重用切入点表达式

大家看我刚才的例子中,有没有发现我这里写的时候。

面向切面:AOP_第21张图片

你发现我这个Before上边,还有AfterReturning上边,包括你看里边我这个切入点表达式写的是不是都是一样的?

那这表达式其实咱们把它定义一次,其他地方直接引用就可以了,而不需要重复写入多次,这就叫做重用切入点表达式。

①声明

    /**
     * 重用切入点表达式
     */
    @Pointcut("execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))")
    public void pointcut() {
    }

②在同一个切面中使用

@Before("pointcut()")
    public void beforePrintLog(JoinPoint joinPoint) {
        // 获取方法名称
        String name = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        System.out.println("[日志] 前置通知 方法开始了,方法名称是:" + name + ",方法参数是:" + Arrays.toString(args));
    }

③在不同切面中使用

 @Before("com.jie.aop.annoaop.aspect.LogAspect.pointcut()")
    public void beforePrintLog(JoinPoint joinPoint) {
        // 获取方法名称
        String name = joinPoint.getSignature().getName();
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        System.out.println("[日志] 前置通知 方法开始了,方法名称是:" + name + ",方法参数是:" + Arrays.toString(args));
    }

4.7 切面的优先级

大家注意,我们相同的方法可能同时存在于多个切面,就是多个切面对它都做增强。那这个时候有一个优先级的问题。那优先级是什么样的。我们有一个约定。

相同目标方法上同时存在多个切面时,切面的优先级控制切面的内外嵌套顺序。

  • 优先级高的切面:外面
  • 优先级低的切面:里面

使用@Order注解可以控制切面的优先级:

  • @Order(较小的数):优先级高
  • @Order(较大的数):优先级低

面向切面:AOP_第22张图片

5、基于XML的AOP

在前面内容中,咱们已经完成了基于注解方式实现AOP,通过注解配置了AOP等5种通知类型。那下面我们基于XML的方式实现AOP,因为过程准备工作跟注解一样,所以里边的准备代码我就直接复制。咱们重点写xml配置文件中的具体配置。

5.1 准备工作

面向切面:AOP_第23张图片

然后我们将复制的切面类的注解全部去掉。因为我们要通过XML的方式去实现AOP。

面向切面:AOP_第24张图片

5.2、实现


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    
    <context:component-scan base-package="com.jie.aop.xmlaop"/>

    
    <aop:config>
        
        <aop:aspect ref="logAspect">
            
            <aop:pointcut id="pointcut" expression="execution(* com.jie.aop.xmlaop.service.impl.CalculatorLogImpl.*(..))"/>
            
            
            <aop:before method="beforePrintLog" pointcut-ref="pointcut"/>
            
            <aop:after method="afterReturningPrintLog" pointcut-ref="pointcut"/>
            
            <aop:after-returning method="afterPrintLog" returning="result" pointcut-ref="pointcut"/>
            
            <aop:after-throwing method="afterThrowingPrintLog" throwing="ex" pointcut-ref="pointcut"/>
            
            <aop:around method="aroundPrintLog" pointcut-ref="pointcut"/>
        aop:aspect>
    aop:config>
beans>

5.3 测试

ramework.org/schema/aop/spring-aop.xsd">






    
    
        
        
        
        
        
        
        
        
        
        
        
        
        
    

```

5.3 测试

面向切面:AOP_第25张图片

你可能感兴趣的:(Spring系列,AOP,java,spring,aop,面向切面)