浅谈设计模式之代理模式

代理模式基本概念

定义:

代理模式(Proxy Pattern)为其他对象提供一种代理以控制对这个对象的访问。代理对象起到中介作用,可去掉功能服务或增加额外的服务。

类图:

代理模式

根据以上类图,可以知道在代理模式中的角色有以下三种:

  1. 抽象对象角色:声明了目标对象和代理对象的共同接口,这样一来在任何可以使用目标对象的地方都可以使用代理对象。

  2. 目标对象角色:定义了代理对象所代表的目标对象。

  3. 代理对象角色:代理对象内部含有目标对象的引用,从而可以在任何时候操作目标对象;代理对象提供一个与目标对象相同的接口,以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后,执行某个操作,而不是单纯地将调用传递给目标对象。

分类:

  1. 远程代理(Remote Proxy):为不同地理的对象提供局域网代表对象
  2. 虚拟代理(Virtual Proxy):根据需要将资源消耗很大的对象进行延迟,真正需要的时候再创建
  3. 保护代理(Protect Proxy):控制用户的访问权限
  4. 智能引用代理(Smart Reference Proxy):提供对目标对象额外的服务

在使用代理模式的时候,九成以上使用到的都是智能引用代理,故以下案例都围绕智能代理展开。

常用代理模式原理

代理模式实现的两种方式:

  • 静态代理
  • 动态代理

首先我们先来看看静态代理的实现原理。


静态代理(Static Proxy)

定义:

代理和被代理对象在代理之前都是确定的。他们都实现相同的接口或者继承相同的抽象类

静态代理实现方法:

  • 继承法:代理类直接继承被代理类,实现其原有方法,并添加一些额外功能
  • 聚合法:代理类实现相同的功能接口(很重要,相同接口,不同代理也可以进行相互代理),并在内声明一个被代理类的对象(类似封装),通过内部对象实现其原有方法,并添加额外功能

静态代理实现代码

首先定义一个接口,这里我们来拿汽车的行驶举例。

1
2
3
public interface Moveable {
void move();
}

然后弄一个车,实现这个接口。Car这个类就是即将要被代理的对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Random;
public class Car implements Moveable {
@Override
public void move() {
//实现开车
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

先来看看继承法实现静态代理。

1
2
3
4
5
6
7
8
9
10
11
public class Car2 extends Car {
@Override
public void move() {
long starttime = System.currentTimeMillis();
System.out.println("汽车开始行驶....");
super.move();
long endtime = System.currentTimeMillis();
System.out.println("汽车结束行驶.... 汽车行驶时间:" + (endtime - starttime) + "毫秒!");
}
}

再来看看聚合法实现静态代理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Car3 implements Moveable {
public Car3(Car car) {
super();
this.car = car;
}
private Car car;
@Override
public void move() {
long starttime = System.currentTimeMillis();
System.out.println("汽车开始行驶....");
car.move();
long endtime = System.currentTimeMillis();
System.out.println("汽车结束行驶.... 汽车行驶时间:" + (endtime - starttime) + "毫秒!");
}
}

最后提供一个客户端的测试类。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Client {
public static void main(String[] args) {
//使用继承方式实现静态代理
Moveable m1 = new Car2();
m1.move();
//使用聚合方式实现静态代理
Car car = new Car();
Moveable m2 = new Car3(car);
m2.move();
}
}

那么继承法和聚合法何者更优呢?

结论是聚合比继承更适合实现代理

如果我们要实现功能的叠加,比如增加方法运行时间处理,增加权限管理,增加日志处理等,或者调整这些功能的实现顺序,如果有一百种实现顺序,我们用继承法就要实现100个代理子类,这显然是不现实的,如果需要修改也是极其繁琐的。而如果使用聚合法,只要一个代理类管理一个功能,在维护和调整顺序上都是最优的。这里就不再举例了。


动态代理(Dynamic Proxy)

类图:

首先看一下动态代理的类图。
动态代理

定义:

所谓Dynamic Proxy是这样一种class:

它是在运行时生成的class,该class需要实现一组interface,使用动态代理类时,必须实现InvocationHandle接口

实现步骤:

  1. 创建一个实现接口InvocationHandler的类,它必须实现invoke方法
  2. 创建被代理的类以及接口
  3. 调用Proxy的静态方法(newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)),创建一个代理类
  4. 通过代理调用方法

动态代理实现方法:

  • JDK动态产生代理
  • cglib动态产生代理

动态代理实现代码:

JDK动态代理:
1
2
3
public interface Moveable {
void move();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Random;
public class Car implements Moveable {
@Override
public void move() {
//实现开车
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

动态代理类:

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
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class TimeHandler implements InvocationHandler {
public TimeHandler(Object target) {
super();
this.target = target;
}
private Object target;
/*
* 参数:
* proxy 被代理对象
* method 被代理对象的方法
* args 方法的参数
*
* 返回值:
* Object 方法的返回值
* */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long starttime = System.currentTimeMillis();
System.out.println("汽车开始行驶....");
method.invoke(target);
long endtime = System.currentTimeMillis();
System.out.println("汽车结束行驶.... 汽车行驶时间:"
+ (endtime - starttime) + "毫秒!");
return null;
}
}

测试类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Test {
/**
* JDK动态代理测试类
*/
public static void main(String[] args) {
Car car = new Car();
InvocationHandler h = new TimeHandler(car);
Class<?> cls = car.getClass();
/**
* loader 类加载器
* interfaces 实现接口
* h InvocationHandler
*/
Moveable m = (Moveable)Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), h);
m.move();
}
}


cglib动态代理:

首先需要导入第三方jar包——cglib-nodep-2.2.jar

创建一个火车类。

1
2
3
4
5
6
public class Train {
public void move(){
System.out.println("火车行驶中...");
}
}

cglib动态代理类:

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
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz){
//设置创建子类的类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
/**
* 拦截所有目标类方法的调用
* obj 目标类的实例
* m 目标方法的反射对象
* args 方法的参数
* proxy代理类的实例
*/
@Override
public Object intercept(Object obj, Method m, Object[] args,MethodProxy proxy) throws Throwable {
System.out.println("日志开始...");
//代理类调用父类的方法
proxy.invokeSuper(obj, args);
System.out.println("日志结束...");
return null;
}
}

测试类:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
CglibProxy proxy = new CglibProxy();
Train t = (Train)proxy.getProxy(Train.class);
t.move();
}
}


参考资料: