Spring AOP（2）原理(代理模式和源码解析)

    上篇文章学习了 Spring AOP 的应用，接下来我们来学习 Spring AOP 的原理，也就是 Spring 是如何实现 AOP 的。
    Spring AOP 是基于动态代理来实现 AOP 的，咱门学习内容主要分以下两部分：

1、代理模式

2、Spring AOP 源码剖析

一、代理模式

    代理模式，也叫 委托模式。

定义：为其他对象提供一种代理以控制这个对象的访问。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。
   某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。

    使用代理前：

    使用代理后：
    ![](https://i-blog.csdnimg.cn/direct/637bcff8852d4f81b10482181704d5f8.png)
    生活中的代理：

艺人经纪人：广告商找艺人拍广告，需要经过经纪人，由经纪人来和艺人沟通。

房屋中介：房屋进行租赁时，卖方会把房屋授权给中介，由中介来代理看房，房屋咨询等服务。

经销商：厂商不直接对外销售产品，由经销商负责代理销售。

秘书/助理：合作伙伴找老板谈合作，需要先经过秘书/助理预约。

    代理模式的主要角色：

1、Subject：业务接口类。可以是抽象类或者接口（不一定有）。

2、RealSubject：业务实现类。具体的业务执行，也就是被代理对象。

3、Proxy：代理类。RealSubject的代理。

比如房屋出租：
    Subject：就是提前定义了房东做的事情，交给中介代理，也是中介要做的事情。
    RealSubject：房东。
    Proxy：中介。

    UML类图如下：
    ![](https://i-blog.csdnimg.cn/direct/6753b8885ba04550836314843f76c4fe.png)
    **代理模式可以在不修改被代理对象的基础上，通过扩展代理类**，进行一些功能的附加与增强。根据代理的创建时期，代理模式分为静态代理和动态代理。
    **静态代理**：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
    **动态代理**：在程序运行时，运用反射机制动态创建而成。

二、静态代理

    静态代理：在程序运行前，代理类的 .class文件 就已经存在了。（在出租房子之前，中介已经做好了相关的工作，就等租户来租房子了）。
    我们通过代码来加深理解。以房租租赁为例：

1、定义接口（定义房东要做的事情，也是中介需要做的事情）：

public interface HouseSubject {
    void rentHouse();
}

2、实现接口（房东出租房子）：

public class RealHouseSubject implements HouseSubject{
    @Override
    public void rentHouse() {
        System.out.println("我是房东, 我出租房子");
    }
}

3、代理（中介，帮房东出租房子）：

public class HouseProxy implements HouseSubject{
    private HouseSubject target;
    public HouseProxy(HouseSubject target) {
        this.target = target;
    }
    @Override
    public void rentHouse() {
        //代理前
        System.out.println("我是中介, 开始代理");
        //出租房子
        target.rentHouse();;
        //代理后
        System.out.println("我是中介, 结束代理");
    }
}

4、使用：

public class Main {
    public static void main(String[] args) {
        HouseSubject subject = new RealHouseSubject();
        //创建代理类
        HouseProxy houseProxy = new HouseProxy(subject);
        //通过代理类访问⽬标⽅法
        houseProxy.rentHouse();
    }
}

    运行结果：

    上面这个代理实现方式就是静态代理（仿佛啥也没干）。从上述程序可以看出，虽然静态代理也完成了对目标对象的代理，但是由于代码都写死了，对目标对象的每个方法的增强都是手动完成的，非常不灵活。所以日常开发几乎看不到静态代理的场景。
    接下来新增需求：中介又新增了其他业务：代理房屋出售。我们就需要对上述代码进行修改。

1、接口定义修改：

public interface HouseSubject {
    void rentHouse();
    void saleHouse();
}

2、接口实现修改：

public class RealHouseSubject implements HouseSubject{
    @Override
    public void rentHouse() {
        System.out.println("我是房东, 我出租房子");
    }
    @Override
    public void saleHouse() {
        System.out.println("我是房东, 我出售房子");
    }
}

3、代理类修改：

public class HouseProxy implements HouseSubject{
    private HouseSubject target;
    public HouseProxy(HouseSubject target) {
        this.target = target;
    }
    @Override
    public void rentHouse() {
        //代理前
        System.out.println("我是中介, 开始代理");
        //出租房子
        target.rentHouse();;
        //代理后
        System.out.println("我是中介, 结束代理");
    }
    @Override
    public void saleHouse() {
        //代理前
        System.out.println("我是中介, 开始代理");
        //出租房子
        target.rentHouse();;
        //代理后
        System.out.println("我是中介, 结束代理");
    }
}

4、使用：

public class Main {
    public static void main(String[] args) {
        HouseSubject subject = new RealHouseSubject();
        //创建代理类
        HouseProxy houseProxy = new HouseProxy(subject);
        //通过代理类访问⽬标⽅法
        houseProxy.rentHouse();
        System.out.println("=========");
        houseProxy.saleHouse();
    }
}

    运行结果：

    从上述代码可以看出，我们修改接口（Subject）和业务实现类（RealSubject），还需要修改代理类（Proxy）。
    同样的，如果新增接口（Subject）和业务实现类（RealSubject），也需要对每一个业务实现类新增代理类（Proxy）。
    既然代理的流程是一样的，有没有一种办法，让他们通过一个代理类来实现呢？这就需要用到动态代理技术了。

三、动态代理

    相比于静态代理来说，动态代理更加灵活。**我们不需要针对每个目标对象都单独创建一个代理对象，而是把这个创建代理对象的工作推迟到程序运行时由JVM来实现**。也就是说动态代理在程序运行时，根据需要动态创建生成。
    比如房屋中介，我不需要提前预测都有哪些业务，而是业务来了我再根据情况创建。
    先看代码再来理解。Java也对动态代理进行了实现，并给我们提供一些API，常见的实现方式有两种：
    **1、JDK动态代理**
    **2、CGLIB动态代理**

动态代理在我们日常开发中使用的相对较少，但是在框架中几乎是必用的一门技术。学会了动态代理之后，对于我们理解和学习各种框架的原理也非常有帮助。

1、JDK动态代理

（1）JDK动态代理实现步骤

1、定义一个接口及其实现类（静态代理中的 HouseSubject 和 RealHouseSubject）。

2、自定义 InvocationHandler 并重写 invoke 方法，在 invoke 方法中我们会调用目标方法（被代理类的方法），并自定义一些处理逻辑。

3、通过 Proxy.newProxyInstance（ClassLoader, Class<?>[ ] Interfaces, InvocationHandler h）方法创建代理对象。

（2）定义JDK动态代理类

    创建 JDKInvocationHandler类 实现 InvocationHandler 接口：

public class JDKInvocationHandler implements InvocationHandler {
    //目标对象，即被代理的对象
    private Object target;
    public JDKInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //代理增强内容
        System.out.println("我是中介，开始代理");
        //通过反射调用被代理类的方法
        Object result = method.invoke(target, args);
        //代理增强内容
        System.out.println("我是中介，结束代理");
        return result;
    }
}

    创建一个代理对象并使用：

public class Main {
    public static void main(String[] args) {
        /**
         * JDK动态代理
         */
        //创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        RealHouseSubject target = new RealHouseSubject();//目标对象
        /**
         * newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
         * loader：加载我们的被代理类的ClassLoad
         * interfaces：要实现的接口
         * h：代理要做的事情，需要实现 InvocationHandler 这个接口
         */
        HouseSubject proxy = (HouseSubject) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{HouseSubject.class},
                new JDKInvocationHandler(target)
        );
        proxy.rentHouse();
        System.out.println("==============");
        proxy.saleHouse();
    }
}

    运行程序，结果如下：

    假设代理的是类，而不是对象，代码如下：

public class Main {
    public static void main(String[] args) {
        RealHouseSubject target = new RealHouseSubject();
        RealHouseSubject proxy = (RealHouseSubject) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{RealHouseSubject.class},
                new JDKInvocationHandler(target)
        );
        proxy.rentHouse();
        System.out.println("==============");
        proxy.saleHouse();
    }
}

    运行程序，结果如下：（报错了）

    **报错原因**：RealHouseSubject is not an interface（RealHouseSubject 类不是接口），**说明JDK 动态代理只能代理接口，不能代理类**，不然会报错。

（3）代码简单讲解

    主要是学习API的使用，我们按照 Java API 的规范来使用即可。

1、InvocationHandler：

    InvocationHandler 接口是 Java 动态代理的关键接口之一，它定义了一个单一方法 invoke()，用于处理被代理对象的方法调用。

    public interface InvocationHandler {
        /**
         * 参数说明
         * proxy：被代理对象
         * method：被代理对象需要实现的⽅法，即其中需要重写的⽅法
         * args：method所对应⽅法的参数
         */
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable;
    }

    通过实现 InvocationHandler 接口，可以对被代理对象的方法进行功能增强。

2、Proxy：

    Proxy 类中使用频率最高的方法：newProxyInstance()，这个方法主要用来生成一个代理对象。

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
            throws IllegalArgumentException
    {
        //...代码省略
    }

    这个方法一共有 3 个参数：

loader：类加载器，用于加载被代理对象。

interface：被代理类实现的一些接口（这个参数的定义，也决定了JDK动态代理只能代理实现了接口的一些类）。

h：代理要做的事情，实现 InvocationHandler 接口的对象。

2、CGLIB动态代理

    JDK动态代理有一个**最致命的问题**，是只能代理实现了接口的类。
    有些场景下，我们的业务码是直接实现的，并没有接口定义。为了解决这个问题，我们可以用 CGLIB 动态代理机制来解决。
    CGLIB（Code Generation Library）是一个基于 ASM 的字节码生产库，它允许我们在运行时对字节码进行修改和动态生成。
    CGLIB 通过继承方式实现代理，很多知名的开源框架都使用到了 CGLIB。例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。（**其中 Spring 是基于动态代理实现的，动态代理是基于反射实现的**）

（1）CGLIB 动态代理类实现步骤

1、定义一个类（被代理类）。

2、自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于增强目标方法，和 JDK 动态代理中的 invoke 方法类似。

3、通过 Enhancer 类的 create() 创建代理类。

    接下来看实现：

（2）添加依赖

    和 JDK 动态代理不同，CGLIB（Code Generation Library）实际是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖。

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

（3）自定义MethodInterceptor（方法拦截器）

    实现 MethodInterceptor 接口:

import org.springframework.cglib.proxy.MethodInterceptor;
import java.lang.reflect.Method;
public class CGLibInterceptor implements MethodInterceptor {
    private Object target;
    public CGLibInterceptor(Object target) {
        this.target = target;
    }
    /**
     * 调用代理对象的方法
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, org.springframework.cglib.proxy.MethodProxy proxy) throws Throwable {
        //代理增强内容
        System.out.println("我是中介，开始代理");
        Object result = method.invoke(target, args);
        //代理增强内容
        System.out.println("我是中介，结束代理");
        return result;
    }
}

（4）创建代理类，并使用

    代理接口：

public class Main {
    public static void main(String[] args) {
        //目标对象
        HouseSubject target = new RealHouseSubject();
        HouseSubject proxy  = (HouseSubject) Enhancer.create(target.getClass(), new CGLibInterceptor(target));
        proxy.rentHouse();
        System.out.println("=============");
        proxy.saleHouse();
    }
}

    运行程序，执行结果如下：

    代理类：

public class Main {
    public static void main(String[] args) {
        //目标对象
        HouseSubject target = new RealHouseSubject();
        RealHouseSubject proxy  = (RealHouseSubject) Enhancer.create(target.getClass(), new CGLibInterceptor(target));
        proxy.rentHouse();
        System.out.println("=============");
        proxy.saleHouse();
    }
}

    运行程序，执行结果如下：

（5）代码简单讲解

1、MethodInterceptor：

    MethodInterceptor 和 JDK动态代理中的 InvocationHandler 类似，它只定义了一个方法 intercept()，用于增强目标方法。

    public interface MethodInterceptor extends Callback {
        /**
         * 参数说明:
         * o: 被代理的对象
         * method: ⽬标⽅法(被拦截的⽅法, 也就是需要增强的⽅法)
         * objects: ⽅法⼊参
         * methodProxy: ⽤于调⽤原始⽅法
         */
        Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable;
    }

**2、Enhancer.create()**：

    public static Object create(Class type, Callback callback) {
        //...代码省略
    }

    **type**：被代理类的类型（类或接口）
    **callback**：自定义方法拦截器 MethodInterceptor

四、Spring AOP 源码剖析（了解）

    Spring AOP 主要基于两种方式实现的：JDK 及 CGLIB 的方式。
    Spring 源码过于复杂，我们只摘出一些主要内容，以了解为主
    Spring 对于 AOP 的实现，基本都是靠 AnnotationAwareAspectJAutoProxyCreator 去完成 生成代理对象的逻辑在父类 AbstractAutoProxyCreator 中。

protected Object createProxy(Class<?> beanClass,@Nullable String beanName,
@Nullable Object[]specificInterceptors,TargetSource targetSource){
        if(this.beanFactory instanceof ConfigurableListableBeanFactory){
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory)
        this.beanFactory,beanName,beanClass);
        }
        //创建代理⼯⼚
        ProxyFactory proxyFactory=new ProxyFactory();
        proxyFactory.copyFrom(this);
        /**
         * 检查proxyTargetClass属性值，spring默认为false
         * proxyTargetClass 检查接⼝是否对类代理, ⽽不是对接⼝代理
         * 如果代理对象为类, 设置为true, 使⽤cglib代理
         */
        if(!proxyFactory.isProxyTargetClass()){
            //是否有设置cglib代理
            if(shouldProxyTargetClass(beanClass,beanName)){
            //设置proxyTargetClass为true,使⽤cglib代理
            proxyFactory.setProxyTargetClass(true);
        }else{
            /**
             * 如果beanClass实现了接⼝，且接⼝⾄少有⼀个⾃定义⽅法，则使⽤JDK代理
             * 否则CGLIB代理(设置ProxyTargetClass为true )
             * 即使我们配置了proxyTargetClass=false, 经过这⾥的⼀些判断还是可能会将其
             设为true
             */
            evaluateProxyInterfaces(beanClass,proxyFactory);
            }
            }
            Advisor[]advisors=buildAdvisors(beanName,specificInterceptors);
            proxyFactory.addAdvisors(advisors);
            proxyFactory.setTargetSource(targetSource);
            customizeProxyFactory(proxyFactory);
    
            proxyFactory.setFrozen(this.freezeProxy);
            if(advisorsPreFiltered()){
            proxyFactory.setPreFiltered(true);
        }
        // Use original ClassLoader if bean class not locally loaded in overriding class loader
        ClassLoader classLoader =getProxyClassLoader();
        if(classLoader instanceof SmartClassLoader&&classLoader != beanClass.getClassLoader()){
            classLoader=((SmartClassLoader)classLoader).getOriginalClassLoader();
        }
//从代理⼯⼚中获取代理
        return proxyFactory.getProxy(classLoader);
        }

    代理工厂有一个重要的属性：proxyTargetClass，默认值为false。也可以通过程序设置

proxyTargetClass⽬标对象代理⽅式false实现了接口jdk代理false未实现接口(只有实现类)cglib代理true实现了接口cglib代理true未实现接口(只有实现类)cglib代理
可以通过 @EnableAspectJAutoProxy(proxyTargetClass = true) 来设置。

    注意：

Spring 默认 proxyTargetClass：false，会分为两种情况：
    **实现了接口**：使用 JDK 代理。
    **普通类**：       使用 CGLIB 代理。
Spring Boot 2.X 开始，默认使用 proxyTargetClass：true
    **默认使用 CGLIB 代理**

    SpringBoot设置 @EnableAspectJAutoProxy 无效，因为 Spring Boot 默认使用 AopAutoConfiguration 进行装配。
    可以通过配置项 spring.aop.proxy-target-class=false 来进行修改，设置为 jdk 代理。
    使用 context.getBean() 需要添加注解，使 HouseProxy，RealHouseSubject 被 Spring 管理。测试 AOP 代理，需要把这些类交给 AOP 管理（自定义注解或使用 @Aspect）
    我们现在从源码中点进去看看代理工厂的代码：

public class ProxyFactory extends ProxyCreatorSupport {
    //...代码省略
    //获取代理
    public Object getProxy(@Nullable ClassLoader classLoader) {
    //分两步 先createAopProxy,后getProxy
        return createAopProxy().getProxy(classLoader);
    }
    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        return getAopProxyFactory().createAopProxy(this);
    }
    //...代码省略
}

    createAopProxy 的实现在 DefaultAopProxyFactory 中

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    //...代码省略
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws
            AopConfigException {
        /**
         * 根据proxyTargetClass判断
         * 如果⽬标类是接⼝, 使⽤JDK动态代理
         * 否则使⽤cglib动态代理
         */
        if (!NativeDetector.inNativeImage() &&
                (config.isOptimize() || config.isProxyTargetClass() ||
                        hasNoUserSuppliedProxyInterfaces(config))) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine
                        target class:" +
                "Either an interface or a target is required for proxy
                creation. ");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) ||
                    ClassUtils.isLambdaClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        } else {
            return new JdkDynamicAopProxy(config);
        }
    }
    //...代码省略
}

    接下来就是创建代理了

JDK动态代理：

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    //...代码省略
    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating JDK dynamic proxy: " +
                    this.advised.getTargetSource());
        }
        return Proxy.newProxyInstance(determineClassLoader(classLoader),
                this.proxiedInterfaces, this);
    }
    //...代码省略
}

CGLIB动态代理：

class CglibAopProxy implements AopProxy, Serializable {
    //...代码省略
    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
    //...代码省略
    // Configure CGLIB Enhancer...
        Enhancer enhancer = createEnhancer();
    // Generate the proxy class and create a proxy instance.
        return createProxyClassAndInstance(enhancer, callbacks);
    }
    //...代码省略
}

五、常见面试题

1、什么是 AOP？

    AOP是 面向切面编程，也是一种思想，切面指的是某一类特定问题，所以 AOP 也可以理解为 面向切面编程。

2、Spring AOP的实现方式有哪些？

（1）基于注解（@Aspect 或自定义注解）

（2）基于 xml

（3）基于代理

3、Spring AOP 的实现原理？

    基于动态代理实现的，其中的动态代理有两种形式：（1）JDK   （2）CGLIB

4、Spring 使用的是哪种代理方式？

    Spring 的 proxyTargetClass 默认为：false，其中：实现了接口，使用 JDK 代理；普通类：使用CGLIB代理。
    Spring Boot 从 2.X 之后，proxyTargetClass 默认为：true，默认使用 CGLIB 代理

     现在我们测试一下：当这个值为 true 时，则使用的是动态代理
    ![](https://i-blog.csdnimg.cn/direct/80b5aa4fb47d4ccf9622b33a7084f322.png)

@SpringBootApplication
public class SpringAopApplication {
    public static void main(String[] args) {
       ApplicationContext context = SpringApplication.run(SpringAopApplication.class, args);
        //代理类
        TestController bean = context.getBean(TestController.class);
        System.out.println(bean);
    }
}

    要打断电才能观察到结果，如图：

    我们获取Spring管理的对象，打断点，观察对象名称，如图：

    可以看到，是 CGLIB代理。

当值设为 false 时；就要看代理对象是不是接口了，是接口用的就是JDK代理，代理对象是类就是CGLIB代理。

    因为要代理接口，所以现在重新创建一个接口，内容如下：

public interface IFace {
    void test();
}

    再创建一个成 Controller 类，实现上面这个类

@RequestMapping("/test2")
@RestController
public class TestController2 implements IFace{
    @MyAspect
    @RequestMapping("t1")
    @Override
    public void test() {
        System.out.println("测试测试");
    }
}

    main方法如下：

@SpringBootApplication
public class SpringAopApplication {
    public static void main(String[] args) {
       ApplicationContext context = SpringApplication.run(SpringAopApplication.class, args);
       //代理类
        TestController bean = context.getBean(TestController.class);
        System.out.println(bean);
        //代理接口
        IFace iFace = (IFace) context.getBean("testController2");
        System.out.println(iFace);
    }
}

    现在看看Spring对象，任然要使用断点才能看到，如图：

    看看bean对象，如图：

5、JDK 和 CGLIB 的区别？

    使用JDK 动态代理只能代理接口。
    使用 CGLIB 动态代理 既可以代理接口，也可以代理类。

六、总结

    1、**AOP 是一种思想**，是对某一类事情的集中处理。Spring 框架实现了AOP，称之为 Spring AOP。
    2、Spring AOP 场景的实现方式有两种：（1）基于注解@Aspect来实现。（2）基于自定义注解来实现，还有一些更原始的方式，比如基于代理、基于 xml 配置的方式，但目标比较少见。
    3、Spring AOP 是基于动态代理实现的，有两种方式：（1）基于 JDK 动态代理实现。（2）基于 CGLIB 动态代理实现。运行时使用哪种方式与项目配置的代理对象有关。

标签： spring 代理模式 java

本文转载自: https://blog.csdn.net/cool_tao6/article/details/140571214
版权归原作者 tao滔不绝 所有，如有侵权，请联系我们删除。