看完这一节之后，听张老师说做开发的时候对JavaBean的内省操作使用的很频繁

1. private static void setProperties(Object pt, String propertyName,Object value)
   
2.                         throws IntrospectionException, IllegalAccessException,
   
3.                         InvocationTargetException {
   
4.                 PropertyDescriptor pd = new PropertyDescriptor(propertyName, pt.getClass());
   
5.                
   
6.                 Method methodSetX = pd.getWriteMethod();
   
7.                
   
8.                 methodSetX.invoke(pt, value);
   
9.         }
   
10.         private static Object getProperties(Object pt,
    
11.                         String propertyName) throws IntrospectionException,
    
12.                         IllegalAccessException, InvocationTargetException {
    
13.                 //PropertyDescriptor pd = new PropertyDescriptor(propertyName, pt.getClass());               
    
14.                
    
15.                 //Method methodGetX = pd.getReadMethod();       
    
16.                
    
17.                 //Object retVal = methodGetX.invoke(pt);
    
18.                 BeanInfo beaninfo = Introspector.getBeanInfo(pt.getClass());
    
19.                
    
20.                 PropertyDescriptor[] pds = beaninfo.getPropertyDescriptors();
    
21.                
    
22.                 Object retVal = null;
    
23.                
    
24.                 for(PropertyDescriptor pd:pds){
    
25.                         if(pd.getName().equals(propertyName)){
    
26.                                 Method methodGetX = pd.getReadMethod();
    
27.                                 retVal = methodGetX.invoke(pt);
    
28.                                 break;
    
29.                         }
    
30.                 }
    
31.                
    
32.                 return retVal;
    
33.         }

复制代码

我想问的是当我们要获取或者修改JavaBean的属性值时，为什么不直接用对象调用get或set方法呢，内省操作的好处是什么？

JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。
如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？
用内省这套api操作JavaBean比用普通类的方式更方便。

比如说有一个Person类
public class person{
   private String name;
   private int age;
   /*这里是对name和age操作的get和set方法  */
}
然后有一个对Person类操作的PersonDao，里面就有很多方法啊，比如增删改查，方法的参数可以是一个Person对象啊，这个时候如果你在方法中要得到哪个属性值就可以直接对象名.getX就行啊，这样操作不是比内省方便么？

给你举个例子吧！
在你做Servlet/JSP的web编程的时候，你的Servlet要经常接收客户端传过来的表单，现在
第一种表单传过来的为：
username : "zhangsan"
password : "lisi"
你有一个User的类，User类中有两个属性username和password

1. public class User{
   
2.         private String username;
   
3.         private String password;
   
4.         public String getUsername() {
   
5.                 return username;
   
6.         }
   
7.         public void setUsername(String username) {
   
8.                 this.username = username;
   
9.         }
   
10.         public String getPassword() {
    
11.                 return password;
    
12.         }
    
13.         public void setPassword(String password) {
    
14.                 this.password = password;
    
15.         }
    
16.        
    
17. }

复制代码

现在你要讲传过来的值包装成一个User的对象，你怎么做？
普通方法是

1. String username = request.getParameter("username");
   
2. String password = request.getParameter("password");
   
3. User u = new User();
   
4. u.setUsername(username);
   
5. u.setPassword(password);

复制代码

好像还简单是吧？？？
加入现在又第二种表单：
name : "wangwu"
age : 26
有一个Person类

1. public class Person{
   
2.         private String name;
   
3.         private int age;
   
4.         public String getName() {
   
5.                 return name;
   
6.         }
   
7.         public void setName(String name) {
   
8.                 this.name = name;
   
9.         }
   
10.         public int getAge() {
    
11.                 return age;
    
12.         }
    
13.         public void setAge(int age) {
    
14.                 this.age = age;
    
15.         }
    
16.        
    
17. }

复制代码

要将上面的两个参数封装成一个Person对象，那么你就要重复
String name = request.getParameter("name");
String age = request.getParameter("age");
Person p = new Person();
p.setName(name);
p.setAge(Integer.parse(age));
这段程序和上面那段程序是不是很像，只是要创建的对象不一样而已，
而如果用放射的方式，就可以只写一个函数就可以了：
因为从request中是可以直接得到字段和值的map的，所以就可以利用反射

1. public class RequestUtil{
   
2.         public static Object getBean(Class c, Map map){
   
3.                 Object o = c.newInstance();
   
4.                 // 下面就是用反射的方式，从mao中得到key值就是o对象的属性的名称，value就是要设置的值
   
5.                 // 是不是只要这个方法就可以对传过来的值就行封装
   
6.                 /// ......具体实现可以参照视频的方式自己实现
   
7.                 return o;
   
8.         }
   
9. }

复制代码

写好上面的函数都，就可以把上面的两段话改写成


1、 User u = (User)RequestUtil.getBean(User.class,map);
2、 Person p = (User)RequestUtil.getBean(Person.class,map);

是不是比原来简单多了
当然你要先从request中获取map,这个获取就是调用一个函数的事情，很简单。

第二个强转的时候应该转成Person类的，一点小错误

用张老师的说法就是，你确定你要操作的JavaBean对象了么？如果你没确定，新来一个又怎么样呢？改源码么？改源码又引发一系列问题怎么办？JavaBean的内省就是干的这事，不管你以后要来哪个类，只要你是JavaBean，配置文件上一方，就可以帮你改了~~~框架思想~~~~

经典啊，我掌握的就是曾祥彬同学前面讲的两种形式，现在对内省有更清晰的认识了。嗯，再回头看一遍内省视频！