
guide
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Un set di API per semplificare l’accesso e la realizzazione di documenti XML attraverso applicazioni scritte direttamente in Java.
JAXB (Java Architecture for XML Binding) è un framework a supporto dell’utilizzo dell’XML in Java. L’Extensible Markup Language (XML) e la tecnologia Java sono partner naturali nel supporto allo scambio di dati in Internet: la stessa accoppiata XML+Java è spesso utilizzata per realizzare web services e relative applicazioni d’accesso. PArtendo da queste premesse JAXB mette a disposizione un set di API per semplificare l’accesso e la realizzazione di documenti XML attraverso applicazioni scritte direttamente in Java, e dalla versione 1.6, JAXB è incluso in Java SE.
Esistonoo ormai diverse applicazioni che permettono di gestire l’accoppiata XML+Java: le due più comuni sono il SAX (Simple API for XML) e il DOM (Document Object Model), entrambi appartenenti al framework JAXP (Java API for XML Processing) ed utilizzate per effettuare l’analisi di un documento XML.
Nell’approccio SAX il documento XML viene esplorato dal principio alla fine senza salvare nulla in memoria, per cui non è possibile eseguire operazioni che richiedono la memorizzazione del documento stesso o di parti di esso, ma i vari contenuti vengono utilizzati via via che vengono letti (ed analizzati) all’interno del documento.
Nell’approccio DOM viene invece creato in memoria un albero rappresentante l’oggetto, per cui un’applicazione può navigare il documento attraverso l’albero e, se necessario, manipolare i dati.
Ciò che consente di fare JAXB è accedere e processare l’XML senza dover conoscere il contenuto del documento stesso e senza dover lavorare “pensando” in XML. Le operazioni principali per poter elaborare un documento XML sono le operazioni di Bind
e di Unmarshall
. Come approfondiremo successivamente, con l’operazione di Bind si semplifica l’operazione di accesso a un documento XML partendo dal corrispondente schema XML. Con l’Unmarshall invece si ottengono degli oggetti Java che rappresentano il contenuto e l’organizzazione del documento XML. Come vedremo, è possibile anche l’operazione duale, il Marshalling.
L’articolo è costituito dalle seguenti sezioni:
Assicurarsi di avere correttamente installato sul computer il Java Development Kit (JDK 6, Update 24 o successiva). Si assume che sia stata correttamente impostata la variabile d’ambiente JAVA_HOME
e aggiornato il Path
di sistema. Si fa inoltre riferimento a Eclipse (a partire dalla versione Helios Sr2 3.6.2).
E’ inoltre utile avere conoscenze basiche sull’argomento, quindi occorre aver affrontato gli argomenti XML e XML schema, consigliamo l’utile guida XML di base, su queste pagine.
JAXB semplifica l’accesso a documenti XML da programmi Java, presentando il documento XML in un formato di facile elaborazione. Il primo passo in questo processo è quello di effettuare il Binding del corrispondente XML schema. Ciò significa generare un insieme di classi Java che rappresentano tale schema. Tutte le implementazioni di JAXB forniscono un tool per richiamare il compilatore (binding compiler) che effettua il bind dello schema. Quello che può cambiare è il modo in cui viene invocato di volta in volta il compilatore. Da sottolineare che, poiché le classi generate sono legate all’implementazione specifica di JAXB, classi generate da un compilatore potrebbero non funzionare correttamente con un’altra implementazione di JAXB.
In questo articolo si fa riferimento all’implementazione di riferimento (JAXB Reference Implementation), che fornisce un compilatore invocabile tramite script, l’xjc
. Supponendo siano soddisfatte le precondizioni indicate, provvediamo a creare una cartella per il nostro primo esempio.
Utilizzeremo come esempio uno schema molto semplice, che descrive le caratteristiche di una pianta. Per comodità creeremo una cartella contenente i nostri esempi, che chiameremo JAXBesempi
, e due sottocartelle All
e Schemi
.
Nella sottocartella All
creiamo il file XSD Pianta.xsd
, per poi popolarlo con:
<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema
xmlns:sc2="http://www.flora.bindings.com"
xmlns:sc1="http://www.elementiBase.bindings.com"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.flora.bindings.com"
>
<xs:import namespace="http://www.elementiBase.bindings.com" schemaLocation="../Schemi/Radice.xsd" />
<xs:import namespace="http://www.elementiBase.bindings.com" schemaLocation="../Schemi/Fusto.xsd" />
<xs:import namespace="http://www.elementiBase.bindings.com" schemaLocation="../Schemi/Foglia.xsd" />
<xs:element name="Pianta">
<xs:complexType>
<xs:sequence>
<xs:element name="Nome" element="xs:string" />
<xs:element ref="sc1:TipologiaRadice" />
<xs:element ref="sc1:CaratteristicheFusto" />
<xs:element ref="sc1:CaratteristicheFoglie" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Quello appena proposto è un semplice schema d’esempio che descrive sommariamente le caratteristiche principali di una pianta, richiamando a sua volta altri tre schemi per fornire ulteriori dettagli.
Come mostrato dagli import
questi schemi si troveranno nella sottocartella Schemi
, che andiamo ora a popolare:
<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema
xmlns:sc1="http://www.elementiBase.bindings.com"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.elementiBase.bindings.com"
>
<xs:import namespace="http://www.w3.org/2001/XMLSchema" />
<xs:element name="TipologiaRadice">
<xs:complexType>
<xs:sequence>
<xs:element name="Ramificazione" type="xs:string" />
<xs:element name="Resistenza" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema
xmlns:sc1="http://www.elementiBase.bindings.com"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.elementiBase.bindings.com"
>
<xs:import namespace="http://www.w3.org/2001/XMLSchema" />
<xs:element name="CaratteristicheFusto">
<xs:complexType>
<xs:sequence>
<xs:element name="Tipo" type="xs:string" />
<xs:element name="Spessore" type="xs:int" />
<xs:element name="Altezza" type="xs:int" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema
xmlns:sc1="http://www.elementiBase.bindings.com"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.elementiBase.bindings.com"
>
<xs:import namespace="http://www.w3.org/2001/XMLSchema" />
<xs:element name="CaratteristicheFoglie">
<xs:complexType>
<xs:sequence>
<xs:element name="Tipo" type="xs:string" />
<xs:element name="Forma" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
La situazione sarà quindi la seguente:
- JAXBesempi --All ---Pianta.xsd --Schemi ---Foglia.xsd ---Fusto.xsd ---Radice.xsd
Partendo da questi schemi con il Binding possiamo generare le relative classi Java. Per farlo apriamo una console e muoviamoci nella cartella All
, lanciando il comando:
xjc -nv Pianta.xsd
Il seguente screenshot mostra il risultato atteso (nell’esempio su windows):
Nel rispetto del namespace impostato, sono state generate le classi corrispondenti agli elementi definiti negli schemi importati e in quello che li richiama. Esplorando le classi generate è possibile notare che il mapping tra XML Schema e Java viene implementato mediante l’uso delle annotazioni. Per ogni package definito dal namespace vengono inoltre generate due classi, ObjectFactory
e package-info
.
Il package-info è il descrittore del package, l’holder delle annotazioni JAXB, con la responsabilità di importare le librerie contenenti le annotazioni JAXB.
L’ObjectFactory ha invece lo scopo di permettere di creare oggetti a tempo d’esecuzione in risposta ad azioni dell’utente o di un flusso di informazioni, oggetti che al tempo della compilazione risultano di tipo sconosciuto. Più in dettaglio, fornisce quindi metodi Factory per le interfacce generate, permettendo la generazione di nuove istanze delle operazioni definite nello schema. Approfondiremo questo aspetto in seguito.
Attraverso le opzioni del tool è possibile specificare diversi aspetti come la cartella di generazione dei file, eventuali file di bindings esterni, il livello di verbosità e così via. Nell’esempio mostrato è stata utilizzata l’opzione -nv
. Questa opzione è una direttiva al compilatore per indicare di non effettuare una validazione con regole stringenti degli schemi di input. Nel nostro caso, una validazione stringente avrebbe sollevato un simile messaggio di errore:
Cannot resolve the name 'sc1:CaratteristicheFusto' to a(n) 'element declaration’ component
É anche possibile lanciare il tool su un singolo schema che non ne richiama altri, ad esempio lo lanciamo sullo schema Foglia.xsd
:
xjc -nv Foglia.xsd
Questa volta, oltre all’ObjectFactory e al package-info, è stata generata solo la classe CaratteristicheFoglie
.
Una volta ottenuti i package con le relative classi sarà possibile importarli in un progetto esistente (ad esempio nell’IDE Eclipse) o utilizzarli come base per un nuovo progetto. Da notare che le classi generate forniscono i metodi di get
e set
(in pieno stile java beans) per specificare ed accedere ai dati per ogni tipo di elemento e attributo definito negli schemi.
Effettuare l’unmarshalling di un documento XML significa creare un albero di oggetti che rappresenta il contenuto e l’organizzazione del documento. Gli oggetti creati sono istanze delle classi prodotte dal binding compiler. Per effettuare un’operazione di unmarshalling occorre istanziare un oggetto JAXBContext, un oggetto Unmarshaller e invocare il metodo per effettuare l’unmarshalling.
Il JAXBContext
fornisce l’entry point per le JAXB API
. Occorre specificare il contesto, che rappresenta una lista di uno o più nomi di package che contengono le interfacce generate da un binding compiler. Se gli schemi utilizzati sono ben strutturati, è sufficiente passare il nome del package contentente la classe contenitore del documento, ossia l’entry point, come vedremo successivamente.
L’oggetto Unmarshaller
controlla il processo di unmarshalling, fornendo un metodo che invocato permette di effettuare l’unmarshalling del documento XML passato sotto forma di File. Ciò che viene restituito è un oggetto, oggetto che può essere convertito nella classe contenitore con una operazione di casting. Questo aspetto è importante perché come vedremo ci consentirà di creare una classe generica utilizzabile per l’unmarshalling di tutti i documenti XML. Vediamo come.
Si suppone che nel progetto si siano importate le classi generate dal binding compiler, rispettando i nomi dei package creati (conseguentemente sotto la cartella src troveremo i package com.bindings.elementibase
e com.bindings.flora
, oltre ad almeno un altro package, ad esempio example
, dove inserire le classi di prova).
public class JaxbUnmarshal {
String filePath;
String context;
JAXBContext jaxbContext;
InputStream InpStr;
public JaxbUnmarshal(String filePath, String context){
this.filePath=filePath;
this.context=context;
try {
jaxbContext = JAXBContext.newInstance (context);
} catch (JAXBException e) {
e.printStackTrace();
}
}
public Object getUnmarshalledObject(){
Unmarshaller unmarshaller=null;
Object objectJAXB=null;
try {
unmarshaller = jaxbContext.createUnmarshaller ();
objectJAXB = unmarshaller.unmarshal( new
FileInputStream(filePath));
} catch (JAXBException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return objectJAXB;
}
}
La classe mostrata richiede il percorso per accedere al file XML di cui effettuare l’unmarshalling e il contesto. Tramite il metodo getUnmarshalledObject()
verrà ritornato un oggetto generico. Ciò consente di adoperare tale classe indipendentemente dal tipo di documento XML di cui si voglia effettuare l’unmarshalling, sempreché si disponga delle classi generate dal binding compiler.
Nel nostro caso possiamo provare ad effettuare l’unmarshalling del documento pianta.xml
, collocato nella cartella xmlExample
:
<?xml version="1.0" encoding="UTF-8"?>
<ns3:Pianta xmlns:ns2="http://www.elementiBase.bindings.com" xmlns:ns3="http://www.flora.bindings.com">
<Nome>Quercia</Nome>
<ns2:TipologiaRadice>
<Ramificazione>decisa</Ramificazione>
<Resistenza>alta</Resistenza>
</ns2:TipologiaRadice>
<ns2:CaratteristicheFusto>
<Tipo>Dritto</Tipo>
<Spessore>1</Spessore>
<Altezza>15</Altezza>
</ns2:CaratteristicheFusto>
<ns2:CaratteristicheFoglie>
<Tipo>Lobate</Tipo>
<Forma>Ellittica</Forma>
</ns2:CaratteristicheFoglie>
</ns3:Pianta>
Notare in primo luogo l’attenzione posta al namespace nella realizzazione dell’XML. Se il namespace non è correttamente specificato, l’operazione di unmarshalling non produrrà il risultato voluto.
Ora vediamo come utilizzare la classe mostrata:
String filePath = "xmlExample/pianta.xml";
String context = "com.bindings.flora";
JaxbUnmarshal unmarshall = new JaxbUnmarshal(filePath, context);
Pianta piantaObj = (Pianta) unmarshall.getUnmarshalledObject();
Il package passato è quello che contiene la classe contenitore Pianta, ossia com.bindings.flora
. Se avessimo voluto effettuare l’unmarshalling del file foglie.xml
invece avremmo passato come context la stringa com.bindings.elementibase
.
Nel richiamare il metodo per effettuare l’unmarshalling viene effettuato il casting, in questo modo la classe JaxbUnmarshal
rimane generica e può essere successivamente adoperata per altri file, come il file foglie.xml
.
É comunque possibile accedere ai dati senza effettuare l’unmarshalling di un documento XML, in quanto le classi ObjectFactory
generate dal compilatore mettono a disposizione metodi per creare oggetti del tipo voluto, esattamente come si fa con le comuni classi Java. Una volta istanziato l’oggetto della classe desiderata, andrà popolato utilizzando i metodi di set. Segue un esempio.
Pianta nuovapianta = new Pianta();
nuovapianta.setNome("Alloro");
CaratteristicheFusto fustoAlloro = new CaratteristicheFusto();
fustoAlloro.setSpessore(1);
fustoAlloro.setAltezza(8);
nuovapianta.setCaratteristicheFusto(fustoAlloro);
Da notare che se si volesse impostare direttamente i valori delle caratteristiche del fusto senza passare la corrispondente classe tramite il metodo setCaratteristicheFusto()
, verrebbe sollevata un’eccezione in quanto la classe cui si fa riferimento non è stata ancora inizializzata.
Un metodo significativo della classe Unmarshaller è quello che consente di effettuare la validazione del documento, ossia il metodo setValidating()
. Questo metodo valida la sorgente dati nei confronti dello schema XML. In riguardo, le specifiche di JAXB obbligano le implementazioni a riportare la presenza di errori nell’elaborazione del documento, mentre ciò che segue è lasciato alle singole implementazioni. E’ pertanto possibile riscontrare comportamenti diversi che possono prevedere un’interruzione forzata fin dalla prima infrazione dello schema, o che l’unmarshalling venga portato a compimento, magari limitandosi a fornire l’elemento padre senza ulteriori elementi. In altre parole, è possibile che l’albero venga creato, ma che ci sia un risultato invalidato o non corrispondente alle intenzioni. E’ comunque possibile evitare la validazione se si vuole evitarne l’overhead, ad esempio nel caso in cui si è sicuri della fonte.
Il marshalling è l’operazione opposta dell’unmarshalling. Partendo da un albero di oggetti JAXB crea il corrispondente documento XML. Più in generale, ciò che consente di fare è serializzare oggetti Java in XML. Detto altrimenti, l’oggetto viene convertito su un supporto di memorizzazione lineare, che può essere un file o un’area di memoria, e/o per trasmetterlo su una connessione di rete. Un esempio di utilizzo del marshalling avviene nei web services. Gli oggetti passati come argomenti delle operazioni remote vengono serializzati per poter essere trasmessi sulla connessione di rete.
Di seguito verrà riportato il caso di serializzazione in una codifica testuale XML. Analogamente all’unmarshalling, occorre specificare il contesto, istanziare un oggetto della classe Marshaller e invocare il metodo marshal()
. L’oggetto istanziato possiede alcuni metodi per impostare delle proprietà, ad esempio per ottenere un file XML completo di rientri ed interruzioni di riga è possibile utilizzare l’opzione JAXB_FORMATTED_OUTPUT
.
Viene mostrata di seguito una classe che effettua il marshalling.
public class JaxbMarshal {
String filePath;
String context;
JAXBContext jaxbContext;
public JaxbMarshal(String filePath, String context){
this.filePath=filePath;
this.context=context;
try {
jaxbContext = JAXBContext.newInstance(context);
} catch (JAXBException e) {
e.printStackTrace();
}
}
public void getMarshalledFile(Object object){
Marshaller marshaller=null;
try {
marshaller = jaxbContext.createMarshaller ();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
new Boolean(true));
marshaller.marshal(object, new FileOutputStream(filePath));
} catch (JAXBException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
Vediamo di seguito come utilizzarla.
JaxbMarshal marshall = new JaxbMarshal("xmlExample/outputFile.xml", context);
marshall.getMarshalledFile(nuovapianta);
Si è deciso di effettuare il marshalling dell’oggetto nuovapianta
, oggetto già istanziato nei precedenti esempi. Osservare che come path di destinazione del file generato dal marshaller si è scelta la cartella dove si trovavano i file XML che abbiamo utilizzato in precedenza. Nella cartella in questione verrà generato il file outputFile.xml
. In alcuni casi, ad esempio se si usa Eclipse, può essere necessario effettuare un refresh (tasto F5) del progetto prima di vedere il file nella cartella di destinazione.
Viste le funzionalità base, si presentano di seguito alcune utility che possono risultare estremamente comode. La prima riguarda la stampa a video di un oggetto JAXB. Si presenta di seguito una classe che offre un metodo statico che svolge questo lavoro.
public class StampGenericXML {
static public void staticStampGenericXML(Object objectJAXB, String
context){
try {
JAXBContext jaxbLocalContext = JAXBContext.newInstance
(context);
Marshaller marshaller =
jaxbLocalContext.createMarshaller();
marshaller.setProperty(marshaller.JAXB_FORMATTED_OUTPUT,
true);
marshaller.marshal(objectJAXB, System.out);
} catch (JAXBException e1) {
e1.printStackTrace();
}
}
}
Si fanno notare due aspetti. Il primo è che come in precedenza si richiede un oggetto generico e il relativo contesto. Il secondo è che di fatto l’operazione di stampa a video non è altro che un marshalling effettuato sulla console invece che su file.
Le due classi successive presentano due funzionalità duali. La prima consente di convertire un oggetto JAXB in una comune stringa di testo. La seconda consente invece di invertire il processo tornando all’oggetto originario. Messe in cascata consentono di effettuare l’unmarshalling del marshalling ed, essendo operazioni inverse, il risultato atteso è l’oggetto di partenza.
public class StringMarshalling {
static public String getXMLString(String context, Object objectJAXB){
StringWriter xml = new StringWriter();
String xmlString = new String();
try {
JAXBContext jaxbLocalContext = JAXBContext.newInstance
(context);
jaxbLocalContext.createMarshaller().marshal(objectJAXB,
xml);
xmlString = xml.toString();
} catch (JAXBException e1) {
e1.printStackTrace();
}
return xmlString;
}
}
public class StringUnmarshalling {
String text;
String context;
JAXBContext jaxbContext;
public static Object getObject(String context, String stringToConvert,
boolean displayStamp){
Unmarshaller unmarshaller=null;
Object objectJAXB=null;
try {
JAXBContext jaxbContext = JAXBContext.newInstance
(context);
unmarshaller = jaxbContext.createUnmarshaller();
StringBuffer xmlString = new StringBuffer(stringToConvert);
objectJAXB = unmarshaller.unmarshal(new
StringReader(xmlString.toString()));
} catch (JAXBException e) {
e.printStackTrace();
}
return objectJAXB;
}
}
Come riprova, è possibile effettuare una stampa a video di un oggetto JAXB, ad esempio dell’oggetto piantaObj
ottenuto tramite unmarshalling del file pianta.xml
. Successivamente è possibile serializzarlo convertendolo in una stringa, per poi deserializzare la stringa riottenendo l’oggetto di partenza, stampando a video l’oggetto finale per confrontarlo con quello iniziale e verificare che si è ottenuto l’oggetto di partenza. Il tutto è riportato di seguito:
StampGenericXML.staticStampGenericXML(piantaObj, context);
String stringPianta = StringMarshalling.getXMLString(context, piantaObj);
Pianta piantaObj2 = (Pianta) StringUnmarshalling.getObject(context, stringPianta);
StampGenericXML.staticStampGenericXML(piantaObj2, context);
Dopo aver descritto le funzionalità principali del framework JAXB possiamo riassumerne i vantaggi. La caratteristica essenziale è quella di semplificare l’accesso ai documenti XML nei programmi Java. Tramite l’unmarshalling è possibile accedere ed elaborare documenti XML, senza bisogno di utilizzare parser SAX e metodi di callback. L’accesso non è sequenziale e non forza a navigare un albero come avviene in DOM. Altro vantaggio rispetto a DOM è quello di assicurare un uso della memoria più efficiente.
Come abbiamo visto, JAXB è flessibile in quanto è possibile effettuare l’unmarshalling e il marshalling in diverse forme e da diverse sorgenti. E’ infatti possibile effettuare l’unmarshalling da file XML, da stringhe, da URL o anche da un nodo DOM. E’ inoltre possibile utilizzare le classi generate con il binding compiler per creare oggetti senza dover accedere a un file XML già realizzato. Infine, è possibile validare le sorgenti durante l’unmarshalling oppure utilizzare una classe apposita, Validator, per validare un albero già a disposizione.
Se vuoi aggiornamenti su JAXB, l'XML in Java: esempi e tutorial inserisci la tua email nel box qui sotto:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
La tua iscrizione è andata a buon fine. Se vuoi ricevere informazioni personalizzate compila anche i seguenti campi opzionali:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
La testimonianza di uno studente del primo anno di Ingegneria Informatica al Politecnico di Milano che già ha pubblicato diverse […]
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Come creare applicazioni per il Web con PHP e MySQL per il DBMS.
Tutte le principali tecnologie per diventare uno sviluppatore mobile per iOS.
I fondamentali per lo sviluppo di applicazioni multi piattaforma con Java.
Diventare degli esperti in tema di sicurezza delle applicazioni Java.
Usare Raspberry Pi e Arduino per avvicinarsi al mondo dei Maker e dell’IoT.
Le principali guide di HTML.it per diventare un esperto dei database NoSQL.
Ecco come i professionisti creano applicazioni per il Cloud con PHP.
Lo sviluppo professionale di applicazioni in PHP alla portata di tutti.
Come sviluppare applicazioni Web dinamiche con PHP e JavaScript.
Fare gli e-commerce developer con Magento, Prestashop e WooCommerce.
Realizzare applicazioni per il Web utilizzando i framework PHP.
Creare applicazioni PHP e gestire l’ambiente di sviluppo come un pro.
Percorso base per avvicinarsi al web design con un occhio al mobile.
Realizzare siti Web e Web application con WordPress a livello professionale.
In questo articolo impareremo a gestire gli URL (Uniform Resource Locator) attraverso le API messe a disposizione dal linguaggio di programmazione Java.
Java 13: In questo articolo andiamo a presentare le nuove caratteristiche introdotte dalla release elencandole in base al codice JEP che le identifica.
Impariamo ad utilizzare le funzionalità di javax.crypto per cifrare e decifrare un file di testo con il linguaggio di programmazione Java.
Impariamo a sviluppare applicazioni Java per i sistemi Embedded, piattaforme che a differenza delle tradizionali soluzioni general purpose vengono progettate per svolgere compiti specifici. Nel corso delle guida verranno fornite le nozioni necessarie per installare Oracle Java SE Embedded, scegliere il profilo e la JVM da utilizzare, configurare una JRE personalizzata, creare una prima App ed effettuarne il deploy