`
javahacker2
  • 浏览: 43525 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

设计模式：代理模式

    博客分类：
  • Java
 
阅读更多
设计模式

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

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

代理模式涉及的角色:
1:抽象主题角色.声明了代理主题和真实主题的公共接口,使任何需要真实主题的地方都能用代理主题代替.

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

3:真实代理对象.定义了代理角色所代表的具体对象.

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


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

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

Java代码 复制代码 收藏代码
  1. /**  
  2. *抽象主题角色,定义了真实角色和代理角色的公共接口  
  3. */  
  4. public interface SellInterface{   
  5.      public Object sell();   
  6. }  
/**
*抽象主题角色,定义了真实角色和代理角色的公共接口
*/
public interface SellInterface{
     public Object sell();
}



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

Java代码 复制代码 收藏代码
  1. /**  
  2. *真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口  
  3. */  
  4. public class RedWineFactory implements SellInterface{   
  5.      public Object sell(){   
  6.          System.out.println("真实主题角色RedWineFactory 被调用了");   
  7.          return new Object();   
  8.      }   
  9. }  
/**
*真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口
*/
public class RedWineFactory implements SellInterface{
     public Object sell(){
         System.out.println("真实主题角色RedWineFactory 被调用了");
         return new Object();
     }
}



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

Java代码 复制代码 收藏代码
  1. /**  
  2. *代理主题角色,这里指红酒代理商.它除了也要实现了sellInterface接口外,还持有红酒  
  3. *厂商RedWineFactory 对象的引用,从而使它能在调用真实主题前后做一些必要处理.  
  4. */  
  5. public class RedWineProxy implements SellInterface{   
  6.      //持有一个RedWineFactory对象的引用   
  7.       private RedWineFactory redWineFactory;   
  8.   
  9.      //销售总量   
  10.       private static int sell_count = 0;   
  11.   
  12.      public Object sell(){   
  13.          if(checkUser()){//在通过代理主题角色,我们可以在真实主题角色被调用前做一些诸如权限判断的事情   
  14.              Object obj = redWineFactory.sell();   
  15.              count ++;//同样,在调用后我们也可以执行一些额外的动作.   
  16.              return obj ;   
  17.          }else{   
  18.              throw new RuntimeException();   
  19.          }   
  20.      }   
  21.   
  22.      protected boolean checkUser(){   
  23.             //do something   
  24.             return true;   
  25.      }   
  26. }  
/**
*代理主题角色,这里指红酒代理商.它除了也要实现了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();
             count ++;//同样,在调用后我们也可以执行一些额外的动作.
             return obj ;
         }else{
             throw new RuntimeException();
         }
     }

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



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

Java代码 复制代码 收藏代码
  1. public static void main(String agr[])   
  2. {   
  3.      SellInterface sell = new RedWineProxy();   
  4.      sell.sell();   
  5. }  
public static void main(String agr[])
{
     SellInterface sell = new RedWineProxy();
     sell.sell();
}



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

java对代理模式的支持 ---动态代理
上面的代理,我们强迫代理类RedWineProxy实现了抽象接口SellInterface.这导致我们的代理类无法通用于其他接口,所以不得不为每一个接口实现一个代理类.幸好,java为代理模式提供了支持.
java主要是通过Proxy类和InvocationHandler接口来给实现对代理模式的支持的.
下面用java的代理机制来实现上面的例子

Java代码 复制代码 收藏代码
  1. import java.lang.reflect.InvocationHandler;   
  2. import java.lang.reflect.Method;   
  3. import java.lang.reflect.Proxy;   
  4. /**  
  5. *代理类一定要实现了InvocationHandler接口  
  6. */  
  7. public class ProxyObject implements InvocationHandler{   
  8.     private Object proxy_obj;   
  9.   
  10.     ProxyObject(Object obj){   
  11.         this.proxy_obj = obj;   
  12.     }   
  13.   
  14.     public static Object factory(Object obj){   
  15.         Class cls = obj.getClass();   
  16.         //通过Proxy类的newProxyInstance方法来返回代理对象   
  17.         return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),new ProxyObject(obj));   
  18.     }   
  19.   
  20. /**  
  21. *实现InvocationHandler接口的invoke  
  22. */  
  23.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {   
  24.         System.out.println("函数调用前被拦截了:   " + method);   
  25.         if(args != null){   
  26.             //打印参数列表   
  27.             System.out.println("方法有  " + args.length + "    个参数");   
  28.             for(int i = 0; i < args.length; i ++){   
  29.                 System.out.println(args[i]);   
  30.             }   
  31.         }   
  32.         //利用反射机制动态调用原对象的方法   
  33.          Object mo = method.invoke(proxy_obj, args);   
  34.         System.out.println("函数调用后进行处理 :   " + method);   
  35.         return mo;   
  36.     }   
  37.   
  38.     //测试代码       
  39.     public static void main(String agr[]){   
  40.         SellInterface si = (SellInterface)factory(new RedWineFactory());   
  41.         si.sell();   
  42.     }   
  43. }  
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编程的基础吧

接着,用代理模式实现一个超级简单的aop拦截机制
这个例子可以拦截我们指定的函数,并在拦截前后根据需要进行处理

Java代码 复制代码 收藏代码
  1. /**  
  2. *切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理  
  3. */  
  4. public interface AopInterface {   
  5.    public void before(Object obj);//调用的处理   
  6.    public void end(Object obj);//调用后的处理   
  7. }  
/**
*切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
*/
public interface AopInterface {
   public void before(Object obj);//调用的处理
   public void end(Object obj);//调用后的处理
}



这个是实现了AopInterface 接口,在这里我们实现了我们的处理逻辑

Java代码 复制代码 收藏代码
  1. public class AopInterfaceImp implements AopInterface{   
  2.   
  3.     public void before(Object obj) {   
  4.         System.out.println("调用前拦截");   
  5.     }   
  6.   
  7.     public void end(Object obj) {   
  8.         System.out.println("调用调用后处理");   
  9.     }   
  10.   
  11. }  
public class AopInterfaceImp implements AopInterface{

    public void before(Object obj) {
        System.out.println("调用前拦截");
    }

    public void end(Object obj) {
        System.out.println("调用调用后处理");
    }

}



接着是代理类

Java代码 复制代码 收藏代码
  1. public class PeoxyObject implements InvocationHandler {   
  2.     private AopInterface aop;//定义了切入时调用的方法   
  3.     private Object proxy_obj;   
  4.     private String methodName;//指定要切入的方法名   
  5.   
  6.     PeoxyObject(){}   
  7.   
  8.     public Object factory(Object obj){   
  9.         proxy_obj = obj;   
  10.         Class cls = obj.getClass();   
  11.         return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);   
  12.     }   
  13.   
  14.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {   
  15.         if(this.aop == null)throw new NullPointerException("aop is null");   
  16.         if(method == null)throw new NullPointerException("method is null");   
  17.   
  18.         Object o;   
  19. //如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理   
  20. //否则当正常方法处理   
  21.         if(methodName != null && method.toString().indexOf(methodName) != -1){   
  22.             aop.before(proxy_obj);//指定方法调用前的处理   
  23.             o = method.invoke(proxy_obj, args);   
  24.             aop.end(proxy_obj);//指定方法调用后的处理   
  25.         }else{   
  26.             //没有指定的方法,以正常方法调用   
  27.             o = method.invoke(proxy_obj, args);   
  28.         }   
  29.         return o;   
  30.     }   
  31.   
  32.     public AopInterface getAop() {   
  33.         return aop;   
  34.     }   
  35.   
  36.     public void setAop(AopInterface aop) {   
  37.         this.aop = aop;   
  38.     }   
  39.   
  40.     public String getMethodName() {   
  41.         return methodName;   
  42.     }   
  43.   
  44.     public void setMethodName(String methodName) {   
  45.         this.methodName = methodName;   
  46.     }   
  47. }  
public class PeoxyObject implements InvocationHandler {
    private AopInterface aop;//定义了切入时调用的方法
    private Object proxy_obj;
    private String methodName;//指定要切入的方法名

    PeoxyObject(){}

    public Object factory(Object obj){
        proxy_obj = obj;
        Class cls = obj.getClass();
        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(this.aop == null)throw new NullPointerException("aop is null");
        if(method == null)throw new NullPointerException("method is null");

        Object o;
//如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理
//否则当正常方法处理
        if(methodName != null && method.toString().indexOf(methodName) != -1){
            aop.before(proxy_obj);//指定方法调用前的处理
            o = method.invoke(proxy_obj, args);
            aop.end(proxy_obj);//指定方法调用后的处理
        }else{
            //没有指定的方法,以正常方法调用
            o = method.invoke(proxy_obj, args);
        }
        return o;
    }

    public AopInterface getAop() {
        return aop;
    }

    public void setAop(AopInterface aop) {
        this.aop = aop;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
}



这里定义一个用来测试用的类

Java代码 复制代码 收藏代码
  1. public interface SubInterface {   
  2.     public void add(String value1,String value2);   
  3.     public void acc(String value1);   
  4. }   
  5.   
  6. public class ImpObject implements SubInterface{   
  7.   
  8.     public void add(String value1,String value2) {   
  9.         System.out.println("ImpObject add(String value1,String value2)");   
  10.     }   
  11.   
  12.     public void acc(String value1){   
  13.         System.out.println("ImpObject acc(String value1)");   
  14.     }   
  15.   
  16. }  
public interface SubInterface {
    public void add(String value1,String value2);
    public void acc(String value1);
}

public class ImpObject implements SubInterface{

    public void add(String value1,String value2) {
        System.out.println("ImpObject add(String value1,String value2)");
    }

    public void acc(String value1){
        System.out.println("ImpObject acc(String value1)");
    }

}



这里是测试代码

Java代码 复制代码 收藏代码
  1. public static void main(String agr[]){   
  2.      PeoxyObject po = new PeoxyObject();   
  3.   
  4.      po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象   
  5.       po.setMethodName("acc");//指定要拦截的函数   
  6.         
  7.       SubInterface si = (SubInterface)po.factory(new ImpObject());   
  8.    //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行   
  9.       si.add("tt","dd");      
  10.   
  11.    //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp   
  12.     //对象的两个方法   
  13.       si.acc("tt");   
  14.  }  
   public static void main(String agr[]){
        PeoxyObject po = new PeoxyObject();

        po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象
         po.setMethodName("acc");//指定要拦截的函数
        
         SubInterface si = (SubInterface)po.factory(new ImpObject());
      //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行
         si.add("tt","dd");   

      //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp
       //对象的两个方法
         si.acc("tt");
    }



通过上面可以看出,拦截机制是代理模式的重要使用方式之一,
除了拦截,代理模式还常用于资源加载,当我们要加载的资源很大时,我们可以让真实主题角色在后台加载资源,让代理主题角色负责处理前台的等待提示信息.
还有就是授权机制,通过代理能拦截真实主题的能力,来控制真实主题的访问权限.

分享到：
| 设计模式：单例模式singleton示例分析
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    设计模式：可复用面向对象软件的基础.zip

    设计模式是软件工程中的一种重要概念，它代表了在特定情境下解决常见问题的最佳实践。这些模式经过时间的考验，被广泛应用于各种面向对象的软件开发中，以提高代码的可读性、可维护性和可复用性。本教程旨在深入讲解...

    设计模式：可复用面向对象软件的基础（非扫描版+高清）

    设计模式分为三类：创建型模式（如单例模式、工厂方法模式）、结构型模式（如代理模式、装饰器模式）和行为型模式（如观察者模式、策略模式）。每种模式都有其特定的用途和适用场景。 4. **具体设计模式详解** - ...

    《设计模式：可复用面向对象软件的基础》英文版

    如适配器模式（Adapter）、桥接模式（Bridge）、组合模式（Composite）、装饰者模式（Decorator）、外观模式（Facade）、享元模式（Flyweight）和代理模式（Proxy）等。 - **行为型模式**：关注于对象间的职责分配，...

    设计模式：可复用面向对象软件的基础--详细书签版

    　“[设计模式]在实用环境下特别有用,因为它分类描述了一组设计良好,表达清楚的面向对象软件设计模式。整个设计模式领域还很新,本书的四位作者也许已占据了这个领域造诣最深的专家中的半数,因而他们定义模式的方法...

    《设计模式：可复用面向对象软件的基础》学习并理解 23 种设计模式

    《设计模式：可复用面向对象软件的基础》一书介绍了23种经典的设计模式，这些模式大致可以分为三大类： 1. **创建型模式**：专注于对象的创建机制，确保系统在合适的时机创建正确的对象。 - **单例模式**...

    设计模式：可复用的面向对象软件的基础

    - 代理模式：用于控制对游戏资源的访问，如延迟加载或异步加载资源。 通过应用设计模式，游戏引擎开发者能够更好地实现软件的复用性、可维护性，以及更好的软件质量。学习和掌握设计模式，对于开发高质量、高性能、...

    设计模式：可复用面向对象软件设计基础（附源码）

    2. **结构型模式**：如适配器模式、装饰器模式、代理模式、桥接模式、组合模式、外观模式和享元模式。这些模式关注如何将类或对象以某种方式组合起来，以实现新的功能或改善现有结构。 3. **行为型模式**：包括责任...

    1.《设计模式：可复用面向对象软件的基础(完整书签)》

    总的来说，《设计模式：可复用面向对象软件的基础》是一本深入理解和应用面向对象设计的必备书籍，它不仅介绍了23种核心设计模式，还提供了大量实例和解释，帮助读者将理论知识转化为实际的编程技巧。通过对这本书的...

    iOS开发中的几种设计模式介绍

    本文将深入探讨几种在iOS开发中常用的设计模式：代理模式、观察者模式、MVC模式、单例模式、策略模式以及工厂模式。 1. **代理模式**： 代理模式在iOS开发中广泛应用，主要用于对象间通信。例如，UITableView的...

    设计模式_基于C#的工程化实现及扩展_源码

    《设计模式：基于C#的工程化实现及扩展》是一份深入探讨软件设计模式的宝贵资源，它提供了C#语言下的具体实现与扩展，旨在帮助开发者提升代码的可读性、可维护性和可复用性。这个压缩包包含了多个源码文件，分别命名...

    C#面向对象设计模式纵横谈(25)：设计模式总结

    12. 代理模式：代理模式为其他对象提供一种代理以控制对这个对象的访问，可以实现远程代理、虚拟代理和保护代理。 13. 模板方法模式：模板方法模式定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类...

    设计模式：简单工厂、方法工厂、抽象工厂、单例、原型、委派、模板、代理、策略

    8. **代理**：代理模式为其他对象提供一种代理以控制对这个对象的访问。它可以在不影响客户端的情况下，增强或限制原始对象的功能。 9. **策略**：策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。...

    设计模式可复用面向对象软件的基础 源码

    在《设计模式：可复用面向对象软件的基础》一书中，作者Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides（通常被称为GoF，Gang of Four）详细阐述了23种经典的设计模式。这些模式分为三类：创建型模式、...

    设计模式：可服用面向对象软件的基础

    7. 代理模式：为其他对象提供一种代理以控制对这个对象的访问。 三、行为型模式（Behavioral Patterns） 1. 责任链模式：将请求沿着处理者链传递，直到有对象处理它为止。 2. 命令模式：将请求封装为一个对象，...

    设计模式教材pdf 中文版

    - 代理模式：为其他对象提供一种代理以控制对这个对象的访问。 - 模板方法模式：在抽象类中定义一个操作中的算法骨架，而将一些步骤延迟到子类中。 3. 行为型设计模式： - 责任链模式：避免将处理逻辑硬编码到...

    23种设计模式(C++).pdf

    - Proxy模式：为其他对象提供一种代理以控制对这个对象的访问。 行为型模式包括： - Template模式：在一个方法中定义一个算法的骨架，将一些步骤延迟到子类中。Template方法使得子类可以在不改变算法结构的情况下，...

    9. 结构性设计模式小结1

    1. 代理模式： 代理模式是一种行为型和结构性模式，它为一个对象提供一个代理以控制对该对象的访问。代理对象在客户端和目标对象之间起到中介的作用，可以添加额外的功能，比如日志记录、安全控制、缓存等非核心...

    设计模式-代理模式

    代理模式是一种常用的设计模式，它在软件开发中扮演着重要的角色，特别是在iOS平台的应用程序设计中。代理模式的核心思想是为一个对象提供一个替身或代理，以控制对这个对象的访问。这种模式允许我们通过代理来间接...

Magicbox
Global site tag (gtag.js) - Google Analytics