代理模式浅析

代理模式属于结构型模式（用于处理类或对象的组合），而代理模式又分为静态代理模式和动态代理模式。

1.静态代理模式

有些类由于自己功能有限，需要其他的类做一些工作来辅助完成某些功能，虽然这些辅助工作是必须的，但是委托类却不需要自己去做，一是他没有资源，二是它应该注重自己擅长的事情。这样一些代理类应运而生，它专门做一些事前和善后的处理，让委托类专注于自己的事情。

例如：

package com.huaxin.reflect.proxy;
/**
 * 代理类
 * @author minGe_000
 *
 */
public class ProxyTeacher implements Subject{
	private Subject sub;
	public ProxyTeacher(Subject sub){
		this.sub = sub;
	}
	
	public void before(){}
	public void teach(){
		before();
		sub.teach();
		after();
	}
	public void after(){}
}

package com.huaxin.reflect.proxy;
/**
 * 主题类
 * @author minGe_000
 *
 */
public interface Subject {
	public void teach();
}

package com.huaxin.reflect.proxy;
/**
 * 主题实现类
 * @author minGe_000
 *
 */
public class Teacher implements Subject{
	private String name;
	public Teacher(String name){
		this.name = name;
	}
	public void teach() {
		System.out.println(name+"正在上Java课");
	}
}

package com.huaxin.reflect.proxy;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Teacher tea = new Teacher("张三");
		ProxyTeacher pt = new ProxyTeacher(tea);
		pt.teach();

	}

}

2.动态代理模式

1）一般的代理模式已经很好的解决了代码重复的问题，但是人总是不满足的，要是代理可以让程序帮我们生成该多好。

2）在JDK1.3以后，Java提供了动态代理技术，允许开发者在运行期创建接口的代理实例。

3）动态代理主要涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler。

4）其中InvocationHandler是一个接口，可以通过实现该接口定义代理逻辑，并通过反射机制调用目标类的代码，动态的

将代理逻辑和业务逻辑组合在一起。而Proxy利用InvocationHandler动态创建一个符合某一接口的实例，生成目标类的代理对象。

例如：

package com.huaxin.reflect.dynproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * 动态代理关联主题
 * @author minGe_000
 *
 */
public class DynProxyObj implements InvocationHandler{
	private Object obj;
	public DynProxyObj(Object obj){
		this.obj = obj;
	}
	public void before(){
		System.out.println("代理之前要执行的事情....");
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		before();
		Object object = method.invoke(obj, args);
		return object;
	}
	
}

package com.huaxin.reflect.dynproxy;

public class Student implements Study{

	@Override
	public void study() {
		System.out.println("学生学习");
	}
}

package com.huaxin.reflect.dynproxy;

public interface Study {
	public void study();
}

package com.huaxin.reflect.dynproxy;
/**
 * 主题类
 * @author minGe_000
 *
 */
public interface Subject {
	public void teach();
}

package com.huaxin.reflect.dynproxy;
/**
 * 主题实现类
 * @author minGe_000
 *
 */
public class Teacher implements Subject{
	private String name;
	public Teacher(String name){
		this.name = name;
	}
	public void teach() {
		System.out.println(name+"正在上Java课");
	}
}

package com.huaxin.reflect.dynproxy;

import java.lang.reflect.Proxy;

public class Test {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Teacher tea  = new Teacher("小左");
		DynProxyObj dpo = new DynProxyObj(tea);
		//动态代理实现
		Subject dyn = (Subject)Proxy.newProxyInstance(tea.getClass().getClassLoader(),tea.getClass().getInterfaces() , dpo);
		dyn.teach();
		
		
		Student stu = new Student();
		DynProxyObj dynProxy = new DynProxyObj(stu);
		Study s = (Study)Proxy.newProxyInstance(stu.getClass().getClassLoader(),stu.getClass().getInterfaces() , dynProxy);
		s.study();
	}
}