Apa itu JavaBean sebenarnya?

Saya mengerti, saya pikir, bahwa "Bean" adalah kelas Java dengan properti dan getter / setter. Sejauh yang saya mengerti, itu setara dengan struct C. Benarkah?

Juga, apakah ada perbedaan sintaksis nyata antara kacang dan kelas reguler? Apakah ada definisi khusus atau antarmuka?

Pada dasarnya, mengapa ada istilah untuk ini?

Juga apa artinya Serializableantarmuka?

JavaBean hanyalah sebuah standar

1. Semua properti pribadi (gunakan getter / setter )
2. Konstruktor tanpa argumen publik
3. Implements Serializable.

Itu dia. Itu hanya sebuah konvensi. Banyak perpustakaan bergantung padanya.

Sehubungan dengan Serializable, dari dokumentasi API :

Serializability suatu kelas diaktifkan oleh kelas yang mengimplementasikan antarmuka java.io.Serializable. Kelas yang tidak mengimplementasikan antarmuka ini tidak akan memiliki status serial atau deserialized. Semua subtipe dari suatu kelas yang dapat diserialkan dengan sendirinya bersifat bersambung. Antarmuka serialisasi tidak memiliki metode atau bidang dan hanya berfungsi untuk mengidentifikasi semantik menjadi serial.

Dengan kata lain, objek serializable dapat ditulis ke stream, dan karenanya file, database objek, apa pun juga.

Juga, tidak ada perbedaan sintaksis antara JavaBean dan kelas lain - kelas adalah JavaBean jika mengikuti standar.

Ada istilah untuk itu karena standar memungkinkan perpustakaan untuk melakukan hal-hal secara terprogram dengan instance kelas yang Anda tetapkan dengan cara yang telah ditentukan. Misalnya, jika perpustakaan ingin melakukan streaming objek apa pun yang Anda lewati, ia tahu itu bisa karena objek Anda serializable (dengan asumsi lib mengharuskan objek Anda menjadi JavaBeans yang tepat).

Ada istilah untuk membuatnya terdengar istimewa. Kenyataannya jauh dari misterius.

Pada dasarnya, "Kacang":

• adalah objek serializable (yaitu, itu mengimplementasikan java.io.Serializable, dan melakukannya dengan benar), itu
• memiliki "properti" yang getter dan setternya hanya metode dengan nama-nama tertentu (seperti, katakanlah, getFoo()adalah pengambil untuk properti "Foo"), dan
• memiliki konstruktor 0-arg publik (sehingga dapat dibuat sesuka hati dan dikonfigurasi dengan menyetel propertinya).

Memperbarui:

Adapun Serializable: Itu tidak lain adalah "antarmuka penanda" (antarmuka yang tidak mendeklarasikan fungsi apa pun) yang memberitahu Java bahwa kelas pelaksana menyetujui (dan menyiratkan bahwa ia mampu) "serialisasi" - suatu proses yang mengubah sebuah instance ke aliran byte. Byte tersebut dapat disimpan dalam file, dikirim melalui koneksi jaringan, dll, dan memiliki cukup info untuk memungkinkan JVM (setidaknya, yang tahu tentang jenis objek) untuk merekonstruksi objek nanti - mungkin dalam contoh berbeda dari aplikasi, atau bahkan pada mesin lain secara keseluruhan!

Tentu saja, untuk melakukan itu, kelas harus mematuhi batasan tertentu. Yang utama di antara mereka adalah bahwa semua bidang instance harus berupa tipe primitif (int, bool, dll), instance dari beberapa kelas yang juga dapat diserialisasi, atau ditandai transientagar Java tidak akan mencoba memasukkannya. (Ini tentu saja berarti bahwa transientbidang tidak akan bertahan dari perjalanan melewati aliran. Kelas yang memiliki transientbidang harus siap untuk menginisialisasi ulang mereka jika perlu.)

Kelas yang tidak dapat mematuhi batasan-batasan itu tidak boleh diimplementasikan Serializable(dan, IIRC, kompiler Java bahkan tidak akan membiarkannya melakukannya.)

JavaBeans adalah kelas Java yang mematuhi konvensi pengkodean yang sangat sederhana. Yang harus Anda lakukan adalah

1. mengimplementasikan java.io.Serializableantarmuka - untuk menyimpan keadaan suatu objek
2. gunakan konstruktor argumen publik kosong - untuk membuat instance objek
3. menyediakan metode pengambil / penyetel publik - untuk mendapatkan dan menetapkan nilai variabel pribadi (properti).

Properti JavaBeans

JavaBean adalah objek Java yang memenuhi konvensi pemrograman tertentu:

1. Kelas JavaBean harus mengimplementasikan salah satu Serializableatau Externalizable

2. Kelas JavaBean harus memiliki konstruktor no-arg

3. Semua properti JavaBean harus memiliki metode setter dan pengambil publik

4. Semua variabel instance JavaBean harus pribadi

Contoh 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;
   }
}

Penjelasan dengan contoh.

1. impor java.io.Serializable

Adapun Serialisasi, lihat dokumentasi .

2. bidang pribadi

Bidang harus pribadi untuk mencegah kelas luar agar mudah memodifikasi bidang tersebut. Alih-alih mengakses langsung ke bidang tersebut, metode pengambil / penyetel yang biasa digunakan.

3. Konstruktor

Konstruktor publik tanpa argumen.

4. pengambil / penyetel

Metode pengambil dan penyetel untuk mengakses dan memodifikasi bidang pribadi.

/** 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 = id;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Java Beans menggunakan lebih sedikit kode dan lebih banyak pendekatan kerja ... Java Beans digunakan di seluruh Java EE sebagai kontrak universal untuk penemuan dan akses runtime. Misalnya, JavaServer Pages (JSP) menggunakan Java Beans sebagai objek transfer data antara halaman atau antara servlets dan JSP. JavaEE JavaBeans Activation Framework menggunakan Java Beans untuk mengintegrasikan dukungan untuk tipe data MIME ke Java EE. Java EE Management API menggunakan JavaBeans sebagai dasar untuk instrumentasi sumber daya yang akan dikelola di lingkungan Java EE.

Tentang Serialisasi:

Dalam serialisasi objek, objek dapat direpresentasikan sebagai urutan byte yang mencakup data objek serta informasi tentang jenis objek dan jenis data yang disimpan dalam objek.

Setelah objek serial telah ditulis ke dalam file, itu dapat dibaca dari file dan deserialized yaitu, informasi jenis dan byte yang mewakili objek dan datanya dapat digunakan untuk membuat ulang objek dalam memori.

Anda akan menemukan Serialisasi yang berguna ketika menyebarkan proyek Anda di beberapa server karena kacang akan bertahan dan ditransfer di seluruh mereka.

Java Beans adalah standar, dan persyaratan sintaksis dasarnya telah dijelaskan dengan jelas oleh jawaban yang lain.

Namun, IMO, ini lebih dari standar sintaksis sederhana. Arti sebenarnya atau maksud penggunaan Java Beans adalah, bersama dengan berbagai dukungan alat di sekitar standar, untuk memfasilitasi penggunaan kembali kode dan rekayasa perangkat lunak berbasis komponen, yaitu memungkinkan pengembang untuk membangun aplikasi dengan merakit komponen yang ada (kelas) dan tanpa harus menulis apa pun kode (atau hanya perlu menulis kode lem kecil). Sayangnya teknologi ini jauh di bawah perkiraan dan kurang dimanfaatkan oleh industri, yang dapat dikatakan dari jawaban di utas ini.

Jika Anda membaca tutorial Oracle tentang Java Beans , Anda bisa mendapatkan pemahaman yang lebih baik tentang hal itu.

Sesuai Wikipedia:

1. Kelas harus memiliki konstruktor default publik (tanpa argumen). Ini memungkinkan instantiasi yang mudah dalam kerangka pengeditan dan aktivasi.

2. Properti kelas harus dapat diakses menggunakan get, set, is (dapat digunakan untuk properti boolean alih-alih get), dan metode lainnya (disebut metode accessor dan metode mutator) sesuai dengan konvensi penamaan standar. Ini memungkinkan inspeksi otomatis yang mudah dan pembaruan status kacang dalam kerangka kerja, banyak di antaranya termasuk editor khusus untuk berbagai jenis properti. Setter dapat memiliki satu atau lebih dari satu argumen.

3. Kelas harus serial. [Ini memungkinkan aplikasi dan kerangka kerja untuk secara andal menyimpan, menyimpan, dan memulihkan keadaan kacang dengan cara yang tidak tergantung pada VM dan platform.]

Untuk informasi lebih lanjut, ikuti tautan ini .

Mengenai bagian kedua dari pertanyaan Anda, Serialisasi adalah mekanisme ketekunan yang digunakan untuk menyimpan objek sebagai urutan byte yang ditandatangani. Secara kurang formal, ia menyimpan keadaan suatu objek sehingga Anda dapat mengambilnya nanti, dengan menghapus serialisasi.

Java Bean adalah kelas java [konseptual] yang harus mengikuti konvensi berikut:

1. Seharusnya memiliki konstruktor no-arg.
2. Itu harus Serializable.
3. Ini harus menyediakan metode untuk mengatur dan mendapatkan nilai-nilai properti, yang dikenal sebagai metode pengambil dan penyetel.

Ini adalah komponen perangkat lunak yang dapat digunakan kembali. Itu dapat merangkum banyak objek menjadi satu objek sehingga objek yang sama dapat diakses dari banyak tempat dan merupakan langkah menuju pemeliharaan kode yang mudah.

Mereka adalah serializable, memiliki konstruktor argumen nol, dan memungkinkan akses ke properti menggunakan metode pengambil dan penyetel. Nama "Bean" diberikan untuk mencakup standar ini, yang bertujuan untuk membuat komponen perangkat lunak yang dapat digunakan kembali untuk Java. according to wiki

Objek yang membentuk tulang punggung aplikasi Anda dan yang dikelola oleh wadah Spring IoC disebut kacang. Kacang adalah objek yang dipakai, dirakit, dan dikelola oleh wadah Spring IoC. Kalau tidak, kacang hanyalah salah satu dari banyak objek dalam aplikasi Anda. according to musim semi io .

Hanya sedikit latar belakang / pembaruan pada konsep kacang. Banyak jawaban lain yang benar-benar memiliki apa tetapi tidak mengapa.

Mereka diciptakan awal di Jawa sebagai bagian dari membangun GUI. Mereka mengikuti pola yang mudah untuk alat untuk memisahkan membiarkan mereka membuat panel properti sehingga Anda dapat mengedit atribut Bean. Secara umum, properti Bean mewakili kontrol di layar (Pikirkan x, y, lebar, tinggi, teks, ..)

Anda juga dapat menganggapnya sebagai struktur data yang sangat diketik.

Seiring waktu, ini menjadi berguna untuk banyak alat yang menggunakan jenis akses yang sama (Misalnya, Hibernate untuk mempertahankan struktur data ke database)

Saat alat berkembang, mereka bergerak lebih ke arah anotasi dan menjauh dari memisahkan nama penyetel / pengambil. Sekarang sebagian besar sistem tidak memerlukan kacang, mereka dapat mengambil objek java tua biasa dengan properti beranotasi untuk memberi tahu mereka cara memanipulasi mereka.

Sekarang saya melihat kacang sebagai bola properti beranotasi - mereka benar-benar hanya berguna untuk penjelasan yang mereka bawa.

Kacang itu sendiri bukanlah pola yang sehat. Mereka menghancurkan enkapsulasi berdasarkan sifatnya karena mereka mengekspos semua properti mereka ke manipulasi eksternal dan ketika mereka digunakan ada kecenderungan (sama sekali tidak persyaratan) untuk membuat kode untuk memanipulasi kacang secara eksternal alih-alih membuat kode di dalam kacang (melanggar "don dapat meminta objek untuk nilainya, minta objek untuk melakukan sesuatu untuk Anda "). Menggunakan pojos beranotasi dengan getter minimal dan tanpa setter jauh lebih OO memulihkan enkapsulasi dan dengan kemungkinan immutability.

Ngomong-ngomong, karena semua hal ini terjadi seseorang memperluas konsep ke sesuatu yang disebut Enterprise Java Beans. Ini ... berbeda. dan mereka cukup rumit sehingga banyak orang merasa mereka tidak memahami seluruh konsep Bean dan berhenti menggunakan istilah itu. Ini, saya pikir, mengapa Anda biasanya mendengar kacang disebut sebagai POJO (karena setiap objek java adalah POJO ini secara teknis OK, tetapi ketika Anda mendengar seseorang berkata POJO mereka paling sering memikirkan sesuatu yang mengikuti pola kacang)

Java Bean adalah kelas java apa saja yang memenuhi tiga kriteria berikut:

1. Seharusnya mengimplementasikan antarmuka serializable (antarmuka Marker).
2. Konstruktor harus bersifat publik dan tidak memiliki argumen (Apa yang orang lain sebut sebagai "konstruktor no-arg").
3. Seharusnya pengambil dan setter.

Baik untuk dicatat bidang serialVersionUID penting untuk mempertahankan status objek. Kode di bawah ini memenuhi syarat sebagai kacang:

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

Untuk memahami JavaBean Anda perlu memperhatikan hal-hal berikut: JavaBean adalah hal yang konseptual dan tidak dapat mewakili kelas hal-hal tertentu

JavaBean adalah alat pengembangan yang dapat divisualisasikan dalam pengoperasian komponen perangkat lunak yang dapat digunakan kembali

JavaBean didasarkan pada spesifikasi Java JavaBeans dan dapat menjadi komponen yang dapat digunakan kembali. Fitur terbesarnya adalah penggunaan ulang.

Kacang adalah kelas Java dengan nama metode yang mengikuti pedoman Java Bean (juga disebut pola desain) untuk properti , metode , dan acara. Dengan demikian, setiap metode publik dari kelas kacang yang bukan bagian dari definisi properti adalah metode kacang. Minimal, kelas Java bahkan dengan properti sebagai anggota tunggal (tentu saja, penyertaan publik dan pembuat set diperlukan), metode publik sebagai anggota tunggal atau hanya satu metode pendaftaran pendengar acara publik adalah kacang Jawa. Selanjutnya, properti dapat berupa properti hanya-baca (memiliki metode pengambil tetapi tidak ada setter) atau properti hanya-tulis (hanya memiliki metode setter). Kacang Jawa harus berupa kelas publik agar dapat dilihat oleh alat atau wadah beanbox apa pun. Wadah itu harus bisa instantiate; dengan demikian, ia harus memiliki konstruktor publik juga. The JavaBeans Spesifikasitidak memerlukan kacang untuk memiliki konstruktor zero-args publik, eksplisit atau default, untuk wadah untuk instantiate. Jika Anda bisa menyediakan file (dengan ekstensi .ser) yang berisi contoh serial, alat beanbox dapat menggunakan file itu untuk membuat contoh prototipe kacang. Kalau tidak, kacang harus memiliki konstruktor zero-args publik, baik eksplisit maupun default.

Setelah kacang dibuat, API Java Bean (java.beans. *) Dapat mengintrospeksi dan memanggil metode di dalamnya. Jika tidak ada kelas yang mengimplementasikan antarmuka BeanInfo atau memperluas implementasi BeanInfo, kelas SimpleBeanInfo, introspeksi melibatkan penggunaan refleksi (introspeksi implisit) untuk mempelajari metode yang didukung oleh kacang target dan kemudian menerapkan pola desain sederhana (pedoman) untuk menyimpulkan dari metode apa yang didukung properti, acara, dan metode publik. Jika kelas mengimplementasikan antarmuka BeanInfo (untuk bean Foo, harus bernama FooBeanInfo) tersedia, API memotong introspeksi implisit dan menggunakan metode publik (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors (), getEventSetDescriptors ()) dari kelas ini untuk mendapatkan informasi. Jika kelas yang memperpanjang SimpleBeanInfo tersedia, tergantung pada mana dari metode publik SimpleBeanInfo (getPropertyDescriptor (), getMethodDescriptors (), getEventSetDescriptors ()) yang diganti, itu akan menggunakan metode yang ditimpa (s) untuk mendapatkan informasi; untuk metode yang tidak diganti, akan default ke introspeksi implisit yang sesuai. Kacang harus tetap dipakai meskipun tidak ada introspeksi implisit yang dilakukan. Dengan demikian, persyaratan konstruktor zeri-args publik. Tetapi, tentu saja, antarmuka Serializable atau Externalizable tidak diperlukan untuk dapat dikenali. Namun spesifikasi Java Bean mengatakan, 'Kami juga ingin itu menjadi "sepele" untuk kasus umum Bean kecil yang hanya ingin memiliki keadaan internal yang disimpan dan tidak ingin memikirkannya.' Jadi, semua kacang harus mengimplementasikan antarmuka Serializable atau Externalizable. Secara keseluruhan, Spesifikasi JavaBeans tidak sulit dan cepat tentang apa yang dimaksud dengan kacang. "Menulis komponen JavaBeans sangat mudah. ​​Anda tidak memerlukan alat khusus dan Anda tidak perlu mengimplementasikan antarmuka apa pun. Menulis kacang hanyalah masalah mengikuti konvensi pengkodean tertentu. Yang harus Anda lakukan hanyalah membuat kelas Anda terlihat seperti kacang - alat yang menggunakan kacang akan dapat mengenali dan menggunakan kacang Anda. " Sepele, bahkan kelas berikut adalah Java Bean,

public class Trivial implements java.io.Serializable {}

Katakanlah, konstruktor kacang memiliki beberapa parameter. Misalkan beberapa tipe sederhana. Wadah tersebut mungkin tidak tahu nilai apa yang diberikan kepadanya; bahkan jika ya, instance yang dihasilkan mungkin tidak dapat digunakan kembali. Mungkin masuk akal hanya jika pengguna dapat mengkonfigurasi (menentukan nilai) dengan mengatakan anotasi atau file konfigurasi xml seperti pada Spring bean. Dan anggaplah beberapa parameter adalah tipe kelas atau antarmuka. Sekali lagi, wadah mungkin tidak tahu nilai apa yang diberikan padanya. Mungkin masuk akal hanya jika pengguna dapat mengkonfigurasi (menentukan objek tertentu) dengan mengatakan anotasi atau file konfigurasi xml. Namun, bahkan di Spring (melalui file konfigurasi xml), menugaskan objek tertentu (dengan nama string) ke argumen konstruktor (atribut atau elemen argumen konstruktor) bukan typesafe, pada dasarnya seperti injeksi sumber daya. Membuat referensi ke kacang Spring lainnya (disebut kolaborator; melalui elemen dalam elemen argumen konstruktor) pada dasarnya injeksi ketergantungan dan dengan demikian typesafe. Jelas, ketergantungan (kacang kolaborator) mungkin memiliki konstruktor dengan parameter yang disuntikkan; ketergantungan yang disuntikkan mungkin memiliki konstruktor dengan parameter dan sebagainya. Dalam skenario ini, pada akhirnya, Anda akan memerlukan beberapa kelas kacang (mis., MyBean.class) agar wadah dapat instantiate dengan hanya memanggil MyBean baru () sebelum dapat membangun kacang kolaborasi lainnya melalui injeksi ketergantungan pada konstruktor — dengan demikian, persyaratan untuk kacang untuk memiliki konstruktor zero-args publik. Misalkan, jika sebuah wadah tidak mendukung injeksi dependensi dan / atau tidak mengizinkan penetapan nilai tipe sederhana untuk konstruktor melalui beberapa anotasi atau file konfigurasi xml seperti di Spring, konstruktor kacang seharusnya tidak memiliki parameter. Bahkan aplikasi kacang Spring akan membutuhkan kacang untuk memiliki konstruktor zero-args publik (misalnya, dalam skenario di mana aplikasi Spring Anda tidak memiliki kacang dengan hanya tipe sederhana sebagai argumen konstruktor).

Kacang dikelola JSF dijalankan dalam wadah web. Mereka dapat dikonfigurasi baik dengan penjelasan @ManagedBean atau dengan file sumber daya konfigurasi aplikasi dikelola-bean.xml. Namun, ini mendukung injeksi melalui injeksi sumber daya (bukan typesafe) saja; tidak cocok untuk injeksi pada konstruktor. The JSF spesifikasimensyaratkan bahwa kacang yang dikelola harus memiliki konstruktor tanpa argumen publik. Lebih lanjut dikatakan, “Pada versi 2.3 spesifikasi ini, penggunaan fasilitas kacang yang dikelola sebagaimana ditentukan dalam bagian ini sangat tidak dianjurkan. Solusi terintegrasi yang lebih baik dan lebih kohesif untuk menyelesaikan masalah yang sama adalah dengan menggunakan Contexts and Dependency Injection (CDI), seperti yang ditentukan dalam JSR-365. untuk kacang Spring. Spesifikasi CDI mengadopsi spesifikasi Managed Beans, yang berlaku untuk semua wadah platform JEE, bukan hanya web tier. Jadi, wadah web perlu menerapkan spesifikasi CDI.

Berikut adalah kutipan dari spesifikasi Managed Bean “Kacang yang Dikelola adalah objek yang dikelola dengan wadah dengan persyaratan minimal, atau dikenal dengan akronim“ POJO ”(Benda Jawa Tua Biasa)… mereka dapat dilihat sebagai versi JavaEE yang disempurnakan platform dari model komponen JavaBeans yang ditemukan pada platform Java SE … Tidak akan terlewatkan oleh pembaca bahwa Managed Beans memiliki pendahulu dalam fasilitas homonim yang ditemukan dalam teknologi JavaServer Faces (JSF)… Managed Beans sebagaimana didefinisikan dalam spesifikasi ini mewakili generalisasi dari yang terdapat di JSF; khususnya, Managed Beans dapat digunakan di mana saja dalam aplikasi Java EE, tidak hanya dalam modul web. Misalnya, dalam model komponen dasar, Kacang Terkelola harus menyediakan konstruktor tanpa argumen, tetapi spesifikasi yang dibangun di atas Kacang Terkelola, seperti CDI (JSR-299), dapat mengendurkan persyaratan itu dan memungkinkan Kacang Terkelola menyediakan tanda tangan yang lebih kompleks kepada konstruktor, selama mereka mengikuti beberapa aturan yang terdefinisi dengan baik ... Kacang Terkelola tidak boleh: kelas akhir, kelas abstrak, kelas dalam non-statis . A Managed Bean mungkin tidak dapat serial seperti komponen JavaBean biasa. " Dengan demikian, spesifikasi untuk Kacang Terkelola, atau dikenal sebagai POJO atau kacang POJO, memungkinkan ekstensi seperti dalam CDI.

Spesifikasi CDI mendefinisikan kembali kacang yang dikelola sebagai: Ketika berjalan di Java EE, kelas Java tingkat atas adalah kacang yang dikelola jika memenuhi persyaratan:

• Ini bukan kelas batin. • Ini adalah kelas non-abstrak, atau @Decorator beranotasi. • Ini tidak mengimplementasikan javax.enterprise.inject.spi.Extension. • Ini bukan @Vetoed beranotasi atau dalam paket @Vetoed beranotasi. • Ia memiliki konstruktor yang sesuai, baik: kelas memiliki konstruktor tanpa parameter, atau kelas menyatakan konstruktor beranotasi @Inject.

Semua kelas Java yang memenuhi persyaratan ini adalah kacang yang dikelola dan dengan demikian tidak diperlukan deklarasi khusus untuk mendefinisikan kacang yang dikelola. Atau

jika didefinisikan sebagai kacang yang dikelola oleh spesifikasi Java EE lainnya dan jika

• Ini tidak dijelaskan dengan anotasi pendefinisian komponen EJB atau dideklarasikan sebagai kelas kacang EJB di ejb-jar.xml.

Tidak seperti Spring Bean, itu tidak mendukung konstruktor dengan tipe sederhana, yang mungkin dimungkinkan jika mendukung konfigurasi dengan file konfigurasi xml seperti di Spring atau anotasi apa pun.

EJB dijalankan dalam wadah EJB. Its spesifikasimengatakan: "Komponen kacang sesi adalah Kacang Managed." "Kelas harus memiliki konstruktor publik yang tidak mengambil argumen," katanya untuk kacang sesi dan kacang yang digerakkan oleh pesan. Selanjutnya, dikatakan, "Kelas kacang sesi adalah tidak diperlukan untuk mengimplementasikan antarmuka SessionBean atau antarmuka Serializable. " Untuk alasan yang sama seperti kacang JSF, bahwa injeksi ketergantungan EJB3 pada dasarnya adalah injeksi sumber daya, kacang JSF tidak mendukung konstruktor dengan argumen, yaitu, melalui injeksi ketergantungan. Namun, jika wadah EJB mengimplementasikan CDI, "Opsional: Kelas mungkin memiliki konstruktor tambahan yang dijelaskan dengan anotasi Suntikan, “dikatakan untuk sesi kacang dan kacang yang digerakkan oleh pesan karena,“ Sebuah EJB yang dikemas dalam arsip kacang CDI dan tidak dijelaskan dengan javax.enterprise.inject. penjelasan Vote, dianggap sebagai CDI-enabled kacang."

Dalam prakteknya, Kacang hanyalah benda yang berguna untuk digunakan. Serializing mereka berarti dapat dengan mudah bertahan mereka (simpan dalam bentuk yang mudah dipulihkan).

Penggunaan khas Kacang di dunia nyata:

• objek reusable sederhana POJO (Plain Old Java Objects)
• objek visual
• Spring menggunakan Beans untuk menangani objek (misalnya, objek Pengguna yang perlu diserialisasi dalam sesi)
• EJB (Enterprise Java Beans), objek yang lebih kompleks, seperti JSF Beans (JSF adalah teknologi yang cukup lama) atau JSP Beans

Jadi sebenarnya, Kacang hanyalah konvensi / standar untuk mengharapkan sesuatu dari objek Java yang akan berperilaku (serialisasi) dan memberikan beberapa cara untuk mengubahnya (setter untuk properti) dengan cara tertentu.

Cara menggunakannya, hanya penemuan Anda, tetapi kasus yang paling umum saya minta di atas.