Qu'est-ce qu'un JavaBean exactement?

Il y a un terme pour le rendre solide. La réalité est loin d'être si mystérieux.

en gros, un "Bean":

• est un objet sérialisable (qui est, elle met en œuvre java.io.Serializable , et le fait correctement), que
• a des " propriétés "dont les getters et les setters sont juste des méthodes avec certains noms (comme, disons, getFoo() est le getter pour la propriété" Foo"), et
• a un constructeur 0-arg public (il peut donc être créé à volonté et configuré en définissant ses propriétés).

mise à Jour:

comme pour Serializable : ce n'est rien d'autre qu'une" interface marqueur "(une interface qui ne déclare aucune fonction) qui dit à Java que la classe d'implémentation accepte (et implique qu'elle est capable de) la" 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 assez d'informations pour permettre à une JVM (au moins une qui connaît le type de l'objet) de reconstruire l'objet plus tard -- peut-être dans une autre instance de l'application, ou même sur une toute autre machine!

bien sûr, pour ce faire, la classe doit respecter certaines limites. Le principal d'entre eux est que tous les champs d'instance doivent être soit des types primitifs (int, bool, etc), des instances de une classe qui est aussi sérialisable, ou marquée comme transient de sorte que Java ne va pas essayer de les inclure. (Cela signifie Bien sûr que les champs transient ne survivront pas au voyage au-dessus d'un ruisseau. Une classe qui a des champs transient devrait être prête à 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 va même pas laisser le faire.)

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

1. implémenter java.io.Serialisable interface - pour enregistrer l'état d'un objet
2. utilisez un argument vide de constructeur Pour instancier l'objet
3. et fournir des méthodes publiques getter et setter - pour obtenir et définir les valeurs des variables privées (propriétés ).

propriétés des Javabéens

un JavaBean est un objet Java qui satisfait à certaines conventions de programmation:

1. la classe JavaBean doit mettre en œuvre soit Serializable ou Externalizable

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

3. toutes les propriétés Javabéennes doivent avoir des méthodes de setter et de 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;
   }
}

Java Beans utilisent pour moins de code et plus de travail approche... Java Beans est utilisé dans L'ensemble de 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 comme objets de transfert de données entre pages ou entre servlets et JSPs. Le cadre D'Activation JavaBeans de Java EE utilise Java Beans pour intégrer le support des types de données MIME dans Java EE. L'API de gestion Java EE utilise JavaBeans comme base pour l'instrumentation de 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é comme une séquence d'octets qui inclut les données de l'objet ainsi que des informations sur le type de l'objet et les types de données stockées dans l'objet.

Après un objet sérialisé a été écrit dans un fichier, il peut être lu à partir du fichier et désérialisé qui est, le type d'informations et d'octets représenter l'objet et ses données peuvent être utilisées pour recréer l'objet en mémoire.

vous trouverez Serialization utile lors du déploiement de votre projet sur plusieurs serveurs car beans sera persisté et transféré à travers eux.

Explication avec un exemple.

1. importer java.io.Serialisable

comme pour la sérialisation, voir la documentation .

2. champs privés

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

3. Constructeur

un constructeur public sans aucun argument.

4. getter / setter

Getter et setter pour l'accès aux champs privés.

/** 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;
    }
}

selon la Wikipédia:

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

2. les propriétés de classe doivent être accessibles en utilisant get, set, is (peut être utilisé pour les propriétés booléennes au lieu de get), et d'autres méthodes (dites méthodes accessor et méthodes mutator) selon un nom standard Convention. Cela permet une inspection automatisée facile et la mise à jour de l'état de haricot dans les cadres, dont beaucoup comprennent des éditeurs personnalisés pour divers types de propriétés. Les Setters peuvent avoir un ou plusieurs arguments.

3. La classe doit être sérialisable. [Cela permet aux applications et aux cadres de sauvegarder, stocker et restaurer de manière fiable l'état de la fève d'une manière indépendante de la VM et de la plateforme.]

pour plus d'information, suivez ce lien .

Java Beans est une norme, et ses exigences syntaxiques de base ont été clairement expliquées par les autres réponses.

cependant, IMO, il est plus qu'une simple norme de syntaxe. La signification réelle ou l'utilisation prévue de Java Beans est, avec divers outils de soutien autour de la norme, de faciliter la réutilisation de code et l'ingénierie logicielle basée sur les composants, c'est-à-dire permettre aux développeurs de construire des applications en assemblant des composants existants (classes) et sans avoir à écrire n'importe quel code (ou seulement avoir à écrire un petit code de colle). Malheureusement, cette technologie est sous-estimée et sous-utilisée par l'industrie, ce qui peut être dit à partir des réponses dans ce fil.

si vous lisez le tutoriel d'Oracle sur Java Beans , vous pouvez obtenir une meilleure compréhension de cela.

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. Mettre moins formellement, il stocke l'état d'un objet, vous pouvez le récupérer plus tard, par la dé-sérialisation.

Un Java Bean est une classe java [conceptuel] que doit suivre les conventions suivantes:

1. il doit avoir un constructeur sans arg.
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.

il s'agit d'un composant logiciel réutilisable. Il peut encapsuler plusieurs objets en un seul objet, de sorte que même l'objet est accessible à partir de plusieurs endroits et constitue une étape vers la maintenance facile du code.

ils sont sérialisables, ont un constructeur à argument zéro, et permettent l'accès aux propriétés en utilisant les 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 to wiki

les objets qui forment l'épine dorsale de votre application et qui sont gérés par le conteneur printemps CIO sont appelés haricots. Un haricot est un objet qui est instancié, assemblé, et par ailleurs géré par un conteneur IoC de printemps. Autrement, un haricot est simplement l'un des nombreux objets dans votre application. according to "151970920 de" printemps " io .

Java Beans sont juste des classes de Java ordinaires qui suivent certaines conventions - vous n'avez pas besoin d'outils spéciaux pour les créer.

il y a deux conventions primaires qui doivent être suivies pour créer des classes Java Bean:

• Chaque " propriété " la Java Bean classe est mis en œuvre par la définition des deux fonctions publiques (d'une fonction et une fonction "set")
• le " opérations " la Java Bean classe sont les autres fonctions publiques définies dans la classe.

pour comprendre JavaBean vous devez noter les suivants: JavaBean est une substance conceptuelle et ne peut pas représenter une classe de choses spécifiques

JavaBean est un outil de développement peut être visualisé dans l'exploitation 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 réutilisation.

Un Java Bean est essentiellement une classe, ce qui le classe une classe comme un haricot est: 1. Il devrait implémenter l'interface sérialisable (une interface marqueur). 2. Le constructeur doit être public et ne pas avoir d'arguments (ce que d'autres appellent un constructeur sans arg). 3. Il devrait y avoir getter et setter.

bon à noter que le champ serialVersionUID est important pour maintenir 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;
}}