Question

我认为，我认为“Bean”是一个带有属性和getter / setter的Java类。据我所知，它相当于C结构。这是真的吗？

此外，bean和普通类之间是否存在真正的语法差异？有没有特殊的定义或界面？

基本上，为什么会有这个术语？

修改：如果您能够如此友善并添加有关Serializable界面的信息及其含义。

对你的回答，我将非常感激。

Answer 1

JavaBean只是standard

所有属性私有（使用getters/setters）
公众no-argument constructor
实施Serializable。

就是这样。这只是一个惯例。很多图书馆都依赖它。

关于Serializable，来自API documentation：

类的可序列化由实现该类的类启用 java.io.Serializable接口。没有实现此功能的类接口不会将其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。该序列化接口没有方法或字段，仅用于确定可序列化的语义。

换句话说，可序列化的对象可以写入流，因此文件，对象数据库，任何东西都可以。

此外，JavaBean与另一个类之间没有语法差异 - 如果一个类符合标准，则该类是JavaBean。

有一个术语，因为标准允许库以编程方式使用您以预定义方式定义的类实例来执行操作。例如，如果一个库想要传递你传递给它的任何对象，它知道它可以，因为你的对象是可序列化的（假设lib要求你的对象是适当的JavaBeans）。

Answer 2

有一个术语让它听起来很特别。现实远不是那么神秘。

基本上，“豆”：

是一个可序列化的对象（即它实现了java.io.Serializable，并且正确地执行了），
有“属性”，其getter和setter只是具有特定名称的方法（例如，getFoo()是“Foo”属性的getter），
有一个公共0-arg构造函数（因此可以随意创建并通过设置其属性进行配置）。

更新

至于Serializable：这只是一个“标记接口”（一个不声明任何函数的接口）告诉Java实现类同意（并暗示它能够）“序列化“ - 将实例转换为字节流的过程。这些字节可以存储在文件中，通过网络连接发送等，并且有足够的信息允许JVM（至少是知道对象类型的那个）稍后重建对象 - 可能在不同的实例中应用程序，甚至是整个其他机器！

当然，为了做到这一点，班级必须遵守某些限制。其中最主要的是所有实例字段必须是基本类型（int，bool等），某些类的实例也可序列化，或标记为transient，以便Java不会尝试包含它们。（这当然意味着transient字段将无法通过流存档。具有transient字段的类应准备好在必要时重新初始化它们。）

不能遵守这些限制的类不应该实现Serializable（而且，IIRC，Java编译器甚至不会让这样做。）

Answer 3

JavaBeans是遵循极其简单的编码约定的Java类。你所要做的就是

实现java.io.Serializable接口 - 保存状态对象
使用公共空参数构造函数 - 实例化对象
提供公共getter / setter方法 - 获取和设置私有变量（属性）的值。

Answer 4

JavaBeans的属性

JavaBean是一个满足某些编程约定的Java对象：

JavaBean类必须实现Serializable或 Externalizable
JavaBean类必须具有无参数构造函数
所有JavaBean属性都必须具有公共setter和getter方法
所有JavaBean实例变量都应该是私有的

JavaBeans示例

@Entity
public class Employee implements Serializable{

   @Id
   private int id;
   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;
   }
   public void setId( int id ) {
      this.id = id;
   }
   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;
   }
}

Answer 5

用例子说明。

<强> 1。 import java.io.Serializable

关于序列化，请参阅documentation。

<强> 2。私人领域

字段应该是私有的，以防止外部类轻松修改这些字段。使用usuagly getter / setter方法而不是直接访问这些字段。

第3。构造

没有任何参数的公共构造函数。

<强> 4。的getter / setter

用于访问和修改私有字段的Getter和setter方法。

/** 1. import java.io.Serializable */ public class User implements java.io.Serializable { /** 2. private fields */ private int id; private String name; /** 3. Constructor */ public User() { } public User(int id, String name) { this.id = id; this.name = name; } /** 4. getter/setter */ // getter public int getId() { return id; } public String getName() { return name; } // setter public void setId(int id) { this.id = is; } public void setName(String name) { this.name = name; } }

Answer 6

Java Bean正在使用更少的代码和更多的工作方法...... Java Bean在整个Java EE中用作运行时发现和访问的通用契约。例如，JavaServer Pages（JSP）使用Java Bean作为页面之间或servlet和JSP之间的数据传输对象。 Java EE的JavaBeans Activation Framework使用Java Bean将MIME数据类型的支持集成到Java EE中。 Java EE Management API使用JavaBeans作为在Java EE环境中管理资源的工具的基础。

关于序列化：

在对象序列化中，对象可以表示为包含对象数据的字节序列，以及有关对象类型和对象中存储的数据类型的信息。

将序列化对象写入文件后，可以从文件中读取并反序列化，即表示对象及其数据的类型信息和字节可用于在内存中重新创建对象。

Answer 7

在跨多个服务器部署项目时，您会发现序列化非常有用，因为bean将被持久化并在它们之间传输。

Answer 8

Java Beans是一种标准，其基本语法要求已经通过其他答案清楚地解释过了。

然而，IMO，它不仅仅是一个简单的语法标准。 Java Bean的真正含义或预期用途是与标准周围的各种工具支持一起，以促进代码重用和基于组件的软件工程，即使开发人员能够通过组合现有组件（类）来构建应用程序，而无需编写任何代码（或只需编写一些胶水代码）。不幸的是，这种技术被业界低估和利用不足，可以从这个帖子的答案中得知。

如果您阅读了Oracle tutorial on Java Beans，您可以更好地理解它。

Answer 9

根据维基百科：

该类必须具有公共默认构造函数（不带参数）。这样可以在编辑和激活框架中轻松实例化。
根据标准命名约定，必须使用get，set，is（可用于布尔属性而不是get）以及其他方法（所谓的访问器方法和mutator方法）来访问类属性。这允许在框架内轻松自动检查和更新bean状态，其中许多包括用于各种类型属性的自定义编辑器。 Setter可以有一个或多个参数。
该类应该是可序列化的。 [这允许应用程序和框架以独立于VM和平台的方式可靠地保存，存储和恢复bean的状态。]

有关详细信息，请参阅此link.

Answer 10

关于问题的第二部分，序列化是一种持久性机制，用于将对象存储为有符号字节序列。不太正式，它存储对象的状态，以便您可以在以后通过反序列化来检索它。

Answer 11

Java Bean是一个java类[概念]，应遵循以下约定：

它应该有一个no-arg构造函数。
应该是Serializable。
它应该提供设置和获取属性值的方法，称为getter和setter方法。

它是一个可重用的软件组件。它可以将许多对象封装到一个对象中，这样就可以从多个位置访问同一个对象，这是向代码轻松维护的一个步骤。

Answer 12

它们是可序列化的，具有零参数构造函数，并允许使用getter和setter方法访问属性。 “Bean”这个名称包含了这个标准，旨在为Java创建可重用的软件组件。according to wiki

构成应用程序主干并由Spring IoC容器管理的对象称为bean。 bean是一个由Spring IoC容器实例化，组装和管理的对象。否则，bean只是应用程序中许多对象之一。 according to spring io。

Answer 13

Java Bean本质上是一个类，将类分类为Bean的是：

它应该实现可序列化的接口（Marker接口）。
该构造函数应该是公共的并且没有参数（其他人称为无参数构造函数）。
它应该有getter和setter。

请注意，serialVersionUID字段对于维护对象状态很重要。以下代码符合Bean的条件：

public class DataDog implements java.io.Serializable {

private static final long serialVersionUID = -3774654564564563L;

private int id;
private String nameOfDog;

//The constructor should NOT have arguments
public DataDog () {}


/** 4. getter/setter */

// getter(s)
public int getId() {
    return id;
}
public String getNameOfDog() {
    return nameOfDog;
}
// setter(s)
public void setId(int id) {
    this.id = id;
}
public void setNameOfDog(String nameOfDog) {
    this.nameOfDog = nameOfDog;
}}

Answer 14

要了解JavaBean，您需要注意以下事项： JavaBean是一个概念性的东西，不能代表一类特定的东西

JavaBean是一个可以在可重用软件组件的操作中可视化的开发工具

JavaBean基于Sun JavaBeans规范，可以是可重用的组件。它最大的特点是可重用性。

Answer 15

关于bean概念的一些背景知识/更新。实际上，许多其他答案都具有其中的含义，但原因却不多。

它们是Java的早期发明，是构建GUI的一部分。它们遵循易于工具分解的模式，从而使它们可以创建属性面板，以便您可以编辑Bean的属性。通常，Bean属性代表屏幕上的一个控件（认为x，y，width，height，text等）。

您也可以将其视为强类型数据结构。

随着时间的流逝，对于许多使用相同访问类型的工具（例如，Hibernate将数据结构持久存储到数据库中）来说，这些变得很有用

随着工具的发展，它们更多地转向注释，而不是分开设置者/获取者的名字。现在，大多数系统不再需要bean，它们可以使用带有注释属性的任何普通的老式java对象来告诉他们如何操作它们。

现在，我将bean视为带注释的属性球-它们实际上仅对它们带有的注释有用。

豆类本身不是健康的模式。它们破坏了封装的性质，因为它们将所有属性暴露给外部操纵，并且在使用它们时，有一种趋势（绝非必要）来创建代码以在外部操纵Bean，而不是在Bean内部创建代码（违反了“不要问一个对象的值，而是要一个对象为您做些事情”。使用带有最小的吸气剂且没有塞子的带注释的pojos，更多的是恢复面向对象的封装并具有不变性的可能性。

顺便说一句，随着所有这些事情的发生，有人将这个概念扩展到了称为Enterprise Java Beans的东西。这些是...不同。而且它们非常复杂，以至于许多人认为他们不了解整个Bean概念，因此停止使用该术语。我想，这就是为什么您通常会听到称为POJO的bean（因为每个Java对象都是POJO，从技术上讲这是可以的，但是当您听到有人说POJO时，他们最常考虑的是遵循bean模式的事物）

Answer 16

Bean is是Java类，其方法名称遵循properties，methods和events的Java Bean准则（也称为设计模式）。因此，不属于属性定义的Bean类的任何公共方法都是Bean方法。至少，一个Java类（即使具有作为其唯一成员的属性（当然，需要附带公共getter和setter），作为唯一成员的public方法或仅一个公共事件侦听器注册方法）也是Java bean。此外，该属性可以是只读属性（具有getter方法，但没有setter）或只写属性（仅具有setter方法）。 Java bean必须是一个公共类，才能对任何beanbox工具或容器可见。容器必须能够实例化；因此，它也必须有一个公共构造函数。 JavaBeans specification不需要Bean具有公用的零参数构造函数（显式或默认），容器可以实例化它。如果您可以提供一个包含序列化实例的文件（扩展名为.ser），则beanbox工具可以使用该文件来实例化原型bean。否则，bean必须具有公共的零参数构造函数，无论是显式的还是默认的。

实例化该bean之后，Java Bean API（java.beans。*）可以对其进行内部检查并在其上调用方法。如果没有实现接口BeanInfo或扩展BeanInfo实现的类SimpleBeanInfo类，则自省涉及使用反射（隐式自省）研究目标Bean支持的方法，然后应用简单的设计模式（准则）从中推断这些方法支持哪些属性，事件和公共方法。如果有实现接口BeanInfo的类（对于Foo，必须将其命名为FooBeanInfo）可用，则API绕过隐式自省，并使用此类的公共方法（getPropertyDescriptor（），getMethodDescriptors（），getEventSetDescriptors（））来获取信息。如果有扩展SimpleBeanInfo的类可用，则根据覆盖哪个SimpleBeanInfo公共方法（getPropertyDescriptor（），getMethodDescriptors（），getEventSetDescriptors（）），它将使用那些覆盖的方法来获取信息；对于未覆盖的方法，默认为相应的隐式自省。无论如何，即使没有进行隐式自省，也需要实例化Bean。因此，需要公共zeri-args构造函数。但是，当然，并不需要Serializable或Externalizable接口。但是，Java Bean规范说：“对于小型Bean的普通情况，我们只是希望它“微不足道”，它只是想保存其内部状态并且不想考虑它。”因此，所有这些bean必须实现Serializable或Externalizable接口。总体而言，JavaBeans规范对于构成bean的要求并不严格。 “编写JavaBeans组件非常容易。您不需要特殊的工具，也不需要实现任何接口。编写bean只是遵循某些编码约定的事情。所有要做的就是使类看起来像一个bean-使用bean的工具将能够识别和使用您的bean。”琐碎地，甚至下面的类都是Java Bean，

public class Trivial implements java.io.Serializable {}

说，bean构造函数有一些参数。假设一些是简单类型。容器可能不知道要为它们分配什么值。即使这样做，结果实例也可能不可重用。仅当用户可以像在Spring bean中那样通过注释或xml配置文件配置（指定值）时，这才有意义。并假设某些参数是类或接口类型。同样，容器可能不知道要为其分配什么值。仅当用户可以通过注释或xml配置文件配置（指定特定对象）时，这才有意义。但是，即使在Spring中（通过xml配置文件），将特定对象（带有字符串名称）分配给构造函数参数（构造函数参数的属性或元素）也不是类型安全的；这基本上就像资源注入一样。引用其他Spring bean（称为合作者；通过构造函数参数元素中的元素）基本上是依赖注入，因此是类型安全的。显然，一个依赖项（协作者bean）可能具有一个带有注入参数的构造函数。那些注入的依赖项可能具有带有参数的构造函数，依此类推。在这种情况下，最终，您需要容器可以通过简单地调用new MyBean（）实例化的一些bean类（例如，MyBean.class），然后才能通过对构造函数的依赖注入构造其他协作Bean，因此， bean具有公共的零参数构造函数。假设，如果一个容器不支持依赖注入和/或不允许像Spring中那样通过一些注释或xml配置文件向构造函数分配简单类型的值，那么bean构造函数应该没有参数。即使是Spring Bean应用程序，也需要一些Bean具有公用的零参数构造函数（例如，在您的Spring应用程序没有使用简单类型作为构造函数参数的Bean的情况下）。

JSF托管的bean在Web容器中运行。可以使用@ManagedBean批注或应用程序配置资源文件managed-bean.xml来配置它们。但是，它仅支持通过资源注入（不是类型安全）进行注入；不适合在构造函数上注入。 JSF spec要求托管Bean必须具有公共零参数构造函数。进一步说，“从本规范的2.3版开始，强烈要求使用本节中指定的托管bean工具泄气。解决同一问题的更好，更紧密集成的解决方案是使用JSR-365中指定的上下文和依赖注入（CDI）。“换句话说，将使用CDI管理的bean，它为构造函数提供了类型安全的依赖注入CDI规范采用了Managed Beans规范，该规范不仅适用于Web层，而且适用于JEE平台的所有容器，因此，Web容器需要实现CDI规范。

这里是Managed Bean specification的摘录 “受管Bean是具有最低要求的容器管理对象，否则以“ POJOs”（普通的旧Java对象）的缩写而闻名……它们可以看作是Java SE平台上JavaBeans组件模型的Java EE平台增强版本……。读者不会错过Managed Bean在JavaServer Faces（JSF）技术中发现的同名功能中的先驱者。本规范中定义的Managed Bean代表了对JSF中发现的那些的概括。特别是，受管Bean可以在Java EE应用程序中的任何地方使用，而不仅仅是在Web模块中使用。例如，在基本组件模型中，托管Bean必须提供无参数的构造函数，但是基于托管Bean的规范（例如CDI（JSR-299））可以放宽该要求，并允许托管Bean为构造函数提供更多功能复杂的签名，只要它们遵循一些明确定义的规则...托管Bean一定不能是：最终类，抽象类，非静态内部类。与常规JavaBean组件不同，托管Bean可能无法序列化。” 因此，托管Bean的规范（也称为POJO或POJO Bean）可以像CDI中那样进行扩展。

The CDI specification将托管bean重新定义为：在Java EE中运行时，如果满足要求，则顶级Java类是托管Bean：

•它不是内部类。 •这是一个非抽象类，或使用@Decorator进行了注释。 •它没有实现javax.enterprise.inject.spi.Extension。 •它没有注释@Vetoed或在带有注释@Vetoed的程序包中。 •它具有适当的构造函数，或者：类具有没有参数的构造函数，或者该类声明带有@Inject注释的构造函数。

所有满足这些条件的Java类都是托管Bean，因此不需要特殊声明定义托管bean所需。或

如果任何人将其定义为托管bean 其他Java EE规范以及是否

•它没有使用EJB组件定义的注释进行注释，也未声明为EJB bean类。在ejb-jar.xml中。

与Spring bean不同，它不支持简单类型的构造函数，如果它支持使用xml config文件（例如Spring或任何注释）进行配置，则可能会实现。

EJB在EJB容器中运行。它的specification说：“会话bean组件是一个受管Bean。”“该类必须具有不带参数的公共构造函数，”它对会话bean和消息驱动bean都说。 “不需要会话bean类来实现SessionBean接口或Serializable接口。”出于与JSF bean相同的原因，EJB3依赖注入基本上是资源注入，JSF bean不支持带有参数的构造函数，即通过依赖关系但是，如果EJB容器实现CDI，则“可选：该类可能具有一个附加的构造函数，并使用Inject注释进行注释”，它对会话bean和消息驱动的bean都说，因为“将EJB打包到CDI bean归档中且未使用javax.enterprise.inject.Vetoed注释进行注释，则被视为启用CDI的bean。”

Answer 17

如果你熟悉 C/Golang，你从来没有听说过 C bean 或 Go bean，因为它们有 struct 关键字，开发人员可以轻松定义结构类型，而无需编写复杂的 OOP 关键字。

type User struct {
  Name string
  Age int
}

var user User

user.Name = "name"
user.Age = 18

var bytes, err = json.Marshal(user)

缺少 struct 类型是 Java 的错误，开发人员发现这种严重短缺。

然后 Java Bean 被发明为另一个无聊的规则，它使 class 假装 struct，您的编辑器或编译器不会因为您对类成员的不安全访问而哭泣或大喊大叫。

Answer 18

豆类构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。 bean 是由 Spring IoC 容器实例化、组装和管理的对象。这些 bean 是使用您提供给容器的配置元数据创建的。

Answer 19

实际上，Bean只是易于使用的对象。序列化它们意味着能够轻松地对其进行持久化（以易于恢复的形式存储）。

现实生活中Bean的典型用法：

简单的可重用对象POJO（普通的旧Java对象）
视觉对象
Spring使用Beans处理对象（例如，需要在会话中序列化的User对象）
EJB（企业Java Beans），更复杂的对象，例如JSF Beans（JSF是一种过时的技术）或JSP Beans

因此，实际上，Bean是只是一个约定/标准，它期望Java对象具有某种行为（序列化），并提供某种方式在一定程度上更改它（属性的设置者）方式。

如何使用它们只是您的发明，但我在上面列出了最常见的情况。

Answer 20

POJO（普通Java对象）：-POJO是普通的Java对象，除了Java语言强制执行的限制外，没有其他限制。

序列化：-用于保存对象的状态并通过网络发送它。它将对象的状态转换为字节流。我们可以通过反序列化过程从字节流中重新创建Java对象。

使您的类实现java.io.Serializable接口。并使用ObjectOutputStream类的writeObject（）方法实现序列化。

JavaBean类：-这是一个特殊的POJO，具有一定的限制（或约定）。 1.实现序列化 2.有公共的无参数构造函数 3.所有具有公开获取程序和设置方法的私有属性。

许多框架（如Spring）都使用JavaBean对象。

Answer 21

Java Bean是 JavaBeans 体系结构的组件或基本构建块。 JavaBeans 体系结构是一种组件体系结构，它受益于基于组件的方法的可重用性和互操作性。

有效的组件体系结构应允许从以下位置汇编程序软件构建块（在这种情况下为Bean），可能由不同的供应商提供，也使架构师/开发人员可以选择组件（Bean），了解其功能并将其合并到应用程序中。

由于类/对象是Java之类的OOP语言的基本构建块，因此它们自然是在 JavaBeans 体系结构中成为 Bean 的竞争者。

将纯Java类转换为Java bean的过程实际上无非就是使其成为可重用和可互操作的组件。这将转化为具有以下能力的Java类：

控制暴露给另一个应用程序的类的属性，事件和方法。（您可以有一个BeanInfo类，该类仅报告外部应用程序需要的那些属性，事件和方法）
持久性（可序列化或可外部化-这也意味着没有参数构造函数，对字段使用瞬态）
注册事件并生成事件的能力（例如，使用绑定和约束属性）
定制程序（通过GUI或提供文档来定制Bean）

为了将Java类称为Java Bean，它们不必具有上述所有功能，而是意味着实现与上下文相关的上述子集（例如，某些框架可能不需要定制程序，另一些bean可能不需要绑定和约束的属性等）

为了获得上述好处，Java中几乎所有领先的框架和库都暗含了JavaBeans体系结构。

Answer 22

Spring @Bean 注解表示一个方法产生一个 bean 由 Spring 容器管理。

更多参考：https://www.concretepage.com/spring-5/spring-bean-annotation

Answer 23

上面重复了 6 到 7 次，JavaBean 没有参数构造函数的要求。

这是错误的，没有这样的要求，尤其是在 Java Spring 的上下文中。

在描述 JavaBeanns API (https://download.oracle.com/otndocs/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/) 的规范版本 (1.01) 中也没有提及该要求。甚至更多 - 本规范在以下上下文中仅提及“空构造函数”两次： “每个定制器都应该有一个空构造函数。” “每个 PropertyEditor 都应该有一个空构造函数。”

因此，似乎规范的作者不知道或不愿意使用术语“空构造函数”，仍然没有提及 JavaBeans 本身。

什么是JavaBean？

23 个答案: