【设计模式】学习笔记17：代理模式之保护代理与Java反射

本文出自 http://blog.csdn.net/shuangde800

本笔记内容：

1. Java动态代理，反射机制

2. 保护代理

3. 应用保护代理实现的约会系统

----------------------------------------------------------------------------

走进保护模式

我们知道，相亲节目已经在天朝的电视上已经火了多年了，说明了有广大同胞需要这个配对服务，更别说咱们程序猿这个群体了。

现在要实现一个约会服务系统。你希望在这个服务系统中，增加一个评分功能，类似于豆瓣上的评分系统。

浏览一个人资料后，可以给对方进行评分。

你希望这套系统能帮助顾客找到一个理想的对象，这也会让事情更有趣。

很快，你应该就能想到服务系统需要一个PersonBean的接口，来设置或取得一个人的信息：

//这个接口可以设置和取得人的名字，性别，兴趣，和评分
public interface PersonBean {
 
    String getName();        // 获取名字
    String getGender();      // 过去性别
    String getInterests();   // 获取兴趣
    int getHotOrNotRating(); // 获取评分值
 
    void setName(String name);           // 设置姓名
    void setGender(String gender);       // 设置性别
    void setInterests(String interests); // 设置兴趣
    void setHotOrNotRating(int rating);  // 设置评分
 
}

然后实现这个接口：

public class PersonBeanImpl implements PersonBean {
	String name;
	String gender;
	String interests;
	int rating;
	int ratingCount = 0;
  
	public String getName() {
		return name;	
	} 
  
	public String getGender() {
		return gender;
	}
  
	public String getInterests() {
		return interests;
	}
   
	public int getHotOrNotRating() {
		if (ratingCount == 0) return 0;
		return (rating/ratingCount);
	}
  
 
	public void setName(String name) {
		this.name = name;
	}
 
	public void setGender(String gender) {
		this.gender = gender;
	} 
  
	public void setInterests(String interests) {
		this.interests = interests;
	} 
  
	public void setHotOrNotRating(int rating) {
		this.rating += rating;	
		ratingCount++;
	}
}

想想如果系统直接使用这个类会有什么问题？

如果真的直接用这个类，而不考虑其他题，那么估计很快就会大量用户抱怨：我的兴趣竟然被别人篡改了！！有人竟然给自己评高分！！太不公平了！！

没错，在这个系统中，应该不允许用户篡改别人的数据，如果直接按照上面的类定义，任何客户都可以调用任何方法了。

在这个例子中，使用保护代理是最合适不过了。

什么是保护代理？是提供某些级别的保护，根据客户的权限和决定客户可否访问哪些特定的方法，所以保护代理可能只提供给客户部分接口。

比如在我们的约会系统中，我们之希望顾客可以设置自己的信息，同时又防止他人更改这些信息。而HotOrNot评分则相反，你不可以更改自己的评分，但是他人可以设置你的评分。

Java动态代理

Java在java.lang.reflect（反射）包中有自己的代理支持，利用这个包你可以在运行时动态地创建一个代理类，实现一个或多个接口，并将方法的调用转发到你所指定的类。因为实际的代理类是在运行时创建的，所以我们称这个Java技术为：动态代理。



Invocation的工作原理是响应代理的任何调用，可以看成是代理收到方法调用后，请求做实际工作的对象。

我们要用Java的动态代理创建这个约会系统的保护代理。

下面来看怎样用Java动态代理实现保护模式。

实现保护代理的约会系统

顾客不可以改变自己的HotOrNot评分，也不可以改变其他顾客的个人信息。为了达到这个目标，必须要创建两个代理：一个用来访问你自己的PersonBean对象，另一个用来访问另一个顾客的PersonBean对象。这样，代理就可以控制在每一种情况下允许哪一种请求了。

创建这个代理，就必须使用Java API的动态代理。Java会为我们创建两个代理，而我们只需要提供handler来处理代理转来的方法。

步骤一：创建两个InvocationHandler

InvocationHandler实现了代理的行为，Java负责创建真实代理类和对象。我们只需要提供在方法调用发生时知道做什么的handler。我们需要写两个InvocationHandler（调用处理器），其中一个给拥有者使用，另一个给非拥有者使用。究竟什么是InvocationHandler呢？可以这样想：当代理方法被调用时，代理就会把这个调用转发给InvocationHandler，但是这并不是通过调用InvocationHandler的对应方法做到的。

给拥有者使用的InvocationHandler:

// 拥有者的InvocationHandler

// InvocationHandler在java.lan.reflect包中
import java.lang.reflect.*;
 

// 所有调用处理器都实现InvocationHandler接口
public class OwnerInvocationHandler implements InvocationHandler { 
	PersonBean person;
 
    // 将person传入构造器，并保持引用
	public OwnerInvocationHandler(PersonBean person) {
		this.person = person;
	}
 
    // 每次代理的方法被调用，就会导致代理调用此invoke方法
	public Object invoke(Object proxy, Method method, Object[] args) 
			throws IllegalAccessException {
  
		try {
			if (method.getName().startsWith("get")) {
                // 如果方法是一个getter，就允许调用
				return method.invoke(person, args);

   			} else if (method.getName().equals("setHotOrNotRating")) {
                // 否则，如果方法是HotOrNotRating(), 因为不能给自己打分，所以就抛出异常，表示不允许
				throw new IllegalAccessException();

			} else if (method.getName().startsWith("set")) {
                // 如果是setter，可以设置自己的信息，所以就给调用
				return method.invoke(person, args);

			} 
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } 
		return null; //其他方法都是未定义的，返回null
	}
}

给非拥有者使用的InvocationHandler:

import java.lang.reflect.*;
 
public class NonOwnerInvocationHandler implements InvocationHandler { 
	PersonBean person;
 
	public NonOwnerInvocationHandler(PersonBean person) {
		this.person = person;
	}
 
	public Object invoke(Object proxy, Method method, Object[] args) 
			throws IllegalAccessException {
  
		try {
			if (method.getName().startsWith("get")) {
                // 可以查看其他人的信息
				return method.invoke(person, args);

   			} else if (method.getName().equals("setHotOrNotRating")) {
                // 可以给其他人评分
				return method.invoke(person, args);

			} else if (method.getName().startsWith("set")) {
                // 不可以设置别人的信息,所以返回异常
				throw new IllegalAccessException();

			} 
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } 
		return null;
	}
}

步骤二：创建Proxy类并实例化Proxy对象

现在，只剩下创建动态Proxy类，并实例化Proxy对象了。让我们开始编写一个以PersonBean为参数，并知道如何为PersonBean对象创建拥有者代理的方法，也就是说，我们要创建一个代理，将它的方法调用转发给 OwnerInvocationHandler。

下面的方法是调用拥有者的方法

// 此方法需要一个person对象作为参数，然后返回该对象的代理
    // 因为代理和主题有相同的接口，所以我们返回接口PersonBean
	PersonBean getOwnerProxy(PersonBean person) {
 		
        // 此代码创建了代理（代码有点丑）
        // 我们利用Proxy类的静态newProxyInstance方法创建代理对象(Java反射机制)
        return (PersonBean) Proxy.newProxyInstance( 
            	person.getClass().getClassLoader(),  // 将personBean的类载入器当作参数
            	person.getClass().getInterfaces(),   // 代理需要实现的接口
                new OwnerInvocationHandler(person)); // 调用非拥有者的处理器
	}

下面方法获取非拥有者的方法

PersonBean getNonOwnerProxy(PersonBean person) {
		
        return (PersonBean) Proxy.newProxyInstance(
            	person.getClass().getClassLoader(),   
            	person.getClass().getInterfaces(),   
                new NonOwnerInvocationHandler(person));
	}

步骤三：测试配对服务系统。利用适当的代理包装任何PersonBean对象。

import java.lang.reflect.*;
import java.util.*;

public class MatchMakingTestDrive {
    // 实例变量, 当作是保存顾客的“数据库”
	Hashtable datingDB = new Hashtable();
 	
	public static void main(String[] args) {
		MatchMakingTestDrive test = new MatchMakingTestDrive();
		test.drive();
	}
 
	public MatchMakingTestDrive() {
        // 在构造器中初始化数据库
		initializeDatabase();
	}

	public void drive() {
		PersonBean joe = getPersonFromDatabase("Joe Javabean");  //从数据库中取出一个人
		PersonBean ownerProxy = getOwnerProxy(joe); // 创建这个人的拥有者代理
		System.out.println("Name is " + ownerProxy.getName()); //  输出这个人的名字
		ownerProxy.setInterests("bowling, Go");  // 使用拥有者代理来设置自己的兴趣
		System.out.println("Interests set from owner proxy");
		try {
            // 尝试用拥有者代理来给自己评分
			ownerProxy.setHotOrNotRating(10);
		} catch (Exception e) {
            // 如果给自己评分会出错
			System.out.println("Can't set rating from owner proxy");
		}
		System.out.println("Rating is " + ownerProxy.getHotOrNotRating());

        // 创建一个非拥有者的代理
		PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
		System.out.println("Name is " + nonOwnerProxy.getName());
		try {
            // 尝试用非拥有者代理来设置兴趣
			nonOwnerProxy.setInterests("bowling, Go");
		} catch (Exception e) {
            // 不可以给别人设置兴趣
			System.out.println("Can't set interests from non owner proxy");
		}
        // 可以给别人评分
		nonOwnerProxy.setHotOrNotRating(3);
		System.out.println("Rating set from non owner proxy");
		System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());
	}

    // 此方法需要一个person对象作为参数，然后返回该对象的代理
    // 因为代理和主题有相同的接口，所以我们返回接口PersonBean
	PersonBean getOwnerProxy(PersonBean person) {
        // 此代码创建了代理（代码有点丑）
        // 我们利用Proxy类的静态newProxyInstance方法创建代理对象(Java反射机制)
        return (PersonBean) Proxy.newProxyInstance( 
            	person.getClass().getClassLoader(),  // 将personBean的类载入器当作参数
            	person.getClass().getInterfaces(),   // 代理需要实现的接口
                new OwnerInvocationHandler(person)); // 调用非拥有者的处理器
	}

PersonBean getNonOwnerProxy(PersonBean person) {
		
        return (PersonBean) Proxy.newProxyInstance(
            	person.getClass().getClassLoader(),   
            	person.getClass().getInterfaces(),   
                new NonOwnerInvocationHandler(person));
	}
	PersonBean getPersonFromDatabase(String name) {
		return (PersonBean)datingDB.get(name);
	}

    // 初始化“数据库”
	void initializeDatabase() {
		PersonBean joe = new PersonBeanImpl();
		joe.setName("Joe Javabean");
		joe.setInterests("cars, computers, music");
		joe.setHotOrNotRating(7);
		datingDB.put(joe.getName(), joe);

		PersonBean kelly = new PersonBeanImpl();
		kelly.setName("Kelly Klosure");
		kelly.setInterests("ebay, movies, music");
		kelly.setHotOrNotRating(6);
		datingDB.put(kelly.getName(), kelly);
	}
}

输出：



小结：

动态代理之所以称为动态代理，是因为运行时才将它的类创建出来。代码开始时，还没有proxy类， 它是根据需要从你传入的接口集创建的。

InvocationHandler不是一个proxy，它只是一个帮助proxy的类，proxy会把调用转发给它处理.Proxy本身是利用静态的Proxy.newProxyInstance()方法在运行时动态创建的。

代理模式一共记了三篇的笔记：远程代理，虚拟代理，和保护代理。代理模式的还远远不止这些：

防火墙代理（Firewall Proxy）：

控制网络资源的访问，保护主题免于“坏客户”的侵害。常用在公司的防火墙系统

智能引用代理（Smart Reference Proxy）：

当主题被引用时，进行额外的动作，例如计算一个对象被引用的次数。

缓存代理（Caching Proxy）：

为开销大的运算结果提供暂时存储：它也可以允许多个客户共享结果，以减少计算或网络延迟。常用在Web服务器代理，以及内容管理与出版系统。

同步代理（Synchronizationi Proxy）:

在多线程的情况下为主题提供安全的访问。常用在JavaSpaces，为分散式环境内的潜在对象集合提供同步访问控制。

复杂隐藏代理（Complexity Hiding Proxy）：

用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理（Facade Proxy），这不难了解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口.

写入时复制代理（Copy-On-Write Proxy）：

用来控制对象的复制，方法是延迟对象的复制，知道客户真的需要为止。这是虚拟代理的变体。