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

定义

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

代理的几种形式

  1. 静态代理
  2. 动态代理
  3. 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之间就可以互相嵌套

静态代理的缺点

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

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

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

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


动态代理

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

JDK动态代理的实现原理

  1. 拿到被代理类的引用, 并且获取他的所有的接口(反射获取)
  2. JDK Proxy类重新生成一个新的类, 实现了被代理类所有接口的方法
  3. 动态生成Java代码, 把增强逻辑加入到新生成代码中
  4. 编译生成新的Java代码的class文件
  5. 加载并重新运行新的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动态代理容易踩的坑

  1. 无法代理final修饰的方法

CGLib和JDK动态代理对比

  1. JDK动态代理是实现了被代理对象的接口, CGLib是继承了被代理对象
  2. JDK和CGLib都是在运行期生成字节码, JDK是直接写Class字节码, CGLib使用ASM框架写Class字节码, CGLib代理实现更复杂, 生成代理类比JDK效率低(只是生成慢, 执行效率还是高的)
  3. 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中的代理选择原则

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

代理模式的优点

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

代理模式的缺点

  • 代理模式会造成系统设计中类的数目增加
  • 在客户端和目标对象之间增加了一个代理对象, 会造成请求处理速度变慢
  • 增加了系统的复杂度
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值