`
yahaitt
  • 浏览: 760758 次
  • 性别: Icon_minigender_2
  • 来自: 杭州
社区版块
存档分类
最新评论

Java反射机制之代理模式

阅读更多

代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。
在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式一般涉及到的角色有
抽象角色:声明真实对象和代理对象的共同接口
代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装
真实角色:代理角色所代表的真实对象,是我们最终要引用的对象

动态代理中最关键的两点是:

InvocationHandler 接口的实现

Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)的方法的调用

一、原理示例

java 代码
  1. /*  
  2.  * 创建日期 2007-3-13  
  3.  *  
  4.  * TODO 要更改此生成的文件的模板,请转至  
  5.  * 窗口 - 首选项 - Java - 代码样式 - 代码模板  
  6.  */  
  7. package com.langsin.proxy;   
  8.   
  9. // 抽象角色   
  10.   
  11. abstract public class Subject   
  12.   
  13. {   
  14.   
  15.     abstract public void request();   
  16.   
  17. }   

 

java 代码
  1. package com.langsin.proxy;   
  2.   
  3. //真实角色:实现了Subject的request()方法   
  4.   
  5. public class RealSubject extends Subject   
  6. {   
  7.   
  8.     public RealSubject()   
  9.     {   
  10.     }   
  11.   
  12.     public void request()   
  13.     {   
  14.         System.out.println("From real subject.");   
  15.     }   
  16.   
  17. }   

 

java 代码
  1. package com.langsin.proxy;   
  2.   
  3. //代理角色   
  4.   
  5. public class ProxySubject extends Subject   
  6.   
  7. {   
  8.     private RealSubject realSubject; // 以真实角色作为代理角色的属性   
  9.   
  10.     public ProxySubject()   
  11.     {   
  12.     }   
  13.   
  14.     public void request() // 该方法封装了真实对象的request方法   
  15.   
  16.     {   
  17.         preRequest();   
  18.   
  19.         if (realSubject == null)   
  20.         {   
  21.             realSubject = new RealSubject();   
  22.         }   
  23.   
  24.         realSubject.request(); // 此处执行真实对象的request方法   
  25.   
  26.         postRequest();   
  27.     }   
  28.   
  29.     private void preRequest()   
  30.     {   
  31.   
  32.         // something you want to do before requesting   
  33.   
  34.     }   
  35.   
  36.     private void postRequest()   
  37.     {   
  38.   
  39.         // something you want to do after requesting   
  40.   
  41.     }   
  42.   
  43. }   

 

java 代码
  1. package com.langsin.proxy;   
  2.   
  3. //客户端调用   
  4.   
  5. public class Client   
  6. {   
  7.     public static void main(String[] args)   
  8.     {   
  9.         Subject sub = new ProxySubject();   
  10.   
  11.         sub.request();   
  12.     }   
  13. }   

 

二、应用示例一、

java 代码
  1. package com.langsin.dynamicproxy;   
  2.   
  3. //抽象角色(之前是抽象类,此处应改为接口):    
  4.   
  5. public interface Subject   
  6. {   
  7.     abstract public void request();   
  8. }   

 

java 代码
  1. package com.langsin.dynamicproxy;   
  2.   
  3. //具体角色   
  4.   
  5. public class RealSubject implements Subject   
  6. {   
  7.   
  8.     public RealSubject()   
  9.     {   
  10.     }   
  11.   
  12.     public void request()   
  13.     {   
  14.         System.out.println("From real subject.");   
  15.     }   
  16.   
  17. }   

 

java 代码
  1. package com.langsin.dynamicproxy;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Method;   
  5. import java.lang.reflect.Proxy;   
  6. import java.util.List;   
  7. import java.util.Vector;   
  8.   
  9. public class VectorProxy implements InvocationHandler   
  10. {   
  11.     private Object proxyobj;   
  12.   
  13.     public VectorProxy(Object obj)   
  14.     {   
  15.         proxyobj = obj;   
  16.     }   
  17.   
  18.     public static Object factory(Object obj)   
  19.     {   
  20.         Class cls = obj.getClass();   
  21.   
  22.         return Proxy.newProxyInstance(cls.getClassLoader(),   
  23.                 cls.getInterfaces(), new VectorProxy(obj));   
  24.     }   
  25.   
  26.     public Object invoke(Object proxy, Method method, Object[] args)   
  27.             throws Throwable   
  28.     {   
  29.         System.out.println("before calling " + method);   
  30.   
  31.         if (args != null)   
  32.         {   
  33.             for (int i = 0; i < args.length; i++)   
  34.             {   
  35.                 System.out.println(args[i] + "");   
  36.             }   
  37.         }   
  38.         Object object = method.invoke(proxyobj, args);   
  39.   
  40.         System.out.println("after calling " + method);   
  41.         return object;   
  42.     }   
  43.   
  44.     @SuppressWarnings("unchecked")   
  45.     public static void main(String[] args)   
  46.     {   
  47.         List<string></string> v = (List<string></string>) factory(new Vector<string></string>(10));   
  48.   
  49.         v.add("New");   
  50.         v.add("York");   
  51.         System.out.println(v);   
  52.   
  53.         v.remove(0);   
  54.         System.out.println(v);   
  55.     }   
  56. }   

 

应用代码二、

java 代码
  1. package com.langsin.dynamicproxy;   
  2.   
  3. public interface Foo   
  4. {   
  5.     void doAction();   
  6. }   

 

java 代码
  1. package com.langsin.dynamicproxy;   
  2.   
  3. public class FooImpl implements Foo   
  4. {   
  5.     public FooImpl()   
  6.     {   
  7.     }   
  8.   
  9.     public void doAction()   
  10.     {   
  11.         System.out.println("in FooImp1.doAction()");   
  12.     }   
  13. }   

 

java 代码
  1. package com.langsin.dynamicproxy;   
  2.   
  3. public class FooImpl2 implements Foo   
  4. {   
  5.     public FooImpl2()   
  6.     {   
  7.     }   
  8.   
  9.     public void doAction()   
  10.     {   
  11.         System.out.println("in FooImp2.doAction()");   
  12.     }   
  13.   
  14. }   
java 代码
  1. package com.langsin.dynamicproxy;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Method;   
  5.   
  6. public class CommonInvocationHandler implements InvocationHandler   
  7. {   
  8.   
  9.     // 动态执行对象,需要回调的对象   
  10.     private Object target;   
  11.   
  12.     // 支持构造子注射   
  13.     public CommonInvocationHandler()   
  14.     {   
  15.   
  16.     }   
  17.   
  18.     // 支持构造子注射   
  19.     public CommonInvocationHandler(Object target)   
  20.     {   
  21.         setTarget(target);   
  22.     }   
  23.   
  24.     /**  
  25.      *   
  26.      * 采用setter方法注射  
  27.      *   
  28.      * @param target  
  29.      *   
  30.      */  
  31.     public void setTarget(Object target)   
  32.     {   
  33.         this.target = target;   
  34.     }   
  35.   
  36.     /**  
  37.      *   
  38.      * 调用proxy中指定的方法method,并传入参数列表args  
  39.      *   
  40.      * @param proxy  
  41.      *            代理类的类型,例如定义对应method的代理接口  
  42.      *   
  43.      * @param method  
  44.      *            被代理的方法  
  45.      *   
  46.      * @param args  
  47.      *            调用被代理方法的参数  
  48.      *   
  49.      * @return  
  50.      *   
  51.      * @throws java.lang.Throwable  
  52.      *   
  53.      */  
  54.   
  55.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable   
  56.     {   
  57.         return method.invoke(target, args);   
  58.     }   
  59.   
  60. }   

 

java 代码
  1. package com.langsin.dynamicproxy;   
  2.   
  3. import java.lang.reflect.Proxy;   
  4.   
  5. public class Demo   
  6. {   
  7.     public static void main(String[] args)   
  8.     {   
  9.   
  10.         // 1.通用的动态代理实现   
  11.   
  12.         CommonInvocationHandler handler = new CommonInvocationHandler();   
  13.   
  14.         Foo f;   
  15.   
  16.         // 2.接口实现1   
  17.   
  18.         handler.setTarget(new FooImpl());   
  19.   
  20.         // 方法参数说明:代理类、代理类实现的接口列表、代理类的处理器   
  21.   
  22.         // 关联代理类、代理类中接口方法、处理器,当代理类中接口方法被调用时,会自动分发到处理器的invoke方法   
  23.   
  24.         // 如果代理类没有实现指定接口列表,会抛出非法参数异常   
  25.   
  26.         f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),   
  27.   
  28.         new Class[] { Foo.class },   
  29.   
  30.         handler);   
  31.   
  32.         f.doAction();   
  33.   
  34.         // 3.接口实现2   
  35.   
  36.         handler.setTarget(new FooImpl2());   
  37.   
  38.         f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),   
  39.   
  40.         new Class[] { Foo.class },   
  41.   
  42.         handler);   
  43.   
  44.         f.doAction();   
  45.     }   
  46. }   
分享到:
评论

相关推荐

    JAVA的反射机制与动态代理

    Java的反射机制与动态代理是Java编程中两个非常重要的高级特性,它们在许多实际场景中发挥着关键作用,如框架开发、插件系统、元数据处理等。下面将详细讲解这两个概念及其应用。 首先,Java的反射机制允许我们在...

    Java反射机制和动态代理

    主要讲述Java反射机制与设计模式之一:代理模式的原理与应用;同时详细讲述了Java对代理模式的支持以及Java中动态代理的原理,应用与实践。

    JAVA 反射机制与动态代理ppt

    总的来说,Java反射机制和动态代理是Java平台强大而灵活的特性,它们使得Java程序能够在运行时具有更高的灵活性和可扩展性。然而,使用反射也可能带来性能开销和安全风险,因此在实际应用中需要权衡利弊,合理使用。

    Java反射机制Demo

    ### Java反射机制详解 #### 一、什么是Java反射机制? Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的...

    Java反射机制与动态代理

    Java反射机制是Java语言的一个强大特性,它允许程序在运行时检查和操作类、接口、字段和方法的信息。通过反射,我们可以在不知道具体类的情况下,动态地获取类的信息并创建对象,调用方法,修改字段值。这种机制在...

    java反射机制PPT

    Java反射机制是Java编程语言中一项强大的工具,它允许程序在运行时检查和操作类、接口、对象等的内部信息。反射机制的核心在于能够在运行时动态地获取类的信息,并且可以动态调用对象的方法,创建对象,甚至修改对象...

    java反射机制详解

    ### Java反射机制详解 #### 一、反射机制是什么 反射机制是Java编程语言的一个核心特性,它允许程序在运行时动态地获取类的信息,并且能够动态地创建对象和调用对象的方法。简单来说,反射机制使得Java程序可以...

    java反射机制与动态代理

    总之,Java反射机制与动态代理为开发者提供了强大的灵活性,可以在运行时探索和修改程序行为,实现更复杂的设计模式和编程策略。然而,由于它们涉及底层操作,过度使用可能会影响程序性能和安全性,因此在实际应用中...

    JAVA反射机制与动态代理综合资料

    总的来说,这份“JAVA反射机制与动态代理综合资料”应该是一个全面的学习资源,涵盖了从基础概念到实际应用的多个方面,对于想要提升Java技能或深入理解J2EE开发的程序员来说,是非常宝贵的学习材料。通过学习和实践...

    JAVA设计模式(代理模式)

    2. **动态代理:**在运行时动态生成代理对象,Java提供了两种动态代理方式:一是通过实现InvocationHandler接口,利用反射机制动态创建代理对象;二是JDK的动态代理API,如java.lang.reflect.Proxy类。动态代理更加...

    Java反射机制说明

    Java反射机制是Java编程语言的核心特性之一,它赋予了程序在运行时检查和操作对象的能力。反射机制使得Java代码能够动态地获取类的信息(如类名、方法、字段),并且能够在运行时创建和调用对象的方法,这为编程带来...

    java反射机制.rar

    Java反射机制是Java编程语言中的一个强大特性,它允许程序在运行时检查和操作类、接口、字段和方法。在Java中,反射机制是通过java.lang.Class类和相关的API实现的,它为我们提供了动态访问和操作类的能力。下面将...

    java反射机制学习(五):工厂模式

    在本篇“java反射机制学习(五):工厂模式”中,我们将探讨如何利用反射与工厂模式结合,提升代码的灵活性和可扩展性。 首先,工厂模式是一种常用的创建型设计模式,它提供了一种创建对象的最佳方式。传统的工厂模式...

    java反射原理详解

    Java反射机制是Java语言的一种强大的特性,它允许程序在运行时动态地获取类的信息并操作类的对象。在Java中,反射主要涉及到`java.lang.Class`类、`java.lang.reflect`包中的类(如Constructor、Method、Field)以及...

    Java反射和动态代理实例

    几个Java反射和动态代理的小例子。可以学习如何通过Java的反射机制实例化对象、调用对象的方法、操作对象的私有成员变量、改变...可以学习Java的动态代理模式、学习Java工厂模式以及如何将工厂模式与属性文件相结合。

    利用Java的反射与代理实现IOC模式

    在这个主题中,我们将深入探讨Java反射和动态代理如何帮助我们实现IOC。 首先,让我们理解Java反射。反射允许程序在运行时检查类、接口、字段和方法的信息,并且能够动态地创建对象和调用方法。在IOC中,反射用于在...

    Java反射机制-PDF文档,详述了反射机制的原理和使用方法

    7. 动态代理:Java反射机制可以结合java.lang.reflect.Proxy类创建动态代理,实现代理模式,为接口的方法提供动态处理逻辑。 在实际开发中,反射机制常用于以下场景: - 插件化开发:通过反射加载插件中的类,实现...

Global site tag (gtag.js) - Google Analytics