En JavaServer Faces, los JSF Managed Beans son un componente fundamental para la creación de aplicaciones. Un Managed Bean es una clase regular de Java Bean (POJO) que es instanciada y administrada por el framework JSF. Estos Managed Beans se utilizan para almacenar datos y realizar operaciones basadas en la entrada del usuario o eventos externos.
Los Managed beans también se pueden usar para almacenar y administrar datos específicos de la aplicación, como por ejemplo, las preferencias del usuario. JSF proporciona soporte para el enlace de datos entre Managed Beans y componentes de la interfaz de usuario, lo que permite que los datos se muestren y manipulen directamente en la interfaz de usuario. Además, los Managed Beans se pueden usar para realizar la lógica del lado del servidor e interactuar con bases de datos u otros sistemas externos.
Un Managed Bean se puede definir para un ámbito particular, como ser sesión o aplicación, lo que determina su ciclo de vida y disponibilidad. El alcance predeterminado es el alcance de Solicitud o Request, lo que significa que se crea una nueva instancia del bean para cada nuevo request. Otras opciones de alcance incluyen el alcance de sesión, el alcance de vista y el alcance de aplicación.
En JSF, los Managed Beans se pueden configurar de varias maneras, como anotaciones, configuración XML o mediante programación. La forma más común de definir un Managed Bean es mediante las anotaciones @ManagedBean o @Named. Estas anotaciones permiten que JSF administre el bean y también defina su alcance.
En las siguientes secciones se aborda la configuración de Managed Beans en diferentes versiones de JSF.
Managed Beans en JSF 1.X
En JSF 1.x, los Managed Beans normalmente se definían en el archivo de configuración faces-config.xml usando el elemento <managed-bean>. El elemento managed-bean contenía subelementos para managed-bean-name (el nombre con el que se identifica el Managed Bean), managed-bean-class (el nombre de la clase Java que contiene el código Managed Bean) y managed-bean-scope (la vida útil del Mananged Bean, como petición, sesión o aplicación).
Aquí hay un ejemplo:
<managed-bean>
<managed-bean-name>myBean</managed-bean-name>
<managed-bean-class>com.example.MyBean</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
</managed-bean>
En este ejemplo, hemos definido un ManagedBean llamado «myBean» que es del tipo com.example.MyBean y tiene un alcance de petición (request).
Si bien este enfoque funcionaba, era engorroso y requería una configuración manual en el archivo faces-config.xml. JSF 2.0 introdujo anotaciones como alternativa, lo que permitió el descubrimiento y configuración automáticos de Managed Beans sin necesidad de archivos de configuración XML.
Managed Beans en JSF 2.0
En JSF 2.0 se introdujo la anotación @ManagedBean para registrar un Managed Bean, utilizando el atributo name para referenciar al Bean desde las páginas xhtml.
Aquí hay un ejemplo:
package main.java;
import java.io.Serializable;
import javax.faces.bean.ManagedBean;
import javax.faces.view.RequestScoped;
@ManagedBean(name = "firstBean")
@RequestScoped
public class MyManagedBean implements Serializable {
private static final long serialVersionUID = 1L;
private String message = "Hello, world!";
public String getMessage() {
return this.message;
}
public void setMessage(String message) {
this.message = message;
}
}
En este ejemplo, hemos creado un Managed Bean llamado «firstBean» usando la anotación @ManagedBean. También hemos agregado una propiedad llamada «message» con sus correspondientes métodos getter y setter.
La propiedad del bean puede ser accedida desde una vista usando una expresión como en el siguiente ejemplo:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Hello JSF 2</title>
</head>
<body>
<h:outputText value="#{firstBean.message}" />
</body>
</html>
Managed Beans en JSF 2.3
Los Managed Beanns siguen siendo una parte importante de las aplicaciones JavaServer Faces (JSF) en la versión 2.3 están deprecadas las anotaciones relativas a configuración de Managed Beans (@ManagedBean, etc), y hay algunas características nuevas importantes que se deben tener en cuenta. JSF 2.3 introdujo soporte para CDI Beans como Managed Beans, lo que permite una mayor flexibilidad en la administración de beans. Además, JSF 2.3 proporciona algunas anotaciones nuevas para la configuración de beans.
Una de las nuevas anotaciones más importantes es @Named, que se utiliza para definir qué beans deben estar disponibles para las expresiones EL (Lenguaje de expresión) en las páginas JSF. Otra anotación importante es @Inject, que se usa para inyectar dependencias en un Managed Bean. Esto se puede usar en lugar de la antigua anotación @ManagedProperty.
Aquí hay un ejemplo de cómo configurar un Managed Bean usando las anotaciones @Named y @Inject en JSF 2.3:
import javax.inject.Inject;
import javax.inject.Named;
import services.MyService;
@Named(value = "myBean")
public class MyManagedBean {
@Inject
MyService service;
public String getMessage() {
return "Hello, world";
}
public String getMessageFromService() {
return service.getNewMessage();
}
}
En este ejemplo, la anotación @Named hace que el bean esté disponible para expresiones EL en páginas JSF. La anotación @Inject inyecta una dependencia en el bean.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Hello JSF 2.3</title>
</head>
<body>
Default Message: #{myBean.message} <br></br>
Service Message: #{myBean.messageFromService}
</body>
</html>
En general, JSF 2.3 proporciona algunas funciones nuevas y potentes para la configuración de Managed Beans, y estas anotaciones son solo la punta del iceberg. Con más exploración y experimentación, los desarrolladores pueden aprovechar al máximo estas funciones para crear aplicaciones JSF más flexibles y potentes.
Conclusión
En resumen, los Managed Beans son una parte esencial del desarrollo de aplicaciones JSF. Proporcionan una forma de administrar los datos de la aplicación, interactuar con los componentes de la interfaz de usuario y realizar la lógica del lado del servidor. Al definir un Managed Bean, JSF se ocupa de la instanciación, el ámbito o scope y la administración del ciclo de vida del bean, lo que lo convierte en una herramienta poderosa y conveniente para crear aplicaciones web.
Te puede interesar
JSF aplicación de ejemplo
En este artículo veremos un ejemplo de como crear una aplicación JSF básica desde cero utilizando Apache Maven.
Arquitectura y Ciclo de Vida JSF
Cómo funciona el ciclo de vida de una aplicación JSF. En el artículo relacionado se cubre el manejo de eventos.
JSF inputSecret
El componente JSF inputSecret permite crear un elemento de HTML. En este artículo se explica su utilización y ejemplos.
