设计模式之Proxy模式(学习笔记)

• 静态代理

问题引入

我们现在有一个Car类,Car类里面有个move方法.

现在我们想每次当这个Car move的时候都记录这个Car move了多久 (在不修改Car的源码的前提下).

public interface Moveable {
	void move();
}

public class Car implements Moveable{

	@Override
	public void move() {
		System.out.println("Car Move ....");
	}
	
}

第一种方法继承:

public class CarProxyByInheritance extends Car{
	@Override
	public void move(){
		System.out.println("time start");
		long start = System.currentTimeMillis();
		super.move();
		long end = System.currentTimeMillis();
		System.out.println(end-start+"ms");
	}
}

第二种方式组合:

public class CarProxyByCombination implements Moveable{
	private Moveable m;
	public CarProxyByCombination(Moveable m){
		this.m = m;
	}
	
	@Override
	public void move() {
		System.out.println("time start");
		long start = System.currentTimeMillis();
		m.move();
		long end = System.currentTimeMillis();
		System.out.println(end-start+"ms");
	}

}

这两种方式都产生了Car对象的代理对象。

那么究竟哪种方法更好呢?

这个问题比较简单,组合更好.

假设现在有很多Moveable接口的实现类如 飞机，轮船，航母，飞碟。

如果采用继承，对于每个实现类，如果你想产生代理对象。都需要创建一个类。

这样类就产生了类爆炸的现象

而用组合，你只需改变构造方法里面的参数即可。

• 动态代理

问题引入:假设现在这个计时功能,我不仅仅要对Moveable的实现类计时,有可能要对别的Sleepable,Eatable类的某个方法。

那么每次,都要动手写一个代理是不是过于麻烦了?而且现在是计时功能，如果是日志功能，或者别的功能呢?

有没有什么方法可以 无论你是什么功能,无论加在某个类上,无论加在某个方法上。我都动态的产生代理对象,而不去每次手写一个类呢?

动态代理的实现方式主要有两种

1.直接生成二进制码   如 cglib

2.一种是利用被代理对象实现了某个接口 如 jdk中的 Proxy , InvocationHandler

在这里以jdk中的Proxy,InvocationHandler举例

具体的实现比较复杂，说一下思想。

思想就是根据你给的一些必要的参数(被代理对象,被代理对象实现了哪些接口,添加逻辑(注:如日志,事务,权限))

导出代理类的源码,动态编译代理类,把代理类load到JVM.利用反射创建一个代理类的对象。

哇,这步骤好麻烦啊,没关系其实jdk已经给我们封装好了。

我们只要运用这个两个类，就可以得到我们想要的代理对象了。

Proxy主要接口

static Object  newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)




只要调用这个方法，并且传入相应参数，Proxy会返回给你一个代理对象.




第一个参数:可以将该代理类load到JVM内存中的ClassLoader（一般情况下，写什么都行）。

第二个参数:被代理对象实现了哪些接口。

第三个参数:实现了InvocationHandler接口的类的对象（里面封装了，你要添加的功能，被代理对象的引用）。

这样创建出的代理类是什么样子的呢?

在这先不说,先看下面一个例子.

人吃东,然后我们给他加上日志.

public interface Eatable {
	void eat();
}

public class People implements Eatable{

	@Override
	public void eat() {
		System.out.println("have lunch");
	}

}

public interface MyAspect {
	void before();
	void after();
}

public class LogAspect implements MyAspect{
	public void before(){
		System.out.println("log begin ....");
	}
	public void after(){
		System.out.println("log end ....");
	}
}

public class MyInvocationHandler implements InvocationHandler{

	private Object target;
	private MyAspect aspect;
	
	
	public MyInvocationHandler(Object target, MyAspect aspect) {
		this.target = target;
		this.aspect = aspect;
	}


	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		aspect.before();
		Object ret = method.invoke(target, args);
		aspect.after();
		return ret;
	}

}

public class Test {
	
	public static void main(String[] args) {
		MyInvocationHandler mh = new MyInvocationHandler(new People(),new LogAspect());
		Class[] cs = {Eatable.class};
		Eatable ea = (Eatable)Proxy.newProxyInstance(Test.class.getClassLoader(), cs, mh);
		ea.eat();
	}

}

输出结果:

log begin....

have lunch

log end....

这个时候如果你输出ea.getClass()

结果就是$Proxy0

就说明，我们拿到了代理对象.

看完这个例子,相信你心中大概应该有个猜测了。

现在我们就说说ea引用指向的对象的类(代理类)大概是个什么样的。

public class $Proxy0 implements Eatable{
	InvocationHandler ih;
	
	public $Proxy0(InvocationHandler ih){
		this.ih = ih;
	}
	
	@Override
	public void eat() {
		try {
			Method m = Eatable.class.getMethod("eat");
			ih.invoke(this, m, null);
			//如果返回值不是void 就应该是 return ih.invoke(this, m, null);
		} catch(Throwable e) {
			e.printStackTrace();
		}
	}

}

• 动态代理的应用

如Spring 的AOP

本人初学,如有不对请包涵。