¿Lugares donde se utilizan JavaBeans?

¿Qué es un JavaBean y por qué lo necesito? ¿Ya puedo crear todas las aplicaciones con la clase y la estructura de la interfaz? ¿Por qué necesito frijoles? ¿Y me puede dar algunos ejemplos donde los beans son esenciales en lugar de clases e interfaces?

Explique la esencialidad de un bean en el siguiente contexto:

• Aplicaciones Wep
• Aplicaciones independientes

A menudo solo representan datos del mundo real. Aquí hay un ejemplo simple de un 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 Serializableno es per se obligatoria, pero es muy útil si desea poder persistir o transferir Javabeans fuera de la memoria de Java, por ejemplo, en disco duro o en red.

En, por ejemplo, una clase DAO, puede usarla para crear una lista de usuarios en la que almacene los datos de la usertabla 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 de 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 a la que puede acceder por EL , que sigue las convenciones de Javabean, para mostrar 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 todas partes para almacenar , transferir y acceder a datos.

Ver también:

• Especificación de JavaBeans

Frijoles

Los JavaBeans están en todas partes, son una convención y casi todas las bibliotecas un poco más grandes que existen utilizan esas convenciones para automatizar las cosas. Solo algunas razones por las que se deben usar JavaBeans:

• Se serializan muy bien.
• Puede ser instanciado usando la reflexión.
• De lo contrario, se puede controlar usando 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 TODOS LOS FRESOS sin ningún tipo de documentación / manual de manera fácil y consistente.
• Muy cerca de POJO s, lo que en realidad significa aún más interoperabilidad entre distintas partes del sistema.

También hay, por supuesto, Enterprise JavaBeans, que son un asunto completamente diferente y no deben mezclarse con JavaBeans simples. Solo quería mencionar EJB: s porque los nombres son similares y es fácil confundirlos.

Frijoles en aplicaciones web

Si considera JavaBeans "normales" en el contexto de la aplicación web, tienen más sentido que usar zapatos en las piernas. Dado que la especificación de Servlet requiere que las sesiones sean serializables, significa que debe almacenar sus datos en la sesión como algo que es serializable, ¡por qué no convertirlo en un bean entonces! Simplemente arroje su SomeBusinessDataBean a la sesión y estará listo, ridículamente fácil, compatible con las especificaciones y conveniente.

También es fácil transferir esos datos alrededor de la aplicación, ya que JavaBeans lo ayuda 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: el Departamento A envía una gran cantidad de datos al Departamento B, el Departamento B no sabe, ni siquiera le importa , de dónde provienen los datos solo como debería ser y solo puede abrir la carta, leer cosas de ella y hacer lo suyo en función de esos datos.

Frijoles en aplicaciones independientes

En realidad, lo anterior también se aplica a las aplicaciones independientes, la única diferencia es que puedes meterte un poco más con la interfaz de usuario, ya que las aplicaciones independientes tienen UI con estado mientras que las aplicaciones web tienen UI con estado que en algunos casos solo simulan interfaz de usuario con estado . Debido a esta diferencia, es más fácil hacer un lío con la aplicación independiente, pero eso vale otro tema y no está directamente relacionado con JavaBeans.

Un frijol no es mucho, de verdad. Para que una clase sea un "bean", todo lo que requiere es:

• tener un constructor público sin argumentos
• ser serializable (para implementar la interfaz serializable, directamente o mediante una de sus superclases).

A eso, puede agregar captadores y establecedores para las propiedades de la clase que se ajustan a una convención de nomenclatura específica si desea que los campos sean reconocibles en ciertas circunstancias (por ejemplo, hacer de esa clase un objeto que pueda arrastrar y soltar desde un editor visual en su IDE, por ejemplo).

Puede encontrar más directamente desde Sun aquí .

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 pronosticar 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 un flujo 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 puede ejecutarse localmente. Sin embargo,

En breve veremos qué cambios específicos debe hacer un desarrollador de software en una clase para que pueda utilizarse 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 en el código son mínimos.

Ventajas de Java Beans

Una arquitectura de componentes de software proporciona mecanismos estándar para lidiar con los componentes básicos del software. La siguiente lista enumera algunos de los beneficios específicos que la tecnología Java proporciona para un desarrollador de componentes:

• Un Bean obtiene todos los beneficios del paradigma de "escribir una vez, ejecutar en cualquier lugar" de Java.
• 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 estar diseñado para funcionar correctamente en diferentes lugares, lo que lo hace útil en los mercados globales.
• Se puede proporcionar 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.
• Los ajustes de configuración de un Bean pueden 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 un 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 un estado (la variable theValue) que será guardado y restaurado automáticamente por el mecanismo de persistencia JavaBeans, y tiene una propiedad llamada MyValue que puede ser utilizada por un entorno de programación visual. Este Bean no tiene ninguna representación visual, pero ese no es un requisito para un componente JavaBean.