大家来学javaBean

ゝ一世哀愁。 2022-08-14 05:47 153阅读 0赞

大家来学javaBean

javaBean是什么？

javabean和java Applet相似，是一个非常简单的遵循某种严格协议的java类。编写javabean就是编写一个java的类，所以只要会写类就能编写一个bean，这个类创建的一个对象称作一个bean。为了能让使用这个bean的应用程序构建工具（如：JSP引擎）知道这个bean的属性和方法，javabean是有一定上位固定写法的java类，只需要在类的方法命名上遵守一下规则，这个java类就是一个javabean。

1．如果类的[成员变量][Link 1]的名字是xxx，那么为了更改或获取成员变量的值，即更改或获取属性，在类中可以使用两个方法：

getXxx()，用来获取属性xxx。

setXxx()，用来修改属性xxx.。

2． 对于boolean[类型][Link 2]的成员变量，即[布尔逻辑][Link 3]类型的属性，允

许使用"is"代替上面的"get"。

3． 类中访问属性的方法都必须是public的，属性一般是private的。

4． 类中如果有[构造方法][Link 4]，那么这个构造方法也是public的并且是无参数的。

提到javabean就不得不说一下内省了

内省（introSpector）是java语言对javabean类属性、事件的一种缺省（默认）的处理方法。

例如：类A中有属性name，那么我们就可以通过getName,setName来得到其值或者设置新的值。通过getName/setName来访问name属性，这就是默认的原则。

java中提供了一套API用来访问某个属性的getter/setter方法，通过这些API可以使你不需要了解这个规则，这些API存放于包java.beans中。

查看API发现java.beans存在于java.lang包下，属于默认导入的。

javabean就是一种规范，当一个类满足这个规范，这个类就能被其他特定的类调用。一个类被当做javabean使用时，JavaBean的属性是根据方法名推断出来的，因为他的属性全部是私有的外界是无法看到的。去掉set前缀，然后取剩下部分，如果剩下部分的第二个字母是小写的，则把剩余部分的首字母改成小写。

这个过程与spring的设置注入正好相反的，依赖注入是根据一个属性拼写相应的get方法。

说到内省，当然也要谈一下反射了。

JAVA反射机制是通过解析类的内部结构,获得这个类的所有属性和方法,并且可以操作这些属性和调用这些方法。反射技术除了可以使我们开发通用的功能外,还可以让程序在运行时动态的加载并使用最开始不存在的新类。

Java内省是假定一个类符合JavaBean的规范, 使用反射技术解析Java类,把类中的字段和该字段的setter/getter方法关联起来.Java内省主要用来方便的把数据封装到对象中。

下面通过一个小例子来对比一下反射与内省。

现在得到了一个存储了数据的Map对象,把这个Map对象中的数据封装成Student对象

三种方式

1．直接调用Student对象的相应的setter方法

2．使用反射技术

3．使用内省技术

**package** com.shc.javabean2;

**publicclass** Student \{

**private** Stringid;

**private** Stringname;

**privateint**age;

**public** StringgetId() \{

**return**id;

**publicvoid** setId(String id) \{

**this**.id= id;

**public** StringgetName() \{

**return**name;

**publicvoid** setName(String name) \{

**this**.name = name;

**publicint** getAge() \{

**return**age;

**publicvoid** setAge(**int**age) \{

**if** (age < 0) \{

age = 0;

**this**.age = age;

package com.shc.javabean2;

import java.beans.BeanInfo;

import java.beans.Introspector;

importjava.beans.PropertyDescriptor;

import java.lang.reflect.Field;

importjava.lang.reflect.Method;

import java.util.HashMap;

import java.util.Map;

//测试反射与内省

//封装数据到Student对象中

public class Test \{

public static void main(String\[\] args) throws Exception \{

Map<String, Object> map = new HashMap<String,Object>();

map.put("id", "110");

map.put("name", "海超");

map.put("age", 18);

// 创建对象

Student student = new Student();

//1.直接创建方式

System.out.println("（直接方式）封装数据之前:" + student);

packagingStudent(student, map);

System.out.println("（直接方式）封装数据之后:" + student);

//2.使用反射把数据封装到对象中

Student student1 = new Student();

System.out.println("（反射方式）封装数据之前:" + student1);

packagingObject(student1, map);

System.out.println("（反射方式）封装数据之后:" + student1);

//3.使用内省方式把数据封装到对象中

Student student2 = new Student();

System.out.println("（内省方式）封装数据之前:" + student2);

packagingObjectUseIntrospector(student2, map);

System.out.println("（内省方式）封装数据之后:" + student2);

//1.直接方式封装数据到对象中

public static void packagingStudent(Student student,Map<String, Object> map) \{

student.setId((String) map.get("id"));

student.setName((String) map.get("name"));

student.setAge((Integer) map.get("age"));

//2.使用反射把数据封装到对象中

public static void packagingObject(Object obj,Map<String, Object> map)

throws Exception \{

Class<? extends Object> clazz = obj.getClass();

Field\[\] fields = clazz.getDeclaredFields();

for (Field field : fields) \{

String fieldName = field.getName();

// 间接得到setter方法的参数的类型

Class<?> paramType = field.getType();

String methodName = "set" + fieldName.substring(0,1).toUpperCase()

\+ fieldName.substring(1);

Method setMethod = clazz.getDeclaredMethod(methodName,paramType);

setMethod.invoke(obj, map.get(fieldName));

//3.使用内省封装数据到对象中

public static void packagingObjectUseIntrospector(Object obj,

Map<String, Object> map) throws Exception\{

/\*BeanInfo是一个符合JavaBean规范的Java类的描述信息,

可以通过BeanInfo的对象获得所有的字段的描述器PropertyDescriptor

(即包含字段信息和该字段的setter/getter方法)\*/

BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());

/\*BeanInfo的对象通过:

BeanInfo beanInfo = Introspector.getBeanInfo(clazz);

方式获得\*/

// 获得所有字段的属性描述器

PropertyDescriptor\[\] propertyDescriptors = beanInfo

.getPropertyDescriptors();

for (PropertyDescriptor propertyDescriptor : propertyDescriptors)\{

// 获得属性的名称,用来从map对象中取得属性值的

String fieldName = propertyDescriptor.getName();

// 获得set方法

Method setMethod = propertyDescriptor.getWriteMethod();

if (setMethod != null) \{

//Java内省依赖JavaBean设计思想和Java反射

setMethod.invoke(obj, map.get(fieldName));

总结：

我们平时做的项目比较小，都是直接用javabean调用set/get方法，这时候用不上内省与反射。

反射和内省大多时候是在框架中体现的，我们一般用的是面向对象编程的，即:我们写的代码都能找到对应的类或者接口，找到具体的方法写出对应的代码。但是在面向抽象编程的时候，即：我们所写的代码完全抽象，如：我们写的框架所要面向的类或方法目前并没有，而是以后别人用我们的框架写出来的类。但是我们又怎么去调用她们的类的set/get方法呢？这个时候就要用到反射和内省进行抽象编程。

[Link 1]: http://baike.baidu.com/view/684821.htm
[Link 2]: http://baike.baidu.com/view/738155.htm
[Link 3]: http://baike.baidu.com/view/27722.htm
[Link 4]: http://baike.baidu.com/view/595732.htm