java代理模式

本文讲述了代理模式，包括了普通代理、强制代理和动态代理。

原文链接：

http://tianweili.github.io/blog/2015/03/13/proxy-pattern/

介绍

代理模式属于结构性模式，使用频率很高。

定义：Provide a surrogate or placeholder for another object to control access to it.为其他对象提供一种代理以控制这个对象的访问。

装饰模式、状态模式、策略模式、访问者模式本质上都是在更特殊的场合采用了代理模式。

UML类图

从以上UML类图中可以看出代理模式主要有三种角色：

抽象主题角色

可以是接口或抽象类，是某类通用业务的定义。

具体主题角色

作为被代理对象，是具体业务的真实执行者。

代理主题角色

是具体主题对象的代理，负责对具体对象的应用，把所有抽象主题定义的方法委托给具体主题对象来实现，它用来在具体主题对象业务处理的前后做一些处理工作。

代码示例

/**
* Abstract subject class.
*/
public interface Subject {
public void someMethod();
}
/**
* Real subject class.
*/
public class RealSubject implements Subject {

private String name;

public RealSubject(String name) {
this.name = name;
}

@Override
public void someMethod() {
System.out.println(name + "'s someMehtod.");
}
}
/**
* Proxy class.
*/
public class ProxySubject implements Subject {

private Subject subject;

public ProxySubject(Subject subject) {
this.subject = subject;
}

@Override
public void someMethod() {
this.before();
subject.someMethod();
this.after();
}

/**
* preprocessing
*/
private void before() {
// do something...
}

/**
* follow-up processing
*/
private void after() {
// do something...
}
}

从以上代码可以看出ProxySubject对象还有before和after方法，可以在RealSubject对象的someMethod业务方法前后做一些预处理和善后处理工作。

一个代理类可以代理多个被代理对象，只要是实现同一个接口。当然也可以一个被代理对象就有一个代理类，不过一般是一个接口有一个代理类就够了，在应用时具体是代理哪一个被代理对象，这是由场景类也就是高层模块定义的，根据构造方法的传入哪一个被代理对象参数来决定代理哪一个对象。

构造方法：

public ProxySubject(Subject subject) {
this.subject = subject;
}

想代理哪个对象就要传入生成这个对象的实例。

优点

各个角色职责清晰，比如被代理对象只需要实现属于自己具体的业务逻辑就行了，不用去关心非本职责的业务处理。其他的一些处理业务可以交给代理类来处理。这样做的好处是编程简洁清晰，业务分明。

扩展性好，具体实现对象的业务发生了变化，只需要修改自身业务处理逻辑，或者增加删减一个实现业务接口的对象，不会影响代理业务。

代理模式可以提供非常好的访问控制，由代理类来控制被代理对象，可以做一些预处理消息，过滤消息，消息转发和善后处理工作等等。

普通代理和强制代理

普通代理和强制代理是代理模式的两种不同结构，是根据调用者能够访问到代理对象还是具体对象来区分的。就好比网络上的代理服务器设置分为普通代理和透明代理。普通代理需要用户手动设置代理服务器的IP地址，用户必须知道代理的存在。透明代理就是用户不需要设置代理服务器地址，就可以直接访问，不用知道代理的存在。

普通代理

普通代理是用户只能访问代理角色，而不能访问真实角色。

只需要对上面代码稍作改动即可实现普通代理的效果，代码如下：

/**
* Abstract subject class.
*/
public interface Subject {
public void someMethod();
}
/**
* Real subject class.
*/
public class RealSubject implements Subject {

private String name;

/**
* Don't allow client call this.
*/
public RealSubject(Subject subject, String name) throws Exception {
if(subject == null) {
throw new Exception("Don't allow realSubject created!");
} else {
this.name = name;
}
}

@Override
public void someMethod() {
System.out.println(name + "'s someMehtod.");
}
}
/**
* Proxy class.
*/
public class ProxySubject implements Subject {

private Subject subject;

/**
* Client call proxy subject.
*/
public ProxySubject(String name) {
try {
this.subject = new RealSubject(this, name);
} catch (Exception e) {
e.printStackTrace();
}
}

@Override
public void someMethod() {
this.before();
subject.someMethod();
this.after();
}

/**
* preprocessing
*/
private void before() {
// do something...
System.out.println("before ...");
}

/**
* follow-up processing
*/
private void after() {
// do something...
System.out.println("after ...");
}
}
public class Client {
public static void main(String[] args) {
Subject subject = new ProxySubject("ZhangSan");
subject.someMethod();
}
}

运行程序结果如下：

before ...
ZhangSan's someMehtod.
after ...

在上面RealSubject的构造方法中是通过传入参数subject来限制用户不能实例化自己，当然也可以通过别的一些限制条件，比如类名必须有Proxy等等。

强制代理

普通代理是通过代理角色找到真是角色，而强制代理是强制只能通过真实角色查找代理角色来访问，想直接通过实例化代理角色或真实角色都不能访问。

UML类图如下：



从以上UML类图可以看出Subject接口中添加了个获取代理的接口方法。

代码清单：

/**
* Abstract subject class.
*/
public interface Subject {
public void someMethod();
public Subject getProxy();
}
/**
* Real subject class.
*/
public class RealSubject implements Subject {

private String name;
private Subject proxy;

public RealSubject(String name) {
this.name = name;
}

@Override
public void someMethod() {
if (this.isProxy()) {
System.out.println(name + "'s someMehtod.");
} else {
System.out.println("Only visit proxy class is allowed!");
}
}

@Override
public Subject getProxy() {
// appoint proxy class.
this.proxy = new ProxySubject(this);
return proxy;
}

private boolean isProxy() {
if (this.proxy == null) {
return false;
} else {
return true;
}
}
}
/**
* Proxy class.
*/
public class ProxySubject implements Subject {

private Subject subject;

public ProxySubject(Subject subject) {
this.subject = subject;
}

@Override
public void someMethod() {
subject.someMethod();
}

@Override
public Subject getProxy() {
return this;
}
}

当客户端想通过真实角色来访问时，客户端代码如下：

public class Client {
public static void main(String[] args) {
Subject realSubject = new RealSubject("ZhangSan");
realSubject.someMethod();
}
}

执行结果：

Only visit proxy class is allowed!

访问被拒绝，因为它是通过真实角色来直接访问的，而不是通过真实角色来获取代理角色来访问。

当客户端想通过代理角色来访问时，客户端代码如下：

public class Client {
public static void main(String[] args) {
Subject realSubject = new RealSubject("ZhangSan");
Subject proxy = new ProxySubject(realSubject);
proxy.someMethod();
}
}

执行结果：

Only visit proxy class is allowed!

访问同样被拒绝，因为它是通过代理角色来直接访问的，而不是通过真实角色来获取代理角色来访问。

只有强制客户端通过真实角色来获取代理对象，才能访问。客户端代码如下：

public class Client {
public static void main(String[] args) {
Subject realSubject = new RealSubject("ZhangSan");
Subject proxy = realSubject.getProxy();
proxy.someMethod();
}
}

执行结果：

ZhangSan's someMehtod.

通过真实角色来获取代理对象访问成功。

动态代理

这一节之前所讲的代理其实都是静态代理，它有一个特点就是要在实现阶段就要指定代理类以及被代理者，很不灵活。而动态代理就是在实现阶段不用管代理具体对象，而在运行阶段指定代理哪个对象即可生产代理对象。

基本的UML类图如下所示：



从类图中可以看出，具体的业务逻辑和代理逻辑是两条线，两者之间没有必然的耦合关系。

InvocationHandler是JDK提供的接口，用来对被代理类的方法进行代理。

注意：被代理者必须实现一个接口，否则动态代理无法生成代理对象。

动态代理是根据被代理者的接口生成所有的方法。通过InvocationHandler接口，所有被代理的方法都由InvocationHandler来接管实际的处理逻辑。

代码清单：

/**
* Abstract subject class.
*/
public interface Subject {
public void someMethod();
}
/**
* Real subject class.
*/
public class RealSubject implements Subject {

private String name;

public RealSubject(String name) {
this.name = name;
}

@Override
public void someMethod() {
System.out.println(name + "'s someMehtod.");
}
}

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

public class MyInvocationHandler implements InvocationHandler {

private Object obj;

public MyInvocationHandler(Object obj) {
this.obj = obj;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before...");
Object result = method.invoke(obj, args);
System.out.println("after...");
return result;
}
}

invoke方法是接口InvocationHandler中定义必须实现的，它用来完成对真实方法的调用。

客户端调用代码：

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

public class Client {
public static void main(String[] args) {
Subject subject = new RealSubject("ZhangSan");

ClassLoader loader = subject.getClass().getClassLoader();
Class[] interfaces = subject.getClass().getInterfaces();
InvocationHandler handler = new MyInvocationHandler(subject);

Subject proxy = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);
proxy.someMethod();
}
}

执行结果：

before...
ZhangSan's someMehtod.
after...

从结果中可以看出我们已经达到了代理RealSubject对象的目的。

看了上面的客户端调用代码，我们可以优化一下，将Proxy封装起来，使得调用更简便一些。增加动态代理封装类：

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

public class DynamicProxy {

public static Object newProxyInstance(Object object) {

ClassLoader loader = object.getClass().getClassLoader();
Class[] interfaces = object.getClass().getInterfaces();
InvocationHandler handler = new MyInvocationHandler(object);

return Proxy.newProxyInstance(loader, interfaces, handler);
}
}

客户端调用：

public class Client {
public static void main(String[] args) {
Subject subject = new RealSubject("ZhangSan");
Subject proxy = (Subject) DynamicProxy.newProxyInstance(subject);
proxy.someMethod();
}
}

动态代理优点

动态代理拥有以上静态代理所有优点，除此之外还有动态代理的代理对象是在需要的时候动态生成的。

在业务逻辑开发时可以不用管代理业务逻辑，这两条线不会耦合。比如在做具体的业务逻辑设计和实现时不用考虑日志、事务、权限等逻辑处理，这些可以通过动态代理来搞定。

Struts2的Form映射和Spring的AOP（Aspect Oriented Programming）就是动态代理的典型应用。