Qu'est-ce qu'un JavaBean exactement?

Question

J'ai compris, je pense, qu'un "haricot" est une classe Java avec des propriétés et des getters/setters. Autant que je sache, c'est l'équivalent d'une structure en C. Est-ce vrai?

En outre, existe-t-il une différence réelle entre un haricot et une classe normale (== --- ==)? Existe-t-il une définition spéciale ou une interface?

Fondamentalement, pourquoi existe-t-il un terme pour cela?

De plus, que signifie l'interface Serializable?

Answer 1

Un JavaBean est juste un standard

1. Toutes les propriétés privées (utiliser getters/setters )
2. Un public constructeur sans argument
3. Implémente Serializable .

C'est ça. C'est juste une convention. Beaucoup de bibliothèques en dépendent cependant.

En ce qui concerne Serializable, à partir de la documentation de l'API :

La possibilité de sérialiser une classe est activée par la classe implémentant l'interface Java.io.Serializable. Les classes qui n'implémentent pas cette interface ne verront ni leur état sérialisé ni désérialisé. Tous les sous-types d'une classe sérialisable sont eux-mêmes sérialisables. L'interface de sérialisation n'a pas de méthodes ni de champs et sert uniquement à identifier la sémantique de la sérialisation.

En d'autres termes, les objets sérialisables peuvent être écrits dans des flux, et donc des fichiers, des bases de données d'objets, etc.

En outre, il n'y a pas de différence syntaxique entre un JavaBean et une autre classe - une classe est un JavaBean si elle respecte les normes.

Il existe un terme pour cela parce que la norme permet aux bibliothèques de faire par programme des choses avec des instances de classe que vous définissez de manière prédéfinie. Par exemple, si une bibliothèque souhaite diffuser un objet que vous lui transmettez, elle le sait car votre objet est sérialisable (en supposant que la lib nécessite que vos objets soient des JavaBeans appropriés).

Answer 2

Il y a un terme pour que ça sonne spécial. La réalité est loin d'être aussi mystérieuse.

En gros, un "haricot":

• est un objet sérialisable (c’est-à-dire qu’il implémente Java.io.Serializable et le fait correctement),
• a des "propriétés" dont les getters et les setters ne sont que des méthodes portant certains noms (comme, par exemple, getFoo() est le getter de la propriété "Foo"), et
• a un constructeur public 0-arg (il peut donc être créé à volonté et configuré en définissant ses propriétés).

Mise à jour:

En ce qui concerne Serializable: ce n'est rien d'autre qu'une "interface de marqueur" (une interface qui ne déclare aucune fonction) qui indique à Java que la classe d'implémentation consent à (et implique qu'elle est capable de) "sérialisation" - un processus qui convertit une instance en un flux d'octets. Ces octets peuvent être stockés dans des fichiers, envoyés via une connexion réseau, etc., et avoir suffisamment d’informations pour permettre à une machine virtuelle Java (au moins, qui connaît le type de l’objet) de reconstruire l’objet ultérieurement, éventuellement dans une autre instance du serveur. application, ou même sur une toute autre machine!

Bien entendu, pour ce faire, la classe doit respecter certaines limites. Le principal d'entre eux est que tous les champs d'instance doivent être des types primitifs (int, bool, etc.), des instances d'une classe également sérialisable, ou marquées comme transient pour que Java ne essayez de les inclure. (Cela signifie bien entendu que les champs transient ne survivront pas au voyage sur un flux. Une classe comportant des champs transient doit être préparée pour les réinitialiser si nécessaire.)

Une classe qui ne peut pas respecter ces limitations ne devrait pas implémenter Serializable (et, IIRC, le compilateur Java ne pourra même pas laisser il le fait.)

Answer 3

Les JavaBeans sont des classes Java qui respectent une convention de codage extrêmement simple. Tout ce que vous avez à faire est de

1. implémenter Java.io.Serializable interface - pour sauvegarder l'état d'un objet
2. utiliser un constructeur d'argument vide public - pour instancier l'objet
3. fournit des méthodes getter/setter publiques - pour obtenir et définir les valeurs des variables privées (propriétés).

Answer 4

Propriétés de JavaBeans

Un JavaBean est un objet Java qui respecte certaines conventions de programmation:

1. La classe JavaBean doit implémenter soit Serializable ou Externalizable

2. La classe JavaBean doit avoir un constructeur no-arg

3. Toutes les propriétés JavaBean doivent avoir des méthodes setter et getter publiques

4. Toutes les variables d'instance JavaBean doivent être privées

Exemple de JavaBeans

@Entity
public class Employee implements Serializable{

   @Id
   private int id;
   private String name;   
   private int salary;  

   public Employee() {}

   public Employee(String name, int salary) {
      this.name = name;
      this.salary = salary;
   }
   public int getId() {
      return id;
   }
   public void setId( int id ) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName( String name ) {
      this.name = name;
   }
   public int getSalary() {
      return salary;
   }
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Answer 5

Explication avec un exemple.

1. importer Java.io.Serializable

En ce qui concerne la sérialisation, voir le documentation .

2. champs privés

Les champs doivent être privés pour empêcher les classes externes de les modifier facilement. Au lieu d’accéder directement à ces champs, on utilise généralement les méthodes getter/setter.

3. Constructeur

Un constructeur public sans aucun argument.

4. getter/setter

Méthodes d'accès et de définition pour accéder aux champs privés et les modifier.

/** 1. import Java.io.Serializable */
public class User implements Java.io.Serializable {
    /** 2. private fields */
    private int id;
    private String name;

    /** 3. Constructor */
    public User() {
    }
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    /** 4. getter/setter */
    // getter
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    // setter
    public void setId(int id) {
        this.id = is;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Answer 6

Les beans Java utilisent moins de code et plus de travail ... Java Les beans sont utilisés dans tout le monde Java EE en tant que contrat universel pour la découverte et l'accès à l'exécution. Par exemple, JavaServer Pages (JSP) utilise Java Beans en tant qu'objets de transfert de données entre pages ou entre servlets et JSP. Java Le cadre d'activation JavaBeans de EE utilise Java Beans pour intégrer la prise en charge des types de données MIME dans Java EE. L'API de gestion Java EE utilise JavaBeans comme fondement de l'instrumentation des ressources à gérer dans un environnement Java EE.

À propos de la sérialisation:

Dans la sérialisation d'objet, un objet peut être représenté sous la forme d'une séquence d'octets incluant les données de l'objet, ainsi que des informations sur le type de l'objet et les types de données stockés dans l'objet.

Une fois qu'un objet sérialisé a été écrit dans un fichier, il peut être lu à partir du fichier et désérialisé, c'est-à-dire que les informations de type et les octets représentant l'objet et ses données peuvent être utilisés pour recréer l'objet en mémoire.

Answer 7

La sérialisation vous sera utile lors du déploiement de votre projet sur plusieurs serveurs, car les beans seront conservés et transférés entre eux.

Answer 8

Java Beans est un standard et ses autres réponses expliquent clairement ses exigences en matière de syntaxe de base.

Cependant, IMO, il s’agit de plus qu’un simple standard de syntaxe. La signification réelle ou l'utilisation prévue de Java Beans consiste, avec l'aide de divers outils autour de la norme, à faciliter la réutilisation du code et l'ingénierie logicielle basée sur les composants, c'est-à-dire de permettre aux développeurs de créer des applications en assemblant des composants existants (classes). et sans avoir à écrire de code (ou seulement à écrire un peu de code collant). Malheureusement, cette technologie est largement sous-estimée et sous-utilisée par l'industrie, ce qui ressort des réponses fournies dans ce fil.

Si vous lisez le tutoriel sur Java Beans d'Oracle, vous pourrez mieux comprendre cela.

Answer 9

Selon le Wikipedia:

1. La classe doit avoir un constructeur public par défaut (sans argument). Cela permet une instanciation facile dans les cadres d’édition et d’activation.

2. Les propriétés de la classe doivent être accessibles à l'aide de get, set, is (peut être utilisé pour les propriétés booléennes au lieu de get) et d'autres méthodes (appelées méthodes d'accès et méthodes de mutation) conformément à une convention de dénomination standard. Cela permet une inspection et une mise à jour automatisées et faciles de l'état des beans au sein de frameworks, dont beaucoup incluent des éditeurs personnalisés pour différents types de propriétés. Les Setters peuvent avoir un ou plusieurs arguments.

3. La classe devrait être sérialisable. [Cela permet aux applications et aux infrastructures de sauvegarder, stocker et restaurer de manière fiable l’état du bean de manière indépendante du VM et de la plate-forme.]

Pour plus d'informations, suivez ceci lien.

Answer 10

En ce qui concerne la deuxième partie de votre question, la sérialisation est un mécanisme de persistance utilisé pour stocker des objets sous forme d'une séquence d'octets signés. En termes moins formels, il stocke l’état d’un objet pour que vous puissiez le récupérer plus tard, par désérialisation.

Answer 11

Un bean Java est une classe Java [conceptuelle] qui doit respecter les conventions suivantes:

1. Il devrait avoir un constructeur sans argument.
2. Il devrait être sérialisable.
3. Il devrait fournir des méthodes pour définir et obtenir les valeurs des propriétés, appelées méthodes getter et setter.

C'est un composant logiciel réutilisable. Il peut encapsuler de nombreux objets dans un seul objet de manière à ce que le même objet puisse être accédé de plusieurs endroits et constitue une étape vers la maintenance facile du code.

Answer 12

Ils sont sérialisables, ont un constructeur zéro argument et permettent l'accès aux propriétés à l'aide des méthodes getter et setter. Le nom "Bean" a été donné pour englober cette norme, qui vise à créer des composants logiciels réutilisables pour Java .according towiki

Les objets qui constituent le cœur de votre application et qui sont gérés par le conteneur Spring IoC sont appelés des beans. Un bean est un objet instancié, assemblé et géré autrement par un conteneur Spring IoC. Sinon, un haricot est simplement l'un des nombreux objets de votre application. according toprintemps io .

Answer 13

Un bean Java est essentiellement une classe. Ce qui classifie une classe en tant que bean est:

1. Il devrait implémenter une interface sérialisable (une interface de marqueur).
2. Le constructeur doit être public et ne pas avoir d'argument (ce que les autres appellent un constructeur sans argument).
3. Il devrait avoir getter et setters.

Il est bon de noter que le champ serialVersionUID est important pour le maintien de l'état de l'objet. Le code ci-dessous est considéré comme un haricot:

public class DataDog implements Java.io.Serializable {

private static final long serialVersionUID = -3774654564564563L;

private int id;
private String nameOfDog;

//The constructor should NOT have arguments
public DataDog () {}


/** 4. getter/setter */

// getter(s)
public int getId() {
    return id;
}
public String getNameOfDog() {
    return nameOfDog;
}
// setter(s)
public void setId(int id) {
    this.id = id;
}
public void setNameOfDog(String nameOfDog) {
    this.nameOfDog = nameOfDog;
}}

Answer 14

Juste un peu de contexte/mise à jour sur le concept de haricot. Beaucoup d'autres réponses ont en fait le quoi mais pas tellement pourquoi.

Ils ont été inventés très tôt dans Java dans le cadre de la construction d'interfaces graphiques. Ils ont suivi des modèles faciles à séparer des outils, ce qui leur a permis de créer un panneau de propriétés vous permettant de modifier les attributs du bean. En général, les propriétés du haricot représentent un contrôle à l'écran (pensez x, y, largeur, hauteur, texte, ..)

Vous pouvez également y voir une structure de données fortement typée.

Avec le temps, ils sont devenus utiles pour de nombreux outils utilisant le même type d'accès (par exemple, Hibernate pour conserver les structures de données dans la base de données).

Au fur et à mesure de l'évolution des outils, ils se sont davantage tournés vers les annotations et ont cessé de séparer les noms des setter/getter. Maintenant, la plupart des systèmes ne nécessitent pas de beans, ils peuvent prendre n'importe quel ancien objet Java avec des propriétés annotées pour leur dire comment les manipuler.

Maintenant, je vois les haricots comme des boules de propriétés annotées - elles ne sont vraiment utiles que pour les annotations qu’elles portent.

Les haricots eux-mêmes ne sont pas un modèle sain. Ils détruisent l’encapsulation par leur nature, car ils exposent toutes leurs propriétés à une manipulation externe et, lorsqu’ils sont utilisés, il existe une tendance (en aucun cas une obligation) à créer du code pour manipuler le bean en externe au lieu de créer du code à l’intérieur du bean 'demandez à un objet ses valeurs, demandez à un objet de faire quelque chose pour vous "). Utiliser des pojos annotés avec un minimum de getters et pas de setters est beaucoup plus OO restaurer l'encapsulation et avec la possibilité d'immutabilité.

En passant, alors que tout cela se passait, quelqu'un a étendu le concept à quelque chose appelé Enterprise Java Beans. Ce sont ... différents. et ils sont suffisamment compliqués pour que beaucoup de gens aient l’impression de ne pas comprendre le concept de Bean et cessent d’employer ce terme. C’est, je pense, pourquoi vous entendez généralement des haricots appelés POJO (puisque chaque objet Java est un POJO, c’est techniquement acceptable, mais lorsque vous entendez quelqu'un dire "POJO", il pense le plus souvent à quelque chose qui suit le motif de haricot)

Answer 15

Pour comprendre JavaBean, vous devez noter les points suivants: JavaBean est un concept et ne peut pas représenter une classe de choses spécifiques.

JavaBean est un outil de développement pouvant être visualisé dans le fonctionnement de composants logiciels réutilisables

JavaBean est basé sur la spécification Sun JavaBeans et peut être des composants réutilisables. Sa plus grande caractéristique est la possibilité de réutilisation.