【设计模式】学习笔记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技术为:动态代理

【设计模式】学习笔记17:代理模式之保护代理与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);
}
}

输出:

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

小结:

动态代理之所以称为动态代理,是因为运行时才将它的类创建出来。代码开始时,还没有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):

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

上一篇:(转)Android之自定义适配器


下一篇:Spring 代理模式及AOP基本术语