设计模式感触之代理模式应用
如果说看完设计模式之后,哪个模式最让我印象深刻和半醉半醒,那一定就是代理模式(Proxy)。代理模式看似非常简单,很直接,应用的也很广泛,然而,放下书,去使用的时候,可能是由于动态代理和远程代理实现的细节还没弄清,忽然发现,代理模式究竟为哪般还是模糊的。此处记录和总结下我所理解的代理模式,本部分主要是基础部分。
1 面向对象设计之路---使用面向对象设计原则
1.1 初始设计
学习程序设计,还是以程序的语言来说吧:
我们有一个接口Callable:
Java代码
public interface Callable {
public void call();
}
现在我们有一个实现类Phone:
Java代码
public class Phone implements Callable {
@Override
public void call() {
System.out.println("Phone is calling ...");
}
//Other Phone methods
}
OK,现在工作的很好,能完成要求的所有功能。
1.2 需求扩展
这时候,出现了一个新的需求,就是需要对Phone的所有动作进行计时,以对最终的收费提供依据,这时候有三种解决方案:
A 如果有源码,直接修改Phone类:一种可能的实现可能是如下形式:
Java代码
public class Phone implements Callable {
@Override
public void call() {
long startTime = System.currentTimeMillis();
System.out.println("Phone is calling ...");
long endTime = System.currentTimeMillis();
System.out.println("Call duration = " + (endTime - startTime));
}
//Other Phone methods
}
B不幸的是,我们没有源代码可以修改,可以采用继承的方式来解决:可能的实现如下:
Java代码
public class Phone2 extends Phone {
@Override
public void call() {
long startTime = System.currentTimeMillis();
super.call();
long endTime = System.currentTimeMillis();
System.out.println("Call duration = " + (endTime - startTime));
}
}
C 除开A、B之外,我们还有一种方式来达到目的,那就是使用聚合来完成:示例如下
Java代码
public class Phone3 implements Callable {
private Callable phone;
public Phone3(Callable phone) {
this.phone = phone;
}
@Override
public void call() {
long startTime = System.currentTimeMillis();
phone.call();
long endTime = System.currentTimeMillis();
System.out.println("Call duration = " + (endTime - startTime));
}
}
A、B、C三种方法对比,很容易发现:
A的做法最是糟糕,完全破坏了伟大程序员缔造伟大程序的美感,破坏了面向对象设计的第一大原则:开闭原则:软件实体应该对扩展开放,对修改关闭。OK,类似于A的做法以后不再出现了。
B的做法使用了面向对象语言里面的继承,相对于A来说,那是大大的进化了,也没有破坏开闭原则,但有一点,如果我们需要对Phone的call职责再加强一下,需要记录日志,那么采用继承的话,在Java中由于只支持单继承,因此需要再次从Phone2继承,容易造成类的爆炸,如此下去,会造成很多很多类和很长很长的继承链。
C的做法采用了对象聚合,在解决上述的新问题时,只需要再次聚合下Phone3就可以解决了,聚合比继承更好的优势主要体现在扩展性上,继承不够灵活,能更好的提高类的复用性。这也是面向对象设计的一大原则之一:合成/聚合复用原则:尽量使用合成/聚合,尽量不要使用继承。
仔细观察,聚合为什么会具有更强的能力呢,这里主要是在Phone3里面传入的是Callable接口,因此非常灵活,其实这是另外一个面向对象设计原则:依赖反转原则:要依赖于抽象,不要依赖与具体。另外一种说法是:要针对接口编程,不要针对实现编程。
2 代理模式的基本形式
代理,按其字面意义来说,就是指代替其他人做他们该做的事情,广泛的来讲,上述的继承和聚合方式实现都是代理的形式,继承中,子类将call的行为交给父类处理,聚合中,将具体的call行为交给引用的类处理。
在GoF提出的设计模式中,代理模式是这样定义的:
对其他对象提供一种代理以控制对这个对象的访问。
它的UML模型如下:
由此可见,代理与真实对象实现了同一个接口,对真实对象的请求事实上是通过代理来处理的。也可以说明前面所述的继承与聚合事实上也是一种代理。
3 代理模式的应用形式
远程代理:可以为一个不同的地址空间的对象提供一个局域代表对象;
虚拟代理:根据需要创建一个资源消耗较大的对象,使得此对象只在需要时才会被真正创建;
保护代理:基于访问权限可以控制对一个对象的访问;
…
4 代理模式的动态代理
上面所述的都属于静态代理,但代理模式的一大犀利之处就是其也能实现动态代理,即在运行时动态决定真实的被代理对象。
Java自身提供了实现动态代理的结构,自定义动态代理类,只需要使用java.lang.reflect包下面的InvocationHandler, Proxy和Method三个类就可以了,下面看一个简单的例子:
Java代码
public class FirstInvocationHandler implements InvocationHandler {
private Object o;
public FirstInvocationHandler(Object phone) {
this.o = phone;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Invoke start!");
method.invoke(o, args);
System.out.println("Invoke completed!");
return null;
}
}
下面只需要调用就可以了,给个测试例子:
Java代码
public class TestJavaProxy {
public static void main(String[] args) {
Phone phone = new Phone();
Callable proxyPhone = (Callable) Proxy.newProxyInstance(phone.getClass().getClassLoader(), phone.getClass().getInterfaces(), new FirstInvocationHandler(phone));
proxyPhone.call();
Date date = new Date();
Serializable proxyDate = (Serializable)Proxy.newProxyInstance(date.getClass().getClassLoader(), date.getClass().getInterfaces(), new FirstInvocationHandler(date));
proxyDate.toString();
}
}
通过例子,将可以发现,我们可以自由实现我们需要的代理,只需要能传递正确的classLoader、interfaces和args,就能被代理到,这对于具有通用增强功能方法的尤其有意义,比如在典型的日志记录、事务管理、权限等控制上非常灵活。
如果说看完设计模式之后,哪个模式最让我印象深刻和半醉半醒,那一定就是代理模式(Proxy)。代理模式看似非常简单,很直接,应用的也很广泛,然而,放下书,去使用的时候,可能是由于动态代理和远程代理实现的细节还没弄清,忽然发现,代理模式究竟为哪般还是模糊的。此处记录和总结下我所理解的代理模式,本部分主要是基础部分。
1 面向对象设计之路---使用面向对象设计原则
1.1 初始设计
学习程序设计,还是以程序的语言来说吧:
我们有一个接口Callable:
Java代码
public interface Callable {
public void call();
}
现在我们有一个实现类Phone:
Java代码
public class Phone implements Callable {
@Override
public void call() {
System.out.println("Phone is calling ...");
}
//Other Phone methods
}
OK,现在工作的很好,能完成要求的所有功能。
1.2 需求扩展
这时候,出现了一个新的需求,就是需要对Phone的所有动作进行计时,以对最终的收费提供依据,这时候有三种解决方案:
A 如果有源码,直接修改Phone类:一种可能的实现可能是如下形式:
Java代码
public class Phone implements Callable {
@Override
public void call() {
long startTime = System.currentTimeMillis();
System.out.println("Phone is calling ...");
long endTime = System.currentTimeMillis();
System.out.println("Call duration = " + (endTime - startTime));
}
//Other Phone methods
}
B不幸的是,我们没有源代码可以修改,可以采用继承的方式来解决:可能的实现如下:
Java代码
public class Phone2 extends Phone {
@Override
public void call() {
long startTime = System.currentTimeMillis();
super.call();
long endTime = System.currentTimeMillis();
System.out.println("Call duration = " + (endTime - startTime));
}
}
C 除开A、B之外,我们还有一种方式来达到目的,那就是使用聚合来完成:示例如下
Java代码
public class Phone3 implements Callable {
private Callable phone;
public Phone3(Callable phone) {
this.phone = phone;
}
@Override
public void call() {
long startTime = System.currentTimeMillis();
phone.call();
long endTime = System.currentTimeMillis();
System.out.println("Call duration = " + (endTime - startTime));
}
}
A、B、C三种方法对比,很容易发现:
A的做法最是糟糕,完全破坏了伟大程序员缔造伟大程序的美感,破坏了面向对象设计的第一大原则:开闭原则:软件实体应该对扩展开放,对修改关闭。OK,类似于A的做法以后不再出现了。
B的做法使用了面向对象语言里面的继承,相对于A来说,那是大大的进化了,也没有破坏开闭原则,但有一点,如果我们需要对Phone的call职责再加强一下,需要记录日志,那么采用继承的话,在Java中由于只支持单继承,因此需要再次从Phone2继承,容易造成类的爆炸,如此下去,会造成很多很多类和很长很长的继承链。
C的做法采用了对象聚合,在解决上述的新问题时,只需要再次聚合下Phone3就可以解决了,聚合比继承更好的优势主要体现在扩展性上,继承不够灵活,能更好的提高类的复用性。这也是面向对象设计的一大原则之一:合成/聚合复用原则:尽量使用合成/聚合,尽量不要使用继承。
仔细观察,聚合为什么会具有更强的能力呢,这里主要是在Phone3里面传入的是Callable接口,因此非常灵活,其实这是另外一个面向对象设计原则:依赖反转原则:要依赖于抽象,不要依赖与具体。另外一种说法是:要针对接口编程,不要针对实现编程。
2 代理模式的基本形式
代理,按其字面意义来说,就是指代替其他人做他们该做的事情,广泛的来讲,上述的继承和聚合方式实现都是代理的形式,继承中,子类将call的行为交给父类处理,聚合中,将具体的call行为交给引用的类处理。
在GoF提出的设计模式中,代理模式是这样定义的:
对其他对象提供一种代理以控制对这个对象的访问。
它的UML模型如下:
由此可见,代理与真实对象实现了同一个接口,对真实对象的请求事实上是通过代理来处理的。也可以说明前面所述的继承与聚合事实上也是一种代理。
3 代理模式的应用形式
远程代理:可以为一个不同的地址空间的对象提供一个局域代表对象;
虚拟代理:根据需要创建一个资源消耗较大的对象,使得此对象只在需要时才会被真正创建;
保护代理:基于访问权限可以控制对一个对象的访问;
…
4 代理模式的动态代理
上面所述的都属于静态代理,但代理模式的一大犀利之处就是其也能实现动态代理,即在运行时动态决定真实的被代理对象。
Java自身提供了实现动态代理的结构,自定义动态代理类,只需要使用java.lang.reflect包下面的InvocationHandler, Proxy和Method三个类就可以了,下面看一个简单的例子:
Java代码
public class FirstInvocationHandler implements InvocationHandler {
private Object o;
public FirstInvocationHandler(Object phone) {
this.o = phone;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Invoke start!");
method.invoke(o, args);
System.out.println("Invoke completed!");
return null;
}
}
下面只需要调用就可以了,给个测试例子:
Java代码
public class TestJavaProxy {
public static void main(String[] args) {
Phone phone = new Phone();
Callable proxyPhone = (Callable) Proxy.newProxyInstance(phone.getClass().getClassLoader(), phone.getClass().getInterfaces(), new FirstInvocationHandler(phone));
proxyPhone.call();
Date date = new Date();
Serializable proxyDate = (Serializable)Proxy.newProxyInstance(date.getClass().getClassLoader(), date.getClass().getInterfaces(), new FirstInvocationHandler(date));
proxyDate.toString();
}
}
通过例子,将可以发现,我们可以自由实现我们需要的代理,只需要能传递正确的classLoader、interfaces和args,就能被代理到,这对于具有通用增强功能方法的尤其有意义,比如在典型的日志记录、事务管理、权限等控制上非常灵活。