Programmazione Distribuita - Java EE

Programmazione distribuita

Nel mondo del business odierno, le applicazioni hanno bisogno di accedere a dati, applicare la logica aziendale, aggiungere livelli di presentazione, essere mobile, usare la geolocalizzazione e comunicare con sistemi esterni e servizi online.

Java Enterprise Edition ha portato nel linguaggio Java una robusta piattaforma software per lo sviluppo aziendale. Portabilità e licenze open source sono alcuni dei punti forti del JEE.

Indice

• Common
  • Context Dependency Injection
• Business Model
  • Java persistence API
  • Object-Relation Mapping
  • Managing Persistent Object
• Business Logic
  • Enterprise Java Beans
  • Callback, Timer Service & Authorization
  • Transactions
• Interoperability
  • Sending Messages
  • SOAP Web Services
  • RESTful Web Services

Java EE è un insieme di specifiche intese per le applicazioni enterprise (aziendali). Può essere visto come un’estensione della Java SE, per facilitare lo sviluppo di applicazioni distribuite, robuste, potenti e altamente disponibili. Java EE è una suite di API che può essere utilizzata per creare applicazioni multilivello basate su componenti standard.

Architettura

Java EE è un insieme di specifiche implementate da differenti container. I container sono ambienti di esecuzione che forniscono determinati servizi ai componenti che ospitano, come gestione del ciclo di vita, iniezione di dipendenze, concorrenza, ec... Questi componenti usano contratti ben definiti per comunicare con l’infrastruttura Java EE e con gli altri componenti. Hanno bisogno di essere impacchettati (packaged) nel modo standard prima di essere installati.

Componenti

Tipi supportati:

• Applets sono applicazioni GUI (interfaccia utente grafica) che vengono eseguite in un browser web. Usano la ricca API Swing per fornire potenti interfacce utente.
• Applications sono programmi che vengono eseguiti su un client. Di solito sono GUI o programmi di elaborazione batch che hanno accesso a tutte le funzionalità del livello intermedio di Java EE.
• Web Applications (composte da servlet, filtri servlet, listener di eventi Web, pagine JSP e JSF) vengono eseguite in un Web container e rispondono alle richieste HTTP dei client Web. Le servlet supportano anche gli endpoint dei servizi Web SOAP e RESTful. Le applicazioni Web possono anche contenere EJB Lite.
• Enterprise Applications (composte da Enterprise Java Beans, Java Message Service, Java Transaction API, chiamate asincrone, servizio timer, RMI/IIOP) vengono eseguite in un contenitore EJB. Gli EJB sono componenti gestiti dal contenitore per l'elaborazione della logica di business transazionale. È possibile accedervi localmente e in remoto tramite RMI (o HTTP per SOAP e servizi web RESTful).

Container

L'infrastruttura Java EE è partizionata in domini logici denominati contenitori. Ogni contenitore ha un ruolo specifico, supporta una serie di API e offre servizi ai componenti (sicurezza, accesso al database, gestione delle transazioni, directory dei nomi, iniezione di risorse). I contenitori nascondono la complessità tecnica e migliorano la portabilità. A seconda del tipo di applicazione che vuoi creare, dovrai comprendere le capacità e i vincoli di ciascun contenitore per poterne utilizzare uno o più.

• Applet containers sono forniti dalla maggior parte dei browser Web per eseguire i componenti dell'applet. Quando sviluppi applet, puoi concentrarti sull'aspetto visivo dell'applicazione mentre il contenitore ti offre un ambiente sicuro. Il contenitore dell'applet utilizza un modello di sicurezza sandbox in cui il codice eseguito nella "sandbox" non può "riprodurre al di fuori della sandbox". Ciò significa che il contenitore impedisce a qualsiasi codice scaricato sul computer locale di accedere alle risorse del sistema locale, come processi o file.
• Application client container (ACC) include una serie di classi Java, librerie e altri file necessari per portare alle applicazioni Java SE l’injection, la gestione della sicurezza e il servizio di naming (swing, elaborazione batch o solo una classe con un main() metodo). L'ACC comunica con il contenitore EJB utilizzando RMI-IIOP e il web container con HTTP (ad esempio, per i servizi web).
• Web container fornisce i servizi sottostanti per la gestione e l'esecuzione dei componenti Web (servlet, EJB Lite, JSP, filtri, listener, pagine JSF e servizi Web). È responsabile dell'istanza, dell'inizializzazione e del richiamo delle servlet e del supporto dei protocolli HTTP e HTTPS. È il contenitore utilizzato per fornire le pagine Web ai browser client.
• EJB container è responsabile della gestione dell'esecuzione dei bean enterprise (session beans e message-driven beans) contenenti il livello di logica aziendale dell'applicazione JavaEE. Crea nuove istanze di bean, gestisce il loro ciclo di vita e fornisce servizi come transazione, sicurezza, concorrenza, distribuzione, servizio di naming o la possibilità di essere invocato in modo asincrono.

Servizi

• Java Transaction API: Questo servizio offre un'API di demarcazione delle transazioni utilizzata dal contenitore ed all'applicazione. Fornisce inoltre un'interfaccia tra il gestore delle transazioni e un gestore delle risorse a livello di Service Provider Interface (SPI).
• Java Persistence API: API standard per la mappatura relazionale a oggetti (ORM). Con il suo Java Persistence Query Language (JPQL), puoi interrogare gli oggetti memorizzati nel database sottostante.
• Bean Validation: Fornisce la dichiarazione dei vincoli a livello di classe e metodo e funzionalità di validazione.
• Java Message Service: Consente ai componenti di comunicare in modo asincrono tramite messaggi. Supporta la messaggistica point-to-point (P2P) affidabile e il modello publish-subscribe (pub-sub).
• Java Naming and Directory Interface: Questa API, inclusa in Java SE, viene utilizzata per accedere ai sistemi di naming e directory. L'applicazione lo utilizza per associare (associare) nomi agli oggetti e quindi per trovare questi oggetti (ricerca) in una directory. È possibile cercare l’origine dei dati, factory JMS, EJB e altre risorse.
• JavaMail: Molte applicazioni richiedono la capacità di inviare e-mail, che può essere implementata tramite l'utilizzo dell'API JavaMail.
• JavaBeans Activation Framework: L'API JAF, inclusa in Java SE, fornisce un framework per la gestione dei dati in diversi tipi MIME. Viene utilizzato da JavaMail.
• Elaborazione XML: La maggior parte dei componenti JavaEE può essere distribuita con descrittori di distribuzione XML facoltativi e le applicazioni spesso devono manipolare documenti XML. L'API Java per l'elaborazione XML (JAXP) fornisce supporto per l'analisi di documenti con API SAX e DOM, nonché per XSLT. L'API Streaming per XML (StAX) fornisce un'API pull-parsing per XML.
• Elaborazione JSON: Novità in Java EE 7, l'API Java per l'elaborazione JSON (JSON-P) consente alle applicazioni di analizzare, generare, trasformare ed eseguire query su JSON.
• Architettura del connettore Java EE: I connettori consentono di accedere a EIS da un componente Java EE. Questi potrebbero essere database, mainframe o programmi di pianificazione delle risorse aziendali (ERP).
• Servizi di sicurezza: Java Authentication and Authorization Service (JAAS) consente ai servizi di autenticare e applicare controlli di accesso agli utenti. Il Java Authorization Service Provider Contract for Containers (JACC) definisce un contratto tra un server di applicazioni Java EE e un provider di servizi di autorizzazione, consentendo ai provider di servizi di autorizzazione personalizzati di essere collegati a qualsiasi prodotto Java EE. Java Authentication Service Provider Interface for Containers (JASPIC) definisce un'interfaccia standard mediante la quale i moduli di autenticazione possono essere integrati con i contenitori in modo che questi moduli possano stabilire le identità di autenticazione utilizzate dai contenitori.
• Servizi Web: Java EE fornisce supporto per i servizi Web SOAP e RESTful. L'API Java per servizi Web XML (JAX-WS), che sostituisce l'API Java per RPC basato su XML (JAX-RPC), fornisce supporto per i servizi Web utilizzando il protocollo SOAP/HTTP. L'API Java per i servizi Web RESTful (JAX-RS) fornisce supporto per i servizi Web utilizzando lo stile REST.
• Dependency Injection: A partire da Java EE 5, alcune risorse (origini dati, fabbriche JMS, unità di persistenza, EJB...) possono essere iniettate nei componenti gestiti. Java EE 7 va oltre utilizzando CDI e le specifiche DI (Dependency Injection for Java).
• Management: Java EE definisce le API per la gestione di contenitori e server utilizzando uno speciale bean aziendale di gestione. L'API Java Management Extensions (JMX) viene utilizzata anche per fornire un supporto di gestione.
• Deployment: La specifica di distribuzione di Java EE definisce un contratto tra strumenti di distribuzione e prodotti Java EE per standardizzare la distribuzione dell'applicazione.

Network protocols

• HTTP
• HTTPS
• RMI-IIOP: Remote Method Invocation (RMI) consente di richiamare oggetti remoti indipendentemente dal protocollo sottostante. Il protocollo RMI nativo di Java SE è Java Remote Method Protocol (JRMP). RMI-IIOP è un'estensione di RMI utilizzata per l'integrazione con CORBA.

Packaging

Per essere installati in un contenitore, i componenti devono prima essere impacchettati in un archivio formattato standard. Java SE definisce i file Java Archive (jar), che vengono utilizzati per aggregare molti file (classi Java, deployment descriptors, risorse o librerie esterne) in un file compresso (basato sul formato ZIP). Java EE definisce diversi tipi di moduli che hanno il proprio formato di packaging basato su questo formato jar comune.

• Un modulo applicativo client contiene classi Java e altri file di risorse impacchettati in un file jar. Questo file jar può essere eseguito in un ambiente Java SE o in un contenitore client dell'applicazione. Come qualsiasi altro formato di archivio, il file jar contiene una directory META-INF facoltativa per le metainformazioni che descrivono l'archivio. Il file META-INF/MANIFEST.MF viene utilizzato per definire i dati relativi all'estensione e al pacchetto. Se distribuito in un ACC, il deployment descriptor può essere facoltativamente situato in META-INF/application-client.xml.
• Un modulo EJB contiene uno o più bean di sessione e/o message-driven (MDB) impacchettati in un file jar (spesso chiamato file jar EJB). Contiene un descrittore di distribuzione META-INF/ejb-jar.xml opzionale e può essere distribuito solo in un contenitore EJB.
• Un modulo di un'applicazione Web contiene servlet, JSP, pagine JSF e servizi Web, nonché qualsiasi altro file relativo al Web (pagine HTML e XHTML, fogli di stile a cascata (CSS), script Java, immagini, video e così via). A partire da Java EE 6, un modulo dell'applicazione Web può anche contenere bean EJB Lite. Tutti questi artefatti sono confezionati in un file jar con estensione .war (comunemente indicato come file war o archivio Web). Il deployment descriptor web facoltativo è definito nel file WEB-INF/web.xml. Se il .war contiene bean EJB Lite, è possibile impostare un deployment descriptor opzionale su WEB-INF/ejb-jar.xml. I file Java.class vengono inseriti nella directory WEB-INF/classes e i file jar dipendenti nella directory WEB-INF/lib.
• Un modulo aziendale (enterprise module) può contenere zero o più moduli di applicazioni Web, zero o più moduli EJB e altre librerie comuni o esterne. Tutto questo è impacchettato in un archivio aziendale (un file jar con estensione .ear) in modo che l'implementazione di questi vari moduli avvenga contemporaneamente e coerentemente. Il deployment descriptor del modulo aziendale facoltativo è definito nel file META-INF/application.xml. La speciale directory lib viene utilizzata per condividere le librerie comuni tra i moduli.

Annotations e deployment descriptor

• POJO (Plain Old Java Object)
• Annotations: dichiarano un certo comportamento
• Deployment descriptor: stesso utilità delle annotazioni

Modello di programmazione

La maggior parte delle specifiche Java EE 7 utilizza lo stesso modello di programmazione. Di solito è un POJO con alcuni metadati (annotazioni o XML) distribuiti in un contenitore. Il più delle volte il POJO non implementa nemmeno un'interfaccia o estende una superclasse. Grazie ai metadati, il contenitore sa quali servizi applicare a questo componente distribuito.

Java SE 7

È importante sottolineare che Java EE è un superset di Java SE. Ciò significa che tutte le funzionalità del linguaggio Java sono disponibili in Java EE e nelle API.

• java.nio package: con una sintassi più espressiva, il suo obiettivo è sostituire il pacchetto java.io esistente per consentire:
  • Una gestione delle eccezioni più pulita.
  • Accesso completo al file system con nuove funzionalità (supporto di attributi specifici del sistema operativo, collegamenti simbolici, ecc.).
  • L'aggiunta della nozione di FileSystem e FileStore (ad esempio, un disco di partizione).
  • Metodi di utilità (sposta/copia file, lettura/scrittura file binari o di testo, percorso, directory, ecc.).

Dependency Injection

Il dependency injection è un design pattern che disaccoppia i componenti dipendenti. Invece di un oggetto che cerca altri oggetti, il container inietta quegli oggetti dipendenti per te.

• Interception: ...
• Bean: è un POJO che non eredita o estende altre classi, può iniettare riferimenti ad altri bean (@Inject), ha un ciclo di vita gestito dal container (@PostConstruct), e i cui metodi possono essere intercettati (@Transactional).

Context

Specifica che ogni componente vive e viene gestito in un scope (ambito) ben definito (request, session, application e conversation). Ad esempio, un contesto di sessione e i relativi bean esistono per la durata di una sessione HTTP. Il container gestisce automaticamente tutti i bean all'interno dell'ambito e, al termine della sessione, li distrugge automaticamente.

A differenza dei componenti stateless (ad esempio, bean di sessione stateless) o singleton (ad esempio, servlet o singleton), diversi client di un bean stateful vedono il bean in stati diversi. Quando il bean è stateful, è importante quale istanza del bean ha il client. I client in esecuzione nello stesso contesto vedranno la stessa istanza del bean. Ma i clienti in un contesto diverso potrebbero vedere un'istanza diversa (a seconda della relazione tra i contesti). In tutti i casi, il client non controlla il ciclo di vita della componente; lo fa il contenitore secondo lo scope a cui appartiene.

CDI

Con il Context Dependency Injection il container si occupa dell’iniezione delle varie componenti ove necessario e della gestione delle stesse per tutta la durata del contesto in cui vivono.

• CDI Bean: è una qualsiasi classe che contenga la logica di business. Può essere chiamato direttamente dal codice Java attraverso l’injection, oppure attraverso l’EL da una pagina JSF. Condizioni:
  • Non è una classe interna non statica, è una classe concreta, o è annotata con @Decorator,
  • Ha un costruttore predefinito senza parametri, oppure dichiara un costruttore annotato @Inject.
• Può avere uno scope facoltativo, un nome EL facoltativo, una serie di interceptor binding e una gestione del ciclo di vita facoltativa.

public class BookService {
    @Inject
    private NumberGenerator numberGenerator;
    @Inject
    private EntityManager em;
    private Date instanciationDate;
    
    @PostConstruct
    private void initDate() {
        instanciationDate = new Date();
    }
    
    @Transactional
    public Book createBook(String title, Float price, String description) {
        Book book = new Book(title, price, description);
        book.setIsbn(numberGenerator.generateNumber());
        book.setInstanciationDate(instanciationDate);
        em.persist(book);
        return book;
    }
}

Una semplice annotazione @Inject sulla proprietà informerà il contenitore che deve inserire un riferimento di un'implementazione NumberGenerator nella proprietà numberGenerator. Questo è chiamato punto di iniezione.