【代理】SpringBoot 代理简单玩法

lcllge

已于 2024-06-14 13:55:33 修改

阅读量1.6k

点赞数 35

CC 4.0 BY-SA版权

文章标签：代理模式 java spring boot

于 2024-06-14 11:54:57 首次发布

本文链接：https://blog.youkuaiyun.com/lcllge/article/details/139673877

Java 独守闺房夜探代理鸡鸣灯灭

初探代理, 心情湿漉漉

初探代理, 心情湿漉漉

曾经某一刻, 我突然觉得生命很空旷, 于是对她说
“我们研究下哲学诗词歌赋以及音律吧”
她侧着头躺我怀里, 昏暗的灯光下她是那样的迷人
“就是不聊人生吗? 算了, 你还是吃药吧!”
我顿感尴尬, 唏嘘道
“吃了, 等会儿, 药效还没上来”…

摘自《年轻时我也是一匹孤狼》

1. 最TM烦人的理论环节

代理不仅仅是一种模式, 也是一个Aop的实现, 今天我们先不谈代理模式, 玩一玩在Spring/Springboot中的代理实现, 简单追溯下其原理和使用方法.

Spring中代理使用的算是非常多, 拿个最简单的例子来说吧, Springboot晓得不, 启动类其实就是被代理的, 不信看代码:

@Slf4j
@Component
public class OwnBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        log.info("完成 初始化Bean {} ： {}", beanName, bean.getClass().getName());
        return bean;
    }
}

看运行结果撒

遇到问题, 不要问为什么 ! 也不要问why, 我们先说说Spring用的两种代理方式

1. Java 自带的代理

JDK中动态代理类只需要使用java.lang.reflect.Proxy.newProxyInstance方法，该方法需要接收三个参数，完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

注意该方法是在Proxy类中是静态方法，且接收的三个参数依次为:

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的
Class<?>[] interfaces：目标对象实现的接口类型,使用泛型方式确认类型，获取接口类型的方法是固定的
InvocationHandler h；事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法作为参数传入

2. Cglib 代理

静态代理和jdk动态代理都要求目标对象实现接口，cglib动态代理，使用以目标对象子类的方式实现代理，（当目标对象是一个单独的对象，没有实现任何接口时使用).

Cglib代理，也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。Cglib是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，为其提供方法的interception(拦截)，例如大家所熟知的Spring AOP。

Cglib包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类。

Cglib子类代理需要注意的是:

需要引入cglib的jar包
代理的类不能是final，否则报错
目标对象的方法如果有final/static，那么不会被拦截，即不会执行目标对象额外的业务方法。

2. 图解理论

无

3. 还原代码原理

代码前置准备工作
编写一个接口, 和实现类

public interface Hello {
    void hello();
}

public class SayHello implements Hello {
    @Override
    public void hello() {
        System.out.println("say hello");
    }
}

JDK 代理实现

创建一个 InvocationHandler 的实现

public class MyInvocationHandler implements InvocationHandler {

    private Object proxy;

    public MyInvocationHandler(Object proxy) {
        this.proxy = proxy;
    }

    /**
     * 真正执行的方法区域
     * @param proxy – 调用该方法的代理实例
     * @param method Method– 与代理实例上调用的接口方法对应的实例。对象的声明类Method将是声明方法的接口，该接口可能是代理类继承方法的代理接口的超接口。
     * @param args – 一个对象数组，其中包含在代理实例上的方法调用中传递的参数值，如果接口方法不接受任何参数，则为 null。基元类型的参数包装在相应的基元包装类的实例中，
     *             例如 java.lang.Integer 或 java.lang.Boolean。
     *
     * @return obj
     * @throws Throwable ex
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("执行方法前" + method);
        Object invoke = method.invoke(this.proxy, args);
        System.out.println("执行方法后");
        return invoke;
    }

    /**
     * loader – 用于定义代理类的类加载器
     * interfaces – 代理类要实现的接口列表
     * h – 将方法调用分派给的调用处理程序
     */
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), proxy.getClass().getInterfaces(), this);
    }
}

使用

public class ProxyTest {

    public static void main(String[] args) {
        // jdk 动态代理实现, 依靠Proxy, InvocationHandler, 通过反射的手法获取类信息, 做增强处理
        Hello hello = new SayHello();
        MyInvocationHandler invocationHandler = new MyInvocationHandler(hello);
        UserService proxy = (UserService) invocationHandler.getProxy();
        System.out.println("代理对象信息为: " + proxy);
        proxy.addUser(new User());
    }

}

运行结果:
在这里插入图片描述

Cglib 代理实现
导包

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

编写代理类

public class CglibProxy implements MethodInterceptor {

    private Enhancer enhancer = new Enhancer();

    /**
     * cglib采用asm字节码编译技术, 创建目标类的子类, 目标方法在其父类被调用
     *
     * @param o           增强对象
     * @param method      调用方法
     * @param objects     参数
     * @param methodProxy 方法代理
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用方法之前=====" + method);
        Object obj = methodProxy.invokeSuper(o, objects);
        System.out.println("调用方法之后...........");
        return obj;
    }

    public Object getProxy(Class<?> clazz) {
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

}

测试类

public class ProxyTest {

    public static void main(String[] args) {
        // cglib通过代理类为实现类的子类来做的
        Hello hello = new SayHello();
        CglibProxy proxy1 = new CglibProxy();
        Hello proxy2 = (Hello) proxy1.getProxy(hello.getClass());
        System.out.println("代理对象信息为: " + proxy2);
        proxy2.hello();
    }

}

运行结果
在这里插入图片描述

4. 总结

最后再一起运行下Test:

public class ProxyTest {

    public static void main(String[] args) {
        // jdk 动态代理实现, 依靠Proxy, InvocationHandler, 通过反射的手法获取类信息, 做增强处理
        Hello hello = new SayHello();
        System.out.println("被代理对象原信息为: " + hello);
        System.out.println("==================================================================================");

        MyInvocationHandler invocationHandler = new MyInvocationHandler(hello);
        Hello proxy = (Hello) invocationHandler.getProxy();
        System.out.println("代理对象信息为: " + proxy);
        proxy.hello();

        System.out.println("与原类是否是同一个类: " + hello.equals(proxy));

        System.out.println("==================================================================================");

        // cglib通过代理类为实现类的子类来做的
        CglibProxy proxy1 = new CglibProxy();
        Hello proxy2 = (Hello) proxy1.getProxy(hello.getClass());
        System.out.println("代理对象信息为: " + proxy2);
        proxy2.hello();
        System.out.println("与原类是否是同一个类: " + hello.equals(proxy2));
    }

}

在这里插入图片描述
你以为就完了吗 ?! 不, 还没有, 接下来继续深究下生成的字节码文件都做了什么

JDK动态代理类

// 设置java字节码生成的开关, 开启后会在项目文件夹中生成一个com的文件夹, 里面会有运行时的代理类生成信息
System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

看一看里面有什么鬼

import com.restudy.proxy.Hello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

// 可以看到这个代理类已经继承了 java.lang.reflect.Proxy, 因此使用jdk的动态代理是无法代理没有接口的实现类的(面试的时候知道该怎么说了吧!)
public final class $Proxy0 extends Proxy implements Hello {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
	
	// 其代理方法被final修饰, 且里面用的是反射实现的调用(答案呼之欲出: jdk用的就是反射生成其代理接口的一个实现类)
    public final void hello() throws  {
        try {
	        // 调用方法[hello()] ⇒ 看下面的static | m3 = Class.forName("com.restudy.proxy.Hello").getMethod("hello");
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            // 这里的m3就是其被代理的方法, 实现时会用 多态 的特性, 调用到其具体实现 (因为在Proxy.newProxyInstance中已经用其构造器构造了一个代理类对象($Proxy0)了)
            m3 = Class.forName("com.restudy.proxy.Hello").getMethod("hello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

Cglib动态代理
设置其生成字节码可见

// 和jdk的配置一样, 在调用代理之前设置就可以了, 会在项目运行根目录下生成一个 cglib_classes 的文件夹
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "cglib_classes");

看看里面有什么鬼
在这里插入图片描述
我不管! 直接深入主题看里面是个什么东西


import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

// 从类的定义上来说, 我们代理类其实就是继承了目标类的一个实现 (这里知道为啥可以代理普通类了吧, 注意, 不是接口!!)
public class SayHello$$EnhancerByCGLIB$$984d29a8 extends SayHello implements Factory {
    ...
	
	// 这玩意太长了, 只要找到被调用的代理方法就行, 其他先不看, 重点看这个
    public final void hello() {
	    // 我们在调用代理方法时创建的 MethodInterceptor 子类在这个
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
	        // 这个intercept方法就是被实际调用的地方了, 跟这个进去看看
            var10000.intercept(this, CGLIB$hello$0$Method, CGLIB$emptyArgs, CGLIB$hello$0$Proxy);
        } else {
            super.hello();
        }
    }

    ...
}

next源码: var10000.intercept(this, CGLIB$hello $0$ Method, CGLIB $e m pt y A r g s, CG L I B$ hello $0$ Proxy);

package net.sf.cglib.proxy;

/**
 * General-purpose {@link Enhancer} callback which provides for "around advice".
 * @author Juozas Baliuka <a href="mailto:baliuka@mwm.lt">baliuka@mwm.lt</a>
 * @version $Id: MethodInterceptor.java,v 1.8 2004/06/24 21:15:20 herbyderby Exp $
 */
public interface MethodInterceptor
extends Callback
{
    /**
     * All generated proxied methods call this method instead of the original method.
     * The original method may either be invoked by normal reflection using the Method object,
     * or by using the MethodProxy (faster).
     * @param obj "this", the enhanced object
     * @param method intercepted Method
     * @param args argument array; primitive types are wrapped
     * @param proxy used to invoke super (non-intercepted method); may be called
     * as many times as needed
     * @throws Throwable any exception may be thrown; if so, super method will not be invoked
     * @return any value compatible with the signature of the proxied method. Method returning void will ignore this value.
     * @see MethodProxy
     */    
    // 得!死胡同了吧, 这时候需要一点古老的中国智慧: 来都来了, 是吧?
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;

}

根据古老的中国智慧(还得是多态)得知, 我们最后调用的 var10000.intercept(this, CGLIB$hello $0$ Method, CGLIB $e m pt y A r g s, CG L I B$ hello $0$ Proxy); 指向就是我们最初编写的 MyInvocationHandler, 然后调用链就清晰了, 最终其实就是调用的 InvocaionHandler的intercept方法, 只不过里面的 methodProxy.invokeSuper(o, objects); 指向的是我们代理类的真正方法

关于 ASM 字节码编译技术, 怎么讲呢 ? 你去看看asm底层实现, 其实就是动态生成二进制数据 (就是.class文件) , 只不过里面的格式需要遵循 JVM 规范去实现, 篇幅所限, 以后可能会开一期讲讲 asm 怎么玩, 你只需要知道, CGlib的目标就是生成规范的class文件就可以了.

可以看到对于代理JDK和CGlib都可以生成一个代理类来增强原有的实现, 但是不同的是使用方法, 以及底层:

JDK代理是生成的代理类的接口实现, 其调用的是反射生成的类对象, 是通过反射类new一个新子类对象, 同时, 调用的是新对象的方法, 和新对象不是同一个类, 本身依赖于接口实现(因此需要传入接口信息)
Cglib使用的是asm字节码生成的对象信息, 本质上是当前类的一个继承类, 因此Cglib可以代理普通类, 而非接口, 但本身受困继承关系因此, final, static等信息是不能实现其细节