1. Managed Beans
Un Managed Bean (Bean géré) est un POJO (une classe qui ne dérive d'aucune autre classe et qui n'implémente ni une interface ni une quelconque classe spécifique) qui respecte les spécifications des Java Bean, supporte un certain nombre de services comme l'Injection de code et la notion de Callback et qui possède un constructeur public sans argument; il est initialisé par le Container au moment de l’exécution par le Serveur de l'application au sein de laquelle il est développé.
Quand il contient les données des formulaires présentes dans une vue (en général une vue est associée à un Managed Bean) on l'appelle Backing Bean; les Managed Beans de façon générale permettent d'échanger des données et des informations entre les différents composants d'une application web JSF.
Les Managed Beans sont prises en charge par la Servlet FacesServlet. Les composants de l’interface utilisateur sont liés aux propriétés du Managed bean (Backing bean) et peuvent invoquer des méthodes du Managed bean qui lui sont associées.
Un Managed bean respecte les contraintes suivantes:
- La classe Managed Bean doit être annotée par @javax.faces.model.ManagedBean ou son équivalent dans le descripteur de déploiement XML faces-config.xml.
- La classe doit avoir une portée ( par défaut la portée d'un Managed Bean est @RequestScoped).
- La classe doit être publique, non finale et non abstraite.
- La classe doit fournir un constructeur public sans paramètre qui sera utilisé par le conteneur pour créer les instances.
- La classe ne doit pas définir de méthode finalize() .
- Pour être liés à un composant, les attributs doivent avoir des getters et des setters publics. Bien qu’un Managed Bean puisse être un simple POJO annoté, sa configuration peut être personnalisée grâce aux éléments de @ManagedBean et @ManagedProperty (ou leurs équivalents XML).
Exemples
@ManagedBean
@SessionScoped
public class UserBean {
@ManagedProperty(value="Camil")
private String firstName;
@ManagedProperty(value="OMARA")
private String lastName;
String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}
Détails
Comme on l'a dit un peu plus haut, une classe est considérée comme un Bean géré si elle précédée de l' annotation @ManagedBean; cette annotation a des attributs et le premier d'entre elles c'est "name"; cet attribut donne un nom à la Managed Bean; si cette attribut n'existe pas le Managed Bean portera le nom de la classe commençant par une lettre minuscule.
@SessionScoped : cette annotation précise la portée du Manage Bean; cest au niveau de la session ....
@ManagedProperty: cette annotaaiton permet d'initialiser l propriété qui le suit; On verra par la suite des annotions au fur et à mesure.
2. Backing Beans
Dans les applications développées avec JSF, les Backing beans gèrent l'interaction entre la Vue (UI) et le Modèle. Le terme "Backing Bean" définit un Managed Bean associé à une page web (une vue - si le nom de la vue est login.xml le Backing Bean Associé portera le nom Login.java -); sa portée est au niveau d'une requête.
Un Backing Bean n'est pas considéré comme faisant partie de la logique métier de l'application; c'est de la responsabilité du Backing Bean de mettre en relation les vues et la logique métier. Les traitements liés directement à l'interface utilisateur sont écrits dans les backing beans; ces Backing Beans font appel à des EJB Stateles ou State-full et des classes Java ordinaires pour effectuer les traitements qui ne sont pas liés directement à l'interface utilisateur.
Exemples
package javaeetutorial.guessnumber;
import java.io.Serializable;
import java.util.Random;style="background-color: #fef86c;"
import javax.enterprise.context.SessionScoped;
import javax.inject.Named;
@Named
@SessionScoped
public class UserNumberBean implements Serializable {
private static final long serialVersionUID = 5443351151396868724L;
Integer randomInt = null;
Integer userNumber = null;
String response = null;
private int maximum = 10;
private int minimum = 0;
public UserNumberBean() {
Random randomGR = new Random();
randomInt = new Integer(randomGR.nextInt(maximum + 1));
// Print number to server logstyle="background-color: #fef86c;"
System.out.println("Duke's number: " + randomInt);
}
public void setUserNumber(Integer user_number) {
userNumber = user_number;
}
public Integer getUserNumber() {
return userNumber;
}
public String getResponse() {
if ((userNumber == null) || (userNumber.compareTo(randomInt) != 0)) {
return "Sorry, " + userNumber + " is incorrect.";
} else {
return "Yay! You got it!";
}
}
public int getMaximum() {
return (this.maximum);
}
public void setMaximum(int maximum) {
this.maximum = maximum;
}
public int getMinimum() {
return (this.minimum);
}
public void setMinimum(int minimum) {
this.minimum = minimum;
}
}
Détails
L'annotation @Named permet à la Managed Bean (ici on a un Managed Bean CDI - voir ci-dessous) d'être accessible par son nom (si le nom n'est pas donné comme ici, le managed bean aura le même nom que la classe mais avec une première lettre minuscule) et l'annotation @SessionScoped précise que la portée du bean est limitée à la session en cours une fois l'application lancée. Le langage EL permet d'échanger des informations entre les Backing Bean et les facelets correspondants.
(à suivre )...
Les Managed Beans CDI
Les Managed Beans sont reconnaissables par l'annotation @ManagedBean. Les Managed Beans sont assez limités et JSF, dans sa dernière version, définit un modèle de Managed bean plus flexible, qu'on peut appelé Managed Bean CDI (Contexts and Dependency Injection). Ce type de Managed bean, comme son nom l'indique, est lié à un context (comme, par exemple, la requête en cours, la session actuelle du navigateur, ou même le cycle de vie du contexte de l'utilisateur). On retrouve pratiquement la même syntaxe que les Managed Beans sauf qu'on utilise l'annotation @Named en lieu et place de l'annotation @ManagedBean.
(à suivre )...
