Endroits où les JavaBeans sont utilisés?

Qu'est-ce qu'un JavaBean et pourquoi en ai-je besoin? Puisque je peux créer toutes les applications avec la structure de classe et d'interface? Pourquoi ai-je besoin de haricots? Et pouvez-vous me donner quelques exemples où les beans sont essentiels au lieu des classes et des interfaces?

Veuillez expliquer l'essentialité d'un haricot dans le contexte ci-dessous:

• Applications Wep
• Applications autonomes

Ils ne représentent souvent que des données du monde réel. Voici un exemple 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 mise en œuvre Serializablen'est pas obligatoire en soi, mais très utile si vous souhaitez pouvoir conserver ou transférer des Javabeans en dehors de la mémoire de Java, par exemple sur un disque dur ou sur le réseau.

Dans une classe DAO par exemple, vous pouvez l'utiliser pour créer une liste d'utilisateurs dans laquelle vous stockez les données de la usertable dans la base de données:

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;

Dans une classe Servlet, par exemple, vous pouvez l'utiliser pour transférer des données de la base de données vers l'interface utilisateur:

protected void doGet(HttpServletRequest request, HttpServletResponse response) {
    List<User> users = userDAO.list();
    request.setAttribute("users", users);
    request.getRequestDispatcher("users.jsp").forward(request, response);
}

Dans une page JSP par exemple, vous pouvez y accéder par EL , qui suit les conventions Javabean, pour afficher les données:

<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>

Est-ce que ça fait du sens? Vous voyez, c'est une sorte de convention que vous pouvez utiliser partout pour stocker , transférer et accéder aux données.

Voir également:

• Spécification JavaBeans

Haricots eux-mêmes

Les JavaBeans sont partout, ils sont une convention et à peu près toutes les bibliothèques légèrement plus grandes utilisent ces conventions pour automatiser les choses. Juste quelques raisons pour lesquelles JavaBeans devrait être utilisé:

• Ils sérialisent bien.
• Peut être instancié à l'aide de la réflexion.
• Peut autrement être contrôlé par réflexion très facilement.
• Idéal pour encapsuler les données réelles du code métier.
• Les conventions communes signifient que n'importe qui peut utiliser vos grains et VOUS POUVEZ UTILISER LES GRAINS DE TOUT LE MONDE D'AUTRE sans aucun type de documentation / manuel facilement et de manière cohérente.
• Très proche de POJO, ce qui signifie en fait encore plus d'interopérabilité entre les différentes parties du système.

Il y a aussi bien sûr les Enterprise JavaBeans qui sont une toute autre affaire et ne devraient pas être mélangés avec des JavaBeans simples. Je voulais juste mentionner EJB: s parce que les noms sont similaires et qu'il est facile de confondre les deux.

Beans dans les applications Web

Si vous considérez les JavaBeans «normaux» dans le contexte d'une application Web, ils ont plus de sens que de porter des chaussures dans les jambes. Puisque la spécification Servlet exige que les sessions soient sérialisables, cela signifie que vous devez stocker vos données en session comme quelque chose de sérialisable - pourquoi ne pas en faire un bean alors! Jetez simplement votre SomeBusinessDataBean dans la session et vous êtes prêt à partir, ridiculement facile, conforme aux spécifications et pratique.

Le transfert de ces données autour de l'application est également facile car les JavaBeans vous aident à découpler complètement certaines parties de votre application. Considérez JavaBeans comme une lettre et divers sous-systèmes de l'application comme des services au sein d'une très grande entreprise: le département A envoie un tas de données au département B, le département B ne sait pas - ou même s'en soucie - d'où viennent les données. comme il se doit et peut simplement ouvrir la lettre, lire des éléments et faire son travail en fonction de ces données.

Beans dans des applications autonomes

En fait, ce qui précède s'applique également aux applications autonomes, la seule différence est que vous pouvez gâcher un peu plus l'interface utilisateur puisque les applications autonomes ont une interface utilisateur avec état, tandis que les applications Web ont une interface utilisateur statels qui, dans certains cas, simule uniquement une interface utilisateur avec état: s . En raison de cette différence, il est plus facile de faire un gâchis avec une application autonome, mais cela vaut un tout autre sujet et n'est pas du tout directement lié aux JavaBeans.

Un haricot n'est pas grand-chose, vraiment. Pour qu'une classe soit un "bean", il suffit de:

• avoir un constructeur public, sans argument
• d'être sérialisable (pour implémenter l'interface Serializable, soit directement, soit via l'une de ses super classes).

À cela, vous pouvez ajouter des getters et des setters pour les propriétés de la classe qui se conforment à une convention de dénomination spécifique si vous voulez que les champs soient détectables dans certaines circonstances (par exemple, en faisant de cette classe un objet que vous pouvez glisser-déposer à partir d'un éditeur visuel dans votre IDE, par exemple).

Vous pouvez trouver plus directement de Sun ici .

Un Java Bean est un composant logiciel qui a été conçu pour être réutilisable dans une variété d'environnements différents. Il n'y a aucune restriction sur la capacité d'un Bean. Il peut remplir une fonction simple, telle que la vérification de l'orthographe d'un document, ou une fonction complexe, telle que la prévision de la performance d'un portefeuille d'actions. Un Bean peut être visible par un utilisateur final. Un exemple de ceci est un bouton sur une interface utilisateur graphique. Un Bean peut également être invisible pour un utilisateur. Un logiciel permettant de décoder un flux d'informations multimédia en temps réel est un exemple de ce type de bloc de construction. Enfin, un Bean peut être conçu pour fonctionner de manière autonome sur le poste de travail d'un utilisateur ou pour travailler en coopération avec un ensemble d'autres composants distribués. Un logiciel permettant de générer un graphique à secteurs à partir d'un ensemble de points de données est un exemple de Bean qui peut s'exécuter localement. cependant,

Nous verrons sous peu quels changements spécifiques un développeur de logiciel doit apporter à une classe pour qu'elle soit utilisable comme un Java Bean. Cependant, l'un des objectifs des concepteurs Java était de faciliter l'utilisation de cette technologie. Par conséquent, les modifications de code sont minimes.

Avantages des Java Beans

Une architecture de composants logiciels fournit des mécanismes standard pour traiter les blocs de construction logiciels. La liste suivante énumère certains des avantages spécifiques de la technologie Java pour un développeur de composants:

• Un Bean bénéficie de tous les avantages du paradigme Java "écriture unique, exécution partout".
• Les propriétés, événements et méthodes d'un Bean qui sont exposés à un outil de création d'application peuvent être contrôlés.
• Un Bean peut être conçu pour fonctionner correctement dans différents paramètres régionaux, ce qui le rend utile sur les marchés mondiaux.
• Un logiciel auxiliaire peut être fourni pour aider une personne à configurer un Bean. Ce logiciel n'est nécessaire que lorsque les paramètres de conception de ce composant sont définis. Il n'a pas besoin d'être inclus dans l'environnement d'exécution.
• Les paramètres de configuration d'un Bean peuvent être enregistrés dans un stockage persistant et restaurés ultérieurement.
• Un Bean peut s'inscrire pour recevoir des événements d'autres objets et peut générer des événements qui sont envoyés à d'autres objets.

Voici un exemple 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;
      }

}

Il s'agit d'un vrai Bean nommé MyBean qui a l'état (la variable theValue) qui sera automatiquement sauvegardé et restauré par le mécanisme de persistance JavaBeans, et il a une propriété nommée MyValue qui est utilisable par un environnement de programmation visuelle. Ce Bean n'a aucune représentation visuelle, mais ce n'est pas une exigence pour un composant JavaBean.