myJavaBlog

java世界
随笔 - 43, 文章 - 0, 评论 - 2, 引用 - 0
数据加载中……

认识java反射与代理

java反射与代理 
一. 关于数据库. 
当今的数据处理大致可以分成两大类:联机事务处理OLTP(on-line transaction processing)、联机分析处理OLAP(On-Line Analytical Processing)。OLTP是传统的关系型数据库的主要应用,主要是基本的、日常的事务处理,例如银行交易。OLAP是数据仓库系统的主要应用,支持复杂的分析操作,侧重决策支持,并且提供直观易懂的查询结果。下表列出了OLTP与OLAP之间的比较。 

                                       OLTP                                                              OLAP 
用户                               操作人员,低层管理人员                               决策人员,高级管理人员 
功能                              日常操作处理                                                 分析决策 
DB 设计                        面向应用                                                        面向主题 
数据                               当前的, 最新的细节的, 二维的分立的         历史的, 聚集的, 多维的集成的, 统一的 
存取                              读/写数十条记录                                           读上百万条记录 
工作单位                       简单的事务                                                     复杂的查询 
用户数                         上千个                                                             上百个 
DB 大小                       100MB-GB                                                      100GB-TB 

二. Java中的类反射: 
反射就是把Java类中的各种成分映射成相应的java类. 
Reflection 是 Java 程序开发语言的特征之一,它允许运行中的 Java 程序对自身进行检查,或者说“自审”,并能直接操作程序的内部属性。 

1.检测类: 

1.1 reflection的工作机制 

考虑下面这个简单的例子,让我们看看 reflection 是如何工作的。 

import java.lang.reflect.*; 
public class DumpMethods { 
public static void main(String args[]) { 
   try { 
    Class c = Class.forName(args[0]); 
    Method m[] = c.getDeclaredMethods(); 
    for (int i = 0; i < m.length; i++) 
    System.out.println(m[i].toString()); 
   } 
   catch (Throwable e) { 
    System.err.println(e); 
   } 



按如下语句执行: 

java DumpMethods java.util.Stack 

它的结果输出为: 

public java.lang.Object java.util.Stack.push(java.lang.Object) 

public synchronized java.lang.Object java.util.Stack.pop() 

public synchronized java.lang.Object java.util.Stack.peek() 

public boolean java.util.Stack.empty() 

public synchronized int java.util.Stack.search(java.lang.Object) 

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。 

这个程序使用 Class.forName 载入指定的类,然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。 

1.2 Java类反射中的主要方法 

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用,以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用: 

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数, 

Constructor[] getConstructors() -- 获得类的所有公共构造函数 

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关) 

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用,在参数类型数组中使用了字段名: 

Field getField(String name) -- 获得命名的公共字段 

Field[] getFields() -- 获得类的所有公共字段 

Field getDeclaredField(String name) -- 获得类声明的命名的字段 

Field[] getDeclaredFields() -- 获得类声明的所有字段 

用于获得方法信息函数: 

Method getMethod(String name, Class[] params) -- 使用特定的参数类型,获得命名的公共方法 

Method[] getMethods() -- 获得类的所有公共方法 

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型,获得类声明的命名的方法 

Method[] getDeclaredMethods() -- 获得类声明的所有方法 


1.3开始使用 Reflection: 

用于 reflection 的类,如 Method,可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤:第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中,用 java.lang.Class 类来描述类和接口等。 

下面就是获得一个 Class 对象的方法之一: 

Class c = Class.forName("java.lang.String"); 

这条语句得到一个 String 类的类对象。还有另一种方法,如下面的语句: 

Class c = int.class; 

或者 

Class c = Integer.TYPE; 

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。 

第二步是调用诸如 getDeclaredMethods 的方法,以取得该类中定义的所有方法的列表。 

一旦取得这个信息,就可以进行第三步了——使用 reflection API 来操作这些信息,如下面这段代码: 

Class c = Class.forName("java.lang.String"); 

Method m[] = c.getDeclaredMethods(); 

System.out.println(m[0].toString()); 

它将以文本方式打印出 String 中定义的第一个方法的原型。 

2.处理对象: 

如果要作一个开发工具像debugger之类的,你必须能发现filed values,以下是三个步骤: 

a.创建一个Class对象 
b.通过getField 创建一个Field对象 
c.调用Field.getXXX(Object)方法(XXX是Int,Float等,如果是对象就省略;Object是指实例). 

例如: 
import java.lang.reflect.*; 
import java.awt.*; 

class SampleGet {  
public static void main(String[] args) { 
   Rectangle r = new Rectangle(100, 325); 
   printHeight(r);  


static void printHeight(Rectangle r) { 
   Field heightField; 
   Integer heightValue; 
   Class c = r.getClass(); 
   try { 
    heightField = c.getField("height"); 
    heightValue = (Integer) heightField.get(r); 
    System.out.println("Height: " + heightValue.toString()); 
   } catch (NoSuchFieldException e) { 
    System.out.println(e); 
   } catch (SecurityException e) { 
    System.out.println(e); 
   } catch (IllegalAccessException e) { 
    System.out.println(e); 
   } 



顾名思义,反射 (reflection) 机制就像是在吴承恩所写的西游记中所提及的「照妖镜」,可以让类别或对象 (object) 在执行时期「现出原形」。我们可以利用反射机制来深入了解某类(class) 的构造函数 (constructor)、方法 (method)、字段 (field),甚至可以改变字段的值、呼叫方法、建立新的对象。有了反射机制,程序员即使对所想使用的类别所知不多,也能照样写程序。反射机制能够用来呼叫方法,这正是反射机制能够取代函数指针的原因。 

以 Java 来说,java.lang.reflect.Method (以下简称 Method) 类别是用来表示某类别的某方法。我们可以透过 java.lang.Class (以下简称 Class) 类别的许多方法来取得 Method 对象。Method 类别提供 invoke() 方法,透过 invoke(),此 Method 对象所表示的方法可以被呼叫,所有的参数则是被组织成一个数组,以方便传入 invoke()。 

举个例子,下面是一个名为 Invoke 的程序,它会将命令列的 Java 类别名称和要呼叫的方法名称作为参数。为了简单起见,我假定此方法是静态的,且没有参数: 

import java.lang.reflect.*; 
class Invoke {        
public static void main(String[] args ) {               
   try {                       
    Class c = Class.forName( args[0] );                       
    Method m = c.getMethod( args[1], new Class [] { } );                       
    Object ret = m.invoke( null, null );                       
    System.out.println(args[0] + "." + args[1] +"() = " + ret );               
   } catch ( ClassNotFoundException ex ) {                       
    System.out.println("找不到此类别");               
   } catch (NoSuchMethodException ex ) {                       
    System.out.println("此方法不存在");               
   } catch (IllegalAccessException ex ) {                       
    System.out.println("没有权限调用此方法");               
   } catch (InvocationTargetException ex ) {                       
    System.out.println("调用此方法时发生下列例外:\n" + ex.getTargetException() );               
   }        


我们可以执行 Invoke 来取得系统的时间: 

java Invoke java.lang.System CurrentTimeMillis执行的结果如下所示: 

java.lang.System.currentTimeMillis() = 1049551169474我们的第一步就是用名称去寻找指定的 Class。我们用类别名称 (命令列的第一个参数) 去呼叫 forName() 方法,然后用方法名称 (命令列的第二个参数) 去取得方法。getMethod() 方法有两个参数:第一个是方法名称 (命令列的第二个参数),第二个是 Class 对象的数组,这个阵例指明了方法的 signature (任何方法都可能会被多载,所以必须指定 signature 来分辨。) 因为我们的简单程序只呼叫没有参数的方法,我们建立一个 Class 对象的匿名空数组。如果我们想要呼叫有参数的方法,我们可以传递一个类别数组,数组的内容是各个类别的型态,依顺序排列。 

一旦我们有了 Method 对象,就呼叫它的 invoke() 方法,这会造成我们的目标方法被调用,并且将结果以 Object 对象传回。如果要对此对象做其它额外的事,你必须将它转型为更精确的型态。 

invoke() 方法的第一个参数就是我们想要呼叫目标方法的对象,如果该方法是静态的,就没有对象,所以我们把第一个参数设为 null,这就是我们范例中的情形。第二个参数是要传给目标方法作为参数的对象数组,它们的型态要符合呼叫 getMethod() 方法中所指定的型态。因为我们呼叫的方法没有参数,所以我们传递 null 作为 invoke() 的第二个参数。 


import   java.lang.reflect.Constructor; 
import   java.lang.reflect.Field; 
import   java.lang.reflect.Method; 
import   java.lang.reflect.Modifier; 
import   java.util.HashMap; 

public    class   TestRef    { 
      public    static    void   main(String[] args)   throws   Exception   { 
         TestRef testRef   =    new   TestRef(); 
         Class clazz   =   TestRef. class ; 
         System.out.println( " getPackage() =   "    +   clazz.getPackage().getName()); 
         //   getModifiers()的返回值可以包含类的种类信息。比如是否为public,abstract,static 
         int   mod   =   clazz.getModifiers(); 
         System.out.println( " Modifier.isAbstract(mod) =   " + Modifier.isAbstract(mod)); 
         System.out.println( " getName() =   " + clazz.getName()); 
         System.out.println( " getSuperclass() =   " + clazz.getSuperclass().getName()); 
         System.out.println( " getInterfaces() =   " + clazz.getInterfaces()); // 实现了哪些Interface 
         System.out.println( " clazz.getDeclaredClasses() =   " + clazz.getDeclaredClasses()); // 包含哪些内部类 
         System.out.println( " getDeclaringClass() =   " + clazz.getDeclaringClass()); 
         // 如果clazz是inner class 那么返回其outer class 
         
         System.out.println( " ---------- " ); 
         Constructor[] constructor   =   clazz.getDeclaredConstructors(); // 返回一组构造函数 Constructor[] 
            if   (constructor   !=    null )   { 
              for   ( int   i   =    0 ; i   <   constructor.length; i ++ )    { 
                 System.out.println(constructor[i].getName()); 
             } 
         } 
        
         System.out.println( " ---------- " ); 
         Method[] method   =   clazz.getDeclaredMethods();   //   Method[] 
            if   (method   !=    null )   { 
              for   ( int   i   =    0 ; i   <   method.length; i ++ )    { 
                 System.out.println(method[i].getName()); 
             } 
         } 
        
         System.out.println( " ---------- " ); 
         Field[] field   =   clazz.getDeclaredFields();   //   Field[] 
            if   (field   !=    null )   { 
              for   ( int   i   =    0 ; i   <   field.length; i ++ )    { 
                 System.out.println(field[i].getName()); 
                 System.out.println(field[i].getType().getName()); 
                 System.out.println(field[i].get(testRef)); 
             } 
         } 
        
         //   动态生成instance(无参数) 
         Class clz   =   Class.forName( " reflection.TestRef " ); 
         Object obj   =   clz.newInstance(); 
         System.out.println(((TestRef)obj).getStr()); 
        
         //   动态生成instance(有参数) 
          Class[] params   =    new   Class[]   {String. class ,   int . class ,   double . class } ; 
         Constructor construct   =   clz.getConstructor(params); 
         //   JDK1.5的情况下可以直接用{"haha",999,100.01}作为参数         
          Object obj2   =   construct.newInstance(new Object[]{"haha",new Integer( 999 ),   new   Double( 100.01 )} ); 
         System.out.println(((TestRef)obj2).getStr()); 
        
         //   动态调用method(public method) 
          Class[] params2   =    new   Class[]   {String. class } ; 
         Method methods   =   clz.getMethod( " setStr " , params2); 
         methods.invoke(testRef,   new   Object[]   { " invoke method " } ); 
         System.out.println(testRef.getStr()); 
        
         //   动态改变field内容(public field) 
         Field fields   =   clz.getField( " str " ); 
         fields.set(testRef,   " set field's value " ); 
         System.out.println(testRef.getStr()); 
        
     } 

      public   TestRef()   { 
         System.out.println( " --- complete TestRef() --- " ); 
     } 
    
     public   TestRef(String str,   int   i,   double   d)   { 
          this .str   =   str; 
          this .i   =   i; 
          this .d   =   d; 
         System.out.println( " --- complete TestRef(String str, int i, double d) --- " ); 
     } 
    
     public   String str   =    " I'm a string " ; 

     int   i   =    1 ; 

     double   d   =    3.14 ; 

     HashMap map   =    new   HashMap(); 

      public    double   getD()    { 
          return   d; 
     } 

       public    void   setD( double   d)    { 
          this .d   =   d; 
     } 

       public    int   getI()    { 
          return   i; 
     } 

       public    void   setI( int   i)    { 
          this .i   =   i; 
     } 

       public   HashMap getMap()    { 
          return   map; 
     } 

       public    void   setMap(HashMap map)    { 
          this .map   =   map; 
     } 

       public   String getStr()    { 
          return   str; 
     } 

       public    void   setStr(String str)    { 
          this .str   =   str; 
     } 


三. 代理(Proxy) 
1. 
我们直接从代码入手吧,我们可以使用一个动态代理类(Proxy),通过拦截一个对象的行为并添加我们需要的功能来完成。Java中的java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口为我们实现动态代理类提供了一个方案,但是该方案针对的对象要实现某些接口;如果针对的目的是类的话,cglib为我们提供了另外一个实现方案。等下会说明两者的区别。 
一、接口的实现方案: 
1)首先编写我们的业务接口(StudentInfoService.java): 
public interface StudentInfoService{ 
void findInfo(String studentName); 

      及其实现类(StudentInfoServiceImpl.java): 
public class StudentInfoServiceImpl implements StudentInfoService{ 
public void findInfo(String name){ 
   System.out.println("你目前输入的名字是:"+name); 


2)现在我们需要一个日志功能,在findInfo行为之前执行并记录其行为,那么我们就首先要拦截该行为。在实际执行的过程中用一个代理类来替我们完成。Java中为我们提供了实现动态代理类的方案: 

1'处理拦截目的的类(MyHandler.java) 
import org.apache.log4j.Logger; 
import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Proxy; 
import java.lang.reflect.Method; 

public class MyHandler implements InvocationHandler{ 
private Object proxyObj; 
private static Logger log=Logger.getLogger(MyHandler.class); 

public Object bind(Object obj){ 
   this.proxyObj=obj; 
   return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this); 


public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{ 
   Object result=null; 
   try{ 
    //请在这里插入代码,在方法前调用 
    log.info("调用log日志方法"+method.getName()); 
    result=method.invoke(proxyObj,args); //原方法 
    //请在这里插入代码,方法后调用 
   }catch(Exception e){ 
    e.printStackTrace(); 
   } 
   return result; 


2'我们实现一个工厂,为了方便我们使用该拦截类(AOPFactory.java): 
public class AOPFactory{ 
private static Object getClassInstance(String clzName){ 
   Object obj=null; 
   try{ 
    Class cls=Class.forName(clzName); 
    obj=(Object)cls.newInstance(); 
   }catch(ClassNotFoundException cnfe){ 
    System.out.println("ClassNotFoundException:"+cnfe.getMessage()); 
   }catch(Exception e){ 
    e.printStackTrace(); 
   } 
   return obj; 


public static Object getAOPProxyedObject(String clzName){ 
   Object proxy=null; 
   MyHandler handler=new MyHandler(); 
   Object obj=getClassInstance(clzName); 
   if(obj!=null) { 
    proxy=handler.bind(obj); 
   }else{ 
    System.out.println("Can't get the proxyobj"); 
    //throw 
   } 
   return proxy; 



3)基本的拦截与其工厂我们都实现了,现在测试(ClientTest.java): 
public class ClientTest{ 
public static void main(String[] args){ 
   StudentInfoService studentInfo=(StudentInfoService)AOPFactory.getAOPProxyedObject("StudentInfoServiceImpl"); 
   studentInfo.findInfo("阿飞"); 


输出结果(看你的log4j设置): 
[INFO]调用log日志方法findInfo 
你目前输入的名字是:阿飞 
      这样我们需要的效果就出来了,业务处理自己在进行,但是我们实现了日志功能 

2.再看一个例子: 
  假设系统由一系列的BusinessObject所完成业务逻辑功能,系统要求在每一次业务逻辑处理时要做日志记录。这里我们略去具体的业务逻辑代码。 

public interface BusinessInterface { 
 public void processBusiness(); 


public class BusinessObject implements BusinessInterface { 
 private Logger logger = Logger.getLogger(this.getClass().getName()); 
 public void processBusiness(){ 
  try { 
   logger.info("start to processing..."); 
   //business logic here. 
   System.out.println(“here is business logic”); 
   logger.info("end processing..."); 
  } catch (Exception e){ 
   logger.info("exception happends..."); 
   //exception handling 
  } 
 } 


  这里处理商业逻辑的代码和日志记录代码混合在一起,这给日后的维护带来一定的困难,并且也会造成大量的代码重复。完全相同的log代码将出现在系统的每一个BusinessObject中。 

按照AOP的思想,我们应该把日志记录代码分离出来。要将这些代码分离就涉及到一个问题,我们必须知道商业逻辑代码何时被调用,这样我们好插入日志记录代码。一般来说要截获一个方法,我们可以采用回调方法或者动态代理。动态代理一般要更加灵活一些,目前多数的AOP Framework也大都采用了动态代理来实现。这里我们也采用动态代理作为例子。 
JDK1.2以后提供了动态代理的支持,程序员通过实现java.lang.reflect.InvocationHandler接口提供一个执行处理器,然后通过java.lang.reflect.Proxy得到一个代理对象,通过这个代理对象来执行商业方法,在商业方法被调用的同时,执行处理器会被自动调用。 

  有了JDK的这种支持,我们所要做的仅仅是提供一个日志处理器。 

public class LogHandler implements InvocationHandler { 

 private Logger logger = Logger.getLogger(this.getClass().getName()); 
  private Object delegate; 
  public LogHandler(Object delegate){ 
   this.delegate = delegate; 
  } 

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  Object o = null; 
  try { 
   logger.info("method stats..." + method); 
   o = method.invoke(delegate,args); 
   logger.info("method ends..." + method); 
  } catch (Exception e){ 
   logger.info("Exception happends..."); 
   //excetpion handling. 
  } 
  return o; 
 } 


  现在我们可以把BusinessObject里面的所有日志处理代码全部去掉了。 

public class BusinessObject implements BusinessInterface { 

 private Logger logger = Logger.getLogger(this.getClass().getName()); 
 public void processBusiness(){ 
  //business processing 
  System.out.println(“here is business logic”); 
 } 


  客户端调用商业方法的代码如下: 

BusinessInterface businessImp = new BusinessObject(); 

InvocationHandler handler = new LogHandler(businessImp); 

BusinessInterface proxy = (BusinessInterface) Proxy.newProxyInstance( 
 businessImp.getClass().getClassLoader(), 
 businessImp.getClass().getInterfaces(), 
 handler); 

proxy.processBusiness(); 

  程序输出如下: 

INFO: method stats... 
here is business logic 
INFO: method ends... 

  至此我们的第一次小尝试算是完成了。可以看到,采用AOP之后,日志记录和业务逻辑代码完全分开了,以后要改变日志记录的话只需要修改日志记录处理器就行了,而业务对象本身(BusinessObject)无需做任何修改。并且这个日志记录不会造成重复代码了,所有的商业处理对象都可以重用这个日志处理器。  
(转载请注明出处:[url=http://www.live588.org]淘金盈[/url]
[url=http://www.10086money.com]时尚资讯[/url])

posted on 2012-04-18 21:14 夏凡 阅读(167) 评论(0)  编辑  收藏


只有注册用户登录后才能发表评论。


网站导航: