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

探讨Java代理模式与反射机制的实际应用

阅读更多

探讨Java代理模式与反射机制的实际应用(1)

    Java的代理模式和反射机制,相信Java的开发者们都非常熟悉,文章会通过一个实例,深入探讨代理模式与Java反射机制的实际应用。

Java 提供了一套机制来动态执行方法和构造方法,以及数组操作等,这套机制就叫反射。而代理模式是为其他对象提供一种代理以控制对这个对象的访问,让我们的目标类和代理类实现同一接口,在代理类中调用目标类对象的方法。

反射机制 是如今很多Java流行框架的实现基础,其中包括Spring Hibernate 等。如果我们将反射机制加入到Java的代理模式中,就可以实现一个公共的代理类,省去我们不少功夫。

  1. import java.lang.reflect.InvocationTargetException;      import java.lang.reflect.Method;     
  2. /**    
  3.  * 方法代理类    
  4.  * @author rongxinhua    
  5. *    
  6.  */    
  7. public class MethodProxy {     
  8.          
  9.     private Class clazz;    //对象所属的类     
  10.     private Object target;  //目标对象     
  11.     private Method method;  //目标方法     
  12.     private Object[] params;    //参数数组     
  13.          
  14.     @SuppressWarnings("unchecked")     
  15.     public MethodProxy(Object target, String methodName, Object ... params) {     
  16.         rebindTarget(target, methodName, params);   //设置目标对象与方法     
  17.     }     
  18.          
  19.     /**    
  20.      * 重新设置目标对象与方法    
  21.      * @param target    
  22.      * @param methodName    
  23.      * @param params    
  24.      */    
  25.     public void rebindTarget(Object target, String methodName, Object ... params) {     
  26.          this.target  = target;     
  27.          this.clazz  =  target .getClass();     
  28.         rebindMethod(methodName, params);   //设置目标方法     
  29.     }     
  30.          
  31.     /**    
  32.      * 重新设置目标方法    
  33.      * @param methodName    
  34.      * @param params    
  35.      */    
  36.     public void rebindMethod(String methodName, Object ...params) {     
  37.          this.params  = params;     
  38.         int  paramLength  =  params .length;     
  39.         Class[]  paramTypes  =  new  Class[paramLength];     
  40.         for(int  i  =  0  ; i  <   paramLength  ; i ++ ) {     
  41.             paramTypes[i] = params[i].getClass();     
  42.         }     
  43.         try {     
  44.              this.method  =  clazz .getMethod(methodName, paramTypes);     
  45.         } catch (SecurityException e) {     
  46.             e.printStackTrace();     
  47.         } catch (NoSuchMethodException e) {     
  48.             e.printStackTrace();     
  49.         }     
  50.     }     
  51.          
  52.     /**    
  53.      * 动态调用已绑定的方法    
  54.      */    
  55.     public void doMethod() {     
  56.         try {     
  57.             this.method.invoke(target, params);     
  58.         } catch (IllegalArgumentException e) {     
  59.             e.printStackTrace();     
  60.         } catch (IllegalAccessException e) {     
  61.             e.printStackTrace();     
  62.         } catch (InvocationTargetException e) {     
  63.             e.printStackTrace();     
  64.         }     
  65.     }     
  66.     
  67. }   
  68.  
  69. import java.lang.reflect.InvocationTargetException;  
  70. import java.lang.reflect.Method;  
  71. /**  
  72.  * 方法代理类  
  73.  * @author rongxinhua  
  74.  *  
  75.  */  
  76. public class MethodProxy {  
  77.    
  78.  private Class clazz; //对象所属的类  
  79.  private Object target; //目标对象  
  80.  private Method method; //目标方法  
  81.  private Object[] params; //参数数组  
  82.    
  83.  @SuppressWarnings("unchecked")  
  84.  public MethodProxy(Object target, String methodName, Object ... params) {  
  85.   rebindTarget(target, methodName, params); //设置目标对象与方法  
  86.  }  
  87.    
  88.  /**  
  89.   * 重新设置目标对象与方法  
  90.   * @param target  
  91.   * @param methodName  
  92.   * @param params  
  93.   */  
  94.  public void rebindTarget(Object target, String methodName, Object ... params) {  
  95.    this.target  = target;  
  96.    this.clazz  =  target .getClass();  
  97.   rebindMethod(methodName, params); //设置目标方法  
  98.  }  
  99.    
  100.  /**  
  101.   * 重新设置目标方法  
  102.   * @param methodName  
  103.   * @param params  
  104.   */  
  105.  public void rebindMethod(String methodName, Object ...params) {  
  106.    this.params  = params;  
  107.   int  paramLength  =  params .length;  
  108.   Class[]  paramTypes  =  new  Class[paramLength];  
  109.   for(int  i  =  0  ; i  <   paramLength  ; i ++ ) {  
  110.    paramTypes[i] = params[i].getClass();  
  111.   }  
  112.   try {  
  113.     this.method  =  clazz .getMethod(methodName, paramTypes);  
  114.   } catch (SecurityException e) {  
  115.    e.printStackTrace();  
  116.   } catch (NoSuchMethodException e) {  
  117.    e.printStackTrace();  
  118.   }  
  119.  }  
  120.    
  121.  /**  
  122.   * 动态调用已绑定的方法  
  123.   */  
  124.  public void doMethod() {  
  125.   try {  
  126.    this.method.invoke(target, params);  
  127.   } catch (IllegalArgumentException e) {  
  128.    e.printStackTrace();  
  129.   } catch (IllegalAccessException e) {  
  130.    e.printStackTrace();  
  131.   } catch (InvocationTargetException e) {  
  132.    e.printStackTrace();  
  133.   }  
  134.  }  
  135.  
  136. }  
  137.  
  138. 这样就可以实现动态地调用某个对象的某个方法了,写个测试代码如下:  
  139.  
  140. public class Manager {     
  141.          
  142.     public void say() {     
  143.         System.out.println("Nobody say nothing");     
  144.     }     
  145.          
  146.     public void love(String boy, String girl) {     
  147.         System.out.println(boy + " love " + girl);     
  148.     }     
  149.          
  150. }   
  151.  
  152. public class Manager {  
  153.    
  154.  public void say() {  
  155.   System.out.println("Nobody say nothing");  
  156.  }  
  157.    
  158.  public void love(String boy, String girl) {  
  159.   System.out.println(boy + " love " + girl);  
  160.  }  
  161.    

我们通过代理类来调用Manager类中的say()和love()方法,测试代码如下:

  1. Manager  man  =  new  Manager();    //目标对象     
  2. MethodProxy  proxy  =  new  MethodProxy(man, "say");    //方法代理对象     
  3. proxy.doMethod();   //调用被代理的方法     
  4. proxy.rebindMethod("love", "Tom", "Marry"); //重新绑定方法     
  5. proxy.doMethod();   //调用被代理的方法   
  6.  
  7. Manager  man  =  new  Manager(); //目标对象  
  8. MethodProxy  proxy  =  new  MethodProxy(man, "say"); //方法代理对象  
  9. proxy.doMethod(); //调用被代理的方法  
  10. proxy.rebindMethod("love", "Tom", "Marry"); //重新绑定方法  
  11. proxy.doMethod(); //调用被代理的方法 

探讨Java代理模式与反射机制的实际应用(2)

    Java的代理模式和反射机制,相信Java的开发者们都非常熟悉,文章会通过一个实例,深入探讨代理模式与Java反射机制的实际应用。

这样就实现了动态代理调用对象的方法,上面代码输出结果就不贴出来了。如果要设置前置通知和后置通知等功能,也很容易实现,只需在“proxy.doMethod()”代码处的前面和后面设置即行。扩展应用:我们在上面的MethodProxy类中加入以下方法:

  1. /**    
  2.  * 获取方法上的注解    
  3.  * @param anClazz 注解类    
  4.  * @return    
  5.  */    
  6. public Annotation getAnnotation(Class anClazz) {     
  7.     return this.method.getAnnotation(anClazz);     
  8. }   
  9.  
  10.  /**  
  11.   * 获取方法上的注解  
  12.   * @param anClazz 注解类  
  13.   * @return  
  14.   */  
  15.  public Annotation getAnnotation(Class anClazz) {  
  16.   return this.method.getAnnotation(anClazz);  
  17.  } 

这个方法用来读取方法上的注解(Annotation),有什么用呢?我们写一个注解来测试下。 

  1. @Retention(RetentionPolicy.RUNTIME)     
  2. @Target(ElementType.METHOD)     
  3. @interface Low {     
  4.     int boyAge();      
  5.     int girlAge();       
  6. }   
  7.  
  8. @Retention(RetentionPolicy.RUNTIME)  
  9. @Target(ElementType.METHOD)  
  10. @interface Low {  
  11.  int boyAge();   
  12.  int girlAge();   

我们要引进Annotation相关的类: 

  1. import java.lang.annotation.Annotation;     
  2. import java.lang.annotation.ElementType;     
  3. import java.lang.annotation.Retention;     
  4. import java.lang.annotation.RetentionPolicy;     
  5. import java.lang.annotation.Target;   
  6.  
  7. import java.lang.annotation.Annotation;  
  8. import java.lang.annotation.ElementType;  
  9. import java.lang.annotation.Retention;  
  10. import java.lang.annotation.RetentionPolicy;  
  11. import java.lang.annotation.Target; 

我们另外写一个测试用的业务类: 

  1. public class LoveManager {     
  2.          
  3.     @Low( boyAge = 12 girlAge = 10 )     
  4.     public void beAbleToLove(Person boy, Person girl) {     
  5.         System.out.println(boy.getName() + " is able to love " + girl.getName());     
  6.     }     
  7.          
  8. }     
  9.     
  10. public class Person {     
  11.     private String name;     
  12.     private int age;     
  13.     public Person(String name, int age) {     
  14.          this.name  = name;     
  15.          this.age  = age;     
  16.     }     
  17.     //getter方法略     
  18. }   
  19.  
  20. public class LoveManager {  
  21.    
  22.  @Low( boyAge = 12 girlAge = 10 )  
  23.  public void beAbleToLove(Person boy, Person girl) {  
  24.   System.out.println(boy.getName() + " is able to love " + girl.getName());  
  25.  }  
  26.    
  27. }  
  28.  
  29. public class Person {  
  30.  private String name;  
  31.  private int age;  
  32.  public Person(String name, int age) {  
  33.    this.name  = name;  
  34.    this.age  = age;  
  35.  }  
  36.  //getter方法略  
  37. }  

接写上例中的proxy对象测试代码: 

  1. LoveManager  loveManager  =  new  LoveManager();     
  2. Person  boy  =  new  Person("Tom", 13);     
  3. Person  girl  =  new  Person("Marry", 10);     
  4. proxy.rebindTarget(loveManager, "beAbleToLove", boy, girl); //重新绑定对象和方法     
  5. Low  low  = (Low)proxy.getAnnotation(Low.class);     
  6. if(boy.getAge()  <   low.boyAge ()) {     
  7.     System.out.println(boy.getName() + "还不到法定年龄,不能谈恋爱!");     
  8. } else if(girl.getAge()  <   low.girlAge ()) {     
  9.     System.out.println(girl.getName() + "还不到法定年龄,不能谈恋爱!");     
  10. } else {     
  11.     proxy.doMethod();     
  12. }   
  13.  
  14.   LoveManager  loveManager  =  new  LoveManager();  
  15.   Person  boy  =  new  Person("Tom", 13);  
  16.   Person  girl  =  new  Person("Marry", 10);  
  17.   proxy.rebindTarget(loveManager, "beAbleToLove", boy, girl); //重新绑定对象和方法  
  18.   Low  low  = (Low)proxy.getAnnotation(Low.class);  
  19.   if(boy.getAge()  <   low.boyAge ()) {  
  20.    System.out.println(boy.getName() + "还不到法定年龄,不能谈恋爱!");  
  21.   } else if(girl.getAge()  <   low.girlAge ()) {  
  22.    System.out.println(girl.getName() + "还不到法定年龄,不能谈恋爱!");  
  23.   } else {  
  24.    proxy.doMethod();  
  25.   } 

这就实现了,通过Java的反射机制来读取Annotation的值,并根据Annotation的值,来处理业务数据有效性的判断,或者面向切面 动态地注入对象,或者作日志、拦截器等等。这种用法在所多框架中都常常看到, 我们在开发自己的Java组件时,不妨也采用一下吧!

【编辑推荐】

  1. Java设计模式之虚拟代理模式
  2. 关于Java反射机制的一个实例
  3. Java实例讲解反射机制Reflection
  4. JAVA反射机制的简单应用
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics