手写简易AOP，彻底悟懂AOP

骑猪看日落 2024-04-01 17:12 35阅读 0赞

**目录**

一、人间真实一波

二、简介

三、架构图

四、目录图

五、开写

1、先导入依赖

2、先做切点表达式匹配验证功能

2.1、定义类匹配类，用于切点找到给定的接口和目标类。

2.2、方法匹配，找到表达式范围内匹配下的目标类和方法。

2.3、切入点接口

2.4、实现切点表达式类

2.5、测试匹配验证

3、包装切面通知信息

4、代理抽象实现(JDK&Cglib)

4.1、定义接口

4.2、封装代理对象所需要的参数

4.3、基于 JDK 实现的代理类

4.4、基于 Cglib实现的代理类

5、测试

5.1、自定义拦截方法

5.2、最终结果

六、总结

## 一、人间真实一波 ##

不知道各位是不是看过很多AOP的文章，背诵AOP的面试题，但是都只是一知半解，面试一问就倒，需求稍微特别一点就不知道如何是好，不生效也不知道是为什么。

那是因为你学会的是皮毛，而想要用得好，问不倒就得要知其然还要知其所以然，当你跟着本文章手撸过后，你此后用AOP不再是回忆之前背诵的理论了，而是脑子里的一整个AOP的3D结构模型

## 二、简介 ##

AOP 意为：面向切面编程，通过预编译的方式和运行期间动态代理实现程序功能功能的统一维护。其实 AOP 也是 OOP 的延续，在 Spring 框架中是一个非常重要的内容，使用 AOP 可以对业务逻辑的各个部分进行隔离，从而使各模块间的业务逻辑耦合度降低，提高代码的可复用性，同时也能提高开发效率。

## 三、架构图 ##

![4f92cd6f067942bc8db60dc795fe56e1.png][]

## 四、目录图 ##

![8f637232fdcf4fa993c9ae4ad64309c7.png][]

## 五、开写 ##

### 1、先导入依赖 ###

<dependency>
                <groupId>aopalliance</groupId>
                <artifactId>aopalliance</artifactId>
                <version>1.0</version>
            </dependency>
    
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.7</version>
            </dependency>
            
            <dependency>
                <groupId>cglib</groupId>
                <artifactId>cglib</artifactId>
                <version>3.3.0</version>
            </dependency>

### 2、先做**切点表达式匹配验证功能** ###

#### 2.1、定义类匹配类，用于切点找到给定的接口和目标类。 ####

/**
     * 定义类匹配类，用于切点找到给定的接口和目标类。
     * @author Lasse
     */
    public interface ClassFilter {
        /**
         * Should the pointcut apply to the given interface or target class?
         * @param clazz the candidate target class
         * @return whether the advice should apply to the given target class
         */
        boolean matches(Class<?> clazz);
    }

#### 2.2、方法匹配，找到表达式范围内匹配下的目标类和方法。 ####

import java.lang.reflect.Method;
    /**
     * 方法匹配，找到表达式范围内匹配下的目标类和方法。
     * @author Lasse
     */
    public interface MethodMatcher {
        /**
         * Perform static checking whether the given method matches. If this
         * @return whether or not this method matches statically
         */
        boolean matches(Method method, Class<?> targetClass);
        
    }

#### 2.3、切入点接口 ####

定义用于获取 ClassFilter、MethodMatcher 的两个类（也就上上面定义的两个接口），这两个接口获取都是切点表达式提供的内容。

/**
     * 切入点接口，定义用于获取 ClassFilter、MethodMatcher 的两个类，
     * 这两个接口获取都是切点表达式提供的内容。
     */
    public interface Pointcut {
        /**
         * Return the ClassFilter for this pointcut.
         */
        ClassFilter getClassFilter();
    
        /**
         * Return the MethodMatcher for this pointcut.
         */
        MethodMatcher getMethodMatcher();
    }

#### 2.4、**实现切点表达式类** ####

import cn.lasse.springframework.aop.ClassFilter;
    import cn.lasse.springframework.aop.MethodMatcher;
    import cn.lasse.springframework.aop.Pointcut;
    import org.aspectj.weaver.tools.PointcutExpression;
    import org.aspectj.weaver.tools.PointcutParser;
    import org.aspectj.weaver.tools.PointcutPrimitive;
    import org.aspectj.weaver.tools.ShadowMatch;
    
    import java.lang.reflect.Method;
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 实现切点表达式类
     * @author Lasse
     */
    public class AspectJExpressionPointcut implements Pointcut ,ClassFilter,MethodMatcher{
        private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<>();
        static {
            SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
        }
    
        //切入点表达式
        private final PointcutExpression pointcutExpression;
    
        public AspectJExpressionPointcut(String expression) {
            PointcutParser pointcutParser = PointcutParser
                    .getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
                            SUPPORTED_PRIMITIVES, this.getClass().getClassLoader());
            pointcutExpression = pointcutParser.parsePointcutExpression(expression);
        }
    
        @Override
        public boolean matches(Class<?> clazz) {
            return pointcutExpression.couldMatchJoinPointsInType(clazz);
        }
    
        @Override
        public boolean matches(Method method, Class<?> targetClass) {
            ShadowMatch shadowMatch = pointcutExpression.matchesMethodExecution(method);
            return shadowMatch.alwaysMatches();
        }
    
        @Override
        public ClassFilter getClassFilter() {
            return this;
        }
    
        @Override
        public MethodMatcher getMethodMatcher() {
            return this;
        }
    }

#### 2.5、测试**匹配验证** ####

public class UserServiceImpl implements IUserService {
        @Override
        public String queryUserInfo() {
            try {
                System.out.println("我是函数：queryUserInfo()");
                Thread.sleep(new Random(1).nextInt(100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "穗爷，007，广州";
        }
    
        @Override
        public String register(String userName) {
            try {
                System.out.println("我是函数：register()");
                Thread.sleep(new Random(1).nextInt(100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "注册用户：" + userName + " success！";
        }
    }

@Test
        public void testAopMatches() throws NoSuchMethodException {
            AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut("execution(* cn.lasse.springframework.aop.impl.UserServiceImpl.*(..))");
            Class<UserServiceImpl> clazz = UserServiceImpl.class;
            Method method = clazz.getDeclaredMethod("queryUserInfo");
    
            System.out.println(pointcut.matches(clazz));
            System.out.println(pointcut.matches(method, clazz));
            // true、true
        }

### 3、包装切面通知信息 ###

/**
     * 被代理的目标对象
     * 是一个目标对象，在目标对象类中提供 Object 入参属性，以及获取目标类 TargetClass 信息。
     * @author Lasse
     */
    public class TargetSource {
    
        private final Object target;
    
        public Object getTarget(){
            return this.target;
        }
    
        public TargetSource(Object target) {
            this.target = target;
        }
    
        public Class<?>[] getTargetClass(){
            return this.target.getClass().getInterfaces();
        }
        
    }

import org.aopalliance.intercept.MethodInterceptor;
    
    /**
     * 包装切面通知信息
     * 主要是用于把代理、拦截、匹配的各项属性包装到一个类中，
     * 方便在 Proxy 实现类进行使用。
     * 和你的业务开发中包装入参是一个道理
     * @author Lasse
     */
    @Getter
    @Setter
    public class AdvisedSupport {
        /**
         * 被代理的目标对象
         *在目标对象类中提供 Object 入参属性，以及获取目标类 TargetClass 信息。
         */
        private TargetSource targetSource;
        /**
         * 方法拦截器
         * 是一个具体拦截方法实现类，由用户自己实现 MethodInterceptor#invoke 方法，
         * 做具体的处理。像我们本文的案例中是做方法监控处理
         */
        private MethodInterceptor methodInterceptor;
    
        /**
         * 方法匹配器(检查目标方法是否符合通知条件)
         * 是一个匹配方法的操作，这个对象由 AspectJExpressionPointcut 提供服务
         */
        private MethodMatcher methodMatcher;
    }

### 4、代理抽象实现(JDK&Cglib) ###

#### 4.1、**定义接口** ####

/**
     * 定义一个标准接口，用于获取代理类。因为具体实现代理的方式可以有 JDK 方式，也可以是 Cglib 方式，所以定义接口会更加方便管理实现类。
     * @author Lasse
     */
    public interface AopProxy {
    
        Object getProxy();
    
    }

#### 4.2、封装代理对象所需要的参数 ####

import org.aopalliance.intercept.MethodInvocation;
    import java.lang.reflect.AccessibleObject;
    import java.lang.reflect.Method;
    
    /**
     * 代理对象：目标对象、方法、入参。
     * @author Lasse
     */
    public class ReflectiveMethodInvocation implements MethodInvocation {
        // 目标对象
        protected final Object target;
        // 方法
        protected final Method method;
        // 入参
        protected final Object[] arguments;
    
        public ReflectiveMethodInvocation(Object target, Method method, Object[] arguments) {
            this.target = target;
            this.method = method;
            this.arguments = arguments;
        }
    
        @Override
        public Method getMethod() {
            return method;
        }
    
        @Override
        public Object[] getArguments() {
            return arguments;
        }
    
        /**
         * 继续往下走
         */
        @Override
        public Object proceed() throws Throwable {
            return method.invoke(target, arguments);
        }
    
        @Override
        public Object getThis() {
            return target;
        }
    
        @Override
        public AccessibleObject getStaticPart() {
            return method;
        }
    
    }

#### 4.3、基于 JDK 实现的代理类 ####

import cn.lasse.springframework.aop.AdvisedSupport;
    import org.aopalliance.intercept.MethodInterceptor;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * 基于 JDK 实现的代理类，需要实现接口 AopProxy、InvocationHandler，
     * 这样就可以把代理对象 getProxy 和反射调用方法 invoke 分开处理了。
     * @author Lasse
     */
    public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
        private final AdvisedSupport advised;
    
        public JdkDynamicAopProxy(AdvisedSupport advised) {
            this.advised = advised;
        }
    
        /**
         * 代理一个对象的操作，需要提供入参 ClassLoader、AdvisedSupport、和当前这个类 this，
         * 因为这个类提供了 invoke 方法。
         */
        @Override
        public Object getProxy() {
            Object instance = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                    advised.getTargetSource().getTargetClass(), this);
            return instance;
        }
    
        /**
         * 处理匹配的方法后，使用用户自己提供的方法拦截实现，
         * 做反射调用 methodInterceptor.invoke 。
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object target = advised.getTargetSource().getTarget();
            if (advised.getMethodMatcher().matches(method, target.getClass())) {
                MethodInterceptor methodInterceptor = advised.getMethodInterceptor();
                return methodInterceptor.invoke(new ReflectiveMethodInvocation(target, method, args));
            }
            return method.invoke(target, args);
        }
    }

#### 4.4、基于 Cglib实现的代理类 ####

import cn.lasse.springframework.aop.AdvisedSupport;
    import cn.lasse.springframework.aop.MethodMatcher;
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    public class Cglib2AopProxy implements AopProxy {
        private final AdvisedSupport advised;
    
        public Cglib2AopProxy(AdvisedSupport advised) {
            this.advised = advised;
        }
    
        @Override
        public Object getProxy() {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(advised.getTargetSource().getTarget().getClass());
            enhancer.setInterfaces(advised.getTargetSource().getTargetClass());
            enhancer.setCallback(new DynamicAdvisedInterceptor(advised));
            return enhancer.create();
        }
    
        private static class DynamicAdvisedInterceptor implements MethodInterceptor {
            private final AdvisedSupport advised;
    
            private DynamicAdvisedInterceptor(AdvisedSupport advised) {
                this.advised = advised;
            }
    
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object target = advised.getTargetSource().getTarget();
    
                CglibMethodInvocation methodInvocation = new CglibMethodInvocation(target,
                        method, objects, methodProxy);
                //匹配器
                MethodMatcher matcher = advised.getMethodMatcher();
                if (matcher.matches(method, target.getClass())) {
                    return advised.getMethodInterceptor().invoke(methodInvocation);
                }
                return methodInvocation.proceed();
            }
        }
    
        private static class CglibMethodInvocation extends ReflectiveMethodInvocation {
            private final MethodProxy methodProxy;
    
            public CglibMethodInvocation(Object target, Method method, Object[] arguments, MethodProxy methodProxy) {
                super(target, method, arguments);
                this.methodProxy = methodProxy;
            }
    
            @Override
            public Object proceed() throws Throwable {
                return this.methodProxy.invoke(this.target, this.arguments);
            }
    
        }
    
    }

### 5、测试 ###

#### 5.1、自定义拦截方法 ####

import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    
    /**
     * 用户自定义的拦截方法需要实现 MethodInterceptor 接口的 invoke 方法，
     * 使用方式与 Spring AOP 非常相似，也是包装 invocation.proceed() 放行，
     * 并在 finally 中添加监控信息。
     */
    public class UserServiceInterceptor implements MethodInterceptor {
    
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            long start = System.currentTimeMillis();
            try {
                System.out.println("我在这疯狂打印日志");
                return invocation.proceed();
            } finally {
                System.out.println("监控 - Begin By AOP");
                System.out.println("方法名称：" + invocation.getMethod());
                System.out.println("方法耗时：" + (System.currentTimeMillis() - start) + "ms");
                System.out.println("监控 - End\r\n");
            }
        }
    }

#### 5.2、最终结果 ####

@Test
        public void testDynamic() {
            // 目标对象
            IUserService userService = new UserServiceImpl();
    
            // 组装代理信息
            AdvisedSupport advisedSupport = new AdvisedSupport();
            advisedSupport.setTargetSource(new TargetSource(userService));
            advisedSupport.setMethodInterceptor(new UserServiceInterceptor());
            advisedSupport.setMethodMatcher(new AspectJExpressionPointcut("execution(* cn.lasse.springframework.aop.IUserService.*(..))"));
    
            // 代理对象(JdkDynamicAopProxy)
            IUserService proxyJdk = (IUserService) new JdkDynamicAopProxy(advisedSupport).getProxy();
            // 测试调用
            System.out.println("测试结果：" + proxyJdk.queryUserInfo());
    
            // 代理对象(Cglib2AopProxy)
            IUserService proxyCglib = (IUserService) new Cglib2AopProxy(advisedSupport).getProxy();
            // 测试调用
            System.out.println("测试结果：" + proxyCglib.register("花花"));
        }

> 我在这疯狂打印日志  
> 我是函数：queryUserInfo()  
> 监控 - Begin By AOP  
> 方法名称：public abstract java.lang.String cn.lasse.springframework.aop.IUserService.queryUserInfo()  
> 方法耗时：96ms  
> 监控 - End
> 
> 测试结果：穗爷，007，广州
> 
>   
> 我在这疯狂打印日志  
> 我是函数：register()  
> 监控 - Begin By AOP  
> 方法名称：public java.lang.String cn.lasse.springframework.aop.impl.UserServiceImpl.register(java.lang.String)  
> 方法耗时：106ms  
> 监控 - End
> 
> 测试结果：注册用户：花花 success！

## 六、总结 ##

*  从本文对 Proxy\#newProxyInstance、MethodInterceptor\#invoke，的使用验证切面核心原理以及再把功能拆解到 Spring 框架实现中，可以看到一个貌似复杂的技术其实核心内容往往没有太多，但因为需要为了满足后续更多的扩展就需要进行职责解耦和包装，通过这样设计模式的使用，以此让调用方能更加简化，自身也可以不断按需扩展。
 *  AOP 的功能实现目前还没有与 Spring 结合，只是对切面技术的一个具体实现，你可以先学习到如何处理代理对象、过滤方法、拦截方法，以及使用 Cglib 和 JDK 代理的区别，其实这里的技术不只是在 Spring 框架中有所体现，在其他各类需要减少人工硬编码的场景下，都会用到。*比如RPC、Mybatis、MQ、分布式任务。。。*
 *  一些核心技术的使用上，都是具有很强的关联性的，它们也不是孤立存在的。而这个能把整个技术栈串联起来的过程，需要你来大量的学习、积累、由点到面的铺设，才能在一个知识点的学习拓展到一个知识面和知识体系的建设

**特别鸣谢**：小傅哥（[https://blog.csdn.net/generalfu?type=blog][https_blog.csdn.net_generalfu_type_blog]）

这位大神（小傅哥）博客写得特别好，特别接地气，本篇文章也只是借花献佛而已。

[4f92cd6f067942bc8db60dc795fe56e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/892869bccd314156b0877dc72656c700.png
[8f637232fdcf4fa993c9ae4ad64309c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3684f013139e47c3a1f58a8fac308b63.png
[https_blog.csdn.net_generalfu_type_blog]: https://blog.csdn.net/generalfu?type=blog