代理模式：
为另一个对象提供一个替身或占位符以控制对这个对象的访问。
被代理的对象可以是远程的对象、创建开销大的对象或需要安全控制的对象。
一，远程代理：
客户对象所做的就像是在做远程方法调用，但其实只是调用本地堆中的“代理”对象上的方法，再由代理处理所有网络通信的低层细节。
远程代理就好比“远程对象的本地代表”。
“远程对象”是指活在不同的Java虚拟机堆的对象（或在不同的地址空间运行的远程对象）。
“本地代表”是指可以由本地方法调用的对象，其行为会转发到远程对象中。
Java RMI已内置了远程代理服务。
步骤：
1，制作远程接囗；
- public interface GumballMachineRemote extends Remote {//必须扩展java.rmi.Remote
- public int getCount() throws RemoteException;//准备支持的方法必须抛出RemoteException
- public String getLocation() throws RemoteException;
- public State getState() throws RemoteException;
- //所有返回类型必须是原语类型或可序列化类型
- }
- public interface State extends Serializable {//扩展Serializable接囗，实现序列化，这样所有子类中的State就可以在网络上传送了
- public void insertQuarter();
- public void ejectQuarter();
- public void turnCrank();
- public void dispense();
- }
//状态对象维护着一个对糖果机的引用，我们不希望整个糖果机都被序列化并随State对象一起传送，所以子类做如下修正
- public class NoQuarterState implements State {
- transient GumballMachine gumballMachine;//对State的每个实现，我们都在GumballMachine实例变量前加上transient关键字，告诉JVM不要序列化这个字段
- //其它方法
- }
2，制作远程的实现；
//GumballMachine要继承UnicastRemoteObject，以成为一个远程服务。另外需要实现远程接囗GumballMachineRemote
- public class GumballMachine
- extends UnicastRemoteObject implements GumballMachineRemote
- {
- //这里有实例变量
- public GumballMachine(String location, int numberGumballs) throws RemoteException {//构造器需要抛出RemoteException，因为超类是这么做的
- //这里代码
- }
- public int getCount() {
- return count;
- }
- public State getState() {
- return state;
- }
- public String getLocation() {
- return location;
- }
- //其他方法
- }
3，在RMI registry中进行注册：执行rmiregistry
4，启动服务
二，虚拟代理：
虚拟代理作为创建开销大的对象的代表。虚拟代理经常直到我们真正需要一个对象时才创建它，在对象创建前和创建中时，由虚拟代理来扮演对象的替身，在对象创建后，代理就会将请求直接委托给对象。
以显示CD封面为例：
代理对象ImageProxy与被代理对象ImageIcon都实现Icon接囗；
ImageProxy首先创建一个ImageIcon，然后从网络加载图像；
在加载未完成时，ImageProxy显示“CD封面加载中，请稍候.....”
当加完完成后，ImageProxy把所有方法调用委托给真正的ImageIcon；
如果用户请求新的图像，我们就创建新代理，重复这样的过程。
三，保护代理：
所谓“保护代理”就是根据访问权限决定客户可否访问对象的代理。
Java在java.lang.reflect包中有自己的代理支持，利用这个包你可以在运行时动态地创建一个代理类，实现一个或多外接囗，并将方法的调用转发到你所指定的类，因为实际的代理类是在运行时创建的，我们称这个Java技术为：动态代理。
本书利用Java的动态代理创建保护代理实现。
以书中配对服务应用为例：
首先设计要求顾客不能改变自己的评分，也不能改变其他顾客的个人信息；由此可知这里需要创建两个代理：一个访问自己的PersonBean对象，一个访问另一顾客的PersonBean对象，这样代理就可以控制在那种情况下允许那种请求；
实例步骤：
1,创建两个InvocationHandler，其中一个给拥有者使用，另一个给非拥有者使用。
什么是InvocationHandler呢？你可以这么想，当代理的方法被调用时，代理就会把这个调用转发给InvocationHandler，但是这并不是通过调用InvocationHandler的相应方法做到的，那么是如何做到的呢？
InvocationHandler只有一个名为invoke的方法，不管代理被调用的是何种方法，各理器被调用的一定是invoke()方法，那么invoke是如何工作的呢？
例设proxy的setHotOrNotRating方法被调用：
ownerProxy.setHotOrNotRating(10);
proxy会接着调用InvocationHandler的invoke()方法：
invoke(代理对象实例ownerProxy,调用方法setHotOrNotRating,参数数组{10});
- package headfirst.proxy.javaproxy;
- import java.lang.reflect.*;
- public class OwnerInvocationHandler implements InvocationHandler {
- PersonBean person;
- public OwnerInvocationHandler(PersonBean person) {
- this.person = person;//被调用对象
- }
- public Object invoke(Object proxy, Method method, Object[] args)
- throws IllegalAccessException {
- try {
- if (method.getName().startsWith("get")) {
- return method.invoke(person, args);//允许操作
- } else if (method.getName().equals("setHotOrNotRating")) {
- throw new IllegalAccessException();//禁止操作，抛出运行时异常
- } else if (method.getName().startsWith("set")) {
- return method.invoke(person, args);
- }
- } catch (InvocationTargetException e) {
- e.printStackTrace();
- }
- return null;
- }
- }
- package headfirst.proxy.javaproxy;
- import java.lang.reflect.*;
- public class NonOwnerInvocationHandler implements InvocationHandler {
- PersonBean person;
- public NonOwnerInvocationHandler(PersonBean person) {
- this.person = person;
- }
- public Object invoke(Object proxy, Method method, Object[] args)
- throws IllegalAccessException {
- try {
- if (method.getName().startsWith("get")) {
- return method.invoke(person, args);
- } else if (method.getName().equals("setHotOrNotRating")) {
- return method.invoke(person, args);
- } else if (method.getName().startsWith("set")) {
- throw new IllegalAccessException();
- }
- } catch (InvocationTargetException e) {
- e.printStackTrace();
- }
- return null;
- }
- }
2，创建Proxy类并实例化Proxy对象
- PersonBean getOwnerProxy(PersonBean person) {
- return (PersonBean) Proxy.newProxyInstance(
- person.getClass().getClassLoader(),
- person.getClass().getInterfaces(),
- new OwnerInvocationHandler(person));
- }
- PersonBean getNonOwnerProxy(PersonBean person) {
- return (PersonBean) Proxy.newProxyInstance(
- person.getClass().getClassLoader(),
- person.getClass().getInterfaces(),
- new NonOwnerInvocationHandler(person));
- }
3，测试程序：
- package headfirst.proxy.javaproxy;
- import java.lang.reflect.*;
- import java.util.*;
- public class MatchMakingTestDrive {
- Hashtable datingDB = new Hashtable();
- public static void main(String[] args) {
- MatchMakingTestDrive test = new MatchMakingTestDrive();
- test.drive();
- }
- public MatchMakingTestDrive() {
- initializeDatabase();
- }
- public void drive() {
- PersonBean joe = getPersonFromDatabase("Joe Javabean");
- PersonBean ownerProxy = getOwnerProxy(joe);
- System.out.println("Name is " + ownerProxy.getName());
- ownerProxy.setInterests("bowling, Go");
- System.out.println("Interests set from owner proxy");
- try {
- ownerProxy.setHotOrNotRating(10);
- } catch (Exception e) {
- System.out.println("Can't set rating from owner proxy");
- }
- System.out.println("Rating is " + ownerProxy.getHotOrNotRating());
- PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
- System.out.println("Name is " + nonOwnerProxy.getName());
- try {
- nonOwnerProxy.setInterests("bowling, Go");
- } catch (Exception e) {
- System.out.println("Can't set interests from non owner proxy");
- }
- nonOwnerProxy.setHotOrNotRating(3);
- System.out.println("Rating set from non owner proxy");
- System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());
- }
- PersonBean getOwnerProxy(PersonBean person) {
- return (PersonBean) Proxy.newProxyInstance(
- person.getClass().getClassLoader(),
- person.getClass().getInterfaces(),
- new OwnerInvocationHandler(person));
- }
- PersonBean getNonOwnerProxy(PersonBean person) {
- return (PersonBean) Proxy.newProxyInstance(
- person.getClass().getClassLoader(),
- person.getClass().getInterfaces(),
- new NonOwnerInvocationHandler(person));
- }
- PersonBean getPersonFromDatabase(String name) {
- return (PersonBean)datingDB.get(name);
- }
- void initializeDatabase() {
- PersonBean joe = new PersonBeanImpl();
- joe.setName("Joe Javabean");
- joe.setInterests("cars, computers, music");
- joe.setHotOrNotRating(7);
- datingDB.put(joe.getName(), joe);
- PersonBean kelly = new PersonBeanImpl();
- kelly.setName("Kelly Klosure");
- kelly.setInterests("ebay, movies, music");
- kelly.setHotOrNotRating(6);
- datingDB.put(kelly.getName(), kelly);
- }
- }
4，其他代码：
- package headfirst.proxy.javaproxy;
- public interface PersonBean {
- String getName();
- String getGender();
- String getInterests();
- int getHotOrNotRating();
- void setName(String name);
- void setGender(String gender);
- void setInterests(String interests);
- void setHotOrNotRating(int rating);
- }
- package headfirst.proxy.javaproxy;
- public class PersonBeanImpl implements PersonBean {
- String name;
- String gender;
- String interests;
- int rating;
- int ratingCount = 0;
- public String getName() {
- return name;
- }
- public String getGender() {
- return gender;
- }
- public String getInterests() {
- return interests;
- }
- public int getHotOrNotRating() {
- if (ratingCount == 0) return 0;
- return (rating/ratingCount);
- }
- public void setName(String name) {
- = name;
- }
- public void setGender(String gender) {
- this.gender = gender;
- }
- public void setInterests(String interests) {
- this.interests = interests;
- }
- public void setHotOrNotRating(int rating) {
- this.rating += rating;
- ratingCount++;
- }
- }
要点：
代理模式为另一个对象提供代表，以便控制客户对对象的访问，管理访问的方式有很多种；
远程代理管理客户和远程对象之间的交互；
虚拟代理控制访问实例化开销大的对象；
保护代理基于调用者控制对对象方法的访问；
代理模式有很多变体；
代理在结构上类似装饰者，但是目的不同：装饰者模式为对象加上行为，而代理则是控制访问；
就象其他的包装者（wraapper）一样，代理会造成你的设计中的类的数目增加。
