代理（Proxy）模式 【结构模式第一篇】

代理（Proxy）模式
是对象的结构模式，代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

一、代理的种类：
如果按照使用目的来划分，代理有以下几种：
1、远程（Remote）代理：为一个位于不同的地址空间的对象提供一个局域代表对象。这个不同的地址空间可以是在本机器中，
   也可以在另一台机器中。远程代理又叫做大使（Ambassador）。
2、虚拟（Virtual）代理：根据需要创建一个资源消耗较大的对象，使得此对象只在需要时才会被真正创建。
3、Copy－on－Write代理：虚拟代理的一种，把复制（克隆）拖延到只有在客户端需要时，才真正采取行动。
4、保护（Protect or Access）代理：控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。
5、Cache（高速缓存）代理：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。
6、防火墙（Firewall）代理：保护目标，不让恶意用户接近。
7、同步化（Synchronization）代理：使几个用户能够同时使用一个对象而没有冲突。
8、智能引用（Smart Reference）代理：当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来。
二、代理模式的结构：
代理模式所涉及的角色有：
1、抽象主题角色：声明了真实主题和代理主题的共同接口，这样一来在任何可以使用真实主题的地方都可以使用代理主题

2、代理主题角色：代理主题角色内部含有对真实主题的引用，从而可以在任何时候操作真实主题对象；
   代理主题角色提供一个与真实主题角色相同的接口，以便可以在任何时候都可以替代真实主体；
   控制对真实主题的引用，负责在需要的时候创建真实主题对象（和删除真实主题对象）；
   代理角色通常在将客户端调用传递给真实的主题之前或者之后，都要执行某个操作，而不是单纯地将调用传递给真实主题对象

3、真实主题角色：定义了代理角色所代表的真实对象。

//抽象主题角色
			public abstract class Subject{
				public abstract void request();
			}
			
			//真实主题角色
			public class RealSubject extends Subject{
				public RealSubject(){}
				
				public void request(){
					System.out.println("From real subject.");
				}
			}
			
			//代理主题角色
			public class ProxySubject extends Subject{
				private RealSubject realSubject;
				
				public ProxySubject(){}
				
				public void request(){
					preRequest();
					if(realSubject == null){
						realSubject = new RealSubject();
					}
					realSubject.request();
					postRequest();
				}
				
				private void preRequest(){
					//..................
				}
				
				private void postRequest(){
					//....................
				}
			}
			
			//VectorProxy
			import java.lang.reflect.InvocationHandler;
			import java.lang.reflect.Proxy;
			import java.lang.reflect.Method;
			import java.util.Vector;
			import java.util.List;
			
			public class VectorProxy implements InvocationHandler{
				private Object proxyobj;
				
				public VectorProxy(Object obj){
					proxyobj = obj;
				}
				
				//静态工厂方法
				public static Object factory(Object obj){
					Class cls = obj.getClass();
					return cls.getClassLoader();
					cls.getInterface(new VectoryProxy(obj));
				}
				
				public Object invoke(Object proxy, Method method, Object[] args)throws Throwable{
					System.out.println("before calling" + method);
					if(args != null){
						for(int i = 0; i < args.length; i ++){
							System.out.println(args[i] + " ");
						}
					}
					Object o = method.invoke(proxyobj,args);
					System.out.println("after calling" + method);
					return o;
				}
				
				public static void main(String args[]){
					List v = null;
					v = (List)factory(new Vector(10));
					v.add("New");
					v.add("York");
				}
			}
			

三、代理模式的优、缺点
1、优点
1－远程代理）优点是系统可以将网络的细节隐藏起来，使得客户端不必考虑网络的存在。
   客户完全可以认为代理的对象是局域的而不是远程的，而代理对象承担了大部分的网络通信工作。
 
2－虚拟代理）优点是代理对象可以在必要的时候才将被代理的对象加载。
   代理可以对加载的过程加以必要的优化。当一个模块的加载十分耗费资源的时候，虚拟代理的优点就非常明显。

3－保护代理）优点是它可以在运行的时间对用户的有关权限进行检查，然后在核实后决定将被调用传递给被代理的对象。

4－智能引用代理）在访问一个对象时可以执行一些内务处理操作。

//一个实例
	//此实例调用的次序是：
		1、客户端调用代理对象
		2、代理对象调用AccessValidator对象，确定用户确实具有相应的权限
		3、代理对象调用RealSearcher对象，完成查询功能
		4、代理对象调用UsageLogger对象，完成计数功能
		5、代理对象将RealSearcher对象的查询结果返回给客户端。
	//客户端
	public class Client{
		//声明一个静态类型为Searcher的静态变量
		private static Searcher searcher;
		
		public static void main(String args[]){
			//此静态变量的真实类型为Proxy
			searcher = new Proxy();
			String userId = "Admin";
			String searchType = "SEARCH_BY_ACCOUNT_NUMBER";
			String result = searcher.doSearch(userId,searchType);
			System.out.println(result);
		}
	}
	
	//抽象主题角色
	public interface Searcher{
		String doSearch(String userId,String searchType);
	}
	
	//代理角色
	public class Proxy implements Searcher{
		private RealSearcher searcher;
		private UsageLogger usageLogger;
		private AccessValidator accessValidator;
		
		public Proxy(){
			searcher = new RealSearcher(); 
		}
		
		public String doSearch(String userId, String keyValue){
			if(checkAccess(userId)){
				String result = searcher.doSearch(null,keyValue);
				logUsage(userId);
				return result;
			}else{
				return null;
			}
		}
		
		public boolean checkAccess(String userId){
			accessValidator = new AccessValidator();
			return accessValidator.validateUser(userId);
		}
		
		private void logUsage(String userId){
			UsageLogger logger = new UsageLogger();
			logger.setUserId(userId);
			logger.save();
		}
	}
	
	//真实主题
	public class RealSearcher implements Searcher{
		public RealSearcher(){}
		
		//真实的查询工作在这里进行
		public String doSearch(String userId,String keyValue){
			String sql = "select * from data_table where key_col = '" + keyValue + "'";
			//execute SQL Statement
			//concatenate a result String
			return "result set";
		}
	}
	
	//检查权限的对象
	public class AccessValidator{
		//用户检查发生在这里
		public boolean validatorUser(String userId){
			if(userId.equals("Admin")){
				return true;
			}else{
				false;
			}
		}
	}
	
	//记录次数
	public class UsageLogger{
		private String userId;
		
		public void setUserId(String userId){
			this.userId = userId;
		}
		
		public void save(){
			String sql = "insert into usage_table(user_id)" + "values(" + userId + ")";
			//execute sql
		}
		
		public void save(*String userId){
			this.userId = userId;
			save();
		}
	}