¿Qué es exactamente un JavaBean?
Creo que entendí que un "Bean" es una clase Java con propiedades y captadores/definidores.
Por lo que tengo entendido, es el equivalente a una structC. ¿Es eso cierto?
Además, ¿existe una diferencia sintáctica real entre a JavaBeany regular class?
¿Existe alguna definición especial o una Interface?
Básicamente, ¿por qué existe un término para esto?
Además, ¿qué Serializablesignifica la interfaz?
Un JavaBean es sólo un estándar . Es un Java normal class, excepto que sigue ciertas convenciones:
- Todas las propiedades son privadas (use getters/setters )
- Un constructor público sin argumentos.
- Implementos
Serializable.
Eso es todo. Es sólo una convención. Sin embargo, muchas bibliotecas dependen de ello.
Con respecto a Serializable, de la documentación API :
La serialización de una clase la habilita la clase que implementa la interfaz java.io.Serializable. Las clases que no implementen esta interfaz no tendrán ningún estado serializado o deseriaizado. Todos los subtipos de una clase serializable son a su vez serializables. La interfaz de serialización no tiene métodos ni campos y solo sirve para identificar la semántica de ser serializable.
En otras palabras, los objetos serializables se pueden escribir en secuencias y, por lo tanto, en archivos, bases de datos de objetos, en cualquier cosa.
Además, no existe diferencia sintáctica entre un JavaBean y otra clase: una clase es un JavaBean si sigue los estándares.
Existe un término para esto, porque el estándar permite a las bibliotecas hacer cosas mediante programación con instancias de clase que usted define de una manera predefinida. Por ejemplo, si una biblioteca quiere transmitir cualquier objeto que usted le pase, sabe que puede hacerlo porque su objeto es serializable (suponiendo que la biblioteca requiera 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, implementa
java.io.Serializabley lo hace correctamente), que - tiene "propiedades" cuyos captadores y definidores son solo métodos con ciertos nombres (como, por ejemplo,
getFoo()es el captador de la propiedad "Foo"), y - tiene un constructor público sin argumentos (por lo que puede crearse a voluntad y configurarse estableciendo sus propiedades).
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) "serialización", un proceso que convierte una instancia en un flujo 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 conozca el tipo de objeto) reconstruya el objeto más tarde, posiblemente en una instancia diferente de la aplicación, ¡o incluso en otra máquina!
Por supuesto, para poder hacerlo, la clase debe 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 estar marcados como tal para transientque Java no intente incluirlos. (Esto, por supuesto, significa que transientlos campos 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 debería implementarse Serializable(y, IIRC, el compilador de Java ni siquiera le permitirá hacerlo).
Los JavaBeans son clases de Java que siguen una convención de codificación extremadamente simple. Todo lo que tienes que hacer es
- implementar la
java.io.Serializableinterfaz - para guardar el estado de un objeto - use un constructor público de argumentos vacíos para crear una instancia del objeto
- proporcionar métodos públicos de captación/definición para obtener y establecer los valores de variables privadas (propiedades).
Propiedades de los JavaBeans
Un JavaBean es un objeto Java que satisface ciertas convenciones de programación:
La clase JavaBean debe implementar uno
SerializableoExternalizableLa clase JavaBean debe tener un constructor sin argumentos.
Todas las propiedades de JavaBean deben tener métodos públicos de establecimiento y obtención.
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, generalmente se utilizan métodos getter/setter.
3. Constructor
Un constructor público sin ningún argumento.
4. captador/definidor
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 para un enfoque con menos código y más trabajo...
Los Java Beans se utilizan en 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 marco de activación de JavaBeans de Java EE utiliza Java Beans para integrar el soporte para 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.
Acerca de la serialización:
En la serialización de objetos, un objeto se puede representar 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.
Una vez que un objeto serializado se ha escrito en un archivo, se puede leer desde el archivo y deserializarlo, es decir, la información de tipo y los bytes que representan el objeto y sus datos se pueden usar para recrear el objeto en la memoria.
