一、什么是代理模式？

为另一个对象提供一个替身或一个占位符以控制对这个对象的访问。

二、 代理模式各种变体。

远程代理：使得客户端可以访问在远程主机的角色（两个程序不在同一个jvm虚拟机）。

虚拟代理：当创建开销大的对象的时候，真正需要这个对象才创建它，当对象在创建前与创建中时候，由虚拟代理扮演对象替身的角色

保护代理：主要用于当前对象有不同访问权限时。（通过java的动态代理实现）

三、代理模式组成

抽象角色：代理类与真实类实现的共同的接口

真实角色：实现接口的功能。是真正做事的对象

代理角色：持有真实角色的引用，控制对真实角色的访问。

客户与真实角色的访问必须通过代理角色。任何出现真实角色的地方都可以被代理角色所替代。

四、具体实现

先说一下远程代理：

远程代理实现方式（rmi）：

问题：有一家糖果机公司，CEO希望能写一个程序在远程查询糖果机中糖果的数量（ps：也就是查看数量的客户端与糖果机系统运行的服务端不在同一个JVM下）

首先，制作远程接口：注意：每一个方法都必须要抛出RemoteException异常。

//糖果机监视器，继承Remote接口。里面包含了需要的查询糖果数量的方法。
public interface SugerMachineMoniter extends Remote{public Integer getCount() throws RemoteException;
}

然后，编写服务端，服务端继承UnicastRemoteObject类，并实现SugerMachineMoniter接口

public class SugerMachine  extends UnicastRemoteObject implements SugerMachineMoniter{private Integer count;protected SugerMachine(int count) throws RemoteException {super();this.count=count;}@Overridepublic Integer getCount() throws RemoteException{return count;}
}

将编写的服务端注册到rmi服务器，供远程客户端调用。

public class Server {public static void main(String args[]){try {LocateRegistry.createRegistry(8888);//注册远程用户访问的端口SugerMachine sugerMachine=new SugerMachine(50);Naming.rebind("myServer", sugerMachine);//注册到rmi服务器上，访问的话就通过  rmi://服务器地址/注册名（这里是myServer）} catch (RemoteException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (MalformedURLException e) {// TODO Auto-generated catch blocke.printStackTrace();} }
}

远程客户端调用：

public class Client {public static void main(String args[]) throws MalformedURLException, RemoteException, NotBoundException{SugerMachineMoniter sugerMachineMoniter=(SugerMachineMoniter) Naming.lookup("rmi://127.0.0.1:8888/myServer");System.out.println(sugerMachineMoniter.getCount());}
}

分析：这里面如何用到代理的？（详细的搜一下rmi的详解）

这需要查看一下rmi的运行过程，客户端调用的对象（也就是SugerMachineMoniter），其实是调用的服务器端生成的远程对象的本地代理（Stub）。我们在客户端调用的时候，每调用一个方法，客户端的代理对象（stub）把信息打包发送给服务端，服务端解包并调用真正的服务端的代码。服务端代码再把反悔信息打包返回给客户端的代理（Stub）,所以看起来就像是调用真正的对象。

再说一下保护代理（通过Java动态代理实现）：

具体问题：有一个交友网站上传个人信息资料，包括三部分（姓名，年龄，热门程度）。本人无法修改热门程度可以修改其他，其他人可以修改这个人的热门程度不可以修改其他（，，，，假装这样做是对的，，，）。

分析:这时候你需要创建两个动态代理，一个用于保护本人修改信息的时候不能修改热门程度，其他人修改这个人信息时候只能修改热门程度。

具体代码：

首先：创建需要修改的Person对象：

public interface PersonBean {//这是一个接口public void setName(String name);public void setAge(int age);public void setRate(int value);public String getName();public int getAge();public int getRate();
}

public class PersonBeanImpl implements PersonBean {//具体实现类private String name;//其他人不能修改nameprivate int age;//其他人不能修改ageprivate int rate;//本人不能修改rate@Overridepublic void setName(String name) {this.name=name;}@Overridepublic void setAge(int age) {this.age=age;}@Overridepublic void setRate(int value) {this.rate=value;}@Overridepublic String getName() {return name;}@Overridepublic int getAge() {return age;}@Overridepublic int getRate() {return rate;}
}

创建两个InvocationHandler：

public class OwnerInvocationHandler implements InvocationHandler {//所调用的处理器都必须实现这个接口private PersonBean personBean;public OwnerInvocationHandler(PersonBean personBean){//将personBean引入保持对它的引用this.personBean=personBean;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//每次调用personBean方法的时候，都是调用的它if (method.getName().contains("get")){return method.invoke(personBean,args);}else if (method.getName().equals("setRate")){//对于自己，不能修改ratethrow  new UnsupportedOperationException("不支持此项操作");}else {return method.invoke(personBean,args);}}
}

public class NoInvocationHandler implements InvocationHandler {private PersonBean personBean;public NoInvocationHandler(PersonBean personBean){this.personBean=personBean;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Exception {if (method.getName().contains("get")) {return method.invoke(personBean,args);}else if (method.getName().equals("setRate")){return method.invoke(personBean,args);}else {                                        //对于别人，不能修改name与agethrow new Exception("不支持此项操作");}}
}

创建Proxy并实例化Proxy对象：我用两个方法实现的

    public  static  PersonBean getOwnerInvocation(PersonBean personBean){return (PersonBean) Proxy.newProxyInstance(personBean.getClass().getClassLoader(),//利用Proxy的静态方法创建代理，需要的参数：需要动态代理personBean.getClass().getInterfaces(),              //的对象的classLoader，所实现的接口，需要调用的invocationhandler     new OwnerInvocationHandler(personBean));}public  static  PersonBean getNoInvocation(PersonBean personBean){return (PersonBean) Proxy.newProxyInstance(personBean.getClass().getClassLoader(),personBean.getClass().getInterfaces(),new NoInvocationHandler(personBean));}

使用：

        PersonBean personBean=new PersonBeanImpl();personBean.setName("luck");personBean.setAge(12);personBean.setRate(6);PersonBean ownerPerson = getOwnerInvocation(personBean);try {ownerPerson.setRate(8);}catch (Exception e){System.out.println("这项操作不支持");}System.out.println(ownerPerson.getName()+","+ownerPerson.getRate()+","+ownerPerson.getAge());PersonBean otherPerson=getNoInvocation(personBean);try{otherPerson.setAge(10);}catch (Exception e){System.out.println("不支持此方法");}otherPerson.setRate(10);System.out.println(otherPerson.getName()+"."+otherPerson.getAge()+","+otherPerson.getRate());}

输出：

这项操作不支持
luck,6,12
不支持
luck.12,10

ps:动态代理之所以称为动态代理，在系统运行时候它才创建出来。

五、总结：

一、代理模式作为一个代表，以便控制客户对真实对象的访问，控制方式有很多种。

二、远程代理管理客户和远程对象的交互，虚拟代理控制访问实例化开销大的对象，保护代理基于调用者控制对象方法的访问

三、代理在结构上类似装饰者，但是目的不同，装饰者模式为对象加上行为，而代理是控制访问  。

四、Java内置的代理支持，可以根据需要创建动态代理。并将所有调用分配到所选的处理器。