Luoghi in cui vengono utilizzati JavaBeans?


172

Che cos'è un JavaBean e perché ne ho bisogno? Da quando posso creare tutte le app con la classe e la struttura dell'interfaccia? Perché ho bisogno dei fagioli? E puoi darmi alcuni esempi in cui i bean sono essenziali al posto di classi e interfacce?

Spiegare l'essenzialità di un bean nel contesto seguente:

  • App Wep
  • App autonome

10
Spero che tu non stia confondendo tra "bean Java" e "Enterprise Java Beans o EJBs".
Rahul,

53
in realtà non so del bean stesso, quindi come posso confondere con EJB .. c'è qualcosa di speciale con esso ..
Sidharth

Risposte:


178

Spesso rappresentano solo dati del mondo reale. Ecco un semplice esempio di giavanese:

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'implementazione Serializablenon è di per sé obbligatoria, ma molto utile se si desidera essere in grado di persistere o trasferire i Javabean al di fuori della memoria di Java, ad esempio nel disco rigido o in rete.

Ad esempio in una classe DAO è possibile utilizzarla per creare un elenco di utenti in cui archiviare i dati della usertabella nel database:

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;

Ad esempio in una classe Servlet è possibile utilizzarlo per trasferire i dati dal database all'interfaccia utente:

protected void doGet(HttpServletRequest request, HttpServletResponse response) {
    List<User> users = userDAO.list();
    request.setAttribute("users", users);
    request.getRequestDispatcher("users.jsp").forward(request, response);
}

Ad esempio in una pagina JSP è possibile accedervi tramite EL , che segue le convenzioni Javabean, per visualizzare i dati:

<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>

Ha senso? Vedi, è una specie di convenzione che puoi usare ovunque per archiviare , trasferire e accedere ai dati.

Guarda anche:


11
Bella spiegazione, e in genere grazie per l' implementazione serializzabile non è di per sé obbligatoria, ma molto utile se si desidera essere in grado di persistere o trasferire i Javabean al di fuori della memoria di Java, ad esempio nel disco rigido o in rete.
agpt

ma in java doc menziona che dovremmo implementare la serializzazione in modo da poterlo chiarire?
SSP

8
@SSP: 1) non c'è javadoc. 2) "should"! = "Must".
BalusC

61

Fagioli stessi

I JavaBeans sono ovunque, sono una convenzione e praticamente ogni singola libreria leggermente più grande là fuori usa quelle convenzioni per automatizzare le cose. Solo alcuni dei motivi per cui JavaBeans dovrebbe essere usato:

  • Si serializzano bene.
  • Può essere istanziato usando la riflessione.
  • Altrimenti può essere controllato usando la riflessione molto facilmente.
  • Buono per incapsulare i dati effettivi dal codice aziendale.
  • Convenzioni comuni indicano che chiunque può usare i tuoi fagioli E PUOI USARE TUTTI I FAGIOLI DI ELSE senza alcun tipo di documentazione / manuale facilmente e in modo coerente.
  • Molto vicino ai POJO , il che significa in realtà ancora più interoperabilità tra parti distinte del sistema.

Inoltre c'è ovviamente Enterprise JavaBeans che è tutt'altra questione e non dovrebbe essere mescolato con semplici JavaBeans. Volevo solo menzionare EJB: s perché i nomi sono simili ed è facile confonderli.

Fagioli nelle applicazioni web

Se consideri i JavaBean "normali" nel contesto delle app web, hanno più senso che indossare scarpe alle gambe. Poiché la specifica Servlet richiede che le sessioni siano serializzabili, significa che dovresti archiviare i tuoi dati in sessione come qualcosa che è serializzabile - perché non renderli un bean allora! Basta inserire SomeBusinessDataBean nella sessione e sei pronto per partire, ridicolmente facile, conforme alle specifiche e conveniente.

Anche il trasferimento di tali dati nell'applicazione è semplice poiché JavaBeans consente di separare completamente parti dell'applicazione. Pensa a JavaBeans come a una lettera e a vari sottosistemi dell'applicazione come dipartimenti all'interno di una società molto grande: Dept.A invia un mucchio di dati a Dept.B, Dept.B non sa - o addirittura se ne cura - da dove provengono i dati come dovrebbe essere e può semplicemente aprire la lettera, leggere cose da essa e fare le sue cose in base a quei dati.

Fagioli in applicazioni autonome

In realtà ciò che sopra si applica anche alle app autonome, l'unica differenza è che puoi rovinare un po 'di più l'interfaccia utente poiché le applicazioni autonome hanno un'interfaccia utente stateful: s mentre le applicazioni web hanno un'interfaccia utente statels: che in alcuni casi simulano solo l'interfaccia utente stateful: s . A causa di questa differenza, è più facile fare confusione con un'applicazione autonoma, ma vale la pena un altro argomento e non è direttamente correlato a JavaBeans.


50

Un fagiolo non è molto, davvero. Perché una classe sia un "bean", tutto ciò che serve è:

  • avere un pubblico, nessun costruttore di argomenti
  • essere serializzabile (per implementare l'interfaccia Serializable, direttamente o tramite una delle sue super classi).

A questo, puoi aggiungere getter e setter per proprietà della classe conformi a una specifica convenzione di denominazione se desideri che i campi siano rilevabili in determinate circostanze (ad es. Rendendo tale classe un oggetto che puoi trascinare e rilasciare da un editor visivo nel tuo IDE, ad esempio).

Puoi trovare più direttamente da Sun qui .


15

Un Java Bean è un componente software che è stato progettato per essere riutilizzabile in una varietà di ambienti diversi. Non ci sono restrizioni sulla capacità di un fagiolo. Può svolgere una funzione semplice, come la verifica dell'ortografia di un documento o una funzione complessa, come la previsione delle prestazioni di un portafoglio azionario. Un bean può essere visibile a un utente finale. Un esempio di questo è un pulsante su un'interfaccia utente grafica. Un fagiolo può anche essere invisibile per un utente. Il software per decodificare un flusso di informazioni multimediali in tempo reale è un esempio di questo tipo di blocco predefinito. Infine, un bean può essere progettato per funzionare autonomamente sulla workstation di un utente o per lavorare in collaborazione con una serie di altri componenti distribuiti. Il software per generare un grafico a torta da un set di punti dati è un esempio di un bean che può essere eseguito localmente. Però,

A breve vedremo quali modifiche specifiche uno sviluppatore software deve apportare a una classe in modo che sia utilizzabile come Java Bean. Tuttavia, uno degli obiettivi dei progettisti Java era rendere semplice l'utilizzo di questa tecnologia. Pertanto, le modifiche al codice sono minime.

Vantaggi dei fagioli di Java

Un'architettura di componente software fornisce meccanismi standard per gestire i blocchi software. L'elenco seguente elenca alcuni dei vantaggi specifici offerti dalla tecnologia Java per uno sviluppatore di componenti:

  • A Bean ottiene tutti i vantaggi del paradigma Java "write-once, run -where".
  • È possibile controllare le proprietà, gli eventi e i metodi di un bean esposti a uno strumento di creazione dell'applicazione.
  • Un fagiolo può essere progettato per funzionare correttamente in diversi locali, il che lo rende utile nei mercati globali.
  • È possibile fornire software ausiliario per aiutare una persona a configurare un bean. Questo software è necessario solo quando vengono impostati i parametri in fase di progettazione per quel componente. Non è necessario che sia incluso nell'ambiente di runtime.
  • Le impostazioni di configurazione di un bean possono essere salvate in un archivio permanente e ripristinate in un secondo momento.
  • Un bean può registrarsi per ricevere eventi da altri oggetti e può generare eventi che vengono inviati ad altri oggetti.

Ecco un semplice esempio di giavanese:

public class MyBean implements java.io.Serializable
{

       protected  int theValue;

       public MyBean()
       {
       }

       public void setMyValue(int newValue)
       {
           theValue = newValue;
       }

      public int getMyValue()
      {
           return theValue;
      }

}

Questo è un vero bean chiamato MyBean che ha uno stato (la variabile theValue) che verrà automaticamente salvato e ripristinato dal meccanismo di persistenza JavaBeans e ha una proprietà chiamata MyValue che è utilizzabile da un ambiente di programmazione visiva. Questo bean non ha alcuna rappresentazione visiva, ma non è un requisito per un componente JavaBean.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.