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

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

代理模式涉及的角色:

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）调用远程方法。