设计模式-代理和动态代理模式

1.简单代理模式

interface Interface {
	void doSomething();
	void somethingElse(String arg);
}

class RealObject implements Interface {

	@Override
	public void doSomething() {
		System.out.println("doSomething");
	}

	@Override
	public void somethingElse(String arg) {
		System.out.println("somethingElse " + arg);
	}
	
}

class SimpleProxy implements Interface {

	private Interface proxied;
	public SimpleProxy(Interface proxied) {
		this.proxied = proxied;
	}
	
	@Override
	public void doSomething() {
		System.out.println("SimpleProxy doSomething");
		this.proxied.doSomething();
	}

	@Override
	public void somethingElse(String arg) {
		System.out.println("SimpleProxy somethingElse " + arg);
		this.proxied.somethingElse(arg);
	}
	
}
public class SimpleProxyDemo {

	public static void consume(Interface iface) {
		iface.doSomething();
		iface.somethingElse("bonobo");
	}
	
	public static void main(String[] args) {
		consume(new RealObject());
		consume(new SimpleProxy(new RealObject()));
	}

}

2. 动态代理模式。动态代理可以将所有调用重定向到调用处理器。因此，通常会向调用处理器的构造器传递一个实际的对象引用。

class DynamicProxyHanler implements InvocationHandler {

	private Object proxied;
	public DynamicProxyHanler(Object object) {
		this.proxied = object;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("***** proxy : " + proxy.getClass() + ".method:" + method + ",args: " + args);
		if (args != null) {
			for (Object arg : args) {
				System.out.println(" " + arg);
			}
		}
		return method.invoke(proxied, args);
	}
	
}
public class SimpleDynamicProxy {

	public static void consumer(Interface iface) {
		iface.doSomething();
		iface.somethingElse("zhangzhaoyu");
	}
	
	public static void main(String[] args) {
		RealObject real = new RealObject();
		consumer(real);
		
		Interface proxy = (Interface)Proxy.newProxyInstance(
				Interface.class.getClassLoader(), new Class[]{Interface.class}, 
				new DynamicProxyHanler(real));
		
		consumer(proxy);
	}

}

class MethodSelector implements InvocationHandler {

	private Object proxied;
	public MethodSelector(Object proxied) {
		this.proxied = proxied;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		if (method.getName().equals("interesting")) {
			System.out.println("Proxy detected the interesting method");
		}
		return method.invoke(proxied, args);
	}
	
}

interface SomeMethods {
	void boring1();
	void boring2();
	void interesting(String arg);
	void boring3();
}

class Implentation implements SomeMethods {

	@Override
	public void boring1() {
		System.out.println("boring1");
	}

	@Override
	public void boring2() {
		System.out.println("boring2");
	}

	@Override
	public void interesting(String arg) {
		System.out.println("interesting : " + arg);
	}

	@Override
	public void boring3() {
		System.out.println("boring3");
	}
	
}

public class SelectingMethods {

	public static void main(String[] args) {
		
		SomeMethods proxy = (SomeMethods) Proxy.newProxyInstance(SomeMethods.class.getClassLoader(),
				new Class[]{SomeMethods.class}, new MethodSelector(new Implentation()));
		
		proxy.boring1();
		proxy.boring2();
		proxy.interesting("zhang");
		proxy.boring3();
	}

}