Session Bean Stateless e implementazione dei task

Creare classi che implementano task per client senza mantenere stati conversazionali

Un Session Bean Stateless è un componente server side
che consente di realizzare processi di business con particolare riguardo alle prestazioni. Quando parliamo di processi di business intendiamo
funzionalità come la prenotazione di una camera di albergo, la registrazione di un utente, l'acquisto di un biglietto ferroviario...
Quando un client, come ad esempio una Web Application Java (Servlet, Managed Bean Jsf....), richiede un session bean per invocarne un particolare
metodo, non accede direttamente all'istanza del bean ma alla sua interfaccia di tipo local o remote.

Le interfacce di tipo
local sono utilizzate da client che risiedono nella stessa JVM del session bean, mentre quelle remote da client che risiedono al di fuori della JVM
del session bean. Quando un client invoca un metodo di un'interfaccia del session bean, in realtà interagisce con un particolare oggetto noto come
EJB Object, esso rappresenta un Proxy Stub che implementa le interfacce local e remote del bean ed è responsabile del routing della chiamata
del client verso l'EJB Container.

In JBoss il Proxy Stub è generato dinamicamente in fase di deploy utilizzando le funzionalità della classe
java.lang.reflect.Proxy. L'EJB container, che gestisce le istanze del session bean ed il loro ciclo di vita, esegue il metodo invocato assicurando
i servizi di sicurezza e gestione delle transazioni. L'EJB container mantiene un piccolo pool di session bean di un particolare tipo, ogni
richiesta di un client può essere servita da una delle istanze presenti nel pool.

Creazione di un progetto Java Enterprise

Quindi molte richieste client
vengono gestite da un pool di session bean e, in generale, le chiamate ad uno stesso metodo o a metodi differenti di
un session bean non verranno servite da una stessa istanza del pool. Vediamo adesso come realizzare un semplice session bean stateless
in JBoss Developer Studio e creiamo un progetto Java Enterprise:

Impostiamo il progetto:

Creiamo un progetto EJB:

Colleghiamo il modulo EJB al modulo Enterprise che installeremo sul server JBoss. Entriamo
nelle proprietà del progetto Java Enterprise e colleghiamo il modulo EJB attraverso la voce "Project References" nella parte sinistra
della finestra delle proprietà:

Sempre rimanendo nella finestra delle proprietà, apriamo la voce "Deployment Assembly" e verifichiamo che il progetto
EJB sia inserito nella struttura package. Se cosi non fosse aggiungiamo il progetto alla struttura
con il pulsante "Add".

All'interno del progetto EJB creiamo il package it.html.progetto1.ejb30 nella cartella dei sorgenti denominata
ejbModule. Facendo click con il tasto destro su di essa e scegliendo sul menù a comparsa "New > Session Bean (Ejb 3.x)" possiamo
avviare il wizard di creazione del session bean stateless:

Nella successiva schermata impostiamo la creazione del session bean in modo tale che siano selezionate le opzioni
Local e Remote e digitando come nome della classe ConverterBean. Il session bean
servirà per offrire il servizio di conversione della temperatura da gradi celsius a fahrenheit e viceversa. Iniziamo con l'analizzare
l'implementazione cosi come si sarebbe realizzata in Ejb 3.0 per vedere successivamente le varianti Ejb 3.1 ed Ejb 3.2.

Nel nostro
esempio desideriamo rendere disponibile il session bean sia ad applicazioni locali che remote. Allo stato attuale, abbiamo
la generazione da parte del wizard delle due interfacce richieste, tuttavia per raggiungere il nostro scopo utilizzando solo
il codice generato saremmo costretti a duplicare del codice avendo due interfacce identiche marcate,
attraverso annotations, solamente in modo diverso (local o remote).

L'interfaccia rappresenta il contratto verso il client, ovvero
i metodi esposti dal session bean verso di esso. Rivediamo il codice generato nel seguente modo. Creiamo all'interno
del package it.html.progetto1.ejb30 l'interfaccia Converter che rappresenterà il contratto verso il client. Aggiungiamo in essa i metodi
del convertitore di temperatura:

package it.html.progetto1.ejb30;
public interface Converter {
	  float celsiusToFahrenheit(float temperature);
	  float fahrenheitToCelsius(float temperature);
}

Successivamente facciamo in modo che le interfacce Local e Remote estendano questa interfaccia:

package it.html.progetto1.ejb30;
import javax.ejb.Local;
@Local
public interface ConverterBeanLocal extends Converter{}

package it.html.progetto1.ejb30;
import javax.ejb.Remote;
@Remote
public interface ConverterBeanRemote extends Converter{}

In questo modo le due interfacce condividono il contratto definito
dall'interfaccia principale. L'implementazione del session bean sarà quindi la seguente:

package it.html.progetto1.ejb30;
import javax.ejb.Stateless;
@Stateless(name="ConverterBean", mappedName = "ConverterBean")
public class ConverterBean implements ConverterBeanRemote, ConverterBeanLocal {
    public ConverterBean() {
        // TODO Auto-generated constructor stub
    }
	@Override
    public float celsiusToFahrenheit(float temperature) {
		return temperature * 1.8f + 32;
    }
	@Override
    public float fahrenheitToCelsius(float temperature) {
		return (temperature - 32) / 1.8f;
    }
}

Abbiamo introdotto tre annotations: javax.ejb.Local, javax.ejb.Remote e javax.ejb.Stateless. Le prime due
applicate ad un interfaccia la marcano di tipo local o remote, l'ultima applicata ad
una classe Java definisce quella classe come session bean stateless.

Possiamo quindi passare alle fase di unit test che verrà analizzata nel prossimo capitolo.