Des endroits où les JavaBeans sont utilisés?
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 haricots? Et pouvez-vous me donner quelques exemples où les haricots sont essentiels au lieu des classes et des interfaces?
S'il vous plaît expliquer l'essentialité d'un haricot dans le contexte ci-dessous:
- Applications Wep
- Applications autonomes
Ils représentent souvent simplement des données du monde réel. Voici un exemple simple de Javabéen:
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);
}
}
L'implémentation de Serializable n'est pas obligatoire en soi, mais elle est très utile si vous souhaitez pouvoir conserver ou transférer des Javabeans en dehors de la mémoire de Java, par exemple. en disque dur ou sur le réseau.
Par exemple, dans une classe DAO, vous pouvez l’utiliser pour créer une liste d’utilisateurs dans lesquels vous stockez les données de la table user de 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 accéder par EL , ce qui suit les conventions javabéennes, 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 store, transfer et accès données.
Voir également:
Haricots eux-mêmes
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 des choses. Quelques raisons pour lesquelles JavaBeans doit être utilisé:
- Ils sérialisent bien.
- Peut être instancié en utilisant la réflexion.
- Peut autrement être contrôlé en utilisant la réflexion très facilement.
- Bon pour encapsuler les données réelles du code d'entreprise.
- Les conventions courantes signifient que tout le monde peut utiliser vos haricots ET VOUS POUVEZ UTILISER LES BEANS DE TOUS LES AUTRES sans n'importe quel type de documentation/manuel facilement et de manière cohérente.
- Très proche de POJO s, ce qui signifie encore plus d'interopérabilité entre des parties distinctes du système.
Il y a aussi bien sûr Enterprise JavaBeans qui est une toute autre affaire et ne doit pas être mélangé avec de simples JavaBeans. Je voulais juste mentionner EJB: s parce que les noms sont similaires et qu'il est facile de confondre ces deux-là.
Beans dans les applications web
Si vous considérez des JavaBeans "normaux" dans le contexte d'applications Web, ils ont plus de sens que de porter des chaussures à la jambe. Étant donné que la spécification Servlet exige que les sessions soient sérialisables, cela signifie que vous devez stocker vos données en session sous un format sérialisable. Pourquoi ne pas en faire un bean! Il suffit de lancer votre SomeBusinessDataBean dans la session et vous êtes prêt à partir, incroyablement facile, conforme aux spécifications et pratique.
Il est également facile de transférer ces données dans l'application, car JavaBeans vous aide à découpler complètement certaines parties de votre application. Pensez à JavaBeans comme une lettre et divers sous-systèmes de l’application en tant que départements d’une très grande entreprise: Dept.A envoie une série de données à Dept.B, Dept.B ne sait pas - ou même attention - d'où proviennent les données telles qu'elles devraient être et qui peuvent simplement ouvrir la lettre, en lire des extraits et faire ce qu'il faut en fonction de ces données.
Les haricots 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 l’interface utilisateur un peu plus, car les applications autonomes ont une interface utilisateur à état dynamique, alors que les applications Web ont une interface utilisateur à états qui, dans certains cas, ne simulent que de l’interface utilisateur à interface utilisateur dynamique. . En raison de cette différence, il est plus facile de gâcher une application autonome, mais cela vaut un tout autre sujet et n’a aucun lien direct avec JavaBeans.
Un haricot n'est pas grand chose, vraiment. Pour qu'une classe soit un "haricot", il suffit de:
- avoir un constructeur public, pas d'argument
- être sérialisable (pour implémenter l'interface Serializable, soit directement, soit via l'une de ses super classes).
Pour cela, vous pouvez ajouter des getters et des setters pour les propriétés de la classe conformes à une convention de dénomination spécifique si vous souhaitez que les champs soient découvrables dans certaines circonstances (par exemple, en faisant de cette classe un objet que vous pouvez glisser-déposer depuis un éditeur visuel de votre écran). IDE, par exemple).
Vous pouvez trouver plus directement de Sun ici .
Un bean Java est un composant logiciel conçu pour être réutilisable dans divers environnements. Il n'y a aucune restriction sur la capacité d'un haricot. 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 de la performance d'un portefeuille d'actions. Un bean peut être visible pour un utilisateur final. Un exemple de ceci est un bouton sur une interface utilisateur graphique. Un haricot peut également être invisible pour un utilisateur. Le 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 coopérer avec un ensemble d'autres composants distribués. Le logiciel permettant de générer un graphique à secteurs à partir d'un ensemble de points de données est un exemple de Bean pouvant être exécuté localement. Cependant, un Bean fournissant des informations de prix en temps réel à partir d'une bourse ou d'un marché de produits de base devrait fonctionner en coopération avec un autre logiciel distribué pour obtenir ses données.
Nous verrons bientôt quelles modifications spécifiques un développeur de logiciel doit apporter à une classe afin qu’elle soit utilisable comme bean Java. Cependant, l'un des objectifs des concepteurs de Java était de faciliter l'utilisation de cette technologie. Par conséquent, les modifications de code sont minimes.
Avantages des beans Java
Une architecture de composant logiciel fournit des mécanismes standard pour traiter les blocs de construction de logiciel. La liste suivante énumère certains des avantages spécifiques que la technologie Java procure aux développeurs de composants:
- Un bean obtient tous les avantages du paradigme "écrire une fois, courir-n'importe où" de Java.
- Les propriétés, les événements et les méthodes d'un bean exposés à un outil de création d'application peuvent être contrôlés.
- Un haricot peut être conçu pour fonctionner correctement dans différents endroits, ce qui le rend utile sur les marchés mondiaux.
- Un logiciel auxiliaire peut être fourni pour aider une personne à configurer un haricot. Ce logiciel est nécessaire uniquement lorsque les paramètres de conception de ce composant sont définis. Il n'est pas nécessaire de l'inclure 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 générer des événements 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 dont l'état (la variable theValue) sera automatiquement sauvegardé et restauré par le mécanisme de persistance JavaBeans, ainsi qu'une propriété nommée MyValue utilisable par un environnement de programmation visuel. Ce bean n'a aucune représentation visuelle, mais ce n'est pas une exigence pour un composant JavaBean.