内省与JavaBean

概述

JavaBean代表一类特殊的Java类，这种类主要用来存储和传递属性信息，JavaBean中的方法主要用于设置和获取这些私有属性，他们有一定的命名规则，我们可以把它们想象为一个侧重属性信息的类，如JSP中的表单信息打包一样，这些信息就可以封装在一个JavaBean对象中，通过一些特殊的方式来操作。

Introspector，即为内省

public class Introspector

extends Object

Introspector 类为通过工具学习有关受目标 Java Bean 支持的属性、事件和方法的知识提供了一个标准方法。

简单说，Introspector就是一种操作JavaBean的标准方式

JavaBean一些简单操作

写一个Bean类用作测试

   1: public class Bean {

   2:     private String name;

   3:     private int age;

   4:     private int num;

   5:     private int score;

   6:     

   7:     public Bean(String name, int age, int num, int score) {

   8:         super();

   9:         this.name = name;

  10:         this.age = age;

  11:         this.num = num;

  12:         this.score = score;

  13:     }

  14:     public String getName() {

  15:         return name;

  16:     }

  17:     public void setName(String name) {

  18:         this.name = name;

  19:     }

  20:     public int getAge() {

  21:         return age;

  22:     }

  23:     public void setAge(int age) {

  24:         this.age = age;

  25:     }

  26:     public int getNum() {

  27:         return num;

  28:     }

  29:     public void setNum(int num) {

  30:         this.num = num;

  31:     }

  32:     public int getScore() {

  33:         return score;

  34:     }

  35:     public void setScore(int score) {

  36:         this.score = score;

  37:     }

  38: }

实现set和get方法的简单操作

   1: public class BeanTest {

   2:  

   3:     /**

   4:      * @param args

   5:      */

   6:     public static void main(String[] args) {

   7:         

   8:         //获取对象

   9:         Bean b = new Bean("Shawn",12,1,97);

  10:         //获取类字节码文件

  11:         Class beanClass = Bean.class;    

  12:         //设置需要操作的属性名

  13:         String propertyName = "name";

  14:         

  15:         //调用set和get方法

  16:         System.out.println(getProperty(beanClass, b, propertyName, null));

  17:         setProperty(beanClass, b, propertyName, new Object[]{"Feng"});

  18:         System.out.println(getProperty(beanClass, b, propertyName, null));

  19:                 

  20:     }

  21:     //封装javabean的set方法

  22:     private static void setProperty(Class beanClass,Object obj,String propertyName,Object[] values){

  23:         try {

  24:             //获取属性描述符对象

  25:             PropertyDescriptor pd = new PropertyDescriptor(propertyName, beanClass);

  26:             //得到set方法对象

  27:             Method setMethod = pd.getWriteMethod();

  28:             //利用反射执行set方法

  29:             setMethod.invoke(obj, values);

  30:         } catch (IllegalArgumentException e) {

  31:             // TODO Auto-generated catch block

  32:             e.printStackTrace();

  33:         } catch (IntrospectionException e) {

  34:             // TODO Auto-generated catch block

  35:             e.printStackTrace();

  36:         } catch (IllegalAccessException e) {

  37:             // TODO Auto-generated catch block

  38:             e.printStackTrace();

  39:         } catch (InvocationTargetException e) {

  40:             // TODO Auto-generated catch block

  41:             e.printStackTrace();

  42:         }

  43:     }

  44:     //封装javabean的get方法

  45:     private static Object getProperty(Class beanClass,Object obj,String propertyName,Object[] args){

  46:         Object retVal = null;

  47:         try {

  48:             //获取属性描述符对象

  49:             PropertyDescriptor pd = new PropertyDescriptor(propertyName, beanClass);

  50:             //得到get方法对象

  51:             Method getMethod = pd.getReadMethod();

  52:             //利用反射执行get方法

  53:             retVal = getMethod.invoke(obj, args);

  54:         } catch (IllegalArgumentException e) {

  55:             // TODO Auto-generated catch block

  56:             e.printStackTrace();

  57:         } catch (IntrospectionException e) {

  58:             // TODO Auto-generated catch block

  59:             e.printStackTrace();

  60:         } catch (IllegalAccessException e) {

  61:             // TODO Auto-generated catch block

  62:             e.printStackTrace();

  63:         } catch (InvocationTargetException e) {

  64:             // TODO Auto-generated catch block

  65:             e.printStackTrace();

  66:         }

  67:         return retVal;

  68:     }

  69: }

利用内省实现一些复杂操作

   1: public class BeanTest2 {

   2:  

   3:     /**

   4:      * @param args

   5:      * @throws IntrospectionException 

   6:      * @throws InvocationTargetException 

   7:      * @throws IllegalAccessException 

   8:      * @throws IllegalArgumentException 

   9:      */

  10:     public static void main(String[] args) throws IntrospectionException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

  11:         

  12:         //获取对象

  13:         Bean b = new Bean("Shawn",12,1,97);

  14:         //获取类字节码文件

  15:         Class beanClass = Bean.class;    

  16:         //设置需要操作的属性名

  17:         String propertyName = "name";

  18:         

  19:         //根据类字节码对象获取Bean信息

  20:         BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);

  21:         //利用内省获取所有的属性描述符

  22:         PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();

  23:         //遍历所有的属性描述符，找到要操作的属性，进行操作

  24:         for(PropertyDescriptor pd : pds){

  25:             if(pd.getName().equals(propertyName)){

  26:                 Method setMethod = pd.getWriteMethod();

  27:                 Method getMethod = pd.getReadMethod();

  28:                 System.out.println(getMethod.invoke(b, null));

  29:                 setMethod.invoke(b, "Feng");

  30:                 System.out.println(getMethod.invoke(b, null));

  31:             }

  32:         }

  33:     }

  34: }

BeanUtils工具包

BeanUtils工具包是apach提供的一套非常方便的用于操作JavaBean的工具

BeanUtil实现set和get方法

   1: public class BeanUtilTest {

   2:  

   3:     /**

   4:      * @param args

   5:      * @throws NoSuchMethodException 

   6:      * @throws InvocationTargetException 

   7:      * @throws IllegalAccessException 

   8:      */

   9:     public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

  10:         

  11:         //获取对象

  12:         Bean b = new Bean("Shawn",12,1,97);

  13:         //设置需要操作的属性名

  14:         String propertyName = "score";

  15:         

  16:         //利用BeanUtils获取属性值

  17:         System.out.println(BeanUtils.getProperty(b, propertyName));

  18:         //利用BeanUtils设置属性值

  19:         BeanUtils.setProperty(b, propertyName, "33");

  20:         System.out.println(BeanUtils.getProperty(b, propertyName));

  21:     }

  22: }

我们可以看到，即便操作的是int型的属性，接收的仍然是字符串数据

BeanUtils包中还提供一个类PropertyUtils，也具有setProperty与getProperty的方法，与BeanUtils不同的是，传入的参数不需要进行类型转换，也就是说，如果BeanUtils中的方法类型转换出了问题时，可以采用PropertyUtils中的方法，直接传入对应类型的参数，同样可以达到目的。

同时，BeanUtils还支持属性的级联操作

比如一个人内部有心脏，而心脏内部又有左心房和右心房，那么我们可以直接通过BeanUtils设置和获取心脏的内部属性

   1: public class Heart{

   2:     private String left;

   3:     private String right;

   4:     public String getLeft() {

   5:         return left;

   6:     }

   7:     public void setLeft(String left) {

   8:         this.left = left;

   9:     }

  10:     public String getRight() {

  11:         return right;

  12:     }

  13:     public void setRight(String right) {

  14:         this.right = right;

  15:     }

  16: }

   1: public class Person{

   2:     private Heart heart = new Heart();

   3:     private Date birthday;

   4:     public Date getBirthday() {

   5:         return birthday;

   6:     }

   7:     public void setBirthday(Date birthday) {

   8:         this.birthday = birthday;

   9:     }

  10:     public Heart getHeart() {

  11:         return heart;

  12:     }

  13:     public void setHeart(Heart heart) {

  14:         this.heart = heart;

  15:     }

  16: }

   1: public class BeanUtilsTest2 {

   2:  

   3:     /**

   4:      * @param args

   5:      * @throws NoSuchMethodException 

   6:      * @throws InvocationTargetException 

   7:      * @throws IllegalAccessException 

   8:      */

   9:     public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

  10:         // TODO Auto-generated method stub

  11:         Person p = new Person();

  12:         System.out.println(BeanUtils.getProperty(p, "heart.left"));

  13:         BeanUtils.setProperty(p, "heart.left", "lll");

  14:         System.out.println(BeanUtils.getProperty(p, "heart.left"));

  15:     }

  16: }

还有一个重要的操作，BeanUtils可以将Map集合对象与JavaBean对象的对应属性内容进行转换

   1: public class BeanUtilsTest3 {

   2:  

   3:     /**

   4:      * @param args

   5:      * @throws InvocationTargetException 

   6:      * @throws IllegalAccessException 

   7:      * @throws NoSuchMethodException 

   8:      */

   9:     public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

  10:         

  11:         //将JavaBean的属性信息映射到一个Map集合中

  12:         Map map = new HashMap();

  13:         Bean b = new Bean("Shawn", 12, 14, 90);        

  14:         map = BeanUtils.describe(b);

  15:         System.out.println(map);

  16:         

  17:         //将map集合中的属性写入到JavaBean对象中

  18:         map = new HashMap();

  19:         map.put("name", "Feng");

  20:         map.put("score", 22);        

  21:         BeanUtils.populate(b, map);

  22:         System.out.println(b.toString());

  23:     }

  24: }

以上三点便是BeanUtils最常用的一些操作和特点，可以看到，BeanUtils的操作非常方便快捷，现在已经很普及了

JavaBean的命名规则

由于JavaBean中只有set和get方法是对外可见的，所以JavaBean内部属性用什么名字并不重要，只要设置好方法名称即可

一般规则是

如果方法名称为setXxx和getXxx，那么表示propertyName全为小写xxx

如果方法名称为setXXx或者setXXX，那么表示propertyName为对应的XXx以及XXX

一般setXxx以及setXXX比较常见，一个代表普通的变量，一个代表具有特殊含义的变量

所以我们写方法名称时尽量按照这个命名规则写，设置propertyName时使用相对应的名称即可