Java语言欠缺属性、事件、多重继承功能。所以，如果要在Java程序中实现一些面向对象编程的常见需求，只能手写大量胶水代码。Java Bean正是编写这套胶水代码的惯用模式或约定。这些约定包括getXxx、setXxx、isXxx、addXxxListener、XxxEvent等。遵守上述约定的类可以用于若干工具或库。

// 编译成 java-int-list_1.0.jar
public final class JavaIntList {
  static class Node {
    public Node next;
    public int value;
  }
  public Node head;
  public int size;
}

JavaIntList myList = new JavaIntList();
System.out.println(myList.size);

// 编译成 java-int-list_2.0.jar
public final class JavaIntList {
  static final class Node {
    public Node next;
    public int value;
  }
  public Node head;
  public int getSize() {
    Node n = head;
    int i = 0;
    while (n != null) {
      n = n.next;
      i++;
    }
    return i;
  }
}

然后发布了2.0版：java-int-list_2.0.jar。发布后，原有java-int-list_1.0.jar的用户纷纷升级版本到2.0。这些用户一升级，就发现自己的程序全部坏掉了，说是找不到什么size变量。于是这些用户就把作者暴打一顿，再也不敢用java-int-list库了。

private int size;
public int getSize() { return size; }

让用户一开始就使用getSize，以便有朝一日修改getSize实现时，不破坏向后兼容性。这种public int getSize() { return size; }的惯用手法，就是Java Bean。

现在是2014年，C#、Scala等比Java新的面向对象语言自身就提供了语言特性来实现这些常用需求，所以根本不需要Java Bean这样繁琐的约定。

// 编译成 scala-int-list_1.0.jar
object ScalaIntList {
  final case class Node(next: Node, value: Int)
}
final class ScalaIntList {
  var head: ScalaIntList.Node = null
  var size: Int = 0
}

val myList = new ScalaIntList
println(myList.size)

// 编译成 scala-int-list_2.0.jar
object ScalaIntList {
  final case class Node(next: Node, value: Int)
}
final class ScalaIntList {
  var head: ScalaIntList.Node = null
  final def size: Int = {
    var n = head
    var i = 0
    while (n != null) {
      n = n.next
      i++
    }
    i
  }
}

用户还是照样能用，根本不破坏向后兼容性。所以Scala程序只要不考虑和Java交互，一般就不需要类似Java Bean这样的约定。

• 在java1996年发布,当年12月即发布了java bean1.00-A,有什么用呢?通过统一的规范可以设置对象的值(get,set方法),这是最初的java bean;
  

• 在实际企业开发中,需要实现事务,安全,分布式,javabean就不好用了.sun公司就开始往上面堆功能,这里java bean就复杂为EJB;
  

• EJB功能强大,但是太重了.此时出现DI(依赖注入),AOP(面向切面)技术,通过简单的java bean也能完成EJB的事情,这里的java bean简化为POJO;
  

• Spring诞生了.

----------这里是分隔线 2016年03月13日更新------

• PO(persistence object):用于持久化时(例如保存到数据库或者缓存);
  

• VO(value object):用于前端展示使用(例如放置到JSP中解析或者给前端传递数据)
  

• DTO(data transfer object):用于接口互相调用返回,数据传输(例如很多接口调用返回值或消息队列内容);

特别地,由于class不同,复制时一般推荐 Dozer · springside/springside4 Wiki · GitHub.

----------这里是分隔线 2016年06月13日更新------

这里规范有一个小坑:属性名ICar是合法的,但iCar是非法的..有一个要求(属性前两个字母大小写必须一致)主要是get和set方法无法区分.上面两个属性set方法都是SetICar()

----------这里是分隔线 2014年12月19日以前的答案------

1. 有一个public默认构造器（例如无参构造器,）

2. 属性使用public 的get，set方法访问，也就是说设置成private，同时get，set方法与属性名的大小也需要对应。例如属性name，get方法就要写成，public String getName(){},N大写。

3. 需要序列化。这个是框架，工具跨平台反映状态必须的

对于j2ee的初学者，javabean确实是一个让人容易困惑的概念。
现在来说说我自己的理解。

javabean其实包含多个方面的含义。

1，顾名思义，bean，保存数据的实体，通常与数据库中的表对应。也称为，pojo，entity，domain。比如Person，Apple等，只有private属性和public setxxxx和getxxx。具体实例就是对应表中的一行。那些hibernate，ibatis等orm框架，都支持它们和表的互相映射。

2，这个就比较高大上，也比较抽象了。javabean被称为完成特定功能的组件。不是有高内聚低耦合的说法么？它就是这样一组java类集合。

谢邀！Java bean 在整个Java体系中占据着非常重要的地位，所以理解好Java bean的概念会对你学习Java有非常大的帮助。

本人从事Java行业近十年，目前在某大型上市互联网公司做核心开发人员，同时在内部带领新人培训，在讲解Java知识方面比较有经验。
以我多年经验来看，理解好Java bean后你才能灵活的掌握快速Java开发的技巧。相信我可以帮助你理解Java bean 的概念。

别不信，读完下面的知识再说吧！（内容偏干，大家得自己消化哈！）

1. 基本概念

Java bean 是一种写成的可重用组件。为写成Java bean，类必须是具体的和公共的，并且具有无参数。。
Java bean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性，set和get方法获取。众所周知，属性名称符合这种模式，其他Java 类可以通过自省机制(反射机制)发现和操作这些Java bean 的属性。
Java bean是一种可重用的Java组件，它可以被Applet、Servlet、JSP等Java应用程序调用．也可以可视化地被Java开发工具使用。它包含属性(Properties)、方法(Methods)、事件(Events)等特性。
这些概念使用术语定义会很难理解，不用担心，我会深入浅出的解释其概念。我们都知道，Java面向对象的基本特性有一个是封装，其具体作用就是当我们在设计Java类的时候，不希望外部可以直接调用类的成员变量，这样不利于程序的安全性，所以我们定义成员函数去调用这些成员变量，即get和set方法规范诞生了。
那么根据实体类中我们想要的这些get和set相关成员函数，就可以设计一个公共类，基于Java反射机制，来使用这些函数。
这就是Java bean最初的用处。Java bean也是一种类，只不过是调用其他对象内部成员函数的类。
但是同样需要强调一点，Java bean 在概念上并不是一种技术，而是一种规范。大量的技术人员根据这种规范，开发总结了很多技巧，便于封装使用，便于开发人员快捷开发。

2. 使用规范

由于Java bean是Java公共的类，所以为了使编译工具或集成开发环境识别这种规范，那么我们需要在设计实体类的时候至少应该满足三个条件：
1、类中有一个public无参构造器，默认即可。
2、属性使用public 的get，set方法访问，也就是说设置成private，同时get，set方法与属性名的大小也需要对应。例如年龄属性age，get方法就要写成，public int getAge(){return this.age},其中很明显A要大写。同理，set方法就要写成public void setAge(int age){this.age = age ;}.
3、继承序列化接口，能够实现序列化功能。当然不一定需要直接实现序列化接口，简介继承了实现序列化接口的类也可以。这个是框架，工具跨平台反映状态必须具备的。
如下图设计原则所示。

我将会以代码实例的形式进行分析，这样更利于你们理解。下图中，箭头所指的地方要对照我上面所说的规范来仔细观看，完成之后，你应该就能理解了。

3. 框架中如何使用

说到底，学习Java bean 概念就是为了如何使用。那么我们以在Java Spring boot项目中开发时设计Java实体类为例。
注：软件架构为MVC，共有三层结构，第一层实体类层POJO,第二层数据对象层DAO,第三层业务层（本次不涉及）。
首先同上面所示，在实体类层定义person类，但是要使用注解注明为实体类，为了和数据库交互，同样在属性上表明唯一性。如下图代码所示，此时无需实现序列化接口。

接下来在接口层也就是数据DAO层，定义personDAO接口。

此时继承于JpaRepository类，该类是Java bean实现的一种规范,实现了Java的序列化接口。
如下图所示，系统会根据命名规范，基于反射机制自动获取相关实体类的内部方法，并且可以组合使用。

根据这个机制，我们可以结合数据库获根据Person实体类暴露出的方法，去获取相关的内容，比如说，我在数据库中根据Person的ID号的唯一性获取所有的Person，或者根据特定的ID号获取某一个Person，这都是可以基于Java bean规范实现的。如下图代码所示。

使用@Query注解的原因是，为了方便我们获取person对象的内容，自定义SQL语句，这样更加方便准确。
其中getAllByID()方法是根据ID获取所有的person，而第二个getByID(int ID)方法是根据某个特定的ID获取person。
当然了，如果你觉得上面代码实例不够多，需要更多的代码去参考，可以去看视频，去听网课。我目前在开课吧上课，里面的老师讲的项目都是企业实战项目，对于我们提升java各方面的知识非常有帮助，而且这些项目都是企业级别的，对于我们以后上班也是非常有帮助。本人从事Java开发多年，依旧可以在上面学习到很多知识，非常值得尝试，链接在下面，大家可以上去看看！

四、使用Java bean的优点

其实从Java bean的定义你也能有个较为清晰的认识，那就是可重用性，Java bean就是使用Java语言开发的一个可重用的组件（遵循一定规则的普通公共Java类）。设计之初也同样是为了解决重用性问题。这是其标志性的特定之一。

Java bean在Swing客户端开中发有非常重要的地位，由于Swing中使用大量的组件，而Java bean可以实现界面和代码分离，利于实际工程中的后续维护和扩展问题。

总结来讲，Java bean有以下几点优点。
1、提高代码的可复用性：对于通用的事务处理逻辑，数据库操作等都可以封装在Java bean中，通过调用Java bean的属性和方法可快速进行程序设计。
2、程序易于开发维护：实现逻辑的封装，使事务处理和显示互不干扰。
3、支持分布式运用：多用Java bean，尽量减少java代码和HTML代码的混编。

读完我的回答，你对Java bean有了一个较为清晰的认识了吗？

什么是JavaBean？

JavaBean实际上是指一种特殊的Java类，它通常用来实现一些比较常用的简单功能，并可以很容易的被重用或者是插入其他应用程序中去。所有遵循“一定编程原则”的Java类都可以被称作JavaBean。

JavaBean是一个遵循特定写法的Java类，是一种Java语言编写的可重用组件，它的方法命名，构造及行为必须符合特定的约定：

1、这个类必须具有一个公共的(public)无参构造函数；

2、所有属性私有化（private）；

3、私有化的属性必须通过public类型的方法（getter和setter）暴露给其他程序，并且方法的命名也必须遵循一定的命名规范。

4、这个类应是可序列化的。（比如可以实现Serializable 接口，用于实现bean的持久性）

JavaBean在Java EE开发中，通常用于封装数据，对于遵循以上写法的JavaBean组件，其它程序可以通过反射技术实例化JavaBean对象（内省机制），并且通过反射那些遵循命名规范的方法，从而获知JavaBean的属性，进而调用其属性保存数据。

因为这些要求主要是靠约定而不是靠实现接口，所以许多开发者把JavaBean看作遵从特定命名约定的POJO。（可以这么理解，POJO按JavaBean的规则来，就可以变成JavaBean）。

简而言之，当一个POJO可序列化，有一个无参的构造函数，使用getter和setter方法来访问属性时，他就是一个JavaBean。（没毛病！）

------------------------------------

JavaBean是一种组件技术，就好像你做了一个扳手，而这个扳手会在很多地方被拿去用，这个扳子也提供多种功能(你可以拿这个扳手扳、锤、撬等等)，而这个扳手就是一个组件。

◇对于JavaBean，就是一个Java模型组件，他为使用Java类提供了一种标准的格式，在用户程序和可视化管理工具中可以自动获得这种具有标准格式的类的信息，并能够创建和管理这些类。

◇JavaBean可以使应用程序更加面向对象，可以把数据封装起来，把应用的业务逻辑和显示逻辑分离开，降低了开发的复杂程度和维护成本！

◇JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBeans 通过提供符合一致性设计模式的公共方法将内部域暴露称为属性。众所周知，属性名称符合这种模式，其他Java 类可以通过内省机制发现和操作这些JavaBean 属性。

◇通常情况下，由于 Java Bean 是被容器所创建（如 Tomcat) 的，所以 Java Bean 应具有一个无参的构造器，另外，通常 Java Bean 还要实现 Serializable 接口用于实现 Bean 的持久性。 Java Bean 是不能被跨进程访问的。

◇JavaBean 是使用 java.beans 包开发的，它是 Java 2 标准版的一部分。JavaBean 是一台机器上同一个地址空间中运行的组件。JavaBean 是进程内组件。

什么是Bean？

Bean的中文含义是“豆子”，Bean的含义是可重复使用的Java组件。所谓组件就是一个由可以自行进行内部管理的一个或几个类所组成、外界不了解其内部信息和运行方式的群体。使用它的对象只能通过接口来操作。

Bean并不需要继承特别的基类(BaseClass)或实现特定的接口(Interface)。Bean的编写规范使Bean的容器(Container)能够分析一个Java类文件，并将其方法(Methods)翻译成属性(Properties)，即把Java类作为一个Bean类使用。Bean的编写规范包括Bean类的构造方法、定义属性和访问方法编写规则。

Java Bean是基于Java的组件模型，由属性、方法和事件3部分组成。在该模型中，JavaBean可以被修改或与其他组件结合以生成新组件或完整的程序。它是一种Java类，通过封装成为具有某种功能或者处理某个业务的对象。因此，也可以通过嵌在JSP页面内的Java代码访问Bean及其属性。

作者：chunlynn

来源：CSDN

原文：https://blog.csdn.net/chenchunlin526/article/details/69939337

Bean的中文含义是“豆子”，顾名思义JavaBean是一段Java小程序。JavaBean实际上是指一种特殊的Java类，它通常用来实现一些比较常用的简单功能，并可以很容易的被重用或者是插入其他应用程序中去。所有遵循一定编程原则的Java类都可以被称作JavaBean。

一. Java Bean技术概述

Java Bean是基于Java的组件模型，由属性、方法和事件3部分组成。在该模型中，JavaBean可以被修改或与其他组件结合以生成新组件或完整的程序。它是一种Java类，通过封装成为具有某种功能或者处理某个业务的对象。因此，也可以通过嵌在JSP页面内的Java代码访问Bean及其属性。

Bean的含义是可重复使用的Java组件。所谓组件就是一个由可以自行进行内部管理的一个或几个类所组成、外界不了解其内部信息和运行方式的群体。使用它的对象只能通过接口来操作。

二. Java Bean编写规范

Java Bean实际上是根据JavaBean技术标准所指定Bean的命名和设计规范编写的Java类。这些类遵循一个接口格式，以便于使函数命名、底层行为以及继承或实现的行为，其最大的优点在于可以实现代码的可重用性。Bean并不需要继承特别的基类(BaseClass)或实现特定的接口(Interface)。Bean的编写规范使Bean的容器(Container)能够分析一个Java类文件，并将其方法(Methods)翻译成属性(Properties)，即把Java类作为一个Bean类使用。Bean的编写规范包括Bean类的构造方法、定义属性和访问方法编写规则。

2.1. Bean组件的工作机制

在JavaBeansVersion1.01 A规范中定义了该组件的5种重要机制：

（1）内省(Introspection)：组建可以发表其支持的操作和属性，同时也支持在其他组件中发现重复利用的对象库，如用户权限控制和电子邮件自动回复等。

（2）通信(Communication)：生成和收集组件的消息事件。

（3）持续(Persistence)：存放组件的状态。

（4）属性(Properties)：支持组件布局的控制，包括组件占用的空间和组件的相对位置。

（5）定制(Customization)：开发者可控制组件所需的改变机制。

2.2. Java Bean的编写要求

编写JavaBean必须满足以下几点要求：

（1）所有的JavaBean必须放在一个包(Package)中。

（2）JavaBean必须生成public class类，文件名称应该与类名称一致。

（3）所有属性必须封装，一个JavaBean类不应有公共实例变量，类变量都为private。

（4）属性值应该通过一组存取方法（getXxx 和 setXxx）来访问：对于每个属性，应该有一个带匹配公用getter 和 setter方法的专用实例变量。

（5）Java Bean 类必须有一个空的构造函数：类中必须有一个不带参数的公用构造器，此构造器也应该通过调用各个属性的设置方法来设置属性的默认值。

2.3. Java Bean的命名规范

Java Bean的命名规范如下：

（1）包命名：全部字母小写。

（2）类命名：每个单词首字母大写。

（3）属性名：第一个单词全部小写，之后每个单词首字母大写。

（4）方法名：与属性命名方法相同。

（5）常量名：全部字母大写。

2.4. Java Bean的包

包即package，JavaBean的包和前面章节中介绍的包含义基本上是一样的，但是也有区别，前面介绍的包都是Java本身定义的，而JavaBean的包是用户自己定义的。

每一个JavaBean源文件被编译成.class文件后，都必须存放在相应的文件夹下，存放这个.class文件的文件夹就是一个包。JavaBean的包必须存放在特定的目录下，在每个JSP引擎中都规定了存放JavaBean包的位置，不同的JSP引擎对JavaBean存放的位置有不同的规定，如在Tomcat中，JavaBean的所有包都存放在WEB-INF/classes文件夹中。如果存在多级目录，则需要将.class文件所在目录的所有上级目录包含到包名称中，每一级目录之间用英文标点“.”隔开。例如下面代码：packagejsp.example.mybean；

2.5. Java Bean的结构

（1）属性：即Java Bean类的成员变量，用于描述JavaBean对象的状态，对象属性值的改变触发事件，属性本身就是事件源。

（2）方法：在Java Bean中，函数和过程统称为方法，通过方法来改变和获取属性的值。方法可以分为构造方法、访问方法和普通方法等。

（3）事件：事件实际上是一种特殊的Java Bean，属性值的改变触发事件，事件激发相关对象作出反应，通过Java Bean注册对象事件监听者机制来接收、处理事件，它实现了Java Bean之间的通信。

三. Java Bean属性

在上一节中我们简单提到了JavaBean的属性，Java Bean的属性与一般Java程序中所指的属性，或者说与所有面向对象的程序设计语言中对象的属性是一个概念，在程序中的具体体现就是类中的变量。属性分为四类，即单值(Simple)、索引(Index)、关联(Bound)和约束(Constrained)属性。本节将对这些属性进行详细说明。

3.1. 单值(simple)属性

单值(Simple)属性是最普通的属性类型，该类属性只有一个单一的数据值，该数据值的数据类型可以是Java中的任意数据类型，包括类和接口等类型。

定义了属性，还需定义对应的访问方法，一般每个单值属性都伴随有一对get/set方法。属性名与和该属性相关的get/set方法名对应。例如如果有一个名为“xxx”的属性，则会有setXxx和getXxx方法。

另外，布尔(Boolean)属性是一种特殊的单值属性，它只有两个允许值：true和false，如果有一个名为“xxx”的布尔属性，则可以通过isX方法访问。

3.2. 索引(Indexed)属性

如果需要定义一批同类型的属性，使用单值属性就会显得非常烦琐，为解决此问题，JavaBean中提供了索引(Indexed) 属性，索引属性是指JavaBean中数组类型的成员变量。使用与该属性对应的set/get方法可取得数组的值。索引属性通过对应的访问方法设置或取得该属性中某个元素的值，也可以一次设置或取得整个属性的值。

3.3. 关联(Bound)属性

关联(Bound)属性是指当该种属性的值发生变化时，要通知其他的对象。每次属性值改变时，这种属性就触发一个PropertyChange事件(在Java程序中，事件也是一个对象)。事件中封装了属性名、属性的原值、属性变化后的新值。这种事件传递到其他的Beans，至于接收事件的Beans应做什么动作，由其自己定义。

属性的改变称为JavaBean事件。外部与Java Bean这些事件相关的类对象称为监听者(Listener)。监听者可能只对JavaBean某一属性相关的事件有兴趣，也可能对所有属性相关的事件有兴趣，因此JavaBean提供两类事件监听者注册和注销的方法，即全局事件监听者注册、注销的方法和一般事件监听者注册、注销的方法。

3.4. 约束(Constrained)属性

Java Bean的属性如果改变时，相关的外部类对象首先要检查这个属性改变的合理性再决定是否接受这种改变，这样的JavaBean属性叫约束(Constrained)属性。当约束属性的改变被拒绝时，改变约束属性的方法产生一个约束属性改变异常(PropertyVetoException)，通过这个异常处理，JavaBean约束属性还原回原来的值，并为这个还原操作发送一个新的属性修改通知。

约束属性的改变可能会被拒绝，因此它的setXxx与一般其他JavaBean属性的setXxx也有所不同。约束属性的写方法如下：

public void setXxx(xxxType newXxx)throws PropertyVetoException

四. Java Bean方法

4.1. 构造方法

Java Bean的构造方法与与之前的普通java类的构造方法意思是一样的，就是对JavaBean的属性及其方法进行初始化，即对所定义的属性及方法设一个初始值，构造方法名要和JavaBean的类名相同。

4.2. 访问方法

在定义了Bean的属性，并通过构造方法将其初始化后，要让其他程序访问Bean的这些属性，就必须为其创建访问方法。访问方法就是对组件中定义的属性的访问，包括读和写两种访问方式。读就是一种用于取出Bean属性的值的取值函数，即getter；而写则是一种用于设置Bean属性的赋值函数，即setter。以下列出的就是Bean属性访问方法的具体语法格式：

public void setPropertyName(PropertyTypevalue);//给属性赋值，即写方法

public PropertyType getPropertyName();//读取属性值，即读方法

4.3. 一般方法

除了对属性的访问方法外，还可以在Bean创建一般方法来实现对函数的调用，只要将Bean中的一般方法定义成公有的方法，就可以供其他程序调用。

五. Java Bean事件

事件处理是JavaBeans体系结构的核心之一。通过事件处理机制，可让一些组件作为事件源，发出可被描述环境或其他组件接收的事件。这样，不同的组件就可在构造工具内组合在一起，组件之间通过事件的传递进行通信，构成一个应用。从概念上讲，事件是一种在“源对象”和“监听者对象”之间某种状态发生变化的传递机制。事件有许多不同的用途，例如在Windows系统中常要处理的鼠标事件、窗口边界改变事件、键盘事件等。

5.1. 事件模型

Java Bean事件模型如图所示，事件源是一个JavaBean类对象，它把属性改变的时间对象传递给事件监听者，事件监听者负责事件的处理。事件监听者必须在事件源注册。

5.2. 事件状态对象

与事件发生有关的状态信息一般都封装在事件状态对象 (EventState Object) 中，这种对象是java.util.EventObject的子类。按设计习惯，这种事件状态对象类的名应以Event结尾。例如代码是一个鼠标移动事件实例。

5.3. 事件监听者接口与事件监听者

由于Java事件模型是基于方法调用的，因此需要一个定义并组织事件操纵方法的方式。JavaBeans中，事件操纵方法都被定义在继承了java.util.EventListener类的事件监听者(EventListener)接口中，按规定，EventListener接口的命名要以Listener结尾。任何一个类如果想操纵在EventListener接口中，定义的方法都必须以实现这个接口方式进行。这个类就是事件监听者。例如如下代码：

//先定义了一个鼠标移动事件对象

public class MouseMovedExampleEventextends java.util.EventObject {

//在此类中包含了与鼠标移动事件有关的状态信息

...

}

//定义了鼠标移动事件的监听者接口

interface MouseMovedExampleListener extends java.util.EventListener {

//在这个接口中定义了鼠标移动事件监听者所应支持的方法

void mouseMoved(MouseMovedExampleEvent mme);

}

5.4. 事件监听者注册与注销

为了让各种可能的事件监听者把自己注册入合适的事件源中，就建立源与事件监听者间的事件流，事件源必须为事件监听者提供注册和注销的方法。在实际中，事件监听者的注册和注销要使用以下标准的设计格式：

public void add<ListenerType>(< ListenerType> listener);

public void remove<ListenerType>(< ListenerType> listener);

下面是一个具体的实例，首先定义了一个事件监听者接口：

import java.util.*;

public interface ModelChangedListenerextends EventListener

{ void modelChanged(EventObjecte);}

5.5. 适配类

适配类是Java事件模型中极其重要的一部分。在一些应用场合，事件从源到监听者之间的传递要通过适配类来“转发”。例如：当事件源发出一个事件，而有几个事件监听者对象都可接收该事件，但只有指定对象做出反应时，就要在事件源与事件监听者之间插入一个事件适配器类，由适配器类来指定事件应该是由哪些监听者来响应。适配类成为了事件监听者，事件源实际是把适配类作为监听者注册入监听者队列中，而真正的事件响应者并未在监听者队列中，事件响应者应做的动作由适配类决定。目前绝大多数的开发工具在生成代码时，事件处理都是通过适配类来进行的。

• 假如同一类型的数据存在三份文件中,分别以csv,json,xml的方式存储

• 你找张三写一个代码,读取这三份文件,然后把每一份数据再投递到 mysql,MongoDB,kafka 上.

• 如果不用 javabean,你接手张三的代码,会看到存在 3* 3 共 9 种的数据处理和对应关系

• 分别为

• csv -> mysql

• csv -> mongodb

• csv -> kafka

• json ->mysql

• json->mongodb

• json->xml

• xml->mysql

• xml->mongodb

• xml->kafka

• 你会看得眼花缭乱,而且要经常打开到源文件里确认数据结构和同时要到目标里去确认数据结构

• 这是一种 N 对 N 的关系,而且以后要更改需求的话,还会至少会产生6*2 共 12 种的数据对应和处理关系,这样总共会有 21 种复杂的数据格式之间的关系

• 如果用 javabean,你接手张三的代码,会发现代码中 只会存在 6 种关系

• 分别为

• csv->javaBean

• json->javaBean

• xml->javaBean

• javaBean->mysql

• javaBean->mongodb

• javaBean->kafka

• 你会非常清晰,而且实际上 这三种源数据和三种目标数据都会映射为 JavaBean,所以在逻辑上其实只有一个数据格式,你不需要翻开不同的文件去看原始的数据格式,也不需要打开数据库去看数据库的数据格式,只需要专心处理一个JavaBean即可

• 这是一种 1 对 N 的关系,如果以后要更改需求的话,最终数据关系总共仍然只有 6 种关系

不一定非要是 javaBean,但是一定要实现类似的功能

Javabean没啥高大上的。就是满足一定规范的Java类而已。
类必须是public的、属性是private的、有无参数的构造方法、有getter和setter方法、实现java.io.serializable接口的就叫Java bean(这一项并不是什么时候都需要。)

至于这么做的目的:方便别人调用你的类，比如spring框架autowired。

对Java Bean的初步理解：

Java Bean 就是Java里一种可以复用的类，经过系统编译后生成一个.class的文件。

将一个具体的实例进行抽象化得到的属性，根据JAVA API规定书写出来的类，其中包含get()和set()两种方法。

例如一个人一定会有名字这一个属性，那我们就把这个属性包装到一个类里，只要程序里调用到人，我们就可以通过这个类设置和得到这个人的姓名。

public class person{
	
	private String name;
	
	public String getName(){
		return this.name;
	}
	
	public String setName(String Name){
		return this.name = name;
	}
	
}

怎样调用Java Bean?

工作当中一般接触的是传统的调用方式。

后台service调用方法：

public String main(){
	//实例初始化
	person man = new person();
	//姓名
	man.setName("ABC");
        //返回值
	return man.getName();
}

前台JSP调用方法：

<%@ page language="java" import="com.anllin.bean.Person" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP 'javabean.jsp' starting page</title>
  </head>

  <body>
    <!--------导入javaBean类,声明javaBean对象------!>
    <jsp:useBean id="person" class="com.anllin.bean.Person"></jsp:useBean>
    <!--------访问javaBean属性--------------------!>
    <jsp:setProperty property="name" name="person" value="jack"/> 
    <jsp:getProperty property="name" name="person"/><br>
  </body>
</html>

Java Bean和JSP的关联 1.可以在<jsp:setProperty>中通过param参数为bean的属性动态赋值。

<jsp:setProperty property="age" name="person" param="sname"/><br>

sage表示参数名,而不是属性 在浏览器地址栏中输入 http://localhost:8080/test/javabean.jsp?sage=JK 则可以得到name属性的值JK

2.Javabean的存活范围

课题：区分page,request,session,application之间的差别以及它们的生命周期。

==========================================================================

CSDM：*********************

JavaBeans是Java中一种特殊的类，可以将多个对象封装到一个对象（bean）中。特点是可序列化，提供无参构造器，提供getter方法和setter方法访问对象的属性。名称中的“Bean”是用于Java的可重用软件组件的惯用叫法。

一开始，我们封装一个对象的时候，以汽车对象为例子：

public class car {
	/**
	 * 这是一个五座小汽车
	 */
	
	private int 车轮 = 4 ;
	private int 方向盘 = 1;
	private int 座位 = 5;
	
	
	public int get车轮() {
		return 车轮;
	}
	public void set车轮(int 车轮) {
		this.车轮 = 车轮;
	}
	public int get方向盘() {
		return 方向盘;
	}
	public void set方向盘(int 方向盘) {
		this.方向盘 = 方向盘;
	}
	public int get座位() {
		return 座位;
	}
	public void set座位(int 座位) {
		this.座位 = 座位;
	}
	
}

一开始学习的java的时候，我们把上述代码称之为一个对象类，而到了后期，我们称之为一个javaBean。因为后期java为了便于操作数据，通常是使用对象为容器，把需要操作的数据赋值给对象，而为了便于赋值，那我们必须要有这种get/set方法。

总结如下：

1、所有属性为private

2、提供默认构造方法

3、提供getter和setter

4、实现serializable接口

看了回答，有种你越说我越不明白了的感觉。如果有人从来没见过苹果，问苹果是什么。那么你回答苹果是一种水果，这就可以得80分了。如果你再说说苹果是长在树上的，苹果的大小和形状，颜色和味道，这就可以得90分了。

我看到无论是这里，还是其他网站，全都是一些越说让人越不明白的说法，比如：苹果是一种可见的东西，人能看见苹果，动物也能看见它。苹果可以放在餐桌上，也可以放到机器中加工一下（还可以长篇大论加工细节）。你可以在超市买到它。它可以送人...。

我想知道苹果是什么！

我不知道我理解的对不对：java bean 是一个类（类的实例？），如果是对的，我觉得这个回答就可以得60分了。 （我看到百度百科是一个什么组件，我一点 也不明白）。然后这个类有什么区别于其他类的特征，说清楚说全了就可以得90分以上了。---如果我理解不对，这一段话忽略。

Bean是一个可重用的软件构件，能够在开发工具中可视化地操作。

• Bean有一个默认的无参构造器。

• 属性修饰符为：private 。

• 实现接口 java.io.Serializable 。

• 所有访问器方法都以get开头，所有的修改器方法都以set开头，布尔类型的属性最好使用 is/set 命名模式。

• JavaBean 持久化，适合于长期存储。用 JavaBean 的属性来将 bean 存储到流中，并在之后的某个时刻，或者在另一个虚拟机中再将它们读回来。

首先，J2EE最常见的一个操作就是从数据库里调用一些数据。然后到java程序里使用。

最常见的关系型数据库里面的数据都是列表形式。

比如有个表叫学生信息，这个表有很多列，每一列分别是学生的姓名，学号，班级，出现年月日等等信息。

如果我们把这样的信息导入java程序，最合适的载体是什么？

当然是先创建一个名叫学生信息的类，然后在这个类里面再定义姓名，学号，班级等等field。

然后每次从数据库把这些信息调出来时，就用这个类创建一个对象，然后把数据库里的值，一一对应的设置在这个对象的field上。

然后我们再来考虑一件事，企业级应用一般不会只有一个人来写，而是更倾向于分工合作。

假如你的同事写一个方法，需要用一个学生的名字，另一个同事写一个方法，需要用一个学生的学号，又有一个同事写一个方法，需要调用另外两个同事写的方法。如果每个人在自己写的方法里都只调用自己需要的那个field，方法之间协同合作性就差了，为了保证协同合作性，产生了一个规定，即使你想要的只有这个学生的学号，在传输数据的时候，你也得把整个学生的对象传过来。对象，是传输数据时，最小的操作单位，就像一个豆子（bean）一样，又小又完整。

提到分工合作，我们又得想到另一件事。

写程序有的程序需要有人来写bean这种，用来储存数据的东西，也有人要写一些复杂的逻辑。

这种事自然是让两个人分开干比较好。最好能避免两个人都在同一个文件里写代码，很容易产生冲突。

那到了实践上，我们奉行的原则就是，bean就是用来储存数据的，不要写有复杂逻辑的方法了（除非一些极特殊情况）。如果要写逻辑，在其他地方写。bean里面只会放一些和储存信息，读取信息有关的方法，比如getter,setter，以及方面更多数据结构使用的equals和hashcode.

总结来说，

bean就是一种特殊的类，首先，这个类一般会和数据库里某个表对应；这个类的每个field会和表的列对应；把数据库里某一行数据提取出来，放进java,java就会通过创建一个对象来储存这些信息。

第二，为了统一信息传输模式，我们在传输有关这个类的信息时，最小也会传输一个对象，不会再进一步精确到对象内部的field了。

第三，为了方便分工合作，bean里面就不写带有复杂逻辑的方法。

————————————————————————————————————————

看了看别的答主的答案，感觉自己说的并不严谨，但是我也觉得核心思想我已经说出来了，其他方向更多是处于别的考虑。

比如说为什么一定要写getter setter？因为spring等主流java框架通过getter和setter来从一个对象取值赋值。

比如为什么要private每一个field? 更多是为了数据安全或者让这个bean immutable以保证多线程时不出问题。

为什么要serializable? 可能是有些框架直接使用对这个类的io来把这个数据存进数据库，取出数据库，就我所知，在spring框架下这是没必要的。

记下一些严谨的标准也是好事，不过不一定非要这么严苛，很多IDE都支持对bean的基础方法的自动生成，只要你把所有field写下来，鼠标点点就能生成合格的bean了。所以理解了思想最重要。

懒得说那么多。

bean就是他妈的一个类；

这个类里只有属性与getter/setter方法；

至于有什么用，你懂的。

请问一下spring中的bean和普通的javabean有什么区别吗  ？

一个servlet一个dao都可以是一个bean通过依赖注入创建对象，但是javabean不是必须要有getter和setter方法吗

java bean 是一种特殊一点的java类，java开拓者们为了让后来的蠢蛋程序猿少捅出一些篓子，不厌其烦的规定了一些规范，比如不要随便把类里的属性搞成public 而是用public方法get/set等去操作，要加上序列化等，符合的就叫java bean。

不谈概念，只谈用处的话，javabean，或更精确的说是目前更流行的pojo，广泛用于分层开发中进行数据交换。
一般而言，pojo与数据表结构对应。逻辑层与数据层之间只通过 pojo进行交换。如
db.save(pojo);
pojos=  db.find(sql);
如此逻辑层不用去考虑复杂的sql拼接问题更关注于具体逻辑过程，从而使系统更有条理。
而表现层与逻辑层之间也可以使用pojo+模板引擎的方式进行处理。

笔记：简单笼统的说就是一个类,就是用来设置数据的属性和一些行为,用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。

Java bean 是一个标准。只有符合这个标准的类才能叫做bean。为什么要符合这个标准呢？因为符合这个标准才好被Spring Container调用。

比如你去饭馆点红烧肉，服务员端上来以后，你会瞅一眼看一下，这肉是不是五花肉做的，这色儿是不是焦糖色等等。总之，你会用一套红烧肉的标准来判断服务员上的是不是红烧肉。

对于Java Bean来说这套标准就是：

1. 类中的全局变量的属性为private;
2. 类中要有无参构造函数
3. 类中要有getter,setter方法
4. 这个类要继承Serializable接口

那符合Bean的类长什么样呢？这就是符合Java Bean标准的Employee类（员工类）。这样的员工类才能被叫做bean，不这么写的员工类都不是bean.

@Entity
public class Employee implements Serializable{ //继承Serializable接口

   @Id
   private int id;//属性private
   private String name;   
   private int salary;  

   public Employee() {}//无参构造方法

   public Employee(String name, int salary) {
      this.name = name;
      this.salary = salary;
   }
   public int getId() {
      return id;
   }//get方法
   public void setId( int id ) {
      this.id = id;
   }//set方法
   public String getName() {
      return name;
   }
   public void setName( String name ) {
      this.name = name;
   }
   public int getSalary() {
      return salary;
   }
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

其他的答案真是。。。不是云里雾里说不到点子上，就是说了一半还是让人不能get到。这就是知识壁垒吧？

你从来没听过 C bean 或者 Go bean 吧，在C和Go里面，有一种叫做 struct 的数据结构，可以由程序员自行设计编写。这种可自定义的，没有业务逻辑的数据类型，像 int string 类型一样易用，可用于赋值传参编码，定义和使用都很高效很好用。

type Person struct {
 Name string
 Age int
}

var p1 Person
var p2 Person

p1.Name = "name"
p1.Age = 20

bytes, _ := json.Marshal(p1)
json.Unmarshal(bytes, &p2)

print(p2)

而 Java 里并没有 struct 这东西，一切都是class，只写 Java 的程序员，因认知里少了这种很好用的数据结构，经常发生惨无人道的编写灾难。

然后大家发现不行，定了个 JavaBean 这样的名词，将类写成特定样子去模拟 struct。

实质就是想要一种单纯，简单，可自定义的结构化数据类型罢了。至于需要 setter getter 之类的私有化封装只是为了迎合 Java 那一套复杂的 OOP规则。

（其实就是给 Java 这门语言填坑）

这玩意儿在 Kotlin 里叫 data class，起码命名上算是清晰了一点点了，不承载代码逻辑的class。

有字段,有getset方法,实现了序列化接口

JavaBean是特殊的Java类，使用J ava语言书写，并且遵守JavaBean API规范。

接下来给出的是JavaBean与其它Java类相比而言独一无二的特征：

• 提供一个默认的无参构造函数。

• 需要被序列化并且实现了Serializable接口。

• 可能有一系列可读写属性。

• 可能有一系列的"getter"或"setter"方法。

javaBean分广义上的javaBean和狭义上的javaBean。

广义javaBean：一个普通的java类。

狭义javaBean：遵循了一定规范的java类（这里的规范有两点）。

第一：属性首字母小写而且是被private关键字修饰（OOP原则：隐藏数据）

第二：属性有对应的getters和setters方法（目的：读值和改值，对数据控制起来更加灵活）

使用javaBean的好处（结合servlet连接数据库理解）：

封装好各种常用的方法，不用重复写，而是用的时候直接调用。

比如：连接数据库常用的方法没必要每次都写一遍，而是统一封装到一个类里面，用到的时候直接调用，使用javaBean的原理和把连接数据库常用的方法封装到一个类里面意思是一样的。

JAVA BEAN也是一个普通的JAVA类，一般来说就是具有set（和/或）get方法，通过这两个方法来暴露属性，以便能被框架探测并使用，这样JAVA BEAN就称为了数据，成为有用的组件，以便提供服务。JAVA BEAN最具吸引力的就是可以用Introspect和BeanInfo来对其进行反射操作。并且自然具备IOC的要求。

最初，JavaBean的目的是为了将可以重复使用的软件代码打包标准。特别是用于帮助厂家开发在综合开发环境(IDE)下使用的java软件部件。这些包括如Grid控件，用户可以将该部件拖放到开发环境中。从此，JavaBean就可以扩展为一个java web 应用的标准部件，并且JavaBean部件框架已经扩展为企业版的 Bean(EJB)。

Java语言欠缺属性、事件、多重继承功能。所以，如果要在Java程序中实现一些面向对象编程的常见需求，只能手写大量胶水代码。Java Bean正是编写这套胶水代码的惯用模式或约定。这些约定包括getXxx、setXxx、isXxx、addXxxListener、XxxEvent等。

一种类的规范，要满足以下要求

1. 类必须被public修饰
2. 必须提供空参的构造器
3. 成员变量必须使用private修饰
4. 提供public的setter和getter方法

JavaBean是一个满足一定规范的Java类，是可重用的Java程序组件。

Java是一种咖啡的名称。Bean是豆子。连起来就是咖啡豆。

这个咖啡豆（JavaBean）的用法是：放到某个容器（某种Java程序，对外提供接口，Javabean通过接口与容器进行交互）中可以运行，以执行所相关的某些功能。
运行程序好比泡咖啡，把Java咖啡的咖啡豆JavaBean放在容器（茶杯）中，就实现了一个程序（泡好了一杯咖啡）。

一个标准的类

从前面我们知道Spring其实就是一个大型的工厂，而Spring容器中的Bean就是该工厂的产品.对于Spring容器能够生产那些产品，则取决于配置文件中配置。
对于我们而言，我们使用Spring框架所做的就是两件事：开发Bean、配置Bean。对于Spring矿建来说，它要做的就是根据配置文件来创建Bean实例，并调用Bean实例的方法完成“依赖注入”。
一、Bean的定义
<beans…/>元素是Spring配置文件的根元素，<bean…/>元素师<beans../>元素的子元素，<beans…/>元素可以包含多个<bean…/>子元素，每个<bean…/>元素可以定义一个Bean实例，每一个Bean对应Spring容器里的一个Java实例定义Bean时通常需要指定两个属性。
Id：确定该Bean的唯一标识符，容器对Bean管理、访问、以及该Bean的依赖关系，都通过该属性完成。Bean的id属性在Spring容器中是唯一的。    
Class：指定该Bean的具体实现类。注意这里不能使接口。通常情况下，Spring会直接使用new关键字创建该Bean的实例，因此，这里必须提供Bean实现类的类名。

偶然看到一篇文章，这里引用开头的一部分，对于Java Bean介绍的很细致了。

文章是对 李刚《轻量级Java EE企业应用实战》 的一篇读书笔记。

原文链接：

概念性知识推荐读书，系统性学习。

JavaBean仅仅是一种规范，规范大家如何去写一个普通Java类。

规范包括

• 类中所有属性都是private，提供getter/setter方法

• 提供public的无参构造函数

• 实现Serializable接口

也就是说，仅仅是一种约定而已。但是很多库的实现依赖这种约定。

为啥要有这个概念呢。举例来说，如果一个函数想要序列化一个你传入的对象，如果约定了传入的是JavaBean，这个函数就知道它可以序列化，对象实现了serializable接口。

简单来说是一种符合某种规范的java类，他按照一定规范来写以方便复用代码。比如说method一定要是public的，而attribute（属性）一定要是private，主要是为了隐藏数据。然后因为是private的属性，所以在class里面一定存在getter（）和setter（）这种方法来得到class内部的属性，或者改写class的属性。此外，还需要一个没有参数的constructor（构造函数）用于实体化。最后他实现了java.io.Serializable的接口。

Irene

=================================================

麦粒学院

您的国际课程专家营

旨在为国际教育体系下的中国学生以及海外留学生提供全方位的学术支持

更多学科干货内容，可关注我们的订阅号：MA麦粒er

1.javabean就是一个普通的java类

2.这个类遵循一定的规范.比如有get/set方法

3.这个类中的类属性对应数据库中的表的字段。便于封装成对象…

绝大多数程序员用不到 get和set方法。把所有字段直接public也没有什么问题。不要担心什么接口会变得问题，这跟普通程序员没有关系。你的数据库字段都会变，难道上层的代码能不变？普通程序员写的代码不是给其他程序员用的，而是给一个字节等于8个比特都不知道的普通用户使用。这些普通用户会关心你是用了 get set 还是直接public的字段？

good!

一串可以重用的代码！

Java Bean的设计目的

1、紧凑方便地创建和使用

2、完全的可移植性

3、继承Java的强大功能

4、开发工具支持

5、分布式计算支持

Java Bean定义为“一种在开发工具中可视化操作的，可复用的，平台独立的软件组件“

Java Bean的特性

1、支持自检：构造器可以分析bean怎样工作；

2、支持定制：用户使用构造器工具定制bean的外观和行为；

3、支持事件处理：bean才能与外部进行通信；

4、支持属性：bean才能具有内容的状态，便于定制和应用开发；

5、支持永久性：bean才能在应用程序构造器工具中定制，并将定制的状态存储起来便于随时使用。