java设计模式之代理模式

代理模式:给某一对象提供代理对象,并由代理对象控制具体对象的引用。

代理,指的就是一个角色代表另一个角色采取行动,就象生活中,一个红酒厂商,是不会直接把红酒零售客户的,都是通过代理来完成他的销售业务的。而客户,也不用为了喝红酒而到处找工厂,他只要找到厂商在当地的代理就行了,具体红酒工厂在那里,客户不用关心,代理会帮他处理。

代理模式涉及的角色:

1:抽象主题角色(Subject):声明了代理主题(Proxy)和真实主题(RealSubject)的公共接口,使任何需要真实主题(RealSubject)的地方都能用代理主题(Proxy)代替。

2:代理主题角色(Proxy):含有真实主题(RealSubject)的引用,从而可以在任何时候操作真实主题,代理主题通过实现和真实主题相同的接口,使它可以随时代替真实主题。代理主题通过持有真实主题的引用,不但可以控制真实主题的创建或删除,可以在真实主题被调用前进行拦截,或在调用后进行某些操作。

3:真实代理对象(RealSubject):定义了代理角色所代表的具体对象。

下面是代理模式的实现类图:

根据上图的关系,我们可以用客户买红酒来模拟代理模式的实现。

红酒代理商和红酒厂商都有销售红酒的只能,我们可以为他们定义一个共同的抽象主题角色,


/**
*抽象主题角色,定义了真实角色和代理角色的公共接口
*/
public interface SellInterface {
public Object sell();
}

接着,我们定义真实主题角色(这里就是红酒工厂),它必须实现了SellInterface接口的。


/**
*真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口
*/
public class RedWineFactory implements SellInterface {
public Object sell() {
System.out.println(“真实主题角色RedWineFactory 被调用了”);
return new Object();
}
}

下面是代理主题角色(这里指红酒代理商),同样,代理主题也必须实现SellInterface接口。


/**
*代理主题角色,这里指红酒代理商。它除了也要实现了sellInterface接口外,还持有红酒
*厂商RedWineFactory 对象的引用,从而使它能在调用真实主题前后做一些必要处理。
*/
public class RedWineProxy implements SellInterface {
//持有一个RedWineFactory对象的引用
private RedWineFactory redWineFactory;

//销售总量
private static int sell_count = 0;

public Object sell() {
if (checkUser()) {//在通过代理主题角色,我们可以在真实主题角色被调用前做一些诸如权限判断的事情
Object obj = redWineFactory.sell();
sell_count++;//同样,在调用后我们也可以执行一些额外的动作。
return obj;
} else {
throw new RuntimeException();
}
}

protected boolean checkUser() {
//do something
return true;
}
}

接下来看看调用代理对象的代码


public static void main(String agr[]) {
SellInterface sell = new RedWineProxy();
sell.sell();
}

从上面的例子可以看出代理模式的工作方式,首先,因为代理主题和真实主题都实现了共同的接口,这使我们可以在不改变原来接口的情况下,只要用真实主题对象的地方,都可以用代理主题来代替。其次,代理主题在客户和真实主题之间起了一个中介作用,利用这个中介平台,我们可以在把客户请求传递给真实主题之前,做一些必要的预处理。

java对代理模式的支持 —动态代理

上面的代理,我们强迫代理类RedWineProxy实现了抽象接口SellInterface。这导致我们的代理类无法通用于其他接口,所以不得不为每一个接口实现一个代理类。幸好,java为代理模式提供了支持。

java主要是通过Proxy类和InvocationHandler接口来给实现对代理模式的支持的。

下面用java的代理机制来实现上面的例子


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

/**
*代理类一定要实现了InvocationHandler接口
*/
public class ProxyObject implements InvocationHandler {
private Object proxy_obj;

ProxyObject(Object obj) {
this.proxy_obj = obj;
}

public static Object factory(Object obj) {
Class cls = obj.getClass();
//通过Proxy类的newProxyInstance方法来返回代理对象
return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), new ProxyObject(obj));
}

/**
*实现InvocationHandler接口的invoke
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(“函数调用前被拦截了: ” + method);
if (args != null) {
//打印参数列表
System.out.println(“方法有 ” + args.length + ” 个参数”);
for (int i = 0; i < args.length; i++) { System.out.println(args[i]); } } //利用反射机制动态调用原对象的方法 Object mo = method.invoke(proxy_obj, args); System.out.println("函数调用后进行处理 : " + method); return mo; } //测试代码 public static void main(String agr[]) { SellInterface si = (SellInterface) factory(new RedWineFactory()); si.sell(); } }

通过上面的代码可以看出,代理主题ProxyObject类并没有实现我们定义的SellInterface借口,

而是实现了java的InvocationHandler接口,这样就把代理主题角色和我们的业务代码分离开来,使代理对象能通用于其他接口。

其实InvocationHandler接口就是一种拦截机制,当系统中有了代理对象以后,对原对象(真实主题)方法的调用,都会转由 InvocationHandler接口来处理,并把方法信息以参数的形式传递给invoke方法,这样,我们就可以在invoke方法中拦截原对象的调用,并通过反射机制来动态调用原对象的方法。这好象也是spring aop编程的基础吧。

本文整理自:http://www.javaeye.com/topic/517835

~~~~~~~~补充~~~~~~~~

静态代理模式的细分:

(1)远程代理(Remote Proxy)
为一个在不同的地址空间提供局部代理。

(2)虚代理(Virtual Proxy)
根据需要了创建开销很大的对象。

(3)保护代理(Protection Proxy)
控制对原始对象的访问。

(4)智能指引(Smart Reference)
取代了简单的指针,它在访问对象时执行一些简单的操作。

代理模式的使用场景:

(1)在每个业务方法前的权限校验;

(2)异常发生时给管理员发送邮件通知;

(3)事务处理。(spring使用动态代理来实现事务管理。)

(4)调用远程方法。

此条目发表在java/j2ee分类目录,贴了, 标签。将固定链接加入收藏夹。

java设计模式之代理模式》有2条回应

  1. java-csh说:

    不错,讲的很生动

发表评论

您的电子邮箱地址不会被公开。

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据