设计模式 - 深度分析代理模式 ( Proxy 静态代理 or 动态代理 )

最新推荐文章于 2023-05-22 15:20:19 发布

zzj0807

最新推荐文章于 2023-05-22 15:20:19 发布

阅读量170

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/weixin_42254177/article/details/109400846

版权

设计模式专栏收录该内容

15 篇文章 0 订阅

订阅专栏

定义

为其他对象提供一种代理, 以控制对这个对象的访问
代理对象在客户端和目标对象之间起到中介作用
数据结构型设计模式

代理的几种形式

静态代理
动态代理
Spring AOP

适用场景

保护目标对象
增强目标对象

静态代理

显式声明被代理对象

原始代码

interface Movable {
    void move();
}
public class Tank implements Movable {
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(1000)); // 模拟坦克移动了一段儿时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

问题1: 我想记录坦克的移动时间

一般的做法是直接改move方法

public class Tank implements Movable {
    @Override
    public void move() {
        long start = System.currentTimeMillis();

        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000)); // 模拟坦克移动了一段儿时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void main(String[] args) {
        new Tank().move();
    }
}

interface Movable {
    void move();
}

问题2: 如果无法改变方法源码呢？ benchmark

像下面这样用继承?

public class Tank implements Movable {
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new Tank2().move();
    }
}

class Tank2 extends Tank {
    @Override
    public void move() {
        long start = System.currentTimeMillis();
        super.move();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

interface Movable {
    void move();
}

这样的话, 耦合度太高, 假如我又需要记录权限, 也需要记录日志, 再记录时间, 就要不断的继承
这样的方式肯定是不好的

我们终于开始引入Proxy类了

加一个TankTimeProxy, TankLogProxy, 在main方法调用中, 有点像装饰者模式, 实现了代理的各种组合
没错, 设计模式到最后就是各种模式相互混杂而成, 是对多态的各种灵活巧妙地使用

public class Tank implements Movable {
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new TankTimeProxy().move();
    }
}

class TankTimeProxy implements Movable {
    Tank tank;
    @Override
    public void move() {
        long start = System.currentTimeMillis();
        tank.move();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

class TankLogProxy implements Movable {
    Tank tank;
    @Override
    public void move() {
        System.out.println("start moving...");
        tank.move();
        System.out.println("stopped!");
    }
}

interface Movable {
    void move();
}

问题: 被代理的对象只能是Tank吗?

把Tank改成Movable就可以了, 如下:

public class Tank implements Movable {
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new TankLogProxy( new TankTimeProxy( new Tank() ) ).move();
    }
}

class TankTimeProxy implements Movable {
    Movable m;

    public TankTimeProxy(Movable m) {
        this.m = m;
    }

    @Override
    public void move() {
        long start = System.currentTimeMillis();
        m.move();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

class TankLogProxy implements Movable {
    Movable m;

    public TankLogProxy(Movable m) {
        this.m = m;
    }

    @Override
    public void move() {
        System.out.println("start moving...");
        m.move();
        long end = System.currentTimeMillis();
        System.out.println("stopped!");
    }
}

interface Movable {
    void move();
}

至此, 发展到这一步, 一个真正的静态代理就产生了

在这里插入图片描述
Tank和Proxy都去实现Movable, 这样ProxyA和ProxyB之间就可以互相嵌套

静态代理的缺点

Tank必须实现Movable, 否则就没法调用move方法
不能代理任意类型的Object子类, 因为Object里没有任何的业务方法 ( 给你一个Movable, 你知道去调用move(), 给你一个Object呢, 里面啥都没有, 代理个啥? 没法指定, 没法写死 )

问题: 如果想让LogProxy可以代理任意类型的Object呢?

毕竟日志记录，时间计算是很多方法都需要的东西，这时该怎么做呢？
难道把Movable改成Object吗? 那move方法怎么办, Object类里, 可没有move方法

本质上来讲, 我们在做这样一件事: 分离代理行为和被代理对象

动态代理

动态代理的Proxy类, 不是自己手写的, 而是动态生成的, 你看不见他的代码

JDK动态代理的实现原理

拿到被代理类的引用, 并且获取他的所有的接口(反射获取)
JDK Proxy类重新生成一个新的类, 实现了被代理类所有接口的方法
动态生成Java代码, 把增强逻辑加入到新生成代码中
编译生成新的Java代码的class文件
加载并重新运行新的class, 得到类就是全新类

public class Tank implements Movable {
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Tank tank = new Tank();
        //reflection 通过二进制字节码分析类的属性和方法
        Movable m = (Movable) Proxy.newProxyInstance(Tank.class.getClassLoader(),
                new Class[]{Movable.class}, //tank.class.getInterfaces()
                new LogHander(tank)
        );
        m.move();
    }
}

class LogHander implements InvocationHandler {
    Object obj;

    public LogHander(Tank tank) {
        this.obj = tank;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("method " + method.getName() + " start..");
        Object o = method.invoke(obj, args);
        System.out.println("method " + method.getName() + " end!");
        return o;
    }
}

interface Movable {
    void move();
}

运行结果:

method move start..
Tank moving claclacla...
method move end!

终于, Proxy类里的类型不再是Movable了, 变成了Object , 可以代理任意类型的对象了
只是, 这个对象还是得实现interface, 并且在调用newProxyInstance方法时, 作为参数传进去

问题: InvocationHandler里的invoke方法, 是在哪里被调用的呢

public Object invoke(Object proxy, Method method, Object[] args)

答案是: 上面这个方法, 是在JDK生成的动态代理类里调用的
我们可以加入下面这句话

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
// 或者
System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles","true");

public class Tank implements Movable {
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Tank tank = new Tank();

        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        Movable m = (Movable) Proxy.newProxyInstance(Tank.class.getClassLoader(),
                new Class[]{Movable.class}, //tank.class.getInterfaces()
                new TimeProxy(tank)
        );
        m.move();
    }
}

class TimeProxy implements InvocationHandler {
    Object obj;

    public TimeProxy(Movable m) {
        this.obj = m;
    }

	// 这里的Object proxy是那个生成的代理对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //Arrays.stream(proxy.getClass().getMethods()).map(Method::getName).forEach(System.out::println);
        System.out.println("method start..");
        Object o = method.invoke(this.obj, args);
        System.out.println("method stop..");
        return o;
    }
}

interface Movable {
    void move();
}

运行上面的代码之后, 会在proxy/v10目录下, 生成$Proxy0.class文件
在这里插入图片描述

点进去, 可以看到如下的代码

package proxy.v10;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

final class $Proxy0 extends Proxy implements Movable { // 自动帮我们实现了Movable接口
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

	// 构造器, 接收了一个实现InvocationHandler的那个类TimeProxy的实例
	// 下面有个super.h, 引用的就是这个传进来的var1对象
    public $Proxy0(InvocationHandler var1) throws  { 
        super(var1);
    }
    
	// object的equals方法, 可以忽略
    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);
        }
    }
    
	// 自动帮我们实现了Proxy中的move方法
    public final void move() throws  {
        try {
			// super.h就是实现了InvocationHandler的那个类TimeProxy的实例
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    
    // object的toString方法, 可以忽略
    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);
        }
    }
    
	// object的hashCode方法, 可以忽略
    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 = Class.forName("proxy.v10.Movable").getMethod("move");
            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());
        }
    }
}

Proxy.newProxyInstance中生成$Proxy0的核心代码是

/*
 * Look up or generate the designated proxy class.
 */
Class<?> cl = getProxyClass0(loader, intfs);

JDK动态代理的时序图

在这里插入图片描述

用了asm之后 , java才能被称之为"动态语言"
所谓动态语言, 就是在执行过程中, 动态的修改代码
反射只能获取代码, 不能修改原先代码的逻辑
asm能直接操纵二进制

在这里插入图片描述

JDK动态代理相比静态代理的优点

被代理对象可以是Object的子类, 而不是某个接口 ( 比如Movable )

JDK动态代理的缺点

被代理对象必须实现接口

Java自带的Instrument

Instrument比asm还要强大, 直接操纵二进制码, 但是需要你理解每一个0和1是什么意思, 而asm是提供了可读的方法, 间接的帮助你实现操纵二进制码
由于专业性太强, 可以不必关注
其实说实话, asm虽然比instrument简单, 但也知道下就行了

CGLib ( Code Generation Library )

优点

被代理对象不需要实现接口, 见下面这行代码

enhancer.setSuperclass(Tank.class); // 在这里设置的是被代理类

完整的代码:

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Tank.class); // 在这里设置的是被代理类
        enhancer.setCallback(new TimeMethodInterceptor());
        Tank tank = (Tank) enhancer.create();
        tank.move();
    }
}

class TimeMethodInterceptor implements MethodInterceptor {
	// Object o 就是CGLib生成的动态代理类的一个实例
	// Object o 在debug时看到的对象是cglib.Tank$$EnhancerByCGLIB$$18e13221@458ad742
	// Method method 是 public void cglib.Tank.move()
	// MethodProxy是cglib的一个类: net.sf.cglib.proxy.MethodProxy
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println(o.getClass().getSuperclass().getName());
        System.out.println("before");
        Object result = null;
        result = methodProxy.invokeSuper(o, objects);
        System.out.println("after");
        return result;
    }
}

class Tank {
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

CGLib底层用的也是asm ( JDK动态代理, Spring用的也都是asm )
但是用CGLib的时候, 被代理对象的类, 不能被final修饰
但是asm可以, asm可以在二进制文件中, 把final修饰符给去掉

CGLib动态代理容易踩的坑

无法代理final修饰的方法

CGLib和JDK动态代理对比

JDK动态代理是实现了被代理对象的接口, CGLib是继承了被代理对象
JDK和CGLib都是在运行期生成字节码, JDK是直接写Class字节码, CGLib使用ASM框架写Class字节码, CGLib代理实现更复杂, 生成代理类比JDK效率低(只是生成慢, 执行效率还是高的)
JDK调用代理方法, 是通过反射机制调用, CGLib是通过FastClass机制直接调用方法, CGLib执行效率更高

Spring AOP

app_auto.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
    <aop:aspectj-autoproxy/>
    <bean id="tank" class="com.mashibing.dp.spring.v2.Tank"/>
    <bean id="timeProxy" class="com.mashibing.dp.spring.v2.TimeProxy"/>
</beans>

Tank.java

public class Tank {
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

TankProxy.java

@Aspect
public class TimeProxy {
    @Before("execution (void com.mashibing.dp.spring.v2.Tank.move())")
    public void before() {
        System.out.println("method start.." + System.currentTimeMillis());
    }

    @After("execution (void com.mashibing.dp.spring.v2.Tank.move())")
    public void after() {
        System.out.println("method stop.." + System.currentTimeMillis());
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("app_auto.xml");
        Tank t = (Tank)context.getBean("tank");
        t.move();
    }
}

SpringAOP中的代理选择原则

当Bean有实现接口时, Spring就会用JDK动态代理
当Bean没有实现接口时, Spring选择CGLib
Spring可以通过配置强制使用CGLib, 只需在Spring的配置文件中加入如下代码<aop:aspectj-autoproxy proxy-target-class=“true” />

代理模式的优点

代理模式能将代理对象与真实被调用的目标对象分离
一定程度上降低了系统的耦合程度, 易于扩展
代理可以起到保护目标对象的作用
增强目标对象的职责

代理模式的缺点

代理模式会造成系统设计中类的数目增加
在客户端和目标对象之间增加了一个代理对象, 会造成请求处理速度变慢
增加了系统的复杂度

zzj0807

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式 - 深度分析代理模式 ( Proxy 静态代理 or 动态代理 )

定义为其他对象提供一种代理, 以控制对这个对象的访问代理对象在客户端和目标对象之间起到中介作用数据结构型设计模式适用场景保护目标对象增强目标对象静态代理显式声明被代理对象JDK动态代理的实现原理拿到被代理类的引用, 并且获取他的所有的接口(反射获取)JDK Proxy类重新生成一个新的类, 实现了被代理类所有接口的方法动态生成Java代码, 把增强逻辑加入到新生成代码中编译生成新的Java代码的class文件加载并重新运行新的class, 得到类就是全新类CGLib
复制链接

扫一扫