Memperkenalkan EJB

Pada artikel ini kita akan melihat EJB - Enterprise JavaBeans. Teknologi ini merupakan bagian dari spesifikasi Java EE. Kami akan menyentuh isu-isu seperti:

• apa itu EJB;
• bagaimana sejarah EJB;
• jenis EJB apa yang ada?

Kami juga akan menulis aplikasi kecil HelloWorld menggunakan EJB dan servlet. Artikel ini akan bermanfaat bagi pembaca yang sudah terbiasa dengan Java SE dan mulai mempelajari Java EE. Untuk memahami sepenuhnya bagian praktis artikel ini, disarankan agar Anda membaca artikel “ Menyiapkan lingkungan lokal ” terlebih dahulu.

Sejarah Singkat EJB

Pada tahun 1996, ketika penulis artikel ini berusia 5 tahun, Java sudah populer di kalangan developer. Alasannya adalah API yang ramah, pengumpulan sampah otomatis, dll. Java banyak digunakan dalam sistem yang bertanggung jawab atas backend. Namun, terlepas dari semua keindahan bahasanya, pemrogram pada masa itu membutuhkan fungsionalitas tertentu yang belum diimplementasikan di JDK. Kebutuhan tersebut adalah:

• memastikan persistensi data;
• integritas transaksi
• akses kompetitif terhadap data (kontrol multi-threading);
• dan kemungkinan besar sesuatu yang lain.

Semua ini menyebabkan pertumbuhan alami dalam populasi perpustakaan yang dibangun sendiri, ditulis sendiri, dan tertutup. Dengan kata lain, setiap orang memenuhi kebutuhannya sebaik mungkin. Hingga IBM mengeluarkan slogan, “Setiap orang harus memenuhi kebutuhannya dengan cara yang sama,” dan merilis spesifikasi Enterprise Java Bean (EJB) pada tahun 1997. Hal inilah yang memungkinkan untuk menyatukan proses pembangunan dan memasukkan solusi terhadap masalah-masalah umum (dijelaskan di atas sebagai kebutuhan) ke dalam kerangka kerja. Sun telah mengadaptasi gagasan IBM selama 2 tahun, dan pada tahun 1999 merilis spesifikasi EJB 1.0. Dari sinilah teknologi lahir, yang akan dibahas lebih lanjut secara lebih terapan.

Apa itu EJB

EJB dalam arti tertentu adalah istilah kolektif yang, tergantung pada konteksnya, dapat berarti teknologi Enterprise JavaBeans itu sendiri secara umum, atau komponen perangkat lunak (bean) Enterprise JavaBean tertentu yang merupakan bagian dari teknologi EJB. Definisi EJB sebagai suatu teknologi diberikan di Wikipedia: Enterprise JavaBeans (juga sering digunakan sebagai singkatan EJB) adalah spesifikasi teknologi untuk menulis dan mendukung komponen server yang berisi logika bisnis. Ini adalah bagian dari Java EE. Teknologi ini biasanya digunakan ketika logika bisnis memerlukan setidaknya satu dari layanan berikut, dan sering kali semuanya:

• dukungan untuk persistensi data: data harus aman bahkan setelah program dihentikan. Paling sering dicapai dengan menggunakan database;
• dukungan untuk transaksi terdistribusi;
• dukungan untuk modifikasi data paralel dan multithreading;
• dukungan acara;
• dukungan penamaan dan direktori (JNDI);
• keamanan dan pembatasan akses terhadap data;
• dukungan untuk instalasi otomatis pada server aplikasi;
• akses jarak jauh.

Layanan yang tercantum di atas merupakan keunggulan teknologi EJB yang tidak diragukan lagi. Keuntungan lainnya adalah semua yang tercantum di atas langsung berfungsi. Itu. programmer tidak perlu memikirkan untuk mendukung transaksi terdistribusi. Pemrogram hanya perlu memikirkan logika bisnis yang sedang ia coba terapkan. EJB sebagai komponen perangkat lunak tertentu adalah kelas Java dengan satu atau lebih anotasi dari spesifikasi EJB yang berisi beberapa logika bisnis aplikasi. Anotasi dari spesifikasi EJB memberikan kekuatan, kekuatan, dan kekuatan super tertentu pada kelas yang diberi tag. Baca lebih lanjut tentang ini di bawah.

tipe EJB

Mari kita rangkum. EJB adalah kelas Java reguler yang ditandai dengan salah satu anotasi khusus. Kelas seperti ini disebut kacang. Bergantung pada anotasi yang digunakan untuk menandai kelas, kelas tersebut akan mewakili satu atau beberapa jenis EJB (kacang). Ada tiga jenis utama kacang:

• Kacang yang Didorong Pesan (pesan yang digerakkan oleh kacang);
• Entity Beans - didefinisikan dalam spesifikasi JPA (Java Persistence API) dan digunakan untuk menyimpan data;
• Kacang Sesi.

Yang terakhir (session beans) dibagi menjadi beberapa subtipe:

• stateless (tanpa negara);
• stateful (dengan dukungan untuk status sesi saat ini);
• singleton (satu objek untuk seluruh aplikasi; mulai dari EJB 3.1).

Di bawah ini kita akan melihat setiap jenis kacang secara lebih rinci.

Kacang Sesi

Session Beans, atau session beans, adalah jenis kacang tertentu. Mereka merangkum logika bisnis yang dapat dipanggil secara terprogram oleh klien dengan memanggil metode kacang. Pemanggilan metode dapat melakukan:

• secara lokal, oleh kelas lain di JVM yang sama dengan kacang sesi;
• dari jarak jauh, melalui jaringan, dari JVM lain, menggunakan teknologi Java RMI (Remote Method Invocation).

Kata “sesi” menyiratkan bahwa bean hanya tersedia saat server sedang melakukan tugas tertentu dan akan dimusnahkan secara permanen jika terjadi kegagalan atau penghentian server. Siklus hidup instance session bean dikendalikan oleh container EJB (Anda dapat membaca lebih lanjut tentang container EJB di kuliah pertama seri ini ). Kacang sesi tanpa kewarganegaraan tidak menyimpan informasi tentang statusnya. Komponen jenis ini dapat digunakan oleh berbagai klien. Kacang tanpa kewarganegaraan digunakan untuk mengimplementasikan proses bisnis yang dapat diselesaikan dalam satu operasi. Misalnya memeriksa riwayat kredit klien. Karena satu instance bean dapat digunakan oleh banyak klien, pengembang harus menyediakan akses thread-safe ke data bean. Membuat kacang jenis ini (dan juga kacang sesi lainnya) cukup sederhana. Ini adalah kelas Java reguler dengan anotasi @Stateless. Mari kita beri contoh di bawah ini:

import javax.ejb.Stateless;

@Stateless
public class StatelessEjbExample {
    public String sayHi() {
        return "Hi, I'm Stateless EJB!";
    }
}

Kacang sesi yang mendukung status sesi saat ini (Stateful) menyimpan informasi tentang statusnya di antara panggilan dari klien yang sama dan mengakhiri keberadaannya atas permintaan eksplisit dari klien. Hal ini dicapai karena fakta bahwa stateful beans bersifat unik untuk setiap klien. Contoh tugas yang menjadi tanggung jawab kacang jenis ini adalah menjaga keranjang belanja di toko online tetap mutakhir untuk setiap pengguna. Siklus hidup biji kopi ini dikelola oleh wadah EJB. Kacang ini juga hancur ketika klien keluar. Kacang seperti itu juga cukup mudah dibuat. Ini adalah kelas Java yang ditandai dengan anotasi Stateful. Contoh di bawah ini:

import javax.ejb.Stateful;

@Stateful
public class StatefulEjbExample {
    public String sayHi() {
        return "Hi, I,m Stateful EJB";
    }
}

Kacang sesi tunggal dimulai satu kali selama masa pakai aplikasi dan berlangsung sepanjang masa pakai aplikasi. Kacang tersebut dirancang untuk situasi di mana satu keadaan harus dibagi di antara semua klien. Seperti halnya kacang yang tidak memiliki kewarganegaraan, dalam kacang yang berdiri sendiri, pengembang perlu memastikan bahwa lingkungan di dalam kacang tersebut diatur dengan cara yang aman bagi thread. Mari kita beri contoh kacang Singleton, yang pembuatannya semudah kacang sejenisnya, yang telah dibahas di atas. Sangat mudah untuk menebak bahwa ini adalah kelas Java dengan anotasi @Singleton. Namun, dalam hal ini Anda perlu berhati-hati. Ada dua anotasi, identik dalam sintaksis, tetapi berbeda tujuannya dan terletak di paket berbeda:

• javax.ejb.Singleton
• javax.inject.Singleton

Untuk membuat EJB, Anda harus menggunakan anotasi dari javax.ejb. Contoh di bawah ini:

import javax.ejb.Singleton;

@Singleton
public class SingletonEjbExample {
    public String sayHi() {
        return "Hi, I'm Singleton EJB!";
    }
}

Kacang yang Didorong Pesan

Kacang yang Didorong Pesan, atau MDB, atau kacang yang digerakkan oleh pesan, menerapkan beberapa logika bisnis, seperti kacang sesi. Namun tidak seperti saudaranya, MDB memiliki satu perbedaan penting. Klien tidak pernah memanggil metode MDB secara langsung. Kacang seperti itu paling sering bertindak sebagai pendengar pesan JMS (Java Message Service) dan berfungsi untuk mengatur pertukaran pesan asinkron antar bagian sistem. Contoh dari pesan tersebut adalah permintaan pengiriman inventaris dari sistem ritel otomatis ke sistem manajemen pasokan. Di bawah ini adalah contoh kacang MDB. Berbeda dengan session beans, pembuatannya sedikit lebih menarik:

import javax.annotation.Resource;
import javax.ejb.MessageDriven;
import javax.ejb.MessageDrivenContext;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(mappedName = "jms/TestQueue")
public class MessageDrivenEjbExample implements MessageListener {

    @Resource
    private MessageDrivenContext messageDrivenContext;

    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                TextMessage msg = (TextMessage) message;
                msg.getText();
            }
        } catch (JMSException e) {
            messageDrivenContext.setRollbackOnly();
        }
    }

}

Anotasi tersebut MessageDrivenmenjadikan kelas MDB kami menarik. Di dalam anotasi, menggunakan JNDI (baca tentang JNDI di sini ), nama distribusi JMS ditentukan, di mana kelas kita menjadi pendengarnya. Selain itu, kelas kami mengimplementasikan antarmuka MessageListenerdan metodenya onMessage. Metode ini akan dipanggil ketika beberapa pesan masuk dari antrian/distribusi dengan nama yang ditentukan di dalam anotasi MessageDriven.

Kacang entitas

Bagian dari teknologi EJB adalah spesifikasi JPA. JPA, atau Java Persistence API, adalah spesifikasi yang menyediakan Pemetaan Relasional Objek (ORM) objek Java (Entity beans) dan menyediakan API untuk menyimpan, mengambil, dan mengelola objek tersebut. JPA memungkinkan Anda untuk merepresentasikan data dari database sebagai objek Java, serta menyimpan objek Java sebagai catatan dalam database. Tidak setiap kelas dapat bertindak sebagai objek seperti itu, tetapi kacang Entitas. Entity Bean adalah kelas Java yang mewakili tabel dalam database. Tampilan (pemetaan) dicapai melalui penggunaan anotasi khusus. Dengan bantuan mereka, kelas Java dibandingkan dengan tabel di database, dan bidang kelas Java dibandingkan dengan bidang tabel database. Berikut ini contoh kacang Entitas, dengan komentar di kodenya:

@Entity // Делает данный класс Entity бином
@Table(name = "employee") // "Связывает" данный класс с таблицей employee в БД
public class Employee implements Serializable {

    @Id // Говорит о том, что поле ниже является первичным ключом
    @GeneratedValue(strategy = GenerationType.AUTO) // Определяет тип генерации значений первичного ключа
    private int id;

    @Column(name="name") // "Связывает" поле ниже с полем name в таблице employee в БД
    private String name;

    @Column (name="age") // "Связывает" поле ниже с полем age в таблице employee в БД
    private int age;

    // getters and setters...
}

Perlu dicatat bahwa jenis kacang ini masuk akal untuk dipelajari hanya dalam konteks mempelajari spesifikasi JPA.

Menulis aplikasi: EJB HelloWorld

Di bagian ini, kita akan menulis aplikasi kecil Java EE HelloWorld, yang akan kita terapkan di server GlassFish. Sebelum membaca artikel ini, sangat disarankan agar Anda membaca artikel tentang menyiapkan lingkungan lokal Anda .

1. Buat proyek Maven baru di IntelliJ IDEA.

   File -> Baru -> Proyek...

2. Klik Berikutnya .

3. Isi parameter proyek Maven:

4. Klik Selesai

5. Proyek telah dibuat dan memiliki struktur sebagai berikut:

File pom.xml terlihat seperti ini: Pertama-tama, kita perlu menambahkan ketergantungan pada Java EE API, dan juga menentukan pengemasan proyek kita dalam bentuk arsip aplikasi web (perang). Untuk melakukannya, Anda perlu mengubah kode pom.xml menjadi bentuk berikut:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.javarush.lectures</groupId>
    <artifactId>ejb_demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>
    </dependencies>

</project>

Selanjutnya, Anda dapat melanjutkan ke kode Java. Aplikasi kami akan menjadi yang paling sederhana. Kami akan memiliki 1 servlet dan 1 EJB. Ini akan menjadi sesi tanpa kewarganegaraan. Di dalam EJB kita hanya akan mendefinisikan 1 metode yang akan mengembalikan string “Hello World”. Pertama-tama, mari kita buat sebuah paket com.javarush.lectures. Kemudian, di dalam paket com.javarush.lectures, kita akan membuat kacang kita - DemoEJB. Kode kacang diberikan di bawah ini:

import javax.ejb.Stateless;

@Stateless
public class DemoEJB {
    public String helloWorld() {
        return "Hello world!";
    }
}

Seperti disebutkan sebelumnya, semuanya cukup sederhana. Langkah kita selanjutnya adalah membuat servlet yang akan meneruskan nilai dari EJB sebagai respons terhadap permintaan HTTP. Perlu dicatat bahwa servlet bukanlah topik artikel ini, tetapi Anda masih perlu menggunakannya untuk mendemonstrasikan EJB. Untuk melakukan ini, mari buat servlet baru DemoServletdalam paket yang sama dengan EJB. Kodenya ada di bawah:

@WebServlet("/helloWorld")
public class DemoServlet extends HttpServlet {

    @EJB
    private DemoEJB ejb;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write(ejb.helloWorld());
    }
}

Berikut beberapa komentar singkat tentang kode tersebut. Abstrak @WebServlet("/helloWorld")- mendefinisikan kelas kita sebagai servlet yang akan memproses permintaan HTTP ke titik akhir /helloWorld. Kelas kami memiliki satu bidang - DemoEJB ejb. Ini adalah kacang yang kami definisikan sebelumnya. Anotasi pada bidang kelas— @EJBmelakukan injeksi ketergantungan (DI). Itu. Variabel ejb secara otomatis diinisialisasi dengan instance baru bila diperlukan. Kelas kami adalah turunan dari HttpServlet dan mengesampingkan salah satu metode superkelas - doGet. Metode ini memproses permintaan HTTP GET dan mengambil dua parameter - HttpServletRequestdan HttpServletResponse. HttpServletRequestberfungsi untuk mendapatkan informasi tentang permintaan HTTP yang masuk. HttpServletResponsediperlukan untuk menghasilkan respons terhadap permintaan. Di dalam metode ini, kita mendapatkan objek PrintWriterdari objek respons ( HttpServletResponse), menggunakan metode getWriter(). Selanjutnya, kita bisa menulis beberapa nilai ke objek yang dihasilkan menggunakan write. Yang sebenarnya adalah apa yang kita gunakan dengan menulis ke dalam PrintWriterobjek -a nilai yang diperoleh dari EJB yang kita definisikan (nilainya adalah string “Hello World!”). Klien yang mengirimkan permintaan HTTP akan menerima nilai ini sebagai respons terhadap permintaannya. Langkah selanjutnya adalah meluncurkan aplikasi di server GlassFish Java EE. Untuk melakukan ini, kami akan membuat konfigurasi baru, seperti yang dijelaskan dalam artikel tentang menyiapkan lingkungan lokal . Di bawah ini adalah tangkapan layar konfigurasi yang telah selesai untuk proyek saat ini. Pastikan Anda telah menginstal server GlassFish sebelum memulai: Setelah membuat konfigurasi peluncuran, luncurkan aplikasi menggunakan menu Run -> Run 'ejb_demo' atau menggunakan hotkey Shift+F10 . Setelah diluncurkan, Anda dapat melihat lognya: Dan juga browser yang terbuka: Semua ini menunjukkan bahwa aplikasi berfungsi sebagaimana mestinya.

Kesimpulan

Pada artikel ini kita berkenalan dengan EJB - Enterprise JavaBeans. Kami mempertimbangkan pertanyaan-pertanyaan seperti:

• Apa itu EJB?
• Sejarah EJB
• Berbagai jenis EJB

Ingatlah bahwa EJB hadir dalam jenis berikut:

• Kacang yang Didorong Pesan (pesan yang digerakkan oleh kacang);
• Entity Beans - ditentukan dalam spesifikasi entitas JPA (Java Persistence API) dan digunakan untuk menyimpan data;
• Kacang Sesi:
  • stateless (tanpa negara)
  • stateful (dengan dukungan untuk status sesi saat ini)
  • singleton (satu objek untuk seluruh aplikasi; mulai dari EJB 3.1)

Kami juga menulis aplikasi kecil HelloWorld menggunakan EJB. Sebagai PD, Anda dapat mengulangi sendiri bagian praktis artikel ini. Dan kemudian tambahkan dua servlet lagi ke aplikasi Anda yang akan menggunakan stateful dan singleton beans untuk menerima nilainya.