【设计模式】动态代理Proxy_01

大家都知道设计模式中一个比较难理解的模式--动态代理模式，下面我们来通过一步一步完善一个工程来学习动态代理。

首先我们创建一个JavaProject，名字为"ProxyTest"。

创建一个类Tank.java，是一个坦克类，然后我们创建一个接口Moveable.java
Moveable.java:

package cn.edu.hpu.proxy;

public interface Moveable {
 void move();
}

Tank类实现Moveable接口
Tank.java:

package cn.edu.hpu.proxy;

import java.util.Random;

public class Tank implements Moveable{

  @Override
  public void move() {
    System.out.println("坦克正在移动中...");
      try {
            //睡眠10秒以内的随机时间，表示坦克正在移动中
            Thread.sleep(new Random().nextInt(10000));
          } catch (InterruptedException e) {
          // TODO Auto-generated catch block
              e.printStackTrace();
          }
  }

}

下面问题来了：
我想知道一个方法的运行时间，如何得到？

大家很容易想到的是，在方法刚刚执行后和就要结束之前计算一下当前时间，然后相减获得执行时间：

@Override
public void move() {
	long start=System.currentTimeMillis();
	System.out.println("坦克正在移动中...");
	try {
		//睡眠10秒以内的随机时间，表示坦克正在移动中
		Thread.sleep(new Random().nextInt(10000));
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	long end=System.currentTimeMillis();
	System.out.println("运行时间:"+(end-start)+"ms");
}

那么，如果不允许修改move中的方法呢？比如说这个方法是别人的包里提供给你的，是人家已经写好的源代码，就编译了class给你，就没有给你源码，你没法在源码上修改怎么办？解决这件事情之前，我们先写一个测试类：

package cn.edu.hpu.proxy;

public class Client {
    public static void main(String[] args) {
         Moveable m=new Tank();
         m.move();
    }
}

不要求计算move()方法执行的时间(JDK为其准备的时间等...)，要计算内部代码执行的时间。

我们再写一个Tank2，继承Tank

package cn.edu.hpu.proxy;

public class Tank2 extends Tank{

     @Override
     public void move() {
         long start=System.currentTimeMillis();
         super.move();
         long end=System.currentTimeMillis();
         System.out.println("运行时间:"+(end-start)+"ms");
     }

}

用继承来实现把原来的方法前后加一些逻辑，这是一种方式，是没有问题的。

除了上面这种方式之外，还有另外一种方式:
写一个Tank3，实现和Tank一样的接口

package cn.edu.hpu.proxy;

public class Tank3 implements Moveable{
	Tank t;

	public Tank3(Tank t) {
		super();
		this.t = t;
	}

	@Override
	public void move() {
		long start=System.currentTimeMillis();
		t.move();
		long end=System.currentTimeMillis();
		System.out.println("运行时间:"+(end-start)+"ms");
		
	}

}

上面一个使用继承来实现，一个是一个类存有另外一个类的对象，叫聚合。
这两种都是简单的代理的实现。

现在请问大家：认为这两种方式那种更好？为什么？
聚合好。为什么呢？
下面来看看。

除了时间的代理之外，还有其他的各种各样的代理，如在方法开始前后做日志记录，或加一段事务控制，或检查运行权限等。

由于Tank3它是记录时间的，而且是Tank的一个代理类，所以我们给它换一个名字，叫"TankTimeProxy"类。

package cn.edu.hpu.proxy;

public class TankTimeProxy implements Moveable{
	Tank t;

	public TankTimeProxy(Tank t) {
		super();
		this.t = t;
	}

	@Override
	public void move() {
		long start=System.currentTimeMillis();
		System.out.println("开始时间:"+start+"ms");
		t.move();
		long end=System.currentTimeMillis();
		System.out.println("运行时间:"+(end-start)+"ms");
		
	}

}

我们再写一个类是对Tank类加日志信息的日志代理类：

package cn.edu.hpu.proxy;

public class TankLogProxy implements Moveable{
	Tank t;

	public TankLogProxy(Tank t) {
		super();
		this.t = t;
	}

	@Override
	public void move() {
		System.out.println("坦克准备移动...");
		t.move();
		System.out.println("坦克移动结束...");
	}

}

下面我们要对日志进行叠加，规定先先记录时间，再记录日志，怎么办？需要在写一个Tank3去继承Tank2(里面已经包含了时间记录代理)，然后把日志记录代码加在move方法前后。如果规定先记录日志，再记录时间，怎么办？又要创建一个Tank4，继承Tank类，然后把日志记录代码加在move方法前后，之后再创建Tank5继承自Tank4，在在move方法前后加上时间记录代码.....你会发现，用继承的方式实现代理的话，这个类会无限制的增加下去，各种各样的代理功能如果想实现叠加的话，这个类要无限的往下继承，无边无际了...

所以，回到刚刚的话题，继承并不是好的实现代理的方式，聚合比较合适。
接下来看看聚合的优点。首先我们把TankTimeProxy和TankLogProxy中的Tank引用类改成Moveable接口(包括构造函数的参数类型)。
拿出TankTimeProxy与TankLogProxy看看：

TankTimeProxy:

package cn.edu.hpu.proxy;

public class TankTimeProxy implements Moveable{
	Moveable t;

	public TankTimeProxy(Moveable t) {
		super();
		this.t = t;
	}

	@Override
	public void move() {
		long start=System.currentTimeMillis();
		System.out.println("开始时间:"+start+"ms");
		t.move();
		long end=System.currentTimeMillis();
		System.out.println("运行时间:"+(end-start)+"ms");
		
	}

}

TankLogProxy:

package cn.edu.hpu.proxy;

public class TankLogProxy implements Moveable{
	Tank t;

	public TankLogProxy(Tank t) {
		super();
		this.t = t;
	}

	@Override
	public void move() {
		System.out.println("坦克准备移动...");
		t.move();
		System.out.println("坦克移动结束...");
	}

}

我们其中的引用类Moveable t;既可以是实现了Moveable接口的Tank类，又可以是实现了Moveable接口的代理类，那么，代理之间的嵌套是不是可以实现呢？可以，加入我们想在日志代理外面嵌套时间代理，即先记录时间后记录日志，那么我们直接把引用类Moveable t;的实现指向日志代理类TankLogProxy即可。
即：

Moveable t=new TankTimeProxy(new TankLogProxy(new Tank()));
t.move();

运行TankTimeProxy的move方法时，

@Override
public void move() {
long start=System.currentTimeMillis();
System.out.println("开始时间:"+start+"ms");
//此时t指向TankLogProxy类，调用的是TankLogProxy类的move方法
t.move();
long end=System.currentTimeMillis();
System.out.println("运行时间:"+(end-start)+"ms");

}

我们知道TankLogProxy类的move方法是这样的(也就是上面的t.move();)：

@Override
public void move() {
System.out.println("坦克准备移动...");
//这里的t指向的是Tank，所以执行的是Tank的move方法
t.move();
System.out.println("坦克移动结束...");
}

把TankTimeProxy的move方法中的t.move();解刨出来就是：

</pre><pre name="code" class="java">@Override
public void move() {
	long start=System.currentTimeMillis();
	System.out.println("开始时间:"+start+"ms");


	System.out.println("坦克准备移动...");
	//Tank的move方法
	t.move();
	System.out.println("坦克移动结束...");


	long end=System.currentTimeMillis();
	System.out.println("运行时间:"+(end-start)+"ms");
		
}

注意：此时Tank类(没加任何代理，只有最原始的移动方法)：

package cn.edu.hpu.proxy;

import java.util.Random;

public class Tank implements Moveable{

	@Override
	public void move() {
		System.out.println("坦克正在移动中...");
		try {
			//睡眠10秒以内的随机时间，表示坦克正在移动中
			Thread.sleep(new Random().nextInt(10000));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

测试：

package cn.edu.hpu.proxy;

public class Client {
	public static void main(String[] args) {
		Moveable t=new TankTimeProxy(new TankLogProxy(new Tank()));
		t.move();
	}
}

测试结果：
开始时间:1435309953538ms
坦克准备移动...
坦克正在移动中...
坦克移动结束...
运行时间:1529ms

此时就实现了时间和日志代理的嵌套，当然还可以嵌套更多的代理逻辑，是不是比继承方便多了？

以后为了方便管理，也可以将代理逻辑的先后通过配置文件来配置。
关键就是实现统一接口。

我们接下来继续讨论(以后只考虑TankTimeProxy)。如果Moveable接口里还有一个方法，stop()停止方法，Tank必须实现这个方法，那么我要知道stop()方法运行的时间，还要加之前写的时间代理代码：
首先是Moveable接口

package cn.edu.hpu.proxy;

public interface Moveable {
	void move();
	void stop();
}

Tank类

package cn.edu.hpu.proxy;

import java.util.Random;

public class Tank implements Moveable{

	@Override
	public void move() {
		System.out.println("坦克正在移动中...");
		try {
			//睡眠10秒以内的随机时间，表示坦克正在移动中
			Thread.sleep(new Random().nextInt(10000));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	@Override
	public void stop() {
		System.out.println("坦克停止中...");
		
	}
	
}

TankTimeProxy类

package cn.edu.hpu.proxy;


public class TankTimeProxy implements Moveable{
	Moveable t;


	public TankTimeProxy(Moveable t) {
		super();
		this.t = t;
	}


	@Override
	public void move() {
		long start=System.currentTimeMillis();
		System.out.println("开始时间:"+start+"ms");
		t.move();
		long end=System.currentTimeMillis();
		System.out.println("运行时间:"+(end-start)+"ms");
		
	}


	@Override
	public void stop() {
		long start=System.currentTimeMillis();
		System.out.println("开始时间:"+start+"ms");
		t.stop();
		long end=System.currentTimeMillis();
		System.out.println("运行时间:"+(end-start)+"ms");
	}
}

这个时候我们注意了，当我们平时在写程序的时候，如果你发现有一段代码你总是在那里写，这个方法里有，那个方法里也有，这个时候我们就要考虑将这段代码封装起来了。
这里我们发现TankTimeProxy类中有关时间记录的代码有重复，我们将其封装起来:

package cn.edu.hpu.proxy;

public class TankTimeProxy implements Moveable{
	Moveable t;
	long start;
	long end;

	public TankTimeProxy(Moveable t) {
		super();
		this.t = t;
	}

	public void before(){
		start=System.currentTimeMillis();
		System.out.println("开始时间:"+start+"ms");
	}
	
	public void after(){
		end=System.currentTimeMillis();
		System.out.println("运行时间:"+(end-start)+"ms");
	}
	
	@Override
	public void move() {
		this.before();
		t.move();
		this.after();
	}


	@Override
	public void stop() {
		this.before();
		t.stop();
		this.after();
	}
}

下面我们考虑一个很难的问题，假如说我想让TankTimeProxy这个代理叫做TimeProxy，意味着它不仅可以计算Tank类的运行方法，还可以把任何一个对象当做被代理对象，可以计算任何代理类的方法运行的时间。(至于为什么会有这种需求，比如说我们又加了一个交通工具Car，我们要对Car计算运行时间的话，要重写一个CarTimeProxy代理，如果还有上百种类型的类，对不同的类实现时间代理，你要写上百种代理类！！！)。

所以我们要实现一种"通用"时间代理，可以对任意对象代理。

我们可以使用Java的反射机制，具体方式详见总结02

转载请注明出处：http://blog.csdn.net/acmman/article/details/46827819