设计模式之06代理模式（笔记）

1 定义：

1.1 定义：Provide asurrogate or placeholder for another object to control access to it.(为其他对象提供一种代理以控制对这个对象的访问)。

1.2 通用类图：

1.3 通用代码：

代理模式也叫做委托模式，它是一项基本设计技巧。许多其它的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式，而且在日常的应用中，代理模式可以提供非常好的访问控制。下面看一下类图中三个角色的定义：

Subject抽象主题角色

可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求；

RealSubject具体主题角色

也叫做被委托角色、被代理角色。它才是业务逻辑的具体执行者；

Proxy代理主题角色

也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。

通用源码如下：

public interface Subject {
         //定义一个方法
         publicvoid request();
}
 
public class RealSubject implements Subject{        
         //实现方法
         publicvoid request() {
                   //业务逻辑处理
         }
}
 
public class Proxy implements Subject {
         //要代理哪个实现类
         privateSubject subject = null;
        
         //默认被代理者
         publicProxy(){
                   this.subject= new Proxy();
         }
        
         publicProxy(Subject _subject){
                   this.subject= _subject;
         }
        
         //通过构造函数传递代理者
         publicProxy(Object...objects ){
 
         }
        
         //实现接口中定义的方法
         publicvoid request() {
                   this.before();
                   this.subject.request();
                   this.after();
         }
        
         //预处理
         privatevoid before(){
                   //dosomething
         }
        
         //善后处理
         privatevoid after(){
                   //dosomething
         }
}
 
public class Client { 
         publicstatic void main(String[] args) {
                   Subjectproxy = new RealSubject();
                   proxy.request();
         }
}

2 优点

2.1 职责清晰：真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件事务，附带的结果就是编程简洁；

2.2 高扩展性：具体主题角色是随时都会发生变化的，只要它实现了接口，不用管它如何变化，都逃不了接口，那我们的代理类完全可以在不做任何修改的情况下使用。

3 缺点

暂无

4 应用场景

4.1 需要将事务委托其它模块的情境。

4.2 需要对另一对象进行访问控制的情境。

5 注意事项

暂无

6 扩展

代理分类：

透明代理：用户不用知道代理的存在，可以直接访问目标；

普通代理：用户要先知道代理的存在，才能访问目标；

强制代理：用户直接调用真实角色，不用关心代理是否存在，但是其代理的产生是由真实角色决定。

6.1普通代理例子：（游戏代理升级）

类图如下：

/**
 *@author cbf4Life cbf4life@126.com
 *I'm glad to share my knowledge with you all.
 * 游戏玩家
 */
public interface IGamePlayer {
 
         //登录游戏
         publicvoid login(String user,String password);
        
         //杀怪，这是网络游戏的主要特色
         publicvoid killBoss();
        
         //升级
         publicvoid upgrade();
}
 
/ * 真实的玩家
 */
public class GamePlayer implementsIGamePlayer {
         privateString name = "";
        
         //构造函数限制谁能创建对象，并同时传递姓名
         publicGamePlayer(IGamePlayer _gamePlayer,String _name) throws Exception{
                   if(_gamePlayer== null ){
                            thrownew Exception("不能创建真是角色！");
                   }else{
                            this.name= _name;
                   }
                  
         }
         //打怪，最期望的就是杀老怪
         publicvoid killBoss() {
                   System.out.println(this.name+ "在打怪！");
         }
        
         //进游戏之前你肯定要登录吧，这是一个必要条件
         publicvoid login(String user, String password) {
                   System.out.println("登录名为"+user+ " 的用户 " + this.name + "登录成功！");
         }
 
         //升级，升级有很多方法，花钱买是一种，做任务也是一种
         publicvoid upgrade() {
                   System.out.println(this.name+ " 又升了一级！");
         }
 
}
 
/ * 代练者
 */
public class GamePlayerProxy implementsIGamePlayer {
         privateIGamePlayer gamePlayer = null;
        
         //通过构造函数传递要对谁进行代练
         publicGamePlayerProxy(String name){
                   try{
                            gamePlayer= new GamePlayer(this,name);
                   }catch (Exception e) {
                            //TODO 异常处理
                   }
         }
        
         //代练杀怪
         publicvoid killBoss() {
                   this.gamePlayer.killBoss();
         }
 
         //代练登录
         publicvoid login(String user, String password) {
                   this.gamePlayer.login(user,password);
         }
 
         //代练升级
         publicvoid upgrade() {
                   this.gamePlayer.upgrade();
         }
 
}
 
/ * 场景类
 */
public class Client {
 
         publicstatic void main(String[] args) {
 
                   //然后再定义一个代练者
                   IGamePlayerproxy = new GamePlayerProxy("张三");
                  
                   //开始打游戏，记下时间戳
                   System.out.println("开始时间是：2009-8-2510:45");
                   proxy.login("zhangSan","password");
                   //开始杀怪
                   proxy.killBoss();
                   //升级
                   proxy.upgrade();
                   //记录结束游戏时间
                   System.out.println("结束时间是：2009-8-2603:40");
                  
         }
 
}

注意：要禁止在别的地方 new 一个真实角色哦。

6.2 强制代理

必须通过真实角色，找到代理角色，才能访问。无论是通过代理类，还是直接new一个主题角色类，都不能访问，只有通过真实角色指定的的代理类才能访问，也就是说由真实角色管理代理角色。

类图如下：

源码如下：

public interface IGamePlayer {
 
         //登录游戏
         publicvoid login(String user,String password);
        
         //杀怪，这是网络游戏的主要特色
         publicvoid killBoss();
        
         //升级
         publicvoid upgrade();
        
         //每个人都可以找一下自己的代理
         publicIGamePlayer getProxy();
}
 
public class GamePlayer implementsIGamePlayer {
         privateString name = "";
         //我的代理是谁
         privateIGamePlayer proxy = null;
                  
         publicGamePlayer(String _name){
                   this.name= _name;        
         }
        
         //找到自己的代理
         publicIGamePlayer getProxy(){
                   this.proxy= new GamePlayerProxy(this);
                   returnthis.proxy;
         }
        
         //打怪，最期望的就是杀老怪
         publicvoid killBoss() {
                   if(this.isProxy()){
                            System.out.println(this.name+ "在打怪！");
                   }else{
                            System.out.println("请使用指定的代理访问");
                   }                
         }
        
         //进游戏之前你肯定要登录吧，这是一个必要条件
         publicvoid login(String user, String password) {
                   if(this.isProxy()){
                            System.out.println("登录名为"+user+ " 的用户 " + this.name + "登录成功！");
                   }else{
                            System.out.println("请使用指定的代理访问");;
                   }
                  
         }
 
         //升级，升级有很多方法，花钱买是一种，做任务也是一种
         publicvoid upgrade() {
                   if(this.isProxy()){
                            System.out.println(this.name+ " 又升了一级！");
                   }else{
                            System.out.println("请使用指定的代理访问");
                   }
         }
        
         //校验是否是代理访问
         privateboolean isProxy(){
                   if(this.proxy== null){
                            returnfalse;
                   }else{
                            returntrue;
                   }
         }
}
 
public class GamePlayerProxy implementsIGamePlayer {
         privateIGamePlayer gamePlayer = null;
        
         //构造函数传递用户名
         publicGamePlayerProxy(IGamePlayer _gamePlayer){  
                   this.gamePlayer= _gamePlayer;
         }
        
         //代练杀怪
         publicvoid killBoss() {
                   this.gamePlayer.killBoss();
         }
 
         //代练登录
         publicvoid login(String user, String password) {
                   this.gamePlayer.login(user,password);
         }
 
         //代练升级
         publicvoid upgrade() {
                   this.gamePlayer.upgrade();
 
         }
        
         //代理的代理暂时还没有,就是自己
         publicIGamePlayer getProxy(){
                   returnthis;
         }
}
 
public class Client {
         publicstatic void main(String[] args) {
                   //定义个游戏的角色
                   IGamePlayerplayer = new GamePlayer("张三");
                  
                   //开始打游戏，记下时间戳
                   System.out.println("开始时间是：2009-8-2510:45");
                   player.login("zhangSan","password");
                   //开始杀怪
                   player.killBoss();
                   //升级
                   player.upgrade();
                   //记录结束游戏时间
                   System.out.println("结束时间是：2009-8-2603:40");         
         }
}

6.3 代理是有个性的

代理为不仅仅可以实现主题接口，也可以实现其他接口完成不同的任务，而且代理的目的是在目标对象方法的基础上作增强，这种增强的本质通常就是对目标对象的方法进行拦截和过滤。

例如，游戏代理是需要收费的，升一级需要5元钱，这个计算功能就是代理类的个性，它应该在代理的接口中定义。如下图

相比上图源代码如下：

public interface IProxy {
         //计算费用
         publicvoid count();
}
public class GamePlayerProxy implementsIGamePlayer,IProxy {
         privateIGamePlayer gamePlayer = null;
        
         //通过构造函数传递要对谁进行代练
         publicGamePlayerProxy(IGamePlayer _gamePlayer){
                   this.gamePlayer= _gamePlayer;
         }
        
         //代练杀怪
         publicvoid killBoss() {
                   this.gamePlayer.killBoss();
         }
 
         //代练登录
         publicvoid login(String user, String password) {
                   this.gamePlayer.login(user,password);
 
         }
 
         //代练升级
         publicvoid upgrade() {
                   this.gamePlayer.upgrade();
                   this.count();
         }
        
         //计算费用
         publicvoid count(){
                   System.out.println("升级总费用是：150元");
         }
}

代理类可以为真实角色预处理消息、过滤消息、消息转发、事后处理消息等功能。当然一个代理类，可以代理多个真实角色，并且真实角色之间可以有耦合关系。

6.4 虚拟代理

虚拟代理：在需要时候才初始化主题对象，可以避免被代理对象较多而引起的初始化缓慢的问题，其缺点是需要在每个方法中判断主题对象是否被创建。

public class Proxy implements Subject {
         //要代理哪个实现类
         private Subject subject;
         //实现接口中定义的方法
         publicvoid request() {
                   //判断一下真实主题是否初始化
                   if(subject == null) {
                            subject= new RealSubject();
                   }
                   subject.request();
         }
}

6.5 动态代理

所谓动态代理：在实现阶段不用关心代理谁，而在运行阶段才指定代理哪一个对象。相对来说，自己写代理类的方式就是静态代理。

面向横切面编程，也就是AOP（AspectOriented Programming），其核心就是采用了动态代理机制。（不懂，完全摘录）

类图如下：

在类图中增加了一个InvocationHandler接口和GamePlayerIH类，作用就是产生一个对象的代理对象，其中InvocationHandler是JDK提供的动态代理接口，对被代理类的方法进行代理。

源代码如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
/**
 *@author cbf4Life cbf4life@126.com
 *I'm glad to share my knowledge with you all.
 * 代练者
 */
public class GamePlayIH implementsInvocationHandler {
         //被代理者
         Classcls =null;
         //被代理的实例
         Objectobj = null;
        
         //我要代理谁
         publicGamePlayIH(Object _obj){
                   this.obj= _obj;
         }
        
         //调用被代理的方法
         publicObject invoke(Object proxy, Method method, Object[] args)
                            throwsThrowable {
                   Objectresult = method.invoke(this.obj, args);
                   returnresult;
         }       
}

其中invoke方法是接口InvocationHandler定义必须实现的，它完成对真实方法的调用。

对于InvocationHandler接口，动态代理是根据被代理的接口生成所有的方法，也就是说给定一个接口，动态代理会宣称“我已经实现该接口下的所有方法了”，通过InvocationHandler接口，所有方法都由该Handler来进行处理，即所有被代理的方法都由InvocationHandler接管实际的处理任务。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
 
 
/**
 *@author cbf4Life cbf4life@126.com
 *I'm glad to share my knowledge with you all.
 * 场景类
 */
public class Client {
 
         publicstatic void main(String[] args) throws Throwable  {
                   //定义一个痴迷的玩家
                   IGamePlayerplayer = new GamePlayer("张三");           
                   //定义一个hanlder
                   InvocationHandlerhandler = new GamePlayIH(player);                  
                   //开始打游戏，记下时间戳
                   System.out.println("开始时间是：2009-8-2510:45");         
                   //获得类的classloader
                   ClassLoadercl = player.getClass().getClassLoader();             
                   //动态产生一个代理者
                   IGamePlayerproxy = (IGamePlayer)Proxy.newProxyInstance(cl,newClass[]{IGamePlayer.class},handler);                  
                   //登录
                   proxy.login("zhangSan","password");            
                   //开始杀怪
                   proxy.killBoss();
                   //升级
                   proxy.upgrade();
                   //记录结束游戏时间
                   System.out.println("结束时间是：2009-8-2603:40");
                  
         }
}
 

对于创建过程的理解：

InvocationHandler handler = newGamePlayIH(player);

ClassLoader cl =player.getClass().getClassLoader();

IGamePlayer proxy = (IGamePlayer)Proxy.newProxyInstance(cl,newClass[]{IGamePlayer.class},handler);

使用类加载器cl ，把 .class的所有方法，让handler来实现。

关于AOP，打住，暂不懂，未接触。

7 范例

若前6.1。 自己并未写。