Vraag Wat is een JavaBean precies?


Ik begreep, denk ik, dat een "Boon" een Java-klasse is met eigenschappen en getters / setters. Voor zover ik begrijp, is het het equivalent van een C struct. Is dat waar?

Ook is er een real syntactisch verschil tussen een boon en een reguliere klas? Bestaat er een speciale definitie of een interface?

Kortom, waarom is hier een term voor?

Bewerk: Als u zo vriendelijk kunt zijn en informatie toevoegen over de Serializable interface, en wat het betekent, voor uw antwoord, zou ik zeer dankbaar zijn.


1361
2017-07-21 00:41


oorsprong


antwoorden:


Een JavaBean is slechts een standaard-

  1. Alle eigenschappen privé (gebruik getters / setters)
  2. Een publiek geen-argument constructor
  3. gereedschap Serializable.

Dat is het. Het is maar een conventie. Veel bibliotheken zijn er echter afhankelijk van.

Rekeninghoudend met Serializable, van de API-documentatie:

Serialiseerbaarheid van een klasse wordt mogelijk gemaakt door de klasse die het   java.io.Serialiseerbare interface. Klassen die dit niet implementeren   interface zal niet een van hun toestand serialized of gedeserialiseerd zijn.   Alle subtypen van een serialiseerbare klasse zijn zelf serialiseerbaar. De   serialisatie-interface heeft geen methoden of velden en dient alleen voor   identificeer de semantiek van serialisatie.

Met andere woorden, serialiseerbare objecten kunnen worden geschreven naar streams en dus naar bestanden, objectdatabases, eigenlijk alles.

Er is ook geen syntactisch verschil tussen een JavaBean en een andere klasse - een klasse definieert een JavaBean als deze de standaarden volgt.

Er is een term voor omdat de standaard het voor bibliotheken mogelijk maakt om dingen programmatisch te doen met klasse-instances die u op een vooraf gedefinieerde manier definieert. Als een bibliotheek bijvoorbeeld elk object dat u erin verstuurt wil streamen, weet het dat dit kan omdat uw object serialiseerbaar is (aangenomen dat de lib vereist dat uw objecten de juiste JavaBeans zijn).


1496
2017-07-21 00:45



Er is een term voor bedoeld om het speciaal te laten klinken. De realiteit is lang niet zo mysterieus.

Kortom, een "Boon":

  • is een serialiseerbaar object (dat wil zeggen, het implementeert java.io.Serializable, en doet dat correct), dat
  • heeft "eigenschappen" waarvan de getters en setters slechts methoden zijn met bepaalde namen (zoals, laten we zeggen, getFoo() is de getter voor de eigenschap "Foo") en
  • heeft een openbare standaardconstructor (dus deze kan naar wens worden gemaakt en worden geconfigureerd door de eigenschappen ervan in te stellen).

Bijwerken:

Wat betreft Serializable: Dat is niets anders dan een "markeerinterface" (een interface die geen functies declareert) die Java vertelt dat de implementatieklasse instemt (en impliceert dat het in staat is tot) "serialisatie" - een proces dat een exemplaar converteert in een stroom van bytes. Die bytes kunnen worden opgeslagen in bestanden, verzonden over een netwerkverbinding, enz., En hebben voldoende info om een ​​JVM (althans iemand die weet wat het objecttype is) toe te staan ​​het object later te reconstrueren - mogelijk in een ander exemplaar van de toepassing, of zelfs op een hele andere machine!

Natuurlijk, om dat te doen, moet de klas zich aan bepaalde beperkingen houden. De belangrijkste onder hen is dat alle instantievelden ofwel primitieve typen (int, bool, enz.) Moeten zijn, exemplaren van een klasse die ook serialiseerbaar is, of gemarkeerd als transient zodat Java niet zal proberen ze op te nemen. (Dit betekent natuurlijk dat transient velden overleven de reis over een stroom niet. Een klasse die dat wel heeft transient velden moeten worden voorbereid om ze indien nodig opnieuw te initialiseren.)

Een klasse die zich niet aan deze beperkingen kan houden, moet dit niet implementeren Serializable (en, IIRC, de Java-compiler zal niet eens laat het doet het.)


242
2017-07-21 00:50



JavaBeans zijn Java-klassen die voldoen aan een uiterst eenvoudige coderingsconventie. Het enige dat u hoeft te doen is

  1. Implementeer java.io.Serializable interface - Om de status van een te bewaren voorwerp
  2. gebruik een openbare lege argumentconstructor - om het object te instantiëren
  3. En bieden openbare methoden voor getter en setter - Om de waarden van privévariabelen (eigenschappen) te verkrijgen en in te stellen.

79
2017-07-21 04:22



Eigenschappen van JavaBeans

Een JavaBean is een Java-object dat aan bepaalde programmeerconventies voldoet:

  1. De JavaBean-klasse moet beide implementeren Serializable of Externalizable 

  2. De JavaBean-klasse moet een constructor zonder arg. Hebben

  3. Alle JavaBean-eigenschappen moeten openbare setter- en gettermethoden hebben

  4. Alle JavaBean-instantievariabelen moeten privé zijn

Voorbeeld van 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;
   }
}

48
2018-01-24 09:33



Java-bonen gebruiken voor minder code en meer werkaanpak ... Java-bonen worden overal in Java EE gebruikt als een universeel contract voor detectie en toegang voor runtime. JavaServer Pages (JSP) gebruikt bijvoorbeeld Java Beans als gegevensoverdrachtobjecten tussen pagina's of tussen servlets en JSP's. Java EE's JavaBeans Activation Framework gebruikt Java Beans voor de integratie van ondersteuning voor MIME-gegevenstypen in Java EE. De Java EE Management API gebruikt JavaBeans als de basis voor de instrumentatie van bronnen die moeten worden beheerd in een Java EE-omgeving.

Over serialisatie:

In serialisatie van objecten kan een object worden weergegeven als een reeks bytes die de gegevens van het object omvat, evenals informatie over het type van het object en de soorten gegevens die in het object zijn opgeslagen.

Nadat een geserialiseerd object in een bestand is geschreven, kan het uit het bestand worden gelezen en gedeserialiseerd, dat wil zeggen dat de typegegevens en bytes die het object en de bijbehorende gegevens vertegenwoordigen, kunnen worden gebruikt om het object in het geheugen opnieuw te maken.


18
2017-09-23 07:30



U zult serialisatie handig vinden wanneer u uw project op meerdere servers implementeert, omdat de bonen blijven bestaan ​​en eroverheen worden overgedragen.


17
2017-07-21 06:03



Uitleg met een voorbeeld.

1. importeer java.io.Serializable

Zie voor de serialisatie het documentatie.

2. privévelden

Velden moeten privé zijn om te voorkomen dat outer classes die velden gemakkelijk kunnen wijzigen. In plaats van rechtstreeks naar die velden te gaan, worden usuagly getter / setter-methoden gebruikt.

3. Constructor

Een openbare constructeur zonder enig argument.

4. vangstof / zetter

Getter- en settermethoden voor toegang tot privévelden.

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

16
2017-08-22 12:45