21.spring系列- aop概念详解

最新推荐文章于 2024-06-17 14:00:16 发布

那个少年~

最新推荐文章于 2024-06-17 14:00:16 发布

阅读量383

点赞数 1

分类专栏： spring 文章标签： spring

原文链接：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=886211e2bf1598f4e0e636170a4b36a5a5edd8811c8b7c30d61135cb114b0ce506a6fa84df0b&idx=1&lang=zh_CN&mid=2648934876&scene=21&sn=7794b50e658e0ec3e0aff6cf5ed4aa2e&token=690771459#wechat_redirect

版权

spring 专栏收录该内容

36 篇文章 14 订阅

订阅专栏

什么是AOP?

比如银行系统会有这么个流程：
在这里插入图片描述有没有发现，这个两者有一个相同的验证流程，上面只是2个操作，如果有更多的操作，验证用户的功能是不是需要写很多次？

有没有想过可以把这个验证用户的代码是提取出来，不放到主流程里去呢，这就是AOP的作用了，有了AOP，你写代码时不要把这个验证用户步骤写进去，即完全不考虑验证用户，你写完之后，在另我一个地方，写好验证用户的代码，然后告诉Spring你要把这段代码加到哪几个地方，Spring就会帮你加过去，而不要你自己Copy过去，如果你有多个控制流呢，这个写代码的方法可以大大减少你的时间。

再举一个通用的例子，经常在debug的时候要打log吧，你也可以写好主要代码之后，把打log的代码写到另一个单独的地方，然后命令AOP把你的代码加过去，注意AOP不会把代码加到源文件里，但是它会正确的影响最终的机器代码。

现在大概明白了AOP了吗，AOP的本质是在一系列纵向的控制流程中，把那些相同的子流程提取成一个横向的面，这句话应该好理解吧，我们把纵向流程画成一条直线，然把相同的部分以绿色突出，如下图左，而AOP相当于把相同的地方连一条横线，如下图右，这个图没画好，大家明白意思就行。
在这里插入图片描述这个验证用户这个子流程就成了一个条线，也可以理解成一个切面，这里的切面只插了两三个流程，如果其它流程也需要这个子流程，也可以插到其它地方去。

通熟易懂的理解为：在程序中具有公共特性的某些类/某些方法上进行拦截, 在方法执行的前面/后面/执行结果返回后增加执行一些方法。

先来考虑几个问题

aop中用什么来表示这些公共的功能？
aop中如何知道这些公共的功能用到哪些类的那些方法中去？
aop中需要将这些公共的功能用在目标方法的什么地方，前面？后面？还是其他什么地方？
aop底层是用什么实现的？

带着这些问题，我们先来理解aop的一些概念

Spring中AOP一些概念

目标对象(target)

目标对象指将要被增强的对象，即包含主业务逻辑的类对象。

连接点(JoinPoint)

连接点由两个信息确定：

方法(表示程序执行点，即在哪个目标方法)
相对点(表示方位，即目标方法的什么位置，比如调用前，后等)

简单来说，连接点就是被拦截到的程序执行点，因为Spring只支持方法类型的连接点，所以在Spring中连接点就是被拦截到的方法。

代理对象(Proxy)

AOP中会通过代理的方式，对目标对象生成一个代理对象，代理对象中会加入需要增强功能，通过代理对象来间接的方式目标对象，起到增强目标对象的效果。

通知(Advice)

需要在目标对象中增强的功能，如上面说的：业务方法前验证用户的功能、方法执行之后打印方法的执行日志。
通知中有2个重要的信息：方法的什么地方，执行什么操作，这2个信息通过通知来指定。

切入点(Pointcut)

用来指定需要将通知使用到哪些地方，比如需要用在哪些类的哪些方法上，切入点就是做这个配置的。

切面(Aspect)

切面来定义在哪些地方（Pointcut）执行什么操作（Advice）。

顾问/通知器（Advisor)

Advisor 其实它就是 Pointcut 与 Advice 的组合，Advice 是要增强的逻辑，而增强的逻辑要在什么地方执行是通过Pointcut来指定的，所以 Advice 必需与 Pointcut 组合在一起，这就诞生了 Advisor 这个类，spring Aop中提供了一个Advisor接口将Pointcut 与 Advice 的组合起来。

其中这4个：连接点(JoinPoint)、通知(Advice)、切入点(pointcut)、顾问（advisor)，在spring中都定义了接口和类来表示这些对象

连接点（JoinPoint）

JoinPoint接口

public interface Joinpoint {

    /**
     * 转到拦截器链中的下一个拦截器
     */
    Object proceed() throws Throwable;

    /**
     * 返回保存当前连接点静态部分【的对象】，这里一般指被代理的目标对象
     */
    Object getThis();

    /**
     * 返回此静态连接点  一般就为当前的Method(至少目前的唯一实现是MethodInvocation,所以连接点得静态部分肯定就是本方法)
     */
    AccessibleObject getStaticPart();

}

几个重要的子接口和实现类，如下：
在这里插入图片描述 Invocation接口

/**
 * 此接口表示程序中的调用
 * 调用是一个连接点，可以被拦截器拦截。
 */
public interface Invocation extends Joinpoint {

    /**
     * 将参数作为数组对象获取。可以更改此数组中的元素值以更改参数。
     * 通常用来获取调用目标方法的参数
     */
    Object[] getArguments();

}

MethodInvocation接口


/**
 * 方法调用的描述，在方法调用时提供给拦截器。
 * 方法调用是一个连接点，可以被方法拦截器拦截。
 */
public interface MethodInvocation extends Invocation {

    /**
     * 返回正在被调用得方法~~~  返回的是当前Method对象。
     * 此时，效果同父类的AccessibleObject getStaticPart() 这个方法
     */
    Method getMethod();

}

通知(Advice)

通知中用来实现被增强的逻辑，通知中有2个关注点，再强调一下：方法的什么地方，执行什么操作。

public interface Advice {

}

通知的顶层接口，这个接口内部没有定义任何方法。它有4个子接口：
在这里插入图片描述 MethodBeforeAdvice接口

方法执行前通知，需要在目标方法执行前执行一些逻辑的，可以通过这个实现。


public interface MethodBeforeAdvice extends BeforeAdvice {

    /**
     * 调用目标方法之前会先调用这个before方法
     * method：需要执行的目标方法
     * args：目标方法的参数
     * target：目标对象
     */
    void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
}

AfterReturningAdvice接口

方法执行后通知，需要在目标方法执行之后执行增强一些逻辑的，可以通过这个实现。
不过需要注意一点：目标方法正常执行后，才会回调这个接口，当目标方法有异常，那么这通知会被跳过。


public interface AfterReturningAdvice extends AfterAdvice {

    /**
     * 目标方法执行之后会回调这个方法
     * method：需要执行的目标方法
     * args：目标方法的参数
     * target：目标对象
     */
    void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;

}

ThrowsAdvice接口

public interface ThrowsAdvice extends AfterAdvice {

}

此接口上没有任何方法，因为方法由反射调用，实现类必须实现以下形式的方法，前3个参数是可选的，最后一个参数为需要匹配的异常的类型。

void afterThrowing([Method, args, target], ThrowableSubclass);

有效方法的一些例子如下：

有效方法的一些例子如下：

public void afterThrowing(Exception ex)
public void afterThrowing(RemoteException)
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)

MethodInterceptor接口

方法拦截器，这个接口最强大，可以实现上面3种类型的通知，上面3种通知最终都通过适配模式将其转换为MethodInterceptor方式去执行。


@FunctionalInterface
public interface MethodInterceptor extends Interceptor {

    /**
     * 拦截目标方法的执行，可以在这个方法内部实现需要增强的逻辑，以及主动调用目标方法
     */
    Object invoke(MethodInvocation invocation) throws Throwable;

}

拦截器链

一个目标方法中可以添加很多Advice，这些Advice最终都会被转换为MethodInterceptor类型的方法拦截器，最终会有多个MethodInterceptor，这些MethodInterceptor会组成一个方法调用链。

Aop内部会给目标对象创建一个代理，代理对象中会放入这些MethodInterceptor会组成一个方法调用链，当调用代理对象的方法的时候，会按顺序执行这些方法调用链，一个个执行，最后会通过反射再去调用目标方法，进而对目标方法进行增强。
在这里插入图片描述

切入点(PointCut)

通知（Advice）用来指定需要增强的逻辑，但是哪些类的哪些方法中需要使用这些通知呢？这个就是通过切入点来配置的，切入点在spring中对应了一个接口

PointCut接口


public interface Pointcut {

    /**
     * 类过滤器, 可以知道哪些类需要拦截
     */
    ClassFilter getClassFilter();

    /**
     * 方法匹配器, 可以知道哪些方法需要拦截
     */
    MethodMatcher getMethodMatcher();

    /**
     * 匹配所有对象的 Pointcut，内部的2个过滤器默认都会返回true
     */
    Pointcut TRUE = TruePointcut.INSTANCE;

}

ClassFilter接口

@FunctionalInterface
public interface ClassFilter {

    /**
     * 用来判断目标类型是否匹配
     */
    boolean matches(Class<?> clazz);

}

MethodMatcher接口

public interface MethodMatcher {

    /**
     * 执行静态检查给定方法是否匹配
     * @param method 目标方法
     * @param targetClass 目标对象类型
     */
    boolean matches(Method method, Class<?> targetClass);

    /**
     * 是否是动态匹配，即是否每次执行目标方法的时候都去验证一下
     */
    boolean isRuntime();

    /**
     * 动态匹配验证的方法，比第一个matches方法多了一个参数args，这个参数是调用目标方法传入的参数
     */
    boolean matches(Method method, Class<?> targetClass, Object... args);


    /**
     * 匹配所有方法，这个内部的2个matches方法任何时候都返回true
     */
    MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;

}

为什么需要2个maches方法？什么是动态匹配？

public class UserService{
    public void work(String userName){
        System.out.print(userName+",开始工作了!");
    }
}

work方法表示当前用户的工作方法，内部可以实现一些工作的逻辑。

我们希望通过aop对这个类进行增强，调用这个方法的时候，当传入的用户名是"spring"的时候，需要先进行问候，其他用户的时候，无需问候，将这个问题的代码可以放在MethodBeforeAdvice中实现，这种情况就是当参数满足一定的条件了，才会使用这个通知，不满足的时候，通知无效，此时就可以使用上面的动态匹配来实现，MethodMatcher类中3个参数的matches方法可以用来对目标方法的参数做校验。

来看一下MethodMatcher过滤的整个过程:

调用matches(Method method, Class<?> targetClass)方法，验证方法是否匹配
isRuntime方法是否为true，如果为false，则以第一步的结果为准，否则继续向下
调用matches(Method method, Class<?> targetClass, Object… args)方法继续验证，这个方法多了一个参数，可以对目标方法传入的参数进行校验。

通过上面的过程，大家可以看出来，如果isRuntime为false的时候，只需要对方法名称进行校验，当目标方法调用多次的时候，实际上第一步的验证结果是一样的，所以如果isRuntime为false的情况，可以将验证结果放在缓存中，提升效率，而spring内部就是这么做的，isRuntime为false的时候，需要每次都进行校验，效率会低一些，不过对性能的影响基本上可以忽略。

顾问(Advisor)

通知定义了需要做什么，切入点定义了在哪些类的哪些方法中执行通知，那么需要将他们2个组合起来才有效啊。顾问（Advisor）就是做这个事情的。

Advisor接口

/**
 * 包含AOP通知（在joinpoint处执行的操作）和确定通知适用性的过滤器（如切入点[PointCut]）的基本接口。
 * 这个接口不是供Spring用户使用的，而是为了支持不同类型的建议的通用性。
 */
public interface Advisor {
    /**
     * 返回引用的通知
     */
    Advice getAdvice();

}

上面这个接口通常不会直接使用，这个接口有2个子接口，通常我们会和这2个子接口来打交道，下面看一下这2个子接口。
在这里插入图片描述 PointcutAdvisor接口

通过名字就能看出来，这个和Pointcut有关，内部有个方法用来获取Pointcut，AOP使用到的大部分Advisor都属于这种类型的。

在目标方法中实现各种增强功能基本上都是通过PointcutAdvisor来实现的。


/**
 * 切入点类型的Advisor
 */
public interface PointcutAdvisor extends Advisor {

    /**
     * 获取顾问中使用的切入点
     */
    Pointcut getPointcut();

}

IntroductionAdvisor接口

这个接口，估计大家比较陌生，干什么的呢？

一个Java类，没有实现A接口，在不修改Java类的情况下，使其具备A接口的功能。可以通过IntroductionAdvisor给目标类引入更多接口的功能

案例

上面都是一些概念，看起来比较枯燥乏味，下面来个使用硬编码的方式来用一下上面提到的一些类或者接口，加深理解。


public class UserService {
    public void work(String userName) {
        System.out.println(userName + "在学Spring Aop，欢迎大家一起来！");
    }
}

案例1：在work方法执行之前，打印一句：你好：userName

测试：

@Test
    public void testAOP(){
        UserService userService = new UserService();
        //创建pointcut，用来拦截UserService中的work方法
        Pointcut pointcut = new Pointcut() {
            @Override
            public ClassFilter getClassFilter() {
                return clazz -> UserService.class.isAssignableFrom(clazz);
            }

            @Override
            public MethodMatcher getMethodMatcher() {
                return new MethodMatcher() {
                    @Override
                    public boolean matches(Method method, Class<?> aClass) {
                        //判断方法名是否是work
                        return ("work").equals(method.getName());
                    }

                    @Override
                    public boolean isRuntime() {
                        return false;
                    }

                    @Override
                    public boolean matches(Method method, Class<?> aClass, Object... objects) {
                        return false;
                    }
                };
            }
        };
        //创建通知，此处需要在方法之前执行操作，所以需要用到MethodBeforeAdvice类型的通知
        MethodBeforeAdvice beforeAdvice = new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] objects, Object o) throws Throwable {
                System.out.println("你好:" + objects[0]);
            }
        };
        //创建Advisor，将pointcut和advice组装起来
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
        advisor.setAdvice(beforeAdvice);
        advisor.setPointcut(pointcut);
        //通过spring提供的代理创建工厂来创建代理
        ProxyFactory proxyFactory = new ProxyFactory();
        //指定目标
        proxyFactory.setTarget(userService);
        //添加Advisor
        proxyFactory.addAdvisor(advisor);
        //获取代理对象
        UserService proxy = (UserService)proxyFactory.getProxy();
        proxy.work("小明");
    }

运行结果：

你好:小明
小明在学Spring Aop，欢迎大家一起来！

上面是采用硬编码的方式来感受一下aop的用法，大家看了上面代码之后，估计会有疑问：我晕，这么复杂？？？

如果大家有使用过spring中的aop经验，可能只需要几行代码就实现了上面的功能，的确，spring中把整个功能简化了很多，不过我们得去了解他的内部是如何实现的，然后才能走的更远。

案例2：统计一下work方法的耗时，将耗时输出

@Test
    public void testAOP1(){
        UserService userService = new UserService();
        //创建pointcut，用来拦截UserService中的work方法
        Pointcut pointcut = new Pointcut() {
            @Override
            public ClassFilter getClassFilter() {
                //判断是否要拦截userService类
                return clazz -> UserService.class.isAssignableFrom(clazz);
            }

            @Override
            public MethodMatcher getMethodMatcher() {
                return new MethodMatcher() {
                    @Override
                    public boolean matches(Method method, Class<?> aClass) {
                        //判断方法名是否是work
                        return ("work").equals(method.getName());
                    }

                    @Override
                    public boolean isRuntime() {
                        return false;
                    }

                    @Override
                    public boolean matches(Method method, Class<?> aClass, Object... objects) {
                        return false;
                    }
                };
            }
        };
        //方法拦截器
        MethodInterceptor methodInterceptor = new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation methodInvocation) throws Throwable {
                System.out.println("准备调用:" + methodInvocation.getMethod());
                long starTime = System.nanoTime();
                Object result = methodInvocation.proceed();
                long endTime = System.nanoTime();
                System.out.println(methodInvocation.getMethod() + "，调用结束！");
                System.out.println("耗时(纳秒):" + (endTime - starTime));
                return result;
            }
        };
        //创建Advisor，将pointcut和advice组装起来
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut,methodInterceptor);
        //通过spring提供的代理创建工厂来创建代理
        ProxyFactory proxyFactory = new ProxyFactory();
        //指定目标
        proxyFactory.setTarget(userService);
        //添加Advisor
        proxyFactory.addAdvisor(advisor);
        //获取代理对象
        UserService proxy = (UserService)proxyFactory.getProxy();
        proxy.work("小明");
    }

准备调用:public void com.spring.beanAOP.UserService.work(java.lang.String)
小明在学Spring Aop，欢迎大家一起来！
public void com.spring.beanAOP.UserService.work(java.lang.String)，调用结束！
耗时(纳秒):18919400

案例3：userName中包含“粉丝”关键字，输出一句：感谢您一路的支持

@Test
    public void testAOP2(){
        UserService userService = new UserService();
        //创建pointcut，用来拦截UserService中的work方法
        Pointcut pointcut = new Pointcut() {
            @Override
            public ClassFilter getClassFilter() {
                //判断是否要拦截userService类
                return clazz -> UserService.class.isAssignableFrom(clazz);
            }

            @Override
            public MethodMatcher getMethodMatcher() {
                return new MethodMatcher() {
                    @Override
                    public boolean matches(Method method, Class<?> aClass) {
                        //判断方法名是否是work
                        return ("work").equals(method.getName());
                    }

                    @Override
                    public boolean isRuntime() {
                        //注意这个地方要返回true
                        return true;
                    }

                    @Override
                    public boolean matches(Method method, Class<?> aClass, Object... objects) {
                        if(Objects.nonNull(objects) && objects.length == 1){
                            String userName = (String) objects[0];
                            if(userName.contains("粉丝")){
                                return true;
                            }
                        }
                        return false;
                    }
                };
            }
        };
        MethodBeforeAdvice advice = new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] args, Object target) throws Throwable {
                System.out.println("感谢您一路的支持");
            }
        };
        //创建Advisor，将pointcut和advice组装起来
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut,advice);
        //通过spring提供的代理创建工厂来创建代理
        ProxyFactory proxyFactory = new ProxyFactory();
        //指定目标
        proxyFactory.setTarget(userService);
        //添加Advisor
        proxyFactory.addAdvisor(advisor);
        //获取代理对象
        UserService proxy = (UserService)proxyFactory.getProxy();
        proxy.work("粉丝");
    }

感谢您一路的支持
粉丝在学Spring Aop，欢迎大家一起来！

上面的一些案例中都用到了ProxyFactory这个类，内部将各种对象进行组装，然后创建代理对象，ProxyFactory这块关联的的东西挺多的，下一篇文章将详说这块的东西，是非常重要的内容。

那个少年~

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
21.spring系列- aop概念详解

什么是AOP?比如银行系统会有这么个流程：有没有发现，这个两者有一个相同的验证流程，上面只是2个操作，如果有更多的操作，验证用户的功能是不是需要写很多次？有没有想过可以把这个验证用户的代码是提取出来，不放到主流程里去呢，这就是AOP的作用了，有了AOP，你写代码时不要把这个验证用户步骤写进去，即完全不考虑验证用户，你写完之后，在另我一个地方，写好验证用户的代码，然后告诉Spring你要把这段代码加到哪几个地方，Spring就会帮你加过去，而不要你自己Copy过去，如果你有多个控制流呢，这个写代码的方法
复制链接

扫一扫