7. 代理模式(Proxy Pattern)
代理模式是一种很重要和常用的设计模式,就像它的名字一样,是关于对象的代理的,代理对象可以控制被代理对象的访问,实现某些特定的功能。
按照功能来划分,代理模式可以分为以下三种:
(1) 远程代理(Remote Proxy)
可以控制对远程对象的访问,Java平台的RMI就是这种代理方式的典型应用。
(2) 虚代理(Virtual Proxy)
可以控制对一个创建开销很大的对象的访问,最典型的做法是延迟对象的创建,直到真正需要使用的时候。另外也可以控制被代理对象创建前和创建时的行为,并在对象创建后将请求委托给实际的对象。
(3) 保护代理(Protection Proxy)
保护代理的用途主要是根据客户端的权限去控制对对象的访问。
在实现上,代理模式主要由3个部分组成:Subject,RealSubject,Proxy。其中RealSubject和Proxy都继承自Subject,而且Proxy中保存着RealSubject的引用,这样,Proxy就可以替代RealSubject来对Client的请求提供服务,实现一种类似"代理人","网关"或者"防火墙"的作用。
类图如下所示:
下面来分别举例子说明一下3种代理。
(1) 远程代理(Remote Proxy)
远程代理的最好例子就是RMI了,下面来举个RMI的简单例子。
首先是Subject,在RMI中叫远程接口,在这个接口中暴露出了给客户端调用的远程方法。
然后是RealSubject,它继承自Subject,在RMI中,叫做远程实现,
这个实现就是打印出"hello"加上传给远程方法的参数。
RealHelloObject要继承自UnicastRemoteObject以提供一些远程的行为,当然也可以自己实现这些行为,不过继承自UnicastRemoteObject更加方便。
另外,由于UnicastRemoteObject的构造函数是会抛出异常的,所以在RealHelloObject中要强制实现一个构造函数并抛出RemoteException。
有了这两个类之后,首先对它们进行编译,然后对RealHelloObject使用rmic命令行工具生成存根(Stub),这个是给客户端使用的,客户端调用Stub就像调用了同一个JVM Heap中的对象一样,其实请求已经转交了服务器端或同一台机器的另外一个JVM Heap。
这里可以说这个存根(Stub)就是RealSubject的代理(Proxy)了。
最后还有两个方法要写一下,分别为暴露远端接口的Server类和使用RMI的客户端类,
然后,开启一个控制台窗口,输入命令"rmiRegistry"开启RMI注册服务,然后就可以运行RMI Server了,最后运行客户端就可以得到远程调用的结果了。
下面是控制台的一些截图:
首先是开启RMI注册服务:
然后是开启RMI Server:
-Djava.rmi.server.codebase这个参数指明了远程对象的类路径。
最后是调用客户端:
(2) 虚代理(Virtual Proxy)
虚代理的例子可以举一个延迟加载的例子。
首先还是Subject接口
然后定义一个被代理的RealSubject,假设这个创建它的实例需要很大的开销,
接着是一个代理对象,
最后,是客户端,
这样,就实现了对象的延迟加载,通过延迟加载,可以减少开销比较大的对象的存活时间,增加了效率。
(3) 保护代理(Protection Proxy)
保护代理可以保护对某些敏感资源的访问,达到控制客户端访问权限的目的。我们来举个例子如下:
这样,通过ResourceProxy就实现了对受限资源SecretResource的访问权限控制。
代理模式是一种很重要和常用的设计模式,就像它的名字一样,是关于对象的代理的,代理对象可以控制被代理对象的访问,实现某些特定的功能。
按照功能来划分,代理模式可以分为以下三种:
(1) 远程代理(Remote Proxy)
可以控制对远程对象的访问,Java平台的RMI就是这种代理方式的典型应用。
(2) 虚代理(Virtual Proxy)
可以控制对一个创建开销很大的对象的访问,最典型的做法是延迟对象的创建,直到真正需要使用的时候。另外也可以控制被代理对象创建前和创建时的行为,并在对象创建后将请求委托给实际的对象。
(3) 保护代理(Protection Proxy)
保护代理的用途主要是根据客户端的权限去控制对对象的访问。
在实现上,代理模式主要由3个部分组成:Subject,RealSubject,Proxy。其中RealSubject和Proxy都继承自Subject,而且Proxy中保存着RealSubject的引用,这样,Proxy就可以替代RealSubject来对Client的请求提供服务,实现一种类似"代理人","网关"或者"防火墙"的作用。
类图如下所示:
下面来分别举例子说明一下3种代理。
(1) 远程代理(Remote Proxy)
远程代理的最好例子就是RMI了,下面来举个RMI的简单例子。
首先是Subject,在RMI中叫远程接口,在这个接口中暴露出了给客户端调用的远程方法。
- public interface RemoteInterface extends Remote {
- public String sayHello(String name) throws RemoteException;
- }
public interface RemoteInterface extends Remote {
public String sayHello(String name) throws RemoteException;
}
然后是RealSubject,它继承自Subject,在RMI中,叫做远程实现,
- public class RealHelloObject extends UnicastRemoteObject implements RemoteInterface {
- /** UID */
- private static final long serialVersionUID = -1124450729017078955L;
- protected RealHelloObject() throws RemoteException {
- super();
- }
- @Override
- public String sayHello(String name) {
- return "hello " + name + "!";
- }
- }
public class RealHelloObject extends UnicastRemoteObject implements RemoteInterface {
/** UID */
private static final long serialVersionUID = -1124450729017078955L;
protected RealHelloObject() throws RemoteException {
super();
}
@Override
public String sayHello(String name) {
return "hello " + name + "!";
}
}
这个实现就是打印出"hello"加上传给远程方法的参数。
RealHelloObject要继承自UnicastRemoteObject以提供一些远程的行为,当然也可以自己实现这些行为,不过继承自UnicastRemoteObject更加方便。
另外,由于UnicastRemoteObject的构造函数是会抛出异常的,所以在RealHelloObject中要强制实现一个构造函数并抛出RemoteException。
有了这两个类之后,首先对它们进行编译,然后对RealHelloObject使用rmic命令行工具生成存根(Stub),这个是给客户端使用的,客户端调用Stub就像调用了同一个JVM Heap中的对象一样,其实请求已经转交了服务器端或同一台机器的另外一个JVM Heap。
这里可以说这个存根(Stub)就是RealSubject的代理(Proxy)了。
最后还有两个方法要写一下,分别为暴露远端接口的Server类和使用RMI的客户端类,
- public class RemoteServer {
- public static void main(String[] args) {
- try {
- RealHelloObject hello = new RealHelloObject();
- Naming.rebind("hello_from_rmi", hello);
- System.out.println("binding complete!");
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- }
- public class Client {
- public static void main(String[] args) {
- try {
- RemoteInterface hello = (RemoteInterface) Naming.lookup("rmi://127.0.0.1/hello_from_rmi");
- System.out.println(hello.sayHello("zddava"));
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- }
public class RemoteServer {
public static void main(String[] args) {
try {
RealHelloObject hello = new RealHelloObject();
Naming.rebind("hello_from_rmi", hello);
System.out.println("binding complete!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class Client {
public static void main(String[] args) {
try {
RemoteInterface hello = (RemoteInterface) Naming.lookup("rmi://127.0.0.1/hello_from_rmi");
System.out.println(hello.sayHello("zddava"));
} catch (Exception e) {
e.printStackTrace();
}
}
}
然后,开启一个控制台窗口,输入命令"rmiRegistry"开启RMI注册服务,然后就可以运行RMI Server了,最后运行客户端就可以得到远程调用的结果了。
下面是控制台的一些截图:
首先是开启RMI注册服务:
- C:\Documents and Settings\archer>rmiRegistry
C:\Documents and Settings\archer>rmiRegistry
然后是开启RMI Server:
- D:\temp>java -Djava.rmi.server.codebase=file:/D:\temp\ cn.archer.rmi.RemoteServer
- binding complete!
D:\temp>java -Djava.rmi.server.codebase=file:/D:\temp\ cn.archer.rmi.RemoteServer
binding complete!
-Djava.rmi.server.codebase这个参数指明了远程对象的类路径。
最后是调用客户端:
- D:\temp>java cn.archer.rmi.Client
- hello zddava!
D:\temp>java cn.archer.rmi.Client
hello zddava!
(2) 虚代理(Virtual Proxy)
虚代理的例子可以举一个延迟加载的例子。
首先还是Subject接口
- public interface Subject {
- public void operate();
- }
public interface Subject {
public void operate();
}
然后定义一个被代理的RealSubject,假设这个创建它的实例需要很大的开销,
- public class BigObject implements Subject {
- @Override
- public void operate() {
- System.out.println("do a lot of things");
- }
- }
public class BigObject implements Subject {
@Override
public void operate() {
System.out.println("do a lot of things");
}
}
接着是一个代理对象,
- public class Proxy implements Subject {
- private BigObject proxyObject = null;
- @Override
- public void operate() {
- if (proxyObject == null) {
- proxyObject = new BigObject();
- }
- proxyObject.operate();
- }
- }
public class Proxy implements Subject {
private BigObject proxyObject = null;
@Override
public void operate() {
if (proxyObject == null) {
proxyObject = new BigObject();
}
proxyObject.operate();
}
}
最后,是客户端,
- public class Client {
- public static void main(String[] args) {
- Subject proxy = new Proxy();
- // 许多其他操作
- proxy.operate();
- }
- }
public class Client {
public static void main(String[] args) {
Subject proxy = new Proxy();
// 许多其他操作
proxy.operate();
}
}
这样,就实现了对象的延迟加载,通过延迟加载,可以减少开销比较大的对象的存活时间,增加了效率。
(3) 保护代理(Protection Proxy)
保护代理可以保护对某些敏感资源的访问,达到控制客户端访问权限的目的。我们来举个例子如下:
- public interface Resource {
- public String readResource();
- }
- public class SecretResource implements Resource {
- @Override
- public String readResource() {
- return "top secret";
- }
- }
- public class ResourceProxy implements Resource {
- private Resource resource;
- public ResourceProxy() {
- resource = new SecretResource();
- }
- @Override
- public String readResource() {
- if (isPermissionAccess) {
- return resource.readResource();
- }
- return null;
- }
- public boolean isPermissionAccess(){
- if(...){
- return true;
- }else{
- return false;
- }
- }
- }
public interface Resource {
public String readResource();
}
public class SecretResource implements Resource {
@Override
public String readResource() {
return "top secret";
}
}
public class ResourceProxy implements Resource {
private Resource resource;
public ResourceProxy() {
resource = new SecretResource();
}
@Override
public String readResource() {
if (isPermissionAccess) {
return resource.readResource();
}
return null;
}
public boolean isPermissionAccess(){
if(...){
return true;
}else{
return false;
}
}
}
这样,通过ResourceProxy就实现了对受限资源SecretResource的访问权限控制。