chen943354

代理模式的理解

    首先代理二字的含义,程序中代理与字面意思的代理并无区别。比如现实生活中办理车辆审车,我们经常会听说花钱找代理(又称黄牛)办手续,即办手续这个事,不是我们亲自执行,而是通过代理(即黄牛)去车管所办理。再比如联系明星商业出演,那明星一般也不会直接和商家对线,而是通过明星的经纪人协商时间地点出场费等。
    换到程序中代理二字也是上述含义:即调用一个对象时,不是直接与此对象示例交互,而是通过对象的代理来完成交互。这就是代理最基本的含义。
    那增加这层代理的好处也可类比现实生活进行理解:
  • 直观的,可以避免调用方和被调用的对象产生直接的联系。也就是程序设计中耦合度问题。
  • 其次,通过代理可以实现目标对象本身所不具备的行为功能。比如明星只负责演出,而经纪人则负责安排档期、经费、缴税等工作。
基于上述的现实案例做铺垫,我们梳理并识别代理模式涉及的几个组成部分:
  • 目标对象:车主、明星
  • 代理人:黄牛、经纪人
  • 行为:办审核手续、唱歌跳舞
  • 提出方、调用方:警察、商人

说回到程序中,代理主要有以下两种形式:

代理的形式之一:静态代理

这里采用明星商演的场景来演示:

public interface IStar {
    void SingAsong(String songName);
}
public class Star implements IStar {
    private String _name;
    public Star(String name) {
        this._name = name;
    }
    @Override
    public void SingAsong(String songName) {
        System.out.println("i am " + _name + ",I'm singing....");
    }
}
public class StaticStarProxy implements IStar {
    Star zhangsanStar = new Star("zhangsan");
    @Override
    public void SingAsong(String songName) {
        this.PlanSingDate();
        zhangsanStar.SingAsong(songName);
        this.PayingTax();
    }
    private String PlanSingDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.add(Calendar.MONTH, 2);
        Date singDate = calendar.getTime();
        System.out.println("sing date =" + singDate);
        return singDate.toString();
    }
    private void PayingTax() {
        System.out.println("payint tex....");
    }
}

public class Main {
    public static void main(String[] args) {

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

        //直接调用,直接与明星对线
        IStar zhangsanStar = new Star("zhangsan");
        zhangsanStar.SingAsong("molihua");
        System.out.println();
        System.out.println("stoping");
    }
上述示例代码中,Star就是明星本人,StarProxy就是代理人,IStar就是行为,Main就是调用方。
程序中静态一般是代表稳定不变的、相对固定的描述。静态代理也就是说代理是相对不变化的,代理程序(StarProxy)怎么写的一般就不会变化。
很显然,明星不止一个,并且明星的行为也不仅仅是唱歌。采用静态代理就会产生几个问题:
  • 如果采用多个明星对应多个代理类的话,那么就会产生大量的代理类出现。【虽然在现实生活中是合理的,但是程序中一般追求精简】
  • 如果采用多个明星对应一个代理类,那么这个代理类的实现就会很复杂,且代理类变更频繁。
  • 还有一个问题,如果明星增加技能(比如跳舞),那么代理类就需要同步的变更。
于是,程序中提出了动态代理来解决这些问题。

代理的形式之二:动态代理

所谓动态代理,直观理解就是代理是动态生成的,而不需要提前编写好。


public class DnyamicStarProxy implements InvocationHandler {
    IStar _targetStar;

    public DnyamicStarProxy(IStar star) {
        this._targetStar = star;
    }

    @Override
    public Object invoke(Object proxyInstance, Method method, Object[] objects) throws Throwable {
        this.PlanSingDate();
        Object invokeResult = method.invoke(_targetStar, objects);
        this.PayingTax();
        return invokeResult;
    }

    private String PlanSingDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.add(Calendar.MONTH, 2);
        Date singDate = calendar.getTime();
        System.out.println("sign date =" + singDate);
        return singDate.toString();
    }

    private void PayingTax() {
        System.out.println("the agent is paying tex....");
    }
}

public class Main {
    public static void main(String[] args) {

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

        //直接调用,直接与明星对线
        IStar zhangsanStar = new Star("zhangsan");
        zhangsanStar.SingAsong("molihua");
        System.out.println();

        //代理模式,通过经纪人对线
        IStar zhangsanProxy = (IStar) new StaticStarProxy();
        zhangsanProxy.SingAsong("molihua");
        System.out.println();

        //代理模式,动态代理调用
        System.out.println("邀请李四演出:");
        IStar lisiStar = new Star("lisi");
        IStar lisiStarProxy = (IStar) Proxy.newProxyInstance(IStar.class.getClassLoader()
                , new Class[]{IStar.class}
                , new DnyamicStarProxy(lisiStar));
        lisiStarProxy.SingAsong("molihua");
        System.out.println();

        System.out.println("邀请王五演出:");
        IStar wangwuStar = new Star("wangwu");
        IStar wangwuStarProxy = (IStar) Proxy.newProxyInstance(IStar.class.getClassLoader()
                , new Class[]{IStar.class}
                , new DnyamicStarProxy(wangwuStar));
        wangwuStarProxy.SingAsong("molihua");
        System.out.println();
     
        System.out.println("stoping");
    }
输出结果:
starting....
i am zhangsan,I'm singing....

sing date =Wed Mar 16 18:14:17 CST 2022
i am zhangsan,I'm singing....
payint tex....

邀请李四演出:
sign date =Wed Mar 16 18:14:17 CST 2022
i am lisi,I'm singing....
the agent is paying tex....

邀请王五演出:
sign date =Wed Mar 16 18:14:17 CST 2022
i am wangwu,I'm singing....
the agent is paying tex....

stoping

进程已结束,退出代码为 0
 
首先对代码中陌生的类和方法做一个说明:
InvocationHandler类的Object invoke(Object o, Method method, Object[] objects)
  • 入参o代表:动态生成的代理类对象
  • 入参method代表;调用方调用的哪个方法,演示代码中即代表SingAsong方法
  • 入参objects代表:调用方法传入的参数,即实参
 
Proxy类的static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
  • 参数loader:代表java反射中的类加载器
  • 参数interfaces:代表依赖的接口
  • 参数h:代表动态代理类的的对象,即DnyamicStarProxy
 
站在调用方角度来说,可以这么理解:调用SingAsong时不是直接new一个Star实例就调用了,而是通过Proxy.newProxyInstance动态的创建一个代理类的对象,然后通过此代理类的对象来调用。
 
通过演示代码,可以看出以下特征:
  • 只有一个DnyamicStarProxy类,而省掉了具体的各个代理人的类;
  • 对商人(调用方)来说,只需要提前知道想要邀请的明星(李四、王五),然后通过特定的代码就生成了明星经纪人对象(lisiStarProxy、wangwuStarProxy)
  • 得到经纪人对象后,就可以通过经纪人对象调用执行具体的行为(唱歌)。
同时,我们梳理分析看看动态代理方式的各个组成部分的依赖情况:
  • 目标对象:Star,没有额外的变化
  • 代理人:省掉了具体的xxx代理人,转为DnyamicStarProxy类,从而依赖InvocationHandler类。
  • 行为:IStar,没有额外的变化
  • 调用方:依赖IStar接口、特定的Star类对象、Proxy类、DnyamicStarProxy类
 
现在,我们考虑一个问题:演示代码中是如何调用了Star类的Sing方法?
根据程序执行输出,可以判断是在DnyamicStarProxy.Invoke中调用的。于是可以看到反射技术的应用,即method.invoke()处利用反射真正执行了Star的SingAsong()方法。
 

动态代理的一些常见思考题:

Java常用的动态代理技术有哪些?

    本次演示程序虽然用到反射技术来实现动态代理,但也有其它技术来实现比如CGLIB等

演示代码中,调用方还是new了具体的明星类(lisiStar、wangwutar),这就产生了严重的依赖。有什么办法可以解除这个依赖?

DnyamicStarProxy.Invoke中通过反射执行了目标对象的方法(Star.SingAsong),此时执行的代码是本地的代码。如果这里通过socket将方法名、入参发送到另一台server上执行,然后把结果在再通过网络返回,这就是RPC框架中常用的动态代理了。

虽然是动态代理,但根据前面的铺垫,按说也是会生成代理类的吧,那动态生成的代理长什么样?

    确实是运行期间动态生成了代理类,如下所示:
注意动态代理类的SingAsong方法;
查看代码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

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

public final class DynamicGeneratedStarProxyClass extends Proxy implements IStar {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public DynamicGeneratedStarProxyClass(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);
        }
    }

    public final void SingAsong(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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 = Class.forName("Stars.IStar").getMethod("SingAsong", Class.forName("java.lang.String"));
            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());
        }
    }
}
 

分类:

技术点:

相关文章: