Les endroits où les JavaBeans sont utilisés ?

Question

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

Veuillez expliquer le caractère essentiel d'un haricot dans le contexte ci-dessous :

• Applications Wep
• Applications autonomes

Answer 1

Ils ne représentent souvent que des données du monde réel. Voici un exemple simple d'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);
    }
}

Mise en œuvre de Serializable n'est pas obligatoire en soi, mais très utile si vous souhaitez être en mesure de conserver ou de transférer des Javabeans en dehors de la mémoire de Java, par exemple sur un disque dur ou sur un réseau.

Dans une classe DAO par exemple, vous pouvez l'utiliser pour créer une liste d'utilisateurs dans laquelle vous magasin les données de la user 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 transfert les 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 accès il par EL qui respecte 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 a du sens ? Vous voyez, c'est une sorte de convention que vous pouvez utiliser partout pour magasin , transfert y accès données.

Voir aussi :

• Spécification JavaBeans

Answer 2

Les haricots eux-mêmes

JavaBeans sont partout, c'est une convention et presque toutes les bibliothèques un peu plus grandes utilisent ces conventions pour automatiser les choses. Ce ne sont que quelques raisons pour lesquelles les JavaBeans devraient être utilisés :

• Ils se sérialisent bien.
• Peut être instancié en utilisant la réflexion.
• Sinon, il est possible de les contrôler très facilement en utilisant la réflexion.
• Bon pour encapsuler les données réelles du code métier.
• Les conventions communes signifient que tout le monde peut utiliser vos haricots et que vous pouvez utiliser les haricots de tout le monde sans aucune sorte 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 JavaBeans d'entreprise qui sont une toute autre affaire et ne devraient pas être mélangés avec des JavaBeans ordinaires. Je voulais simplement mentionner les EJB:s parce que les noms sont similaires et qu'il est facile de les confondre.

Les beans dans les applications web

Si vous considérez les JavaBeans "normaux" dans le contexte des applications 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 dans la session comme quelque chose qui est sérialisable - pourquoi ne pas en faire un bean alors ! Il suffit de lancer votre SomeBusinessDataBean dans la session et c'est parti, c'est ridiculement facile, conforme aux spécifications et pratique.

Le transfert de ces données dans l'application est également facile puisque les JavaBeans vous permettent de découpler complètement certaines parties de votre application. Imaginez les JavaBeans comme une lettre et les différents sous-systèmes de l'application comme les départements d'une très grande entreprise : Le département A envoie un paquet de données au département B, le département B ne sait pas - et n'a pas besoin de savoir - que les données ont été envoyées. ou même de s'en soucier - d'où proviennent les données, comme il se doit, et peut ouvrir la lettre, y lire des informations et faire son travail sur la base de ces données.

Les haricots dans les applications autonomes

En fait, ce qui précède s'applique également aux applications autonomes, la seule différence étant que vous pouvez modifier un peu plus l'interface utilisateur, car les applications autonomes ont des interfaces utilisateur à état, tandis que les applications Web ont des interfaces utilisateur à état qui, dans certains cas, ne font que simuler des interfaces utilisateur à état. En raison de cette différence, il est plus facile de faire des dégâts avec une application autonome, mais cela vaut un tout autre sujet et n'est pas du tout lié directement à JavaBeans.

Answer 3

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

• pour avoir un constructeur public, sans argument
• doit être sérialisable (mettre en œuvre l'interface Serializable, soit directement, soit par l'intermédiaire d'une de ses super classes).

En outre, vous pouvez ajouter des récupérateurs et des régleurs pour les propriétés de la classe qui se conforment à une convention d'appellation spécifique si vous souhaitez que les champs puissent être découverts dans certaines circonstances (par exemple, pour faire de cette classe un objet que vous pouvez faire glisser et déposer à partir d'un éditeur visuel dans votre IDE).

Vous pouvez en savoir plus directement auprès de Sun aquí .

Answer 4

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 quant à la capacité d'un Bean. Il peut exécuter une fonction simple, telle que la vérification de l'orthographe d'un document, ou une fonction complexe, telle que la prévision des performances d'un portefeuille d'actions. Un Bean peut être visible par un utilisateur final. C'est le cas, par exemple, d'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 circulaire à partir d'un ensemble de points de données est un exemple de Bean qui peut s'exécuter localement. En revanche, un Bean qui fournit des informations en temps réel sur les prix d'une bourse de valeurs ou de marchandises devra travailler en coopération avec d'autres logiciels distribués pour obtenir ses données.

Nous verrons prochainement quelles modifications spécifiques un développeur de logiciels doit apporter à une classe pour qu'elle soit utilisable en tant que Java Bean. Cependant, l'un des objectifs des concepteurs de Java était de faciliter l'utilisation de cette technologie. Par conséquent, les modifications du code sont minimes.

Avantages de 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 que la technologie Java offre à un développeur de composants :

• Un Bean bénéficie de tous les avantages du paradigme "write-once, run-anywhere" de Java.
• Les propriétés, les événements et les méthodes d'un Bean qui sont exposés à une application. peuvent être contrôlés.
• Un Bean peut être conçu pour fonctionner correctement dans différentes localités, 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 uniquement lorsque les paramètres de conception de ce composant sont définis. Il est disponible à l'adresse n'a pas besoin d'être inclus dans l'environnement d'exécution.
• Les paramètres de configuration d'un Bean peuvent être sauvegardés dans un stockage persistant et restaurés. à un moment ultérieur.
• Un Bean peut s'enregistrer pour recevoir des événements d'autres objets et peut générer des événements qui 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 véritable Bean nommé MyBean qui possède un état (la variable theValue) qui sera automatiquement sauvegardé et restauré par le mécanisme de persistance des JavaBeans, et il possède une propriété nommée MyValue qui est utilisable par un environnement de programmation visuelle. Ce Bean n'a pas de représentation visuelle, mais ce n'est pas une exigence pour un composant JavaBean.