代理模式

杀鸡不想用牛刀-用代理

  大家好,我是小赵,求职的路虽然难,但最终还是有个着落,我现在进了藏剑山庄任职铸剑师,不过没意思,因为活都是低级的活,批量铸些普通的匕首、短剑之类,一天到晚忙个没完,这藏剑山庄果然是个大厂,订单超级多。

 

  做着做着我就没动力了,没啥技术含量,虽然是计件,但还不如我的打印机业务赚钱来的多,于是我就私底下请一些有空的同事帮我干活,而我就每天打个卡,然后就在家发展我的打印事业。

  其实主要原因呢,还是因为我暂时不打算离职,先静观其变,等待机会,毕竟这是个大企业。

 

  现在,是写日记的时候,我要记录一下我请同事干活的过程。

 

  首先,同事给我干活,那就必须要有和我一样的技能,比如调剂、熔炼、浇铸、加工这些铸剑流程,所以铸剑的流程应该抽象出来。而同事给我干活,天知地知,虽然是他干的活,但这些剑的创建者名字必须是我。

 

  思考完毕之后,我画下了类图:

  接下来我就根据这个类图来写程序

铸剑流程抽象:

public interface IMakeSword {
    //调剂
    void adjust();

    //熔炼
    void smelt();

    //浇铸
    void casting();

    //加工
    void process();
} 

 

我:

public class User implements IMakeSword {
    //名字
    private String name = "";

    public User(String name) {
        this.name = name;
    }
    @Override
    public void adjust() {
        System.out.println(this.name + "正在调剂...");
    }
    @Override
    public void smelt() {
        System.out.println(this.name + "正在熔炼...");
    }
    @Override
    public void casting() {
        System.out.println(this.name + "正在浇铸...");
    }
    @Override
    public void process() {
        System.out.println(this.name + "正在加工...");
    }
} 

 

同事:

public class Colleague implements IMakeSword{
    private IMakeSword user;

    //构造函数把我传进来
    public Colleague(IMakeSword user) {
        this.user = user;
    }
    @Override
    public void adjust() {
        this.user.adjust();
    }
    @Override
    public void smelt() {
        this.user.smelt();
    }
    @Override
    public void casting() {
        this.user.casting();
    }
    @Override
    public void process() {
        this.user.process();
    }
}

 

  差不多了,现在我的同事要开始给我干活了:

    public static void main(String[] args) {
        IMakeSword xiaoZhao = new User("小赵");
        IMakeSword colleague = new Colleague(xiaoZhao);
        colleague.adjust();
        colleague.smelt();
        colleague.casting();
        colleague.process();
    }

 

输出:

小赵正在调剂...
小赵正在熔炼...
小赵正在浇铸...
小赵正在加工...

 

  这个活干的是非常的好,工资我当然会转给同事,但是我的工作量在山庄里还不至于难看。

  随手一招代理模式,暂时保着这份工作,赚个五险一金。

 

严查之下-强制代理

  后来,不知道是哪里传出的风声,山庄高层领导好像知道了什么,安排了专案小组暗地里对一些不正之风进行严查严打。

  我不怕顶风作案,就怕做的不严实。

  如果,专案小组假扮我的同事,那我不就嗝屁了吗?于是,我决定把我和我同事的关系隐藏到内部,不让人看到,也不接受外面传入。

 

  来看看我更改后的程序:

铸剑流程抽象:

public interface IMakeSword {
    //调剂
    void adjust();

    //熔炼
    void smelt();

    //浇铸
    void casting();

    //加工
    void process();

    //获取我的代理
    IMakeSword getProxy();
}

  加一个getProxy方法,获取我的代理,就是我的同事嘛,增加这个方法是为了防止外人假冒。

 

我:

public class User implements IMakeSword {
    //名字
    private String name = "";

    //我的同事
    private IMakeSword proxy = null;

    public User(String name) {
        this.name = name;
    }
    @Override
    public void adjust() {
        if(null == this.proxy){
            System.out.println("你好,"+this.name+"在休息。");
            return;
        }
        System.out.println(this.name + "正在调剂...");
    }
    @Override
    public void smelt() {
        if(null == this.proxy){
            System.out.println("你好,"+this.name+"在休息。");
            return;
        }
        System.out.println(this.name + "正在熔炼...");
    }
    @Override
    public void casting() {
        if(null == this.proxy){
            System.out.println("你好,"+this.name+"在休息。");
            return;
        }
        System.out.println(this.name + "正在浇铸...");
    }
    @Override
    public void process() {
        if(null == this.proxy){
            System.out.println("你好,"+this.name+"在休息。");
            return;
        }
        System.out.println(this.name + "正在加工...");
    }

    @Override
    public IMakeSword getProxy() {
        //我和同事的小黑屋
        this.proxy = new Colleague(this);
        return this.proxy;
    }
}

在getProxy方法里,我在小黑屋里自己联系我的同事,并且在每个动作执行的时候,先检测我有没有代理,没代理的话千万别乱动。

 

同事:

public class Colleague implements IMakeSword{
    private IMakeSword user;

    //构造函数把我传进来
    public Colleague(IMakeSword user) {
        this.user = user;
    }
    @Override
    public void adjust() {
        this.user.adjust();
    }
    @Override
    public void smelt() {
        this.user.smelt();
    }
    @Override
    public void casting() {
        this.user.casting();
    }
    @Override
    public void process() {
        this.user.process();
    }

    @Override
    public IMakeSword getProxy() {
        return this;
    }
}

同事类则几乎没变化,getProxy方法也不需要的,返回同事自己就可以了。

 

  来,现在再试一下合作:

    public static void main(String[] args) {
        IMakeSword xiaoZhao = new User("小赵");
        IMakeSword colleague = xiaoZhao.getProxy();
        colleague.adjust();
        colleague.smelt();
        colleague.casting();
        colleague.process();
    }

输出:

小赵正在调剂...
小赵正在熔炼...
小赵正在浇铸...
小赵正在加工...

 

  这是新的合作方式,谁也不知道我的代理是谁。

如果专案小组来假冒同事呢:

    public static void main(String[] args) {
        IMakeSword xiaoZhao = new User("小赵");
        IMakeSword colleague = new Colleague(xiaoZhao);
        colleague.adjust();
        colleague.smelt();
        colleague.casting();
        colleague.process();
    }

输出:

你好,小赵在休息。
你好,小赵在休息。
你好,小赵在休息。
你好,小赵在休息。

 

  这就是强制代理的手法,代理由自己管理,从此以后,我又可以高枕无忧了。

 

降低合作门槛-动态代理

  我没想到,我那个同事不仅接我的活,还同时接别人的活,可别人就没我这么聪明啊,天天对着他new、new、new!结果没过几天就被专案小组给逮着了,直接翻船,同事也被供出来了,被劝退。

  

  随着我同事的牺牲,山庄的严打行动逐渐结束,不久后专案小组解散,紧张的氛围舒缓而开。

  但是我得从新找合作人啊,私底下接触了几个有意向的同事,都觉得我的合作方式太过麻烦,必须要有代理类,就是Colleague类,要实现一箩筐方法,而且创建了类就是留下了证据,将来就有被查到的风险。

  

  在我的一阵子研究之后,发现JDK有一个InvocationHandler接口可以用,于是乎,我重新写了一个程序。

 

铸剑流程抽象:

public interface IMakeSword {
    //调剂
    void adjust();

    //熔炼
    void smelt();

    //浇铸
    void casting();

    //加工
    void process();
}

 

我:

public class User implements IMakeSword {
    //名字
    private String name = "";

    public User(String name) {
        this.name = name;
    }
    @Override
    public void adjust() {
        System.out.println(this.name + "正在调剂...");
    }
    @Override
    public void smelt() {
        System.out.println(this.name + "正在熔炼...");
    }
    @Override
    public void casting() {
        System.out.println(this.name + "正在浇铸...");
    }
    @Override
    public void process() {
        System.out.println(this.name + "正在加工...");
    }
}

 

动态代理类:

public class ColleagueHandler implements InvocationHandler {
    Object object = null;

    //代理的目标
    public ColleagueHandler(Object object) {
        this.object = object;
    }

    //调用目标方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(this.object,args);
    }
}

 

开始干活:

    public static void main(String[] args) throws Throwable{
        IMakeSword xiaoZhao = new User("小赵");
        InvocationHandler handler = new ColleagueHandler(xiaoZhao);
        handler.invoke(null,xiaoZhao.getClass().getMethod("adjust", null),null);
        handler.invoke(null,xiaoZhao.getClass().getMethod("smelt", null),null);
        handler.invoke(null,xiaoZhao.getClass().getMethod("casting", null),null);
        handler.invoke(null,xiaoZhao.getClass().getMethod("process", null),null);
    }

输出:

小赵正在调剂...
小赵正在熔炼...
小赵正在浇铸...
小赵正在加工...

 

  很好,程序实现了,从始至终都没有创建代理类,虽然很多人都会说这是动态代理,但实际上却不是,这只是反射而已。

  对于一个优秀的架构师来讲,这简直就是渣渣玩法,一箩筐方法名都写死在外面了,去他大爷的JDK。

  在寻求优化的过程中,听说JDK还提供了Proxy类,里面有个newProxyInstance方法用来创建一个对象的代理对象,这个方法总共有3个参数,ClassLoader loader用来指明生成代理对象使用哪个类装载器,Class<?>[] interfaces用来指明生成哪个对象的代理对象,通过接口指定,InvocationHandler h用来指明产生的这个代理对象要做什么事情。

 

  于是乎,我又舔着大逼脸去使用JDK的接口了。

 

增加一个动态代理类:

public class MyProxy {
    public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
        T newProxyInstance = (T) Proxy.newProxyInstance(loader,interfaces, h);
        return newProxyInstance;
    }
}

 

开始干活:

    public static void main(String[] args) throws Throwable{
        IMakeSword xiaoZhao = new User("小赵");
        ClassLoader cl = xiaoZhao.getClass().getClassLoader();
        IMakeSword proxy = MyProxy.newProxyInstance(cl,new Class[] {IMakeSword.class}, new ColleagueHandler(xiaoZhao));
        proxy.adjust();
        proxy.smelt();
        proxy.casting();
        proxy.process();
        System.out.println(xiaoZhao.equals(proxy));
    }

输出:

小赵正在调剂...
小赵正在熔炼...
小赵正在浇铸...
小赵正在加工...
false

 

  最后一个比较两个对象是否相同,证明了proxy对象并不是我,但实际上却又是我在干活,这才叫动态代理。

 

通知机制-切面

  其实我们细看之下,已经发现了一个情况,就是铸剑相关的类已经和代理解耦了。

  第一条线:IMakeSword接口->User类。

  第二条线:InvocationHandler接口->ColleagueHandler类->MyProxy类。

  动态代理实现代理的职责,业务逻辑负责功能实现。

 

  现在,为了安全起见,我希望做一件事情,就是每次干活的时候,要给我发一个通知,让我知道。

  其实非常的简单,我们在创建动态代理的时候发这个通知就行了。

 

  先创建一个通知抽象,因为以后可能会有前置通知、后置通知、各种切入的通知等等,所以通知也是一条独立发展的线。

 

通知抽象:

public interface IAdvice {
    void exec();
}

 

前置通知:

public class BeforeAdvice implements IAdvice {
    @Override
    public void exec() {
        System.out.println("准备要干活了");
    }
}

 

动态代理类:

public class MyProxy {
    public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
        new BeforeAdvice().exec();
        T newProxyInstance = (T) Proxy.newProxyInstance(loader,interfaces, h);
        return newProxyInstance;
    }
}

 

开始干活:

public static void main(String[] args) throws Throwable{
        IMakeSword xiaoZhao = new User("小赵");
        ClassLoader cl = xiaoZhao.getClass().getClassLoader();
        IMakeSword proxy = MyProxy.newProxyInstance(cl,new Class[] {IMakeSword.class}, new ColleagueHandler(xiaoZhao));
        proxy.adjust();
        proxy.smelt();
        proxy.casting();
        proxy.process();
        System.out.println(xiaoZhao.equals(proxy));
    }

 

输出:

准备要干活了
小赵正在调剂...
小赵正在熔炼...
小赵正在浇铸...
小赵正在加工...
false

 

  如果有的代理需要通知,有的时候不需要通知呢?很简单,传个参数,写个if条件即可,如果不想传参数呢?一般AOP的做法是使用注解的方式标记切入位置,然后在动态代理类里面对注解进行判断。

  获取注解也可以使用反射机制实现,类头上的注解、方法头上的注解、参数上的注解都可以获取,有兴趣的朋友可以自行研究。

 

最后声明

本故事写到后面有点怪,原因是动态代理和静态代理的使用场景是不同的,用同一个故事延续下来导致需求逻辑上出现了一些bug,在此致歉。

 

posted @ 2019-04-22 16:24 不该相遇在秋天 阅读(...) 评论(...) 编辑 收藏