que - ¿Dónde se utilizan JavaBeans?
patrón javabeans (4)
Los frijoles mismos
JavaBeans están en todas partes, son una convención y casi todas las bibliotecas un poco más grandes usan esas convenciones para automatizar las cosas. Solo unas pocas razones por las que JavaBeans debería usarse:
- Se serializan muy bien.
- Puede ser instanciado usando reflexión.
- De lo contrario, se puede controlar utilizando la reflexión muy fácilmente.
- Bueno para encapsular datos reales del código comercial.
- Las convenciones comunes significan que cualquiera puede usar sus frijoles Y USTED PUEDE UTILIZAR CADA VEZ DE FRIJOLES sin ningún tipo de documentación / manual fácilmente y de manera consistente.
- Muy cerca de POJO s, que en realidad significa aún más interoperabilidad entre las distintas partes del sistema.
También están, por supuesto, Enterprise JavaBeans, que son un asunto completamente diferente y no deberían mezclarse con JavaBeans simples. Solo quería mencionar a EJB: s porque los nombres son similares y es fácil confundirlos.
Frijoles en aplicaciones web
Si considera los JavaBeans "normales" en el contexto de la aplicación web, tienen más sentido que usar zapatos en sus piernas. Como la especificación de Servlet requiere que las sesiones sean serializables, significa que debe almacenar sus datos en sesión como algo que se puede serializar. ¡Entonces, por qué no convertirlo en frijol! Simplemente arroje su SomeBusinessDataBean en la sesión y estará listo, ridículamente fácil, conforme a las especificaciones y conveniente.
También es fácil transferir esos datos alrededor de la aplicación, ya que los JavaBeans lo ayudan a desacoplar partes de su aplicación por completo. Piense en JavaBeans como una carta y varios subsistemas de la aplicación como departamentos dentro de una corporación muy grande: Dept.A envía un montón de datos al Dept.B, Dept.B no sabe, ni siquiera le importa , de dónde provienen los datos. como debería ser y puede simplemente abrir la carta, leer cosas de ella y hacer sus cosas en base a esos datos.
Frijoles en aplicaciones independientes
En realidad, lo anterior también se aplica a las aplicaciones independientes, la única diferencia es que puedes jugar un poco más con la UI ya que las aplicaciones independientes tienen UI con estado mientras que las aplicaciones web tienen UIs de estado que en algunos casos solo simulan UI con estado: s . Debido a esta diferencia, es más fácil hacer un lío con la aplicación independiente, pero eso vale un tema completamente diferente y no está directamente relacionado con JavaBeans en absoluto.
¿Qué es un JavaBean y por qué lo necesito? ¿Puedo crear todas las aplicaciones con la clase y la estructura de la interfaz? ¿Por qué necesito frijoles? ¿Y puede darme algunos ejemplos donde los frijoles son esenciales en lugar de clases e interfaces?
Por favor explique la esencialidad de un frijol en el siguiente contexto:
- Aplicaciones Wep
- Aplicaciones autónomas
A menudo solo representan datos del mundo real. Aquí hay un ejemplo simple de Javabean:
public class User implements java.io.Serializable {
// Properties.
private Long id;
private String name;
private Date birthdate;
// Getters.
public Long getId() { return id; }
public String getName() { return name; }
public Date getBirthdate() { return birthdate; }
// Setters.
public void setId(Long id) { this.id = id; }
public void setName(String name) { this.name = name; }
public void setBirthdate(Date birthdate) { this.birthdate = birthdate; }
// Important java.lang.Object overrides.
public boolean equals(Object other) {
return (other instanceof User) && (id != null) ? id.equals(((User) other).id) : (other == this);
}
public int hashCode() {
return (id != null) ? (getClass().hashCode() + id.hashCode()) : super.hashCode();
}
public String toString() {
return String.format("User[id=%d,name=%s,birthdate=%d]", id, name, birthdate);
}
}
La implementación de Serializable no es obligatoria en sí misma, pero es muy útil si desea poder conservar o transferir Javabeans fuera de la memoria de Java, por ejemplo, en el disco duro o en la red.
En, por ejemplo, una clase DAO, puede usarla para crear una lista de usuarios en la que almacena los datos de la tabla de user en la base de datos:
List<User> users = new ArrayList<User>();
while (resultSet.next()) {
User user = new User();
user.setId(resultSet.getLong("id"));
user.setName(resultSet.getString("name"));
user.setBirthdate(resultSet.getDate("birthdate"));
users.add(user);
}
return users;
En, por ejemplo, una clase Servlet puede usarla para transferir datos de la base de datos a la IU:
protected void doGet(HttpServletRequest request, HttpServletResponse response) {
List<User> users = userDAO.list();
request.setAttribute("users", users);
request.getRequestDispatcher("users.jsp").forward(request, response);
}
En, por ejemplo, una página JSP, puede acceder a ella mediante EL , que sigue las convenciones de Javabean, para visualizar los datos:
<table>
<tr>
<th>ID</th>
<th>Name</th>
<th>Birthdate</th>
</tr>
<c:forEach items="${users}" var="user">
<tr>
<td>${user.id}</td>
<td><c:out value="${user.name}" /></td>
<td><fmt:formatDate value="${user.birthdate}" pattern="yyyy-MM-dd" /></td>
</tr>
</c:forEach>
</table>
¿Tiene sentido? Verá, es una especie de convención que puede usar en cualquier lugar para almacenar , transferir y acceder a los datos.
Ver también:
Un Java Bean es un componente de software que ha sido diseñado para ser reutilizable en una variedad de entornos diferentes. No hay restricción en la capacidad de un Bean. Puede realizar una función simple, como verificar la ortografía de un documento, o una función compleja, como prever el rendimiento de una cartera de acciones. Un Bean puede ser visible para un usuario final. Un ejemplo de esto es un botón en una interfaz gráfica de usuario. Un Bean también puede ser invisible para un usuario. El software para decodificar una secuencia de información multimedia en tiempo real es un ejemplo de este tipo de bloques de construcción. Finalmente, un Bean puede estar diseñado para funcionar de manera autónoma en la estación de trabajo de un usuario o para trabajar en cooperación con un conjunto de otros componentes distribuidos. El software para generar un gráfico circular a partir de un conjunto de puntos de datos es un ejemplo de un Bean que se puede ejecutar localmente. Sin embargo, un Bean que proporcione información de precios en tiempo real de una bolsa de acciones o de materias primas deberá trabajar en cooperación con otro software distribuido para obtener sus datos.
Veremos en breve qué cambios específicos debe realizar un desarrollador de software en una clase para que se pueda utilizar como Java Bean. Sin embargo, uno de los objetivos de los diseñadores de Java era facilitar el uso de esta tecnología. Por lo tanto, los cambios de código son mínimos.
Ventajas de Java Beans
Una arquitectura de componentes de software proporciona mecanismos estándar para tratar con los componentes básicos del software. La siguiente lista enumera algunos de los beneficios específicos que proporciona la tecnología Java para un desarrollador de componentes:
- A Bean obtiene todos los beneficios del paradigma de Java "write-once, run-anywhere".
- Las propiedades, eventos y métodos de un Bean que están expuestos a una herramienta de creación de aplicaciones se pueden controlar.
- Un Bean puede diseñarse para funcionar correctamente en diferentes lugares, lo que lo hace útil en los mercados globales.
- Se puede proporcionar un software auxiliar para ayudar a una persona a configurar un Bean. Este software solo es necesario cuando se establecen los parámetros de tiempo de diseño para ese componente. No necesita ser incluido en el entorno de tiempo de ejecución.
- La configuración de configuración de un Bean puede guardarse en un almacenamiento persistente y restaurarse en otro momento.
- Un Bean puede registrarse para recibir eventos de otros objetos y puede generar eventos que se envían a otros objetos.
Aquí hay un ejemplo simple de Javabean:
public class MyBean implements java.io.Serializable
{
protected int theValue;
public MyBean()
{
}
public void setMyValue(int newValue)
{
theValue = newValue;
}
public int getMyValue()
{
return theValue;
}
}
Este es un Bean real llamado MyBean que tiene estado (la variable theValue) que se guardará y restaurará automáticamente por el mecanismo de persistencia JavaBeans, y tiene una propiedad llamada MyValue que se puede utilizar mediante un entorno de programación visual. Este Bean no tiene ninguna representación visual, pero eso no es un requisito para un componente JavaBean.
Un frijol no es mucho, realmente. Para que una clase sea un "frijol", todo lo que se requiere es:
- tener un constructor público, sin argumentos
- ser serializable (para implementar la interfaz Serializable, ya sea directamente o a través de una de sus súper clases).
Para eso, puede agregar getters y setters para propiedades de la clase que se ajusten a una convención de nomenclatura específica si desea que los campos sean reconocibles en ciertas circunstancias (p. Ej. Hacer de esa clase algún objeto que pueda arrastrar y soltar de un editor visual en su IDE, por ejemplo).
Puede encontrar más directamente de Sun here .