李天炜

代理模式

发表于 | 分类于 | 阅读次数

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

原文链接：

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类图中可以看出代理模式主要有三种角色：

抽象主题角色

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

具体主题角色

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

代理主题角色

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

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/**
 * 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业务方法前后做一些预处理和善后处理工作。

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

构造方法：

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

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

优点

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

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

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

普通代理和强制代理

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

普通代理

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/**
 * 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();
    }
}

运行程序结果如下：

1
2
3
before ...
ZhangSan's someMehtod.
after ...

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

强制代理

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

UML类图如下：

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

代码清单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/**
 * 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;
    }
}

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

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

执行结果：

1
Only visit proxy class is allowed!

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

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

1
2
3
4
5
6
7
public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject("ZhangSan");
        Subject proxy = new ProxySubject(realSubject);
        proxy.someMethod();
    }
}

执行结果：

1
Only visit proxy class is allowed!

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

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

1
2
3
4
5
6
7
public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject("ZhangSan");
        Subject proxy = realSubject.getProxy();
        proxy.someMethod();
    }
}

执行结果：

1
ZhangSan's someMehtod.

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

动态代理

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

基本的UML类图如下所示：

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

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

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

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

代码清单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
 * 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中定义必须实现的，它用来完成对真实方法的调用。

客户端调用代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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();
    }
}

执行结果：

1
2
3
before...
ZhangSan's someMehtod.
after...

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
    }
}

客户端调用：

1
2
3
4
5
6
7
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）就是动态代理的典型应用。

作者：李天炜

原文链接：http://tianweili.github.io/blog/2015/03/13/proxy-pattern/

转载请注明作者和文章出处，谢谢。