JavaBeans

En informatique basée sur la plate-forme Java , JavaBeans est une technologie développée par Sun Microsystems et publiée en 1996, dans le cadre du JDK 1.1.

Les « beans » de JavaBeans sont des classes qui encapsulent un ou plusieurs objets dans un seul objet standardisé (le bean). Cette standardisation permet de gérer les beans de manière plus générique, ce qui facilite la réutilisation et l'introspection du code . Cela permet ensuite de traiter les beans comme des composants logiciels et d'être manipulés visuellement par les éditeurs et les IDE sans nécessiter de configuration initiale ni de connaître les détails d'implémentation interne.

Dans le cadre de la normalisation, tous les beans doivent être sérialisables , avoir un constructeur sans argument et autoriser l'accès aux propriétés à l'aide des méthodes getter et setter .

Introspection

L'introspection est un processus d'analyse d'un Bean pour déterminer ses capacités. Il s'agit d'une fonctionnalité essentielle de la spécification Java Beans car elle permet à une autre application, comme un outil de conception, d'obtenir des informations sur un composant.

Propriétés

Une propriété est un sous-ensemble de l'état d'un Bean. Les valeurs attribuées aux propriétés déterminent le comportement et l'apparence de ce composant. Elles sont définies via une méthode setter et peuvent être obtenues via une méthode getter.

Personnalisation

Un personnalisateur peut fournir un guide étape par étape que le processus doit suivre pour utiliser le composant dans un contexte spécifique.

Événements

Les Beans peuvent interagir avec le modèle EventObject EventListener.

Persistance

La persistance est la capacité de sauvegarder l'état actuel d'un Bean, y compris les valeurs des propriétés et des variables d'instance d'un Bean, dans un stockage non volatil et de les récupérer ultérieurement.

Méthodes

Un Bean doit utiliser des méthodes d'accès pour encapsuler les propriétés. Un Bean peut fournir d'autres méthodes pour la logique métier non liée à l'accès aux propriétés.

• Les propriétés, événements et méthodes d'un bean peuvent être exposés à une autre application.
• Un bean peut s'enregistrer pour recevoir des événements d'autres objets et peut générer des événements qui sont envoyés à ces autres objets.
• Un logiciel auxiliaire peut être fourni pour aider à configurer un bean.
• Les paramètres de configuration d'un bean peuvent être enregistrés dans un stockage persistant et restaurés.

• Une classe avec un constructeur sans argument est susceptible d'être instanciée dans un état non valide. Si une telle classe est instanciée manuellement par un développeur (plutôt qu'automatiquement par un framework), le développeur peut ne pas se rendre compte que la classe a été instanciée de manière incorrecte. Le compilateur ne peut pas détecter un tel problème, et même s'il est documenté, il n'y a aucune garantie que le développeur verra la documentation.
• Les JavaBeans sont intrinsèquement mutables et ne bénéficient donc pas des avantages offerts par les objets immuables .
• Le fait de devoir créer des getters pour chaque propriété et des setters pour plusieurs, la plupart ou la totalité d'entre elles peut conduire à une immense quantité de code standard .

La fonctionnalité JavaBeans est fournie par un ensemble de classes et d'interfaces dans le java.beanspackage.

Pour fonctionner comme une classe JavaBean , une classe d'objet doit obéir à certaines conventions concernant la dénomination, la construction et le comportement des méthodes. Ces conventions permettent de disposer d'outils capables d'utiliser, de réutiliser, de remplacer et de connecter des Java Beans.

Les conventions requises sont les suivantes :

• La classe doit avoir un constructeur public par défaut (sans arguments). Cela permet une instanciation facile dans les frameworks d'édition et d'activation.
• Les propriétés de classe doivent être accessibles à l'aide de get , set , is (peut être utilisé pour les propriétés booléennes à la place de get), to et d'autres méthodes (appelées méthodes d'accès et méthodes de mutation ) selon une convention de nommage standard . Cela permet une inspection et une mise à jour automatisées faciles de l'état du bean dans les frameworks, dont beaucoup incluent des éditeurs personnalisés pour différents types de propriétés. Les setters peuvent avoir un ou plusieurs arguments.
• La classe doit être sérialisable . (Cela permet aux applications et aux frameworks de sauvegarder, stocker et restaurer de manière fiable l'état du bean d'une manière indépendante de la VM et de la plateforme.)

lecteur de paquets ;
la classe publique PersonBean implémente java . io . Serializable {
/** Propriétés **/ 
booléen privé décédé = false ;
Liste privée liste ;
/** Propriété "name", lisible/inscriptible. */ 
private String name = null ;
/** Constructeur sans argument (ne prend aucun argument). */ 
public PersonBean () { }
public List getList () { renvoie la liste ; } public void setList ( liste finale liste ) { this . list = liste ; }
/** 
 * Getter pour la propriété "name". 
 */ 
public String getName () { return name ; }
/** 
 * Setter pour la propriété "name". 
 * 
 * @param value 
 */ 
public void setName ( final String value ) { this . name = value ; }
/** 
 * Getter pour la propriété "deceased" 
 * Syntaxe différente pour un champ booléen (is vs get) 
 */ 
public boolean isDeceased () { return died ; }
/** 
 * Setter pour la propriété "décédé". 
 * @param value 
 */ 
public void setDeceased ( boolean value ) { died = value ; } }

TestPersonBean.java:

importer le joueur.PersonBean ;
/** 
* Classe "TestPersonBean". 
*/ 
public class TestPersonBean { /**  * Méthode de testeur "main" pour la classe "PersonBean".  *  * @param arguments  */ public static void main ( final String [] arguments ) { final PersonBean person = new PersonBean ();
personne . setName ( "Bob" ); 
personne . setDeceased ( false ); personne . setList ( new ArrayList ());
// Sortie : « Bob [vivant] » 
System . out . print ( person . getName ()); System . out . println ( person . isDeceased () ? « [décédé] » : « [vivant] » ); } }

<jsp:useBean id= "personne" class= "joueur.PersonBean" portée= "page" /> <jsp:setProperty name= "personne" property= "*" />
<html> 
<body> Nom : <jsp:getProperty name= "person" property= "name" /><br/> Décédé ? <jsp:getProperty name= "person" property= "deceased" /><br/> <br/> <form name= "beanTest" method= "POST" action= "testPersonBean.jsp" > Entrez un nom : <input type= "text" name= "name" size= "50" ><br/> Choisissez une option : <select name= "deceased" > <option value= "false" > Vivant </option> <option value= "true" > Mort </option> </select> <input type= "submit" value= "Tester le Bean" > </form> </body> </html>