代理模式

最近重新学习了代理模式，感觉这真的是一个很好的思想~故在此和大家分享下~

      代理模式的用处：在“开闭原则中”，我们必须对扩展开放，对修改关闭。如果想在调用原来的类的业务方法之前或者之后做某事，那么我们经常用代理模式。

      静态代理和动态代理的异同点：

      相同点：都是在调用原来的业务方法之前或者之后的时候，我们做了一些处理。

      不同点：静态代理需要三个角色：第一是一个公共的父类，第二是实际业务类，第三是代理业务类。实际业务类和代理业务类都要继承公共的父类或者实现父接口。

                      同时在代理类中需要实例化实际业务类，并调用其实际业务方法。

                      java动态代理的实现依靠java反射机制提供的三个类：一个是Proxy，一个是InvacationHandler，另外一个是Method。Proxy中的newProxyInstance（）方

                     法创建一  个代理的实例， 当系统有了一个代理对象后，对原对象方法的调用会首先被分派给调用处理器（InvocationHandler），然后在分派处理器的invoke

                    方法中采用代理，一方面调用原对象方法，另一方面执行其他代理操作。

      静态代理的实现

package com.pattern.proxy.jingtai;
/**
 * title:代理类和实际服务类要继承的公共抽象类
 * @author Administrator
 *
 */
abstract public class Bank {
	abstract public  void saveMoney();
}

package com.pattern.proxy.jingtai;
/**
 * title:实际的业务处理类
 * @author Administrator
 *
 */
public class RealBankService extends Bank{
	
	public RealBankService(){
		
	}
	@Override
	public void saveMoney() {
		// TODO Auto-generated method stub
		System.out.println("save money........");
	}

}

package com.pattern.proxy.jingtai;

public class ProxyBankService extends Bank{
	
	public ProxyBankService(){
		
	}
	@Override
	public void saveMoney(){
		System.out.println("before save money  do  something.....");
		RealBankService rbs=new RealBankService();
		rbs.saveMoney();
		
		System.out.println("after save money do something.....");
	}

}

package com.pattern.proxy.jingtai;

public class Client {
	public static void main(String[] args){
		Bank pbs=new ProxyBankService();
		pbs.saveMoney();
	}
}

     动态代理的实现

package com.pattern.proxy.dynamic;

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

/**
 * title:动态代理类
 * @author Administrator
 *
 */
public class ProxyObject implements InvocationHandler{
	private Object proxyobj;
	public ProxyObject(){
		
	}
	/**
	 * @param obj  被代理的类（实际的类）
	 */
	public ProxyObject(Object obj){
		this.proxyobj=obj;
	}
	/**
	 * 简单工厂模式   
	 * @param obj
	 * @return   代理类对象
	 */
	@SuppressWarnings("rawtypes")
	public static Object factory(Object obj){
		Class clz=obj.getClass();
		
		return Proxy.newProxyInstance(clz.getClassLoader(), clz.getInterfaces(), new ProxyObject(obj));
	}
	/**
	 * 代理类执行方法时被调用
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("before invoke.....");
		//如果参数不为空
		if(args!=null){
			for (int i = 0; i < args.length; i++) {
				System.out.println("args"+i+"....."+args[i]);
			}
		}
		Object obj=method.invoke(proxyobj, args);
		
		System.out.println("after invoke....");
		return obj;
	}

	
}

package com.pattern.proxy.dynamic;

import java.util.ArrayList;
import java.util.List;

public class Client {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args){
		List list=null;
		list=(List<String>)ProxyObject.factory(new ArrayList());//list是代理类
		list.add("aaa");
	}
}

解释：要理解这段代码，首先得先学习java反射机制。首先在客户端我们利用简单工厂创建了一个代理类。【factory方法里面Proxy.newProxyInstance()方法有三个参数，第 一个是对象的类加载器，第二个是对象实现的接口，第三个是一个InvocationHandler实例，返回值的是一个代理类】，当我们调用原对象方法时，调用处理器（invocationHandler的invoke方法会拦截这个调用，执行invoke（）方法。在invoke（）方法中我们通过Method反射调用原对象的方法，在调用之前或者之后我们可以执行我们想做的操作，从而达到代理的目的！