关于Java反射机制的一个实例

    *
      关于Java反射机制的一个实例
    * http://developer.51cto.com  2009-06-19 13:59  abruzzi  javaeye  我要评论(0)

      本文向您展示Java反射机制的一个实例，该实例持简单EL的taglib，基本上实现了多级bean的属性的访问。

      JSP的规范中，有个表达式语言(Expression Language, 简称EL)，可以算是一个微型的语言，其中对request, page, session, application中预存的JavaBean对象的引用方式很是简单。最近正好需要写一个支持简单EL的taglib，所以就研究了下Java反射机制，目前基本上实现了多级bean的属性的访问，经测试，还是可以用的。如：

         1. public static void main(String[] args){ 
         2.     UserBean bean = new UserBean(); 
         3.     bean.setName("John Abruzzi"); 
         4.     bean.setNick("Abruzzi"); 
         5.     bean.setAge(24); 
         6.      
         7.     AddressBean addr = new AddressBean(); 
         8.     addr.setZip("0086"); 
         9.     addr.setStreet("Bell Street #12"); 
        10.     bean.setAddress(addr); 
        11.      
        12.     System.out.println(BeanParser.doParse(bean, "bean.address.street")); 
        13.     System.out.println(BeanParser.doParse(bean, "bean.address.zip")); 
        14.     System.out.println(BeanParser.doParse(bean, "bean.name")); 
        15.     System.out.println(BeanParser.doParse(bean, "bean.nick")); 
        16.     System.out.println(BeanParser.doParse(bean, "bean.age")); 
        17. }

      需要可以输出：

         1. Bell Street #12
         2. 0086
         3. John Abruzzi 
         4. Abruzzi 
         5. 24

      反射，即由一个抽象的对象(如Object)，取出这个具体对象的属性或者方法(就EL中关于Bean的引用来说，这个定义已经够了)。在EL中，对一个Bean的某字段进行引用，只需 ${bean.field}，当然，这个bean是已经被set到容器中的，这就是Java反射机制。

      我们从容器中取出以bean为名字的Object，通过Java反射机制知道它的真实类型，然后通过field以javabean规范拼出方法名，进行调用，如果这个表达式是多级的，如${bean.field.field}，其中第一个field本身就是一个bean对象，同样需要递归的进行解析。

      大概原理就是这些了，看代码吧：

      现有一个UserBean, 其中的一个字段Address本身又是一个AddressBean。

         1. package elparser; 
         2. 
         3. public class AddressBean { 
         4.     private String street; 
         5.     private String zip; 
         6.      
         7.     public String getZip() { 
         8.         return zip; 
         9.     } 
        10. 
        11.     public void setZip(String zip) { 
        12.         this.zip = zip; 
        13.     } 
        14. 
        15.     public String getStreet() { 
        16.         return street; 
        17.     } 
        18. 
        19.     public void setStreet(String street) { 
        20.         this.street = street; 
        21.     } 
        22.      
        23. }

      然后是UserBean

         1. package elparser; 
         2. 
         3. public class UserBean { 
         4.     private String name; 
         5.     private String nick; 
         6.     private AddressBean address; 
         7.     private int age; 
         8.      
         9.     public int getAge(){ 
        10.         return this.age; 
        11.     } 
        12.      
        13.     public void setAge(int age){ 
        14.         this.age = age; 
        15.     } 
        16.      
        17.     public String getName() { 
        18.         return name; 
        19.     } 
        20.     public void setName(String name) { 
        21.         this.name = name; 
        22.     } 
        23.     public String getNick() { 
        24.         return nick; 
        25.     } 
        26.     public void setNick(String nick) { 
        27.         this.nick = nick; 
        28.     } 
        29.     public AddressBean getAddress() { 
        30.         return address; 
        31.     } 
        32.     public void setAddress(AddressBean address) { 
        33.         this.address = address; 
        34.     } 
        35. }

      Bean都是很简单的，考虑到对基本类型的支持，所以在UserBean中加入一个int型的字段age

      好了，看看怎么通过一个串和一个对象来取出其中的字段来：

         1. package elparser; 
         2. 
         3. import java.lang.reflect.Method; 
         4. 
         5. public class BeanParser { 
         6.      
         7.     private static String getMethodName(String property, String prefix){ 
         8.         String prop = Character.toUpperCase(property.charAt(0))+property.substring(1); 
         9.      
        10.         String methodName = prefix + prop; 
        11.      
        12.         return methodName; 
        13.     } 
        14.      
        15.     private static Object parse(Object bean, String expr){ 
        16.         Class beanClass = bean.getClass(); 
        17.          
        18.         Method method = null; 
        19.         Object result = null; 
        20.          
        21.         try{ 
        22.             //这两步是关键，get方法不需要传入参数，所以只是new出两个空数组传入 
        23.             method = beanClass.getMethod(getMethodName(expr, "get"), new Class[]{}); 
        24.             result = method.invoke(bean, new Object[]{}); 
        25.         }catch(Exception e){ 
        26.             System.out.println(e.getMessage()); 
        27.         } 
        28.          
        29.         return result; 
        30.     } 
        31.      
        32.     public static Object doParse(Object bean, String expr){ 
        33.         String keys[] = expr.split("\\."); 
        34.          
        35.         Object obj = null; 
        36.          
        37.         for(int i = 1; i < keys.length;i++){ 
        38.             obj = parse(bean, keys[i]); 
        39.             bean = obj; 
        40.         }//递归parse 
        41.          
        42.         return obj; 
        43.     } 
        44.      
        45.     public static void main(String[] args){ 
        46.         UserBean bean = new UserBean(); 
        47.         bean.setName("John Abruzzi"); 
        48.         bean.setNick("Abruzzi"); 
        49.         bean.setAge(24); 
        50.          
        51.         AddressBean addr = new AddressBean(); 
        52.         addr.setZip("0086"); 
        53.         addr.setStreet("Bell Street #12"); 
        54.         bean.setAddress(addr); 
        55.          
        56.         System.out.println(BeanParser.doParse(bean, "bean.address.street")); 
        57.         System.out.println(BeanParser.doParse(bean, "bean.address.zip")); 
        58.         System.out.println(BeanParser.doParse(bean, "bean.name")); 
        59.         System.out.println(BeanParser.doParse(bean, "bean.nick")); 
        60.         System.out.println(BeanParser.doParse(bean, "bean.age")); 
        61.     } 
        62. }

      代码比较简短，重要部分有注释，应该很容易理解。当然这篇文章主要是关于Java的反射机制，如果需要对EL完全支持，可以使用JavaCC做一个简单的分析器(Apache的commons中包含一个el的项目，就是用javacc写的分析器)。

      【编辑推荐】
         1. 在Java应用程序中使用Jfreechart配置
         2. Java程序员学习Flex和BlazeDS的十三个理由
         3. 用JavaFX编写用户界面控制器
         4. Java WEB开发中的中文乱码问题解决
         5. 总结Java Web中几个函数的作用
      【责任编辑：red7 TEL：[phone]】