¿Qué es un JavaBean exactamente?

Comprendí, creo, que un "Bean" es una clase Java con propiedades y captadores / establecedores. Por lo que entiendo, es el equivalente de una estructura C. ¿Es eso cierto?

Además, ¿existe una diferencia sintáctica real entre un bean y una clase regular? ¿Hay alguna definición especial o una interfaz?

Básicamente, ¿por qué hay un término para esto?

Además, ¿qué significa la Serializableinterfaz?

Un JavaBean es solo un estándar

1. Todas las propiedades privadas (use getters / setters )
2. Un constructor público sin argumentos
3. Implementos Serializable.

Eso es. Es solo una convención. Sin embargo, muchas bibliotecas dependen de ello.

Con respecto a Serializable, de la documentación de la API :

La serialización de una clase está habilitada por la clase que implementa la interfaz java.io.Serializable. Las clases que no implementan esta interfaz no tendrán ninguno de sus estados serializados o deserializados. Todos los subtipos de una clase serializable son serializables. La interfaz de serialización no tiene métodos o campos y sirve solo para identificar la semántica de ser serializable.

En otras palabras, los objetos serializables se pueden escribir en secuencias y, por lo tanto, archivos, bases de datos de objetos, cualquier cosa realmente.

Además, no existe una diferencia sintáctica entre un JavaBean y otra clase: una clase es un JavaBean si sigue los estándares.

Hay un término para ello porque el estándar permite a las bibliotecas hacer cosas mediante programación con instancias de clase que defina de una manera predefinida. Por ejemplo, si una biblioteca quiere transmitir cualquier objeto que le pase, sabe que puede porque su objeto es serializable (suponiendo que la biblioteca requiere que sus objetos sean JavaBeans adecuados).

Hay un término para que suene especial. La realidad no es tan misteriosa.

Básicamente, un "frijol":

• es un objeto serializable (es decir, lo implementa java.io.Serializabley lo hace correctamente), que
• tiene "propiedades" cuyos captadores y establecedores son solo métodos con ciertos nombres (como, por ejemplo, getFoo()es el captador de la propiedad "Foo"), y
• tiene un constructor público de 0 argumentos (por lo que puede crearse a voluntad y configurarse estableciendo sus propiedades).

Actualizar:

En cuanto a Serializable: Eso no es más que una "interfaz de marcador" (una interfaz que no declara ninguna función) que le dice a Java que la clase implementadora consiente (e implica que es capaz de) la "serialización", un proceso que convierte una instancia en una secuencia de bytes. Esos bytes pueden almacenarse en archivos, enviarse a través de una conexión de red, etc., y tener suficiente información para permitir que una JVM (al menos, una que sepa sobre el tipo de objeto) reconstruya el objeto más tarde, posiblemente en una instancia diferente del aplicación, o incluso en una máquina completamente diferente!

Por supuesto, para hacer eso, la clase tiene que cumplir con ciertas limitaciones. El principal de ellos es que todos los campos de instancia deben ser tipos primitivos (int, bool, etc.), instancias de alguna clase que también sea serializable o marcadas transientpara que Java no intente incluirlas. (Esto, por supuesto, significa que los transientcampos no sobrevivirán al viaje a través de un arroyo. Una clase que tenga transientcampos debe estar preparada para reinicializarlos si es necesario).

Una clase que no puede cumplir con esas limitaciones no debe implementarse Serializable(y, IIRC, el compilador de Java ni siquiera lo permitirá ).

JavaBeans son clases de Java que se adhieren a una convención de codificación extremadamente simple. Todo lo que tienes que hacer es

1. java.io.Serializableinterfaz de implementación : para guardar el estado de un objeto
2. usar un constructor de argumento vacío público - para instanciar el objeto
3. Proporcionar métodos públicos de obtención / establecimiento: para obtener y establecer los valores de variables privadas (propiedades).

Propiedades de JavaBeans

Un JavaBean es un objeto Java que satisface ciertas convenciones de programación:

1. La clase JavaBean debe implementar Serializableo Externalizable

2. La clase JavaBean debe tener un constructor sin argumentos

3. Todas las propiedades JavaBean deben tener métodos públicos de establecimiento y obtención.

4. Todas las variables de instancia de JavaBean deben ser privadas

Ejemplo de 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;
   }
}

Explicación con un ejemplo.

1. importar java.io.Serializable

En cuanto a la serialización, consulte la documentación .

2. campos privados

Los campos deben ser privados para evitar que las clases externas modifiquen fácilmente esos campos. En lugar de acceder directamente a esos campos, se utilizan usualmente métodos getter / setter.

3. Constructor

Un constructor público sin ningún argumento.

4. getter / setter

Métodos getter y setter para acceder y modificar campos privados.

/** 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 = id;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Los Java Beans se utilizan por menos código y más enfoque de trabajo ... Los Java Beans se usan en todo Java EE como un contrato universal para el descubrimiento y el acceso en tiempo de ejecución. Por ejemplo, JavaServer Pages (JSP) utiliza Java Beans como objetos de transferencia de datos entre páginas o entre servlets y JSP. El JavaBeans Activation Framework de Java EE utiliza Java Beans para integrar el soporte para los tipos de datos MIME en Java EE. La API de administración de Java EE utiliza JavaBeans como base para la instrumentación de los recursos que se administrarán en un entorno Java EE.

Sobre la serialización:

En la serialización de objetos, un objeto puede representarse como una secuencia de bytes que incluye los datos del objeto, así como información sobre el tipo de objeto y los tipos de datos almacenados en el objeto.

Después de que un objeto serializado se haya escrito en un archivo, puede leerse del archivo y deserializarse, es decir, la información de tipo y los bytes que representan el objeto y sus datos pueden usarse para recrear el objeto en la memoria.

Encontrará que la serialización es útil al implementar su proyecto en varios servidores, ya que los beans se conservarán y transferirán a través de ellos.

Java Beans es un estándar, y sus requisitos básicos de sintaxis han sido explicados claramente por las otras respuestas.

Sin embargo, en mi opinión, es más que un simple estándar de sintaxis. El significado real o el uso previsto de Java Beans es, junto con varios soportes de herramientas en torno al estándar, para facilitar la reutilización de código y la ingeniería de software basada en componentes, es decir, permitir a los desarrolladores crear aplicaciones mediante el ensamblaje de componentes (clases) existentes y sin tener que escribir ninguno código (o solo tiene que escribir un pequeño código de pegamento). Desafortunadamente, esta tecnología es muy poco estimada y poco utilizada por la industria, lo que se puede deducir de las respuestas en este hilo.

Si lee el tutorial de Oracle sobre Java Beans , puede comprenderlo mejor.

Según la Wikipedia:

1. La clase debe tener un constructor público predeterminado (sin argumentos). Esto permite una fácil creación de instancias dentro de los marcos de edición y activación.

2. Las propiedades de clase deben ser accesibles usando get, set, is (puede usarse para propiedades booleanas en lugar de get) y otros métodos (los llamados métodos de acceso y métodos de mutación) de acuerdo con una convención de nomenclatura estándar. Esto permite una inspección y actualización automática y fácil del estado del bean dentro de los marcos, muchos de los cuales incluyen editores personalizados para varios tipos de propiedades. Los setters pueden tener uno o más de un argumento.

3. La clase debe ser serializable. [Esto permite que las aplicaciones y los marcos guarden, almacenen y restauren de manera confiable el estado del bean de una manera independiente de la VM y de la plataforma].

Para más información sigue este enlace.

Con respecto a la segunda parte de su pregunta, la serialización es un mecanismo de persistencia utilizado para almacenar objetos como una secuencia de bytes firmados. Dicho de manera menos formal, almacena el estado de un objeto para que pueda recuperarlo más tarde, por deserialización.

Un Java Bean es una clase java [conceptual] que debe seguir las siguientes convenciones:

1. Debería tener un constructor sin argumentos.
2. Debe ser serializable.
3. Debe proporcionar métodos para establecer y obtener los valores de las propiedades, conocidos como métodos getter y setter.

Es un componente de software reutilizable. Puede encapsular muchos objetos en un solo objeto para que se pueda acceder al mismo objeto desde múltiples lugares y es un paso hacia un fácil mantenimiento del código.

Son serializables, tienen un constructor de argumento cero y permiten el acceso a propiedades utilizando métodos getter y setter. El nombre "Bean" se le dio para abarcar este estándar, cuyo objetivo es crear componentes de software reutilizables para Java. according to wiki

Los objetos que forman la columna vertebral de su aplicación y que son administrados por el contenedor Spring IoC se denominan beans. Un bean es un objeto que se crea una instancia, se ensambla y, de lo contrario, se administra mediante un contenedor Spring IoC. De lo contrario, un bean es simplemente uno de los muchos objetos en su aplicación. according to primavera io .

Solo un poco de antecedentes / actualización sobre el concepto de frijol. Muchas otras respuestas realmente tienen el por qué, pero no tanto por qué.

Fueron inventados al principio en Java como parte de la construcción de GUI. Siguieron patrones que eran fáciles de separar para las herramientas, permitiéndoles crear un panel de propiedades para que pudiera editar los atributos del Bean. En general, las propiedades de Bean representaban un control en la pantalla (Piense x, y, ancho, alto, texto, ..)

También puede considerarlo como una estructura de datos fuertemente tipada.

Con el tiempo, esto se volvió útil para muchas herramientas que usaban el mismo tipo de acceso (por ejemplo, Hibernate para mantener estructuras de datos en la base de datos)

A medida que las herramientas evolucionaron, se movieron más hacia las anotaciones y lejos de separar los nombres de setter / getter. Ahora, la mayoría de los sistemas no requieren beans, pueden tomar cualquier objeto Java simple con propiedades anotadas para decirles cómo manipularlos.

Ahora veo los frijoles como bolas de propiedades anotadas: en realidad solo son útiles para las anotaciones que llevan.

Los frijoles en sí mismos no son un patrón saludable. Destruyen la encapsulación por su naturaleza, ya que exponen todas sus propiedades a la manipulación externa y, a medida que se usan, existe una tendencia (de ninguna manera un requisito) a crear código para manipular el bean externamente en lugar de crear código dentro del bean (viola "don" no le pidas valores a un objeto, pídele a un objeto que haga algo por ti "). Usar pojos anotados con getters mínimos y sin setters es mucho más OO que restaura la encapsulación y con la posibilidad de inmutabilidad.

Por cierto, mientras todo esto sucedía, alguien extendió el concepto a algo llamado Enterprise Java Beans. Estos son ... diferentes. y son lo suficientemente complicados que muchas personas sintieron que no entendían todo el concepto de Bean y dejaron de usar el término. Creo que esta es la razón por la que generalmente escuchas beans denominados POJO (dado que cada objeto Java es un POJO, esto está técnicamente bien, pero cuando escuchas a alguien decir POJO, a menudo piensan en algo que sigue el patrón del bean)

Un Java Bean es cualquier clase de Java que satisface los siguientes tres criterios:

1. Debe implementar una interfaz serializable (interfaz A Marker).
2. El constructor debe ser público y no tener argumentos (lo que otras personas llaman "constructor sin argumentos").
3. Debería tener getter y setters.

Es bueno tener en cuenta que el campo serialVersionUID es importante para mantener el estado del objeto. El siguiente código califica como un 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;
}}

Para comprender JavaBean, debe tener en cuenta lo siguiente: JavaBean es un elemento conceptual y no puede representar una clase de cosas específicas

JavaBean es una herramienta de desarrollo que se puede visualizar en la operación de componentes de software reutilizables

JavaBean se basa en la especificación Sun JavaBeans y puede ser componentes reutilizables. Su característica más importante es la reutilización.

Un bean es una clase Java con nombres de métodos que siguen las pautas de Java Bean (también llamados patrones de diseño) para propiedades , métodos y eventos.. Por lo tanto, cualquier método público de la clase bean que no forme parte de una definición de propiedad es un método bean. Como mínimo, una clase Java, incluso con una propiedad como único miembro (por supuesto, se requiere un getter y setter público acompañante), un método público como único miembro o solo un método de registro de escucha de eventos públicos es un bean Java. Además, la propiedad puede ser propiedad de solo lectura (tiene un método getter pero no setter) o propiedad de solo escritura (tiene solo un método setter). El bean Java debe ser una clase pública para que sea visible para cualquier herramienta o contenedor de beanbox. El contenedor debe poder instanciarlo; por lo tanto, debe tener un constructor público también. La especificación JavaBeansno requiere que un bean tenga un constructor público de cero argumentos, explícito o predeterminado, para que un contenedor lo instancia. Si pudiera proporcionar un archivo (con extensión .ser) que contenga una instancia serializada, una herramienta beanbox podría usar ese archivo para crear una instancia de un prototipo de bean. De lo contrario, el bean debe tener un constructor público de cero argumentos, explícito o predeterminado.

Una vez que se instancia el bean, la API de Java Bean (java.beans. *) Puede introspectarlo y llamar a métodos en él. Si no hay disponible ninguna clase que implemente la interfaz BeanInfo o que extienda una implementación de BeanInfo, la clase SimpleBeanInfo, la introspección implica el uso de la reflexión (introspección implícita) para estudiar los métodos admitidos por un bean de destino y luego aplicar patrones de diseño simples (las pautas) para deducir de aquellos métodos con los que se admiten propiedades, eventos y métodos públicos. Si una clase que implementa la interfaz BeanInfo (para un bean Foo, debe llamarse FooBeanInfo) está disponible, la API omite la introspección implícita y utiliza métodos públicos (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors ()) de esta clase para obtener el información. Si una clase que extiende SimpleBeanInfo está disponible, dependiendo de cuál de los métodos públicos SimpleBeanInfo (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors ()) se anula, utilizará esos métodos anulados para obtener información; para un método que no se anula, el valor predeterminado será la introspección implícita correspondiente. Un bean necesita ser instanciado de todos modos, incluso si no se lleva a cabo una introspección implícita. Por lo tanto, el requisito de un constructor público zeri-args. Pero, por supuesto, la interfaz Serializable o Externalizable no es necesaria para que sea reconocida. Sin embargo, la especificación de Java Bean dice: "También nos gustaría que fuera" trivial "para el caso común de un pequeño Bean que simplemente quiere tener su estado interno guardado y no quiere pensar en ello". Por lo tanto, todos los beans deben implementar una interfaz serializable o externalizable. En general, La especificación JavaBeans no es difícil y rápida sobre lo que constituye un bean. "Escribir componentes JavaBeans es sorprendentemente fácil. No necesitas una herramienta especial y no tienes que implementar ninguna interfaz. Escribir beans es simplemente una cuestión de seguir ciertas convenciones de codificación. Todo lo que tienes que hacer es hacer que tu clase se vea como un bean: las herramientas que usan beans podrán reconocer y usar su bean ". Trivialmente, incluso la siguiente clase es un Java Bean,

public class Trivial implements java.io.Serializable {}

Digamos que un constructor de beans tiene algunos parámetros. Supongamos que algunos son tipos simples. Es posible que el contenedor no sepa qué valores asignarles; incluso si lo hace, la instancia resultante podría no ser reutilizable. Puede tener sentido solo si el usuario puede configurar (especificar valores) mediante anotaciones o archivos de configuración xml como en Spring Beans. Y supongamos que algunos parámetros son tipos de clase o interfaz. Nuevamente, el contenedor podría no saber qué valores asignarle. Puede tener sentido solo si el usuario puede configurar (especificar objetos específicos) mediante anotaciones o archivos de configuración xml. Sin embargo, incluso en Spring (a través de archivos de configuración xml), la asignación de objetos específicos (con nombres de cadena) a argumentos del constructor (atributo o elemento de los argumentos del constructor) no es seguro; es básicamente como la inyección de recursos. Hacer referencias a otros beans Spring (llamados colaboradores; a través de un elemento en un elemento de argumento de constructor) es básicamente una inyección de dependencia y, por lo tanto, es seguro. Obviamente, una dependencia (bean colaborador) podría tener un constructor con parámetros inyectados; esas dependencias inyectadas pueden tener un constructor con parámetros, etc. En este escenario, en última instancia, necesitaría algunas clases de beans (por ejemplo, MyBean.class) que el contenedor puede instanciar simplemente llamando a New MyBean () antes de que pueda construir los otros beans colaborativos a través de la inyección de dependencia en los constructores, por lo tanto, el requisito para los beans para tener un constructor público de cero args. Supongamos que si un contenedor no admite la inyección de dependencia y / o no permite asignar valores de tipo simple al constructor a través de algunas anotaciones o archivos de configuración xml como en Spring, los constructores de beans no deberían tener parámetros. Incluso una aplicación Spring beans necesitaría algunos beans para tener un constructor público de cero args (por ejemplo, en un escenario donde su aplicación Spring no tiene bean con solo tipos simples como argumentos de constructor).

Los beans gestionados por JSF se ejecutan en un contenedor web. Se pueden configurar con la anotación @ManagedBean o con un archivo de recursos de configuración de la aplicación managed-bean.xml. Sin embargo, solo admite la inyección a través de la inyección de recursos (no de tipo seguro); no apto para inyección en constructores. los especificación JSFrequiere que los beans gestionados tengan un constructor público de argumento cero. Además, dice: “A partir de la versión 2.3 de esta especificación, se desaconseja el uso de la función de bean administrado como se especifica en esta sección. Una solución mejor y más integrada para resolver el mismo problema es usar Contexts and Dependency Injection (CDI), como se especifica en JSR-365 ". a Spring beans. La especificación CDI adopta la especificación Managed Beans, que se aplica a todos los contenedores de la plataforma JEE, no solo al nivel web. Por lo tanto, el contenedor web necesita implementar la especificación CDI.

Aquí hay un extracto de la especificación Managed Bean “Los beans gestionados son objetos gestionados por contenedor con requisitos mínimos, también conocidos bajo el acrónimo“ POJOs ”(Objetos Java simples y sencillos) ... pueden verse como una versión mejorada de la plataforma Java EE del modelo de componentes JavaBeans que se encuentra en la plataforma Java SE ... El lector no pasará por alto que los beans gestionados tienen un precursor en la instalación homónima que se encuentra en la tecnología JavaServer Faces (JSF) ... Los beans gestionados tal como se definen en esta especificación representan una generalización de los que se encuentran en JSF; en particular, Managed Beans se puede usar en cualquier lugar de una aplicación Java EE, no solo en módulos web. Por ejemplo, en el modelo de componente básico, los beans gestionados deben proporcionar un constructor sin argumentos, pero una especificación que se basa en beans gestionados, como CDI (JSR-299), puede relajar ese requisito y permitir que los beans gestionados proporcionen a los constructores firmas más complejas, siempre que sigan algunas reglas bien definidas ... Un bean gestionado no debe ser: una clase final, una clase abstracta, una clase interna no estática . Un bean gestionado puede no ser serializable a diferencia de un componente JavaBean normal ". Por lo tanto, la especificación para beans gestionados, también conocidos como POJO o beans POJO, permite la extensión como en CDI.

La especificación CDI redefine los beans gestionados como: Cuando se ejecuta en Java EE, una clase Java de nivel superior es un bean gestionado si cumple los requisitos:

• No es una clase interna. • Es una clase no abstracta, o se anota @Decorator. • No implementa javax.enterprise.inject.spi.Extension. • No está anotado @Vetoed o en un paquete anotado @Vetoed. • Tiene un constructor apropiado, ya sea: la clase tiene un constructor sin parámetros, o la clase declara un constructor anotado @Inject.

Todas las clases Java que cumplen con estas condiciones son beans administrados y, por lo tanto, no se requiere una declaración especial para definir un bean administrado. O

si se define como un bean administrado por cualquier otra especificación Java EE y si

• No se anota con una anotación que define el componente EJB ni se declara como una clase de bean EJB en ejb-jar.xml.

A diferencia de Spring Beans, no admite constructores con tipos simples, lo que podría ser posible si admitiera la configuración con archivos de configuración xml como en Spring o cualquier anotación.

Los EJB se ejecutan en un contenedor EJB. Sus especificacióndice: "Un componente de bean de sesión es un bean administrado". "La clase debe tener un constructor público que no tome argumentos", dice tanto para bean de sesión como para bean controlado por mensajes. Además, dice: "La clase de bean de sesión es no es necesario para implementar la interfaz SessionBean o la interfaz serializable ". Por la misma razón que los beans JSF, que la inyección de dependencia EJB3 es básicamente una inyección de recursos, los beans JSF no admiten constructores con argumentos, es decir, mediante inyección de dependencia. Sin embargo, si el contenedor EJB implementa CDI, "Opcionalmente: la clase puede tener un constructor adicional anotado con la anotación Inject ", dice tanto para bean de sesión como para bean controlado por mensaje porque" un EJB empaquetado en un archivo de bean CDI y no anotado con javax.enterprise.inject. Anotación vetada, se considera un CDI habilitado frijol."

En la práctica, los frijoles son solo objetos que son útiles de usar. Serializarlos significa poder persistirlos fácilmente (almacenar en una forma que se recupere fácilmente).

Usos típicos de frijoles en el mundo real:

• Objetos simples reutilizables POJO (Objetos Java simples y sencillos)
• objetos visuales
• Spring usa Beans para que los objetos los manejen (por ejemplo, Objeto de usuario que necesita ser serializado en sesión)
• EJB (Enterprise Java Beans), objetos más complejos, como JSF Beans (JSF es una tecnología antigua bastante desactualizada) o JSP Beans

De hecho, los Beans son solo una convención / estándar para esperar algo de un objeto Java que se comportaría (serialización) y dar algunas formas de cambiarlo (establecedores de propiedades) de cierta manera.

Cómo usarlos, es solo tu invención, pero los casos más comunes en los que me alisté anteriormente.