`

java动态代理

    博客分类:
  • java
阅读更多

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

代理模式一般涉及到的角色有: 

抽象角色:声明真实对象和代理对象的共同接口; 

代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。 

真实角色:代理角色所代表的真实对象,是我们最终要引用的对象。(参见文献1) 

以下以《Java与模式》中的示例为例: 

抽象角色: 

Java代码  收藏代码
  1. abstract public class Subject  
  2.   
  3. {  
  4.   
  5.     abstract public void request();  
  6.   
  7. }  


真实角色:实现了Subject的request()方法。 

Java代码  收藏代码
  1. public class RealSubject extends Subject   
  2.   
  3. {  
  4.   
  5.        public RealSubject()  
  6.   
  7.        {   
  8.   
  9.        }  
  10.   
  11.          
  12.   
  13.        public void request()  
  14.   
  15.        {   
  16.   
  17.               System.out.println("From real subject.");  
  18.   
  19.        }  
  20.   
  21. }  


代理角色: 

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


客户端调用: 

Java代码  收藏代码
  1. Subject sub=new ProxySubject();  
  2.   
  3. Sub.request();  



       由以上代码可以看出,客户实际需要调用的是RealSubject类的request()方法,现在用ProxySubject来代理RealSubject类,同样达到目的,同时还封装了其他方法(preRequest(),postRequest()),可以处理一些其他问题。 

       另外,如果要按照上述的方法使用代理模式,那么真实角色必须是事先已经存在的,并将其作为代理对象的内部属性。但是实际使用时,一个真实角色必须对应一个代理角色,如果大量使用会导致类的急剧膨胀;此外,如果事先并不知道真实角色,该如何使用代理呢?这个问题可以通过Java的动态代理类来解决。 



2.动态代理类 

       Java动态代理类位于Java.lang.reflect包下,一般主要涉及到以下两个类: 

(1). Interface InvocationHandler:该接口中仅定义了一个方法Object:invoke(Object obj,Method method, J2EEjava语言JDK1.4APIjavalangObject.html">Object[] args)。在实际使用时,第一个参数obj一般是指代理类,method是被代理的方法,如上例中的request(),args为该方法的参数数组。这个抽象方法在代理类中动态实现。 


(2).Proxy:该类即为动态代理类,作用类似于上例中的ProxySubject,其中主要包含以下内容: 

Protected Proxy(InvocationHandler h):构造函数,估计用于给内部的h赋值。 

Static Class getProxyClass (ClassLoader loader, Class[] interfaces):获得一个代理类,其中loader是类装载器,interfaces是真实类所拥有的全部接口的数组。 

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):返回代理类的一个实例,返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。 



       所谓Dynamic Proxy是这样一种class:它是在运行时生成的class,在生成它时你必须提供一组interface给它,然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦,这个Dynamic Proxy其实就是一个Proxy,它不会替你作实质性的工作,在生成它的实例时你必须提供一个handler,由它接管实际的工作。(参见文献3) 

    在使用动态代理类时,我们必须实现InvocationHandler接口,以第一节中的示例为例: 

抽象角色(之前是抽象类,此处应改为接口): 

Java代码  收藏代码
  1. public interface Subject  
  2.   
  3. {  
  4.   
  5.     abstract public void request();  
  6.   
  7. }  


具体角色RealSubject:同上; 



代理角色: 

Java代码  收藏代码
  1. import java.lang.reflect.Method;  
  2.   
  3. import java.lang.reflect.InvocationHandler;  
  4.   
  5.    
  6.   
  7. public class DynamicSubject implements InvocationHandler {  
  8.   
  9.   private Object sub;  
  10.   
  11.    
  12.   
  13.   public DynamicSubject() {  
  14.   
  15.   }  
  16.   
  17.    
  18.   
  19.   public DynamicSubject(Object obj) {  
  20.   
  21.     sub = obj;  
  22.   
  23.   }  
  24.   
  25.    
  26.   
  27.    
  28.   
  29.   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  30.   
  31.     System.out.println("before calling " + method);  
  32.   
  33.    
  34.   
  35.     method.invoke(sub,args);  
  36.   
  37.    
  38.   
  39.     System.out.println("after calling " + method);  
  40.   
  41.     return null;  
  42.   
  43.   }  
  44.   
  45.    
  46.   
  47. }  



       该代理类的内部属性为Object类,实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值;此外,在该类还实现了invoke方法,该方法中的 

method.invoke(sub,args); 

其实就是调用被代理对象的将要被执行的方法,方法参数sub是实际的被代理对象,args为执行被代理对象相应操作所需的参数。通过动态代理类,我们可以在调用之前或之后执行一些相关操作。 

客户端: 

Java代码  收藏代码
  1. import java.lang.reflect.InvocationHandler;  
  2.   
  3. import java.lang.reflect.Proxy;  
  4.   
  5. import java.lang.reflect.Constructor;  
  6.   
  7. import java.lang.reflect.Method;  
  8.   
  9.    
  10.   
  11. public class Client  
  12.   
  13. {  
  14.   
  15.    
  16.   
  17.     static public void main(String[] args) throws Throwable  
  18.   
  19.        {  
  20.   
  21.       RealSubject rs = new RealSubject();  //在这里指定被代理类  
  22.   
  23.       InvocationHandler ds = new DynamicSubject(rs);  //初始化代理类  
  24.   
  25.          Class cls = rs.getClass();  
  26.   
  27.       //以下是分解步骤  
  28.   
  29.       /* 
  30.  
  31.       Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces()) ; 
  32.  
  33.       Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class}); 
  34.  
  35.       Subject subject =(Subject) ct.newInstance(new Object[]{ds}); 
  36.  
  37.      */  
  38.   
  39.      //以下是一次性生成  
  40.   
  41.       Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),  
  42.   
  43.                                  cls.getInterfaces(),ds );  
  44.   
  45.   
  46.   
  47.       subject.request();  
  48.   
  49. }  


       通过这种方式,被代理的对象(RealSubject)可以在运行时动态改变,需要控制的接口(Subject接口)可以在运行时改变,控制的方式(DynamicSubject类)也可以动态改变,从而实现了非常灵活的动态代理关系 

分享到:
评论

相关推荐

    java动态代理demo

    Java动态代理是Java编程中一个重要的特性,它允许我们在运行时创建代理对象,这些代理对象可以代表并增强原对象的功能。动态代理在很多场景下都非常有用,比如日志记录、性能监控、事务管理等。本示例将带你深入理解...

    java动态代理实例

    Java动态代理是Java语言提供的一种在运行时创建代理对象的技术,它允许我们为已存在的接口创建代理类,以便在调用真实目标对象的方法时添加额外的功能或行为。在这个实例中,我们将深入探讨Java动态代理的核心概念,...

    java动态代理 经典文章(word 2007格式的)

    Java动态代理是Java编程中一个重要的特性,它允许在运行时创建代理对象,这些代理对象可以代表并增强原对象的功能。动态代理主要应用于面向切面编程(AOP)和事件监听等场景,使得代码更加模块化,易于维护。以下是...

    Java动态代理两种实现方式

    Java动态代理技术是Java编程中一个非常重要的特性,它允许我们在运行时动态创建具有特定行为的对象。这种技术常用于AOP(面向切面编程)和框架中,如Spring AOP,用于实现方法拦截、事务管理等功能。Java提供了两种...

    Java动态代理helloworld

    本篇文章将深入探讨Java动态代理的概念、原理以及如何通过一个简单的"Hello, World!"示例来理解它。 动态代理,顾名思义,是在程序运行时动态地生成代理对象。与静态代理(编译时已知)相比,动态代理更加灵活,...

    Java 动态代理详解(学习资料)

    JDK 动态代理JDK 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来支持动态代理。Proxy 类用于创建一个代理对象,而 InvocationHandler 接口则定义了代理对象的方法调用处理逻辑。...

    java 动态代理 简单实例

    Java动态代理是Java语言提供的一种在运行时创建代理对象的技术,它允许我们为已存在的接口创建代理类,以便在调用方法时添加额外的功能或控制。动态代理在很多场景下非常有用,比如日志记录、性能监控、事务管理等。...

    java动态代理源代码

    Java动态代理是Java编程中一个重要的特性,它允许我们在运行时创建代理对象,这些代理对象可以代表并增强原对象的功能。动态代理主要涉及到Java.lang.reflect包下的两个类:Proxy和InvocationHandler。本教程将通过...

    java动态代理机制

    Java动态代理机制是Java语言提供的一种强大的功能,它允许在运行时创建代理对象来实现特定接口,从而可以灵活地扩展或增强已有代码的功能。在Java中,动态代理主要通过两个类来实现:`java.lang.reflect.Proxy` 和 `...

    java 动态代理实现AOP

    ### Java动态代理实现AOP详解 #### 一、引言 随着软件开发复杂度的提升,传统的面向对象编程(OOP)已经难以满足现代软件工程的需求。为了更好地管理跨切面的关注点,如日志记录、性能监控、安全控制等,面向切面...

    java动态代理和反射

    java动态代理 public class HireProxy implements InvocationHandler { //被代理的真实角色 private Object obj; public HireProxy(Object obj) { super(); this.obj = obj; } //第二个参数method,被...

    一个简单的java动态代理的实例

    Java动态代理是Java提供的一种在运行时创建代理对象的技术,主要由`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口组成。在这个简单的Java动态代理实例中,我们将探讨如何利用这两个核心...

    java动态代理(2)

    Java动态代理机制是Java语言提供的一种强大的功能,它允许在运行时创建代理对象来实现指定的接口。这一机制使得我们可以在不修改已有代码的情况下,为已有接口增加额外的功能或者增强已有功能的行为。在Java中,动态...

    java动态代理机制分析及拓展

    Java动态代理机制的优点在于灵活性和便捷性,它允许在运行时动态创建符合特定接口的代理对象,无需对原有代码做任何修改,使得我们可以方便地实现诸如日志、事务控制等跨切面的逻辑。不过,动态代理仅限于代理接口,...

    用Java动态代理实现AOP

    Java动态代理实现AOP Java动态代理是实现Aspect Oriented Programming(AOP)的重要手段。在Java中,动态代理可以通过java.lang.reflect InvocationHandler接口和java.lang.reflect.Proxy类来实现。AOP的主要思想...

    java动态代理(3)

    Java动态代理是Java编程中一个非常重要的特性,它允许我们在运行时创建代理对象来代替目标对象,以便在不修改原有代码的情况下对目标对象的行为进行增强或扩展。在Java.lang.reflect包下,动态代理主要涉及两个核心...

    对代理模式与Java动态代理类的理解

    对代理模式与Java动态代理类的理解说明

    基于Java动态代理和反射机制实现ORM

    总之,基于Java动态代理和反射机制实现ORM,可以有效地解耦业务逻辑和数据库操作,提高代码的可读性和可维护性。虽然现有的ORM框架如Hibernate、MyBatis已经相当成熟,但对于学习和理解Java的高级特性,这样的实践...

Global site tag (gtag.js) - Google Analytics