神秘代理-Proxy

前言：

　　代理模式作为常见的设计模式之一，在项目开发中不可或缺。本文就尝试着揭开代理的神秘面纱，也欢迎各路人批评指正！

1.如何实现代理：

【假设有个关于汽车移动（move）的计时需求】
设计：Moveable接口，一个Car的实现类；两个代理CarTimer,TimeHandler.UML图如下：

1）继承

package com.gdufe.proxy;

import java.util.Random;

public class CarTimer extends Car {
    
    @Override
    public void move() {
        long start=System.currentTimeMillis();
        super.move();        //调用父类的move（）方法
        try{
            Thread.sleep(new Random().nextInt(10000));
        }catch(Exception e){
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
        System.out.println("I'm time machine.Time for moving:"+(end-start));
    }
}

2）组合

package com.gdufe.proxy;

import java.util.Random;

public class TimeHandler implements Moveable {
    private Moveable m;
    public TimeHandler(Moveable m) {
        this.m = m;
    }
    @Override
    public void move() {
        long start=System.currentTimeMillis();
        m.move();
        try{
            Thread.sleep(new Random().nextInt(10000));
        }catch(Exception e){
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
        System.out.println("I'm time machine.Time for moving:"+(end-start));
    }

}

 

客户端代码：

package com.gdufe.proxy;

public class Client {
    public static void main(String[] args) {
        System.out.println("继承实现代理：");
        new CarTimer().move();
        System.out.println("组合实现代理：");
        new TimeHandler(new Car()).move();
    }
}

 

输出结果：

继承实现代理：
Car moving...
I'm time machine.Time for moving:7080
组合实现代理：
Car moving...
I'm time machine.Time for moving:5169

 

分析：从上述例子实现当中，我们第一感觉自然是分不出两种代理的实现方式孰优孰劣。且继续往下面看。

2.灵活代理-接口切换

【假设现在特殊需求不确定：“汽车移动之前先往左还是先往右”】
很明显，我们此时若使用继承的方式实现代理，则后续很不容易维护，而且会形成臃肿的继承链；但使用接口的方式我们发现仅需要两个代理类：TurnLeft,TurnRight。而且，不管后续需求如何都只需要做简单的调整。UML图如下：

----------

TurnLeft.java

package com.gdufe.proxy;

public class TurnLeft implements Moveable {
    private Moveable m;
    public TurnLeft(Moveable m) {
        this.m = m;
    }
    @Override
    public void move() {
        System.out.println("turn left...");
        m.move();
    }

}

TurnRight.java

package com.gdufe.proxy;

public class TurnRight implements Moveable {

    private Moveable m;
    public TurnRight(Moveable m) {
        this.m = m;
    }
    @Override
    public void move() {
        System.out.println("turn right");
        m.move();
    }

}

客户端代码：

package com.gdufe.proxy;

public class Client0 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("Turn right,then left before moving:");
        test1();
        
        System.out.println("Turn left,then right before moving:");
        test2();
    }
    //对接口的实现内外包装
    private static void test1() {
        Car car  = new Car();
        Moveable m1 = new TurnLeft(car);
        Moveable m2 = new TurnRight(m1);
        m2.move();
    }
    public static void test2(){
        Car car = new Car();
        Moveable m1 = new TurnRight(car);
        Moveable m2 = new TurnLeft(m1);
        m2.move();
    }

}

 

输出结果：

Turn right,then left before moving:
turn right
turn left...
Car moving...
Turn left,then right before moving:
turn left...
turn right
Car moving...

 

======================== 

3.动态代理：

其实，不管是继承还是组合的方式，我们上面实现的都仅仅是“静态代理”，也是我们平时用的比较多的。现在，我们开始聊聊Java的神器---“动态代理”。
【假设现在需要实现一个“万能”的日志工具，即不管对任何类的任何方法都可以动态对其进行日志操作】
例如：上面的例子中，请思考如何实现在汽车移动之前进行日志操作？
常规的静态代理方式当然可以实现，下面我们就利用Java中的Proxy类进行实现。UML图如下：

 

添加关键类：LogHandler.java

package com.gdufe.proxy;

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

public class LogHandler implements InvocationHandler {
    
    //被代理对象
    private Object proxied;
    
    public LogHandler(Object proxied) {
        this.proxied = proxied;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("I'm log machine.");
        return method.invoke(proxied);
    }

}

 

客户端代码：

package com.gdufe.proxy;

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

public class Client1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        //单独创建Moveable接口对象
        Moveable m=null;
        m = new Car();
        m = new TimeHandler(m);
        
        //初始化LogHandler实现的InvacationHandler接口
        InvocationHandler h =  new LogHandler(m);
        m = (Moveable) Proxy.newProxyInstance(
                Moveable.class.getClassLoader(),
                new Class[] {Moveable.class},h);
        
        //m在动态代理处理完后，move（）方法已被修改
        m.move();
    }

}

 

输出结果：

I'm log machine.
Car moving...
I'm time machine.Time for moving:110

 

分析：

　　上述的实现代码对于刚接触Java的朋友来说估计比较费解。要理解其过程，至少对java的反射机制有一定的理解。看穿了的话，其实动态代理的关键环节，就在newProxyInstance()操作上。代码实现的关键步骤：

Step1:初始化被代理的对象（如上图中的TimeHandler）；

Step2:创建一个实现了InvocationHandler接口的类，在invoke()方法进行你希望执行的代理操作（如上图的LogHandler）;

Step3:将通过Proxy拿到的新对象赋给最终要实现的接口，最后调用该接口方法（如代码中的“m.move()”）。

---------------------------------------------------------------------

有朋友可能犯迷糊了，动态代理的内部实现过程呢？Proxy是怎样一步一步识别到Car的呢？

请看图：

 

（注意：$Proxy类是虚拟存在的，在Java API中是找不到的。也就是说，它只存在于中间过程。所以，为方便大家理解就加上了。）

　　
　　那么，到底动态代理适用于什么情形呢？从上面汽车的简单日志实例也许还难以看出。下面我们再引入一个测试。
【假设现在增加一个司机（Driver）类,其实现了Speakable接口；很明显他跟汽车没有很直接的关联，那么现在我们利用动态代理的方式将上面的LogHandler加到司机的speak（）方法上】
----------
客户端代码：

package com.gdufe.proxy;

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

public class Client2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Moveable m=null;
        m = new Car();

        Speakable s =null;
        s = new Driver();
        
        InvocationHandler h = null;
        h=new LogHandler(m);
        m = (Moveable) Proxy.newProxyInstance(Moveable.class.getClassLoader(),new Class[] {Moveable.class},h);
        m.move();
        
        //司机被代理
        h = new LogHandler(s);
        s = (Speakable)Proxy.newProxyInstance(Speakable.class.getClassLoader(),new Class[]{Speakable.class}, h);
        s.speak();
        }

}

 

输出结果：

I'm log machine.
Car moving...
I'm log machine.
Driver speak...

　　在汽车move()跟司机speak()之前，都自动实现LogHandler操作！

-----------------------------------------------------

后语：

通过上述例子，总结动态代理优点：
·适用任何类的任何方法；
·使用灵活，可随时将代理工具类加入或抽出。

　　动态代理是Java语言的精华所在，很多的开发框架都是基于其内部原理。本人目前对动态代理的理解也仅限于此，欢迎对Java有深度学识的朋友拍砖，谢谢~