黑马程序员技术交流社区

标题: 关于张孝祥老师视频中的javabean [打印本页]

作者: 燃烧端午 时间: 2012-6-22 23:16
标题: 关于张孝祥老师视频中的javabean
张老师视频中讲到：在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！
真的没任何原因的要求用JavaBean方式操作吗？
请了解详情的黑马同学们给一个合理的解释

作者: 耿鑫 时间: 2012-6-23 00:57
你现在担心是多余的，等你学到最后你就知道了，javabean是必须的，如果没有javabean你对谁去增删改查啊，如果没有javabean你会很郁闷的，
其实到最后你会明白，各个逻辑模块功能模块可以说都是 javabean。

作者: 车风波 时间: 2012-6-24 11:44
这应该是长期经验总结出来的吧，实际上，程序自始至终都是围绕对象去操作。

作者: 陈淑飞 时间: 2012-6-24 12:52
简单理解JavaBean，应该与Java语言的封装性有关。
比如一个实体，人。给他对象化时，你不会准备，把人的所有属性都暴露出来吧。这样也太危险了，程序也不健壮了。
所以啊，你得把属性都封装起来，那么私有化(private)吧。你私有化了，你得应该提供人家如何访问你的方法吧。
所以呢，要把方法公开出来，那么公开化(public)吧，通常get与set是一对的，你得提供人家如何修改或获取属于的值啊。
而且，封装起来呢，还有个好处，可以进行一些逻辑验证呢。比如人的属于中有性别属性，你得防止人家插入了个‘人妖’进去吧。呵呵。
当然像这种简单明确的验证，我们都是在表现层或在客户端就验证掉的。
最后，一般这种javabean得提供一个无参的构造函数。得让人家可以方便的new出来对象，实例化掉吧。

以上是个人一些理解，欢迎大家指正。

作者: 邓杰 时间: 2012-6-24 15:43
刚才回答了另一个朋友关于内省的疑问；感觉这两个问题差不多
尤其是下面从网上的查到的资料应该能比较详细的解释关于JavaBean的应用；记住一点Java中的那些代码不一定都自己写的它的属性也都不是一成不变的；你总不能每次修改都去改原代码吧；JavaBean的作用就是把别人给你的对象的中的属性可以让你自己获取或修改；
内省:
IntroSpector//英语直译有，自省，反省，内省；等几种说法；Java取了内省；
下面是API中的介绍感觉比较抽象：

Introspector 类为通过工具学习有关受目标 Java Bean 支持的属性、事件和方法的知识提供了一个标准方法。
对于这三种信息，Introspector 将分别分析 bean 的类和超类，寻找显式或隐式信息，使用这些信息构建一个全面描述目标 bean 的 BeanInfo 对象。
对于每个 "Foo" 类，如果存在相应的 "FooBeanInfo" 类，显式信息可能是可用的，查询这些信息时，FooBeanInfo 类会提供一个非 null 值。通过获得目标 bean 类的完全受限定包名称并追加 "BeanInfo" 形成一个新类，首先查找 BeanInfo 类。如果此操作失败，则采用此名称的最终类名称组件，在 BeanInfo 包搜索路径中指定的每个包中搜索该类。
因此对于某个类，比如说 "sun.xyz.OurButton"，首先需要查找称为 "sun.xyz.OurButtonBeanInfo" 的 BeanInfo 类，如果失败，则查找 BeanInfo 搜索路径中的每个包来搜索 OurButtonBeanInfo 类。对于默认搜索路径，这意味着将查找 "sun.beans.infos.OurButtonBeanInfo"。
如果某个类提供有关其自身的显式 BeanInfo，则将它添加到从分析所有派生类得到的 BeanInfo 信息中，并将显式信息视为当前类及其基类的确定的信息，无需进一步深入超类链进行分析。
如果没有在某个类上发现显式 BeanInfo，则使用低层次的反射来研究类的方法，并应用标准设计模式来标识属性存储器、事件源或公共方法。然后深入分析类的超类，从它那里（可能在超类链的顶部）添加信息。
因为 Introspector 缓存 BeanInfo 类来获得更好的性能，所以如果在使用多个类加载器的应用程序中使用它，则需小心谨慎。通常，在破坏一个已用于 introspect 类的 ClassLoader 时，应使用 Introspector.flushCaches 或 Introspector.flushFromCaches 方法从缓存中清除所有内省的类。
有关内省和设计模式的更多信息，请参阅 JavaBeans specification。

下面是在网上找的一些关于内省的一些总结和应用；结合下面的代码应该就可以明白内省是怎么一回事了；

是Java语言对Bean类属性、事件的一种缺省处理方法
内省(IntroSpector)是Java语言对JavaBean 类属性、事件的一种缺省处理方法。
　　例如类A中有属性name, 那我们可以通过getName,setName 来得到其值或者设置新的值。
　　通过getName/setName 来访问name属性，这就是默认的规则。
　　Java中提供了一套API 用来访问某个属性的getter/setter方法，通过这些API 可以使你不需要了解这个规则，这些API存放于包java.beans 中。
　　一般的做法是通过类Introspector的getBeanInfo方法获取某个对象的BeanInfo 信息,然后通过BeanInfo来获取属性的描述器(PropertyDescriptor),通过这个属性描述器就可以获取某个属性对应的getter/setter方法,然后我们就可以通过反射机制来调用这些方法。
　　我们又通常把javabean的实例对象称之为值对象（Value Object），因为这些bean中通常只有一些信息字段和存储方法，没有功能性方法。
　　一个JavaBean类可以不当JavaBean用，而当成普通类用。JavaBean实际就是一种规范，当一个类满足这个规范，这个类就能被其它特定的类调用。一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。去掉set前缀，然后取剩余部分，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。
　　除了反射用到的类需要引入外，内省需要引入的类如下所示，它们都属于java.beans包中的类，自己写程序的时候也不能忘了引入相应的包或者类。下面代码片断是设置某个JavaBean类某个属性的关键代码：
1 package com.ljq.test;
　　2
　　3  import java.beans.BeanInfo;
　　4  import java.beans.IntrospectionException;
　　5  import java.beans.Introspector;
　　6  import java.beans.PropertyDescriptor;
　　7  import java.lang.reflect.InvocationTargetException;
　　8  import java.lang.reflect.Method;
　　9
　　10  import org.apache.commons.beanutils.BeanUtils;
　　11
　　12
　　13  public class IntrospectorTest {
　　14
　　15    public static void main(String[] args) throws IllegalArgumentException,
　　16       IntrospectionException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
　　17
　　18       UserInfo userInfo=new UserInfo("zhangsan", "123456");
　　19       String propertyName="userName";
　　20       Object retVal=getProperty(userInfo, propertyName);
　　21       System.out.println("retVal="+retVal); //retVal=zhangsan
　　22
　　23       Object value="abc";
　　24       setProperty(userInfo, propertyName, value);
　　25       retVal=getProperty(userInfo, propertyName);
　　26       System.out.println("retVal="+retVal); //retVal=abc
　　27
　　//使用BeanUtils工具包操作JavaBean
　　28       String userName=BeanUtils.getProperty(userInfo, propertyName);
　　29       System.out.println("userName="+userName);
　　30       BeanUtils.setProperty(userInfo, propertyName, "linjiqin");
　　31       userName=BeanUtils.getProperty(userInfo, propertyName);
　　32       System.out.println("userName="+userName);
　　33    }
　　34
　　35    /**
　　36    * 设置属性
　　37    *
　　38    * @param clazz 对象名
　　39    * @param propertyName 属性名
　　40    * @param value 属性值
　　41    */
　　42    private static void setProperty(Object clazz, String propertyName, Object value)
　　43          throws IntrospectionException,IllegalAccessException, InvocationTargetException{
　　44       //方法一相对于第二种方法这个简单一些；
　　45       /*PropertyDescriptor pd=new PropertyDescriptor(propertyName, clazz.getClass());
　　46       Method methodSet=pd.getWriteMethod();
　　47       methodSet.invoke(clazz, value);*/
　　48
　　49       //方法二
　　50       BeanInfo beanInfo=Introspector.getBeanInfo(clazz.getClass());
　　51       PropertyDescriptor[] pds=beanInfo.getPropertyDescriptors();
　　52       for(PropertyDescriptor pd:pds){
　　53          if(propertyName.equals(pd.getName())){
　　54                Method methodSet=pd.getWriteMethod();
　　55                methodSet.invoke(clazz, value);
　　56                break;
　　57          }
　　58       }
　　59    }
　　60
　　61    /**
　　62    * 获取属性
　　63    *
　　64    * @param clazz 对象名
　　65    * @param propertyName 属性名
　　66    * @return
　　67    * @throws IntrospectionException
　　68    * @throws InvocationTargetException
　　69    * @throws IllegalAccessException
　　70    * @throws IllegalArgumentException
　　71    */
　　72    private static Object getProperty(Object clazz, String propertyName)
　　73          throws IntrospectionException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
　　74       //方法一
　　75       /*PropertyDescriptor pd=new PropertyDescriptor(propertyName, clazz.getClass());
　　76       Method methodGet=pd.getReadMethod();
　　77       return methodGet.invoke(clazz);*/
　　78
　　79       //方法二
　　80       Object retVal=null;
　　81       BeanInfo beanInfo=Introspector.getBeanInfo(clazz.getClass());
　　82       PropertyDescriptor[] pds=beanInfo.getPropertyDescriptors();
　　83       for(PropertyDescriptor pd:pds){
　　84          if(propertyName.equals(pd.getName())){
　　85                Method methodGet=pd.getReadMethod();
　　86                retVal=methodGet.invoke(clazz);
　　87                break;
　　88          }
　　89       }
　　90       return retVal;
　　91    }
　　92
　　93 }
　　UserInfo类
　　1 package com.ljq.test;
　　2
　　3 public class UserInfo {
　　4    private String userName;
　　5    private String pwd;
　　6
　　7    public UserInfo(String userName, String pwd) {
　　8       super();
　　9       this.userName = userName;
　　10       this.pwd = pwd;
　　11    }
　　12
　　13    public String getUserName() {
　　14       return userName;
　　15    }
　　16
　　17    public void setUserName(String userName) {
　　18       this.userName = userName;
　　19    }
　　20
　　21    public String getPwd() {
　　22       return pwd;
　　23    }
　　24
　　25    public void setPwd(String pwd) {
　　26       this.pwd = pwd;
　　27    }
　　28
　　29 }

作者: Forever。 时间: 2012-6-24 15:56
对javabean的一些浅浅理解：
属性私有化，并且提供相应的对此属性操作的方法，当然这些方法通常不会私有化。
这样的好处就是当别的类想去改变你的属性值得时候，只能通过你对外提供的方法去操作，而你可以再方法内写你对该属性各种限制或者修改的条件。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2