简单_代理模式(proxy)/装饰模式(decorator)

代理模式是一种很常用的设计模式，其目的是对其他对象提供一种代理以控制对这个对象的访问。

代理模式又分为静态代理和动态代理，静态代理是在程序运行之前就已经存在了代理类，动态代理是程序运行中在内存中生成代理类。
代理模式存在的意义：代理模式是为了解决滥用继承的问题而生的，当想对某个类的功能进行扩充的时候可以使用继承或聚合，很明显用继承的话会造成类泛滥，还有一点就是继承是类具有很强的层级关系的情况下用才好，而紧紧对某个类进行功能的扩充就拿起继承的大刀明显的不合适，那么用聚合呢？聚合是一种松耦合的，用聚合创建的代理类就是静态代理，还有更好的代理是动态代理。

动态代理自己实现其实也很简单，不过JDK提供了方便的解决方案。
java.lang.reflect.InvocationHandler
java.lang.reflect.Proxy
这两个东东就是为动态代理而生的

package design.proxy.hello;
/** 
 * @author 作者 E-mail: [e-mail]
 * @version 创建时间：2012-2-2 下午03:57:56 <br>
 */
public interface Hello {
	void say();
}

package design.proxy.hello;

/**
 * @author 作者 E-mail: [e-mail]
 * @version 创建时间：2012-2-2 下午03:58:10 <br>
 * 被代理的类
 */
public class HelloImpl implements Hello {

	public void say() {
		System.out.println("say");
	}
}

package design.proxy.hello;

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

/**
 * @author 作者 E-mail: [e-mail]
 * @version 创建时间：2012-2-2 下午03:54:45 <br>
 * 动态代理
 */
public class HelloProxy {
	public static Object newProxyInstance(final Object target) {
		InvocationHandler h = new InvocationHandler() {

			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				before();
				Object result = method.invoke(target, args);
				after();
				return result;
			}
		};
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),
				target.getClass().getInterfaces(), h);
	}

	private static void before() {
		System.out.println("before");
	}

	private static void after() {
		System.out.println("after");
	}
}

package design.proxy.hello;
/** 
 * @author 作者 E-mail: [e-mail]
 * @version 创建时间：2012-2-2 下午03:57:44 <br>
 * 
 */
public class Test {
	public static void main(String[] args) {
		/*
		 * 代理模式
		 */
		Hello proxy = (Hello) HelloProxy.newProxyInstance(new HelloImpl());
		proxy.say();
	}
}

-----------------------------分割线----------------------------------
上面是代理模式，其实装饰模式和代理模式极为相似
相同点：都是为被代理(被装饰)的类扩充新的功能。
不同点：代理模式具有控制被代理类的访问等性质，而装饰模式紧紧是单纯的扩充被装饰的类。所以区别紧紧在是否对被代理/被装饰的类进行了控制而已。

package design.staticProxy;
/** 
 * @author 作者 E-mail: [e-mail]
 * @version 创建时间：2012-2-3 下午10:10:43 <br>
 */
public interface InputStream {
	void read();
}

package design.staticProxy;
/** 
 * @author 作者 E-mail: [e-mail]
 * @version 创建时间：2012-2-3 下午10:11:16 <br>
 */
public class FileInputStream implements InputStream{

	public void read() {
		System.out.println("FileInputStream.read");
	}

}

package design.staticProxy;

/**
 * @author 作者 E-mail: [e-mail]
 * @version 创建时间：2012-2-3 下午10:11:50 <br>
 * 代理/装饰类具有和被代理/被装饰的类相同的接口
 */
public class BufferedInputStream implements InputStream {
	protected InputStream in;

	public BufferedInputStream(InputStream in) {
		this.in = in;
	}

	public void read() {
		//加入控制代码就是代理，否则单纯的扩充功能就是装饰模式
		if(true){
			System.out.println("BufferedInputStream.read");
		}
		this.in.read();
	}
}

package design.staticProxy;

/**
 * @author 作者 E-mail: [e-mail]
 * @version 创建时间：2012-2-3 下午10:13:20 <br>
 */
public class Test {
	public static void main(String[] args) {
		BufferedInputStream buffIn = new BufferedInputStream(new FileInputStream());
		buffIn.read();
	}
}

很明显，装饰模式和静态代理极为相似。设计模式里面有许多模式都看起来很相似，要区分估计得从目的上去区分了。