Presentazione di EJB

In questo articolo esamineremo EJB - Enterprise JavaBeans. Questa tecnologia fa parte della specifica Java EE. Toccheremo temi come:

• cos'è l'EJB;
• qual è la storia di EJB;
• quali tipi di EJB esistono?

Scriveremo anche una piccola applicazione HelloWorld utilizzando EJB e servlet. Questo articolo sarà utile ai lettori che hanno acquisito dimestichezza con Java SE e stanno iniziando a imparare Java EE. Per comprendere appieno la parte pratica di questo articolo, si consiglia di leggere prima l'articolo “ Impostazione dell'ambiente locale ”.

Una breve storia di EJB

Nel 1996, quando l'autore di questo articolo aveva 5 anni, Java era già popolare tra gli sviluppatori. Il motivo di ciò era l'API amichevole, la raccolta automatica dei rifiuti, ecc. Java era ampiamente utilizzato nei sistemi responsabili del backend. Tuttavia, nonostante tutte le bellezze del linguaggio, i programmatori dell'epoca avevano bisogno di alcune funzionalità che non erano ancora state implementate nel JDK. Tali bisogni erano:

• garantire la persistenza dei dati;
• integrità della transazione
• accesso competitivo ai dati (controllo multi-threading);
• e molto probabilmente qualcos'altro.

Tutto ciò ha portato a una crescita naturale della popolazione delle biblioteche chiuse, autoprodotte e autoprodotte. In altre parole, ognuno ha soddisfatto i propri bisogni come meglio poteva. Questo fino a quando IBM non lanciò lo slogan “Tutti dovrebbero soddisfare le proprie esigenze allo stesso modo” e pubblicò la specifica Enterprise Java Bean (EJB) nel 1997. È stato questo che ha permesso di unificare il processo di sviluppo e portare nel quadro la soluzione ai problemi tipici (descritti sopra come bisogni). Sun ha adattato il frutto dell'ingegno di IBM per 2 anni e nel 1999 ha rilasciato la specifica EJB 1.0. È così che è nata la tecnologia, di cui parleremo più avanti in chiave più applicata.

Cos'è l'EJB

EJB in un certo senso è un termine collettivo che, a seconda del contesto, può significare la stessa tecnologia Enterprise JavaBeans in generale, o qualche componente software specifico Enterprise JavaBean (bean) che fa parte della tecnologia EJB. La definizione di EJB come tecnologia è riportata su Wikipedia: Enterprise JavaBeans (spesso utilizzato anche come abbreviazione EJB) è una specifica di una tecnologia per scrivere e supportare componenti server contenenti logica aziendale. Fa parte di Java EE. Questa tecnologia viene in genere utilizzata quando la logica aziendale richiede almeno uno dei seguenti servizi, e spesso tutti:

• supporto per la persistenza dei dati: i dati dovrebbero essere al sicuro anche dopo aver interrotto il programma. Molto spesso ottenuto utilizzando un database;
• supporto per transazioni distribuite;
• supporto per la modifica parallela dei dati e il multithreading;
• supporto agli eventi;
• supporto per denominazione e directory (JNDI);
• sicurezza e limitazione dell'accesso ai dati;
• supporto per l'installazione automatizzata sul server delle applicazioni;
• accesso remoto.

I servizi sopra elencati rappresentano un indubbio vantaggio della tecnologia EJB. Un altro vantaggio è che tutto quanto elencato sopra funziona immediatamente, immediatamente. Quelli. il programmatore non deve pensare a supportare le transazioni distribuite. Il programmatore deve solo pensare alla logica aziendale che sta attualmente cercando di implementare. Un EJB come componente software specifico è una classe Java con una o più annotazioni dalla specifica EJB che contiene parte della logica aziendale dell'applicazione. Le annotazioni delle specifiche EJB conferiscono alla classe contrassegnata determinati poteri, poteri e superpoteri. Maggiori informazioni al riguardo di seguito.

Tipi EJB

Riassumiamo. Un EJB è una normale classe Java contrassegnata da una delle annotazioni speciali. Tali classi sono chiamate bean. A seconda dell'annotazione con cui è contrassegnata la classe, sarà un rappresentante dell'uno o dell'altro tipo di EJB (bean). Esistono tre tipi principali di fagioli:

• Bean a messaggi (bean a messaggi);
• Entity Beans - definiti nella specifica JPA (Java Persistence API) e utilizzati per archiviare dati;
• Fagioli di sessione.

Questi ultimi (session bean) si dividono in più sottotipi:

• apolide (senza stato);
• stateful (con supporto per lo stato della sessione corrente);
• singleton (un oggetto per l'intera applicazione; a partire da EJB 3.1).

Di seguito esamineremo ogni tipo di fagiolo in modo più dettagliato.

Fagioli di sessione

I Session Bean, o session bean, sono un tipo specifico di bean. Incapsulano la logica aziendale che il client può richiamare a livello di codice chiamando i metodi del bean. Una chiamata al metodo può fare:

• localmente, da un'altra classe nella stessa JVM del bean di sessione;
• in remoto, in rete, da un'altra JVM, utilizzando la tecnologia Java RMI (Remote Method Invocation).

La parola "sessione" implica che il bean è disponibile solo mentre il server esegue un'attività specifica e viene irrimediabilmente distrutto in caso di guasto o arresto del server. Il ciclo di vita di un'istanza di bean di sessione è controllato da un contenitore EJB (puoi leggere ulteriori informazioni sui contenitori EJB nella prima lezione della serie ). I bean di sessione senza stato non memorizzano informazioni sul proprio stato. Questo tipo di componente può essere utilizzato da diversi client. I bean senza stato vengono utilizzati per implementare processi aziendali che possono essere completati in un'unica operazione. Ad esempio, controllando la storia creditizia dei clienti. Poiché una singola istanza di bean può essere utilizzata da più client, lo sviluppatore deve fornire un accesso thread-safe ai dati del bean. Creare un bean di questo tipo (così come tutti gli altri bean di sessione) è abbastanza semplice. Questa è una normale classe Java con un'annotazione @Stateless. Diamo un esempio qui sotto:

import javax.ejb.Stateless;

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

I bean di sessione che supportano lo stato della sessione corrente (Stateful) conservano le informazioni sul loro stato tra le chiamate ad esso dallo stesso client e terminano la loro esistenza su una richiesta esplicita da parte del client. Ciò è possibile grazie al fatto che i bean con stato sono unici per ciascun client. Un esempio di attività di cui questo tipo di bean può essere responsabile è mantenere aggiornato il carrello della spesa in un negozio online per ciascun utente. Il ciclo di vita di questi bean è gestito dal contenitore EJB. Questi bean vengono distrutti anche quando il client esce. Questi fagioli sono anche abbastanza facili da creare. Questa è una classe Java contrassegnata dall'annotazione Stateful. Esempio di seguito:

import javax.ejb.Stateful;

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

I bean di sessione singleton vengono avviati una volta durante la vita dell'applicazione ed esistono per l'intera vita dell'applicazione. Tali bean sono progettati per situazioni in cui uno stato deve essere condiviso tra tutti i client. Come i bean senza stato, nei bean standalone lo sviluppatore deve garantire che l'ambiente all'interno del bean sia organizzato in modo thread-safe. Diamo un esempio di un bean Singleton, che è facile da creare quanto i suoi omologhi, di cui abbiamo parlato sopra. È facile intuire che si tratta di una classe Java con l'annotazione @Singleton. Tuttavia, in questo caso bisogna stare attenti. Esistono due annotazioni, identiche nella sintassi, ma diverse nello scopo e situate in pacchetti diversi:

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

Per creare un EJB, è necessario utilizzare l'annotazione dal file javax.ejb. Esempio di seguito:

import javax.ejb.Singleton;

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

Bean guidati da messaggi

I Message Driven Bean, o MDB, o message-driven bean, implementano alcune logiche di business, come i session bean. Ma a differenza dei suoi parenti, MDB presenta un’importante differenza. I client non chiamano mai direttamente i metodi MDB. Tali bean molto spesso fungono da ascoltatori per i messaggi JMS (Java Message Service) e servono per organizzare lo scambio asincrono di messaggi tra parti del sistema. Un esempio di tale messaggio potrebbe essere una richiesta di consegna dell'inventario da un sistema di vendita al dettaglio automatizzato a un sistema di gestione della fornitura. Di seguito è riportato un esempio di bean MDB. A differenza dei session bean, la sua creazione è un po’ più interessante:

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

}

L'annotazione MessageDrivenrende la nostra classe MDB un bean. All'interno dell'annotazione, utilizzando JNDI (leggi di JNDI qui ), viene determinato il nome della distribuzione JMS, di cui la nostra classe diventa ascoltatrice. Inoltre, la nostra classe implementa l'interfaccia MessageListenere il suo metodo onMessage. Questo metodo verrà chiamato quando arriva qualche messaggio dalla coda/distribuzione con il nome definito all'interno dell'annotazione MessageDriven.

Bean di entità

Parte della tecnologia EJB è la specifica JPA. JPA, o Java Persistence API, è una specifica che fornisce Object-Relational Mapping (ORM) di oggetti Java (Entity bean) e fornisce un'API per archiviare, recuperare e gestire tali oggetti. JPA consente di rappresentare i dati da un database come oggetti Java, nonché di salvare oggetti Java come record nel database. Non tutte le classi possono agire come tali oggetti, ma i bean Entity. Entity Bean è una classe Java che rappresenta una tabella in un database. La visualizzazione (mappatura) è ottenuta mediante l'uso di annotazioni speciali. Con il loro aiuto, una classe Java viene confrontata con una tabella nel database, così come i campi di una classe Java vengono confrontati con i campi di una tabella del database. Ecco un esempio di bean Entity, con commenti nel codice:

@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...
}

Vale la pena notare che questo tipo di fagiolo ha senso studiare solo nel contesto dello studio delle specifiche JPA.

Scrivere un'applicazione: EJB HelloWorld

In questa sezione scriveremo una piccola applicazione Java EE HelloWorld, che distribuiremo sul server GlassFish. Prima di leggere questo articolo, si consiglia vivamente di leggere l'articolo sulla configurazione dell'ambiente locale .

1. Crea un nuovo progetto Maven in IntelliJ IDEA.

   File -> Nuovo -> Progetto...

2. Fare clic su Avanti .

3. Compila i parametri del progetto Maven:

4. Fare clic su Fine

5. Il progetto è stato realizzato ed ha la seguente struttura:

Il file pom.xml si presenta così: Prima di tutto, dobbiamo aggiungere una dipendenza dall'API Java EE e anche specificare la confezione del nostro progetto sotto forma di archivio di applicazioni web (war). Per fare ciò, è necessario modificare il codice pom.xml nel seguente formato:

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

Successivamente, puoi passare al codice Java. La nostra applicazione sarà la più semplice. Avremo 1 servlet e 1 EJB. Questo sarà un bean di sessione senza stato. All'interno dell'EJB definiremo solo 1 metodo che restituirà la stringa “Hello World”. Prima di tutto creiamo un pacchetto com.javarush.lectures. Quindi, all'interno del pacchetto com.javarush.lectures, creeremo il nostro bean - DemoEJB. Il codice del chicco è riportato di seguito:

import javax.ejb.Stateless;

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

Come detto prima, tutto è abbastanza semplice. Il nostro prossimo passo è creare una servlet che trasferirà il valore dall'EJB come risposta alla richiesta HTTP. Vale la pena notare che i servlet non sono l'argomento di questo articolo, ma sarà comunque necessario utilizzarli per dimostrare EJB. Per fare ciò, creiamo una nuova servlet DemoServletnello stesso pacchetto dell'EJB. Il suo codice è il seguente:

@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());
    }
}

Ecco alcuni brevi commenti sul codice. Abstract @WebServlet("/helloWorld"): definisce la nostra classe come una servlet che elaborerà le richieste HTTP all'endpoint /helloWorld. La nostra classe ha un campo: DemoEJB ejb. Questo è il nostro bean definito in precedenza. Un'annotazione su un campo di classe: @EJBesegue l'inserimento delle dipendenze (DI). Quelli. La variabile ejb viene inizializzata automaticamente con una nuova istanza quando richiesto. La nostra classe è un discendente di HttpServlet e sovrascrive uno dei metodi della superclasse: doGet. Questo metodo elabora le richieste HTTP GET e accetta due parametri: HttpServletRequeste HttpServletResponse. HttpServletRequestserve per ottenere informazioni su una richiesta HTTP in entrata. HttpServletResponsenecessario per generare una risposta a una richiesta. All'interno del metodo, otteniamo l'oggetto PrintWriterdall'oggetto risposta ( HttpServletResponse), utilizzando il metodo getWriter(). Successivamente, possiamo scrivere un valore nell'oggetto risultante utilizzando il metodo write. Che, di fatto, è ciò che utilizziamo scrivendo nell'oggetto PrintWriter-a il valore ottenuto dall'EJB da noi definito (il valore è la stringa “Hello World!”). Il client che ha inviato la richiesta HTTP riceverà questo valore come risposta alla sua richiesta. Il passaggio successivo è avviare l'applicazione sul server GlassFish Java EE. Per fare ciò, creeremo una nuova configurazione, come descritto nell'articolo sulla configurazione dell'ambiente locale . Di seguito è riportato uno screenshot della configurazione completata per il progetto corrente. Assicurati di avere installato il server GlassFish prima di iniziare: dopo aver creato la configurazione di avvio, avvia l'applicazione utilizzando il menu Esegui -> Esegui 'ejb_demo' o utilizzando il tasto di scelta rapida Shift+F10 . Dopo l'avvio, puoi vedere i suoi registri: E anche il browser che si apre: Tutto ciò indica che l'applicazione funziona come previsto.

Conclusione

In questo articolo abbiamo conosciuto EJB - Enterprise JavaBeans. Abbiamo considerato domande come:

• Cos'è l'EJB?
• Storia dell'EJB
• Diversi tipi di EJB

Ricordiamo che gli EJB sono disponibili nei seguenti tipi:

• Bean a messaggi (bean a messaggi);
• Entity Beans: definiti nella specifica delle entità JPA (Java Persistence API) e utilizzati per archiviare dati;
• Bean di sessione:
  • apolide (senza stato)
  • stateful (con supporto per lo stato della sessione corrente)
  • singleton (un oggetto per l'intera applicazione; a partire da EJB 3.1)

Abbiamo anche scritto una piccola applicazione HelloWorld utilizzando EJB. Come PD, puoi ripetere tu stesso la parte pratica di questo articolo. Quindi aggiungi altri due servlet alla tua applicazione che utilizzeranno bean con stato e singleton per ricevere il valore.