|
Per prima cosa abbiamo bisogno di una tabella sulla quale effettuare l'inserimento dei dati. Supponiamo che la nostra tabella si chiami ANAGRAFICA e contenga i campi ID, NOME e COGNOME. Ecco lo skin completo: | ANAGRAFICA | | ID | PK | INT | 3 | | NOME | | VARCHAR | 20 | | COGNOME | | VARCHAR | 20 |
Per questo esempio useremo un database opensource di tipo MYSQL scaricabile al link http://www.mysql.org e vi navigheremo con un tool anch'esso opensource di nome MySQL-Front.
Una volta realizzata la tabella, dobbiamo preoccuparci di creare una web application contenente la servlet in grado di inserirvi i dati. La struttura della nostra web-app sarà simile a questa: 
Fig. 2 Ambiente Andiamo quindi a scrivere il codice per le varie risorse. Ecco la servlet che inserisce i dati nel DB: //Importiamo i package necessari.
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.sql.*; public class Insert extends HttpServlet
{ public void init()
{
System.out.println("<<<[ Insert inizializzata ]>>>");
}
protected void service(
HttpServletRequest request,
HttpServletResponse response)throws IOException
{
/*
Dichiariamo due variabili di tipo java.lang.String e le valorizziamo utilizzando dei parametri della request(nome,cognome).
/**/
String nome = request.getParameter("nome");
String cognome = request.getParameter("cognome");
/*
Gazie alle API JDBC apriamo una connessione nei confronti del DB ed istanziiamo un oggetto java.sql.Statement utilizzando il driver di connessione per mysql scaricabile all'url http://www.mysql.org.
/**/ Connection con =null;
Statement sta = null;
try
{
Class.forName("org.gjt.mm.mysql.Driver");
con = DriverManager.getConnection(
"jdbc:mysql://localhost/micro"
,"root"
,"root");
sta = con.createStatement();
/*
A questo punto siamo in grado di lanciare l'istruzione SQL per inserire i dati utilizzando per tale operazione i parametri presi dalla request.
/**/
sta.executeUpdate
(
"INSERT INTO anagrafica VALUES('','"+nome+"','"+cognome+"');"
); /*
La risposta verrà inviata al client con un java.io.PrintWriter che scrive sull'oggetto response.
Notare come il content della response viene settato in modalita' text/plain.
/**/
PrintWriter out = response.getWriter();
response.setContentType("text/plain");
out.print("Parametri inseriti\nnome: " + nome +"\ncognome: " + cognome);
}catch(Exception e)
{
System.out.println(e);
}finally
{
try
{
/*
Come ultima operazione dobbiamo deallocare le risorse prima utilizzate.
/**/
if(sta!=null)sta.close();
if(con!=null)con.close();
}catch(Exception e)
{
System.out.println(e);
} } } } Fai il download di Servlet.zip Adesso mappiamo la servlet con un url-pattern nel file descrittore di deploy web.xml: <?xml version="1.0"?><!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">
<web-app>
<servlet>
<servlet-name>alias</servlet-name>
<servlet-class>Insert</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>alias</servlet-name>
<url-pattern>inserisci</url-pattern>
</servlet-mapping>
</web-app> Possiamo testarne il funzionamento utilizzando un semplice file html che invia i dati alla servlet in modalità POST: <html>
<body>
<h2>Pagina di registrazione</h2>
<hr>
<table>
<form action="inserisci" method="post">
<tr>
<td>
Nome
</td>
<td>
<input type="text" name="nome">
</td>
</tr>
<tr>
<td>
Cognome
</td>
<td>
<input type="text" name="cognome">
</td>
</tr>
</table>
<hr>
<input type="submit" name="registra" value="inserisci">
</form>
</body>
</html> Come è possibile notare, ho inserito un form con l'impostazione action="inserisci" che invia i dati in POST alla servlet. Una volta eseguiti tutti i passaggi, impacchettiamo l'applicazione in un war ed effettuiamo il deploy su un application server compatibile j2ee. Per questo esempio ho utilizzato Jboss3.0.4. Ecco il risultato: 
Fig. 3 Ambiente Il comando inserisci invierà i dati presenti nella form alla servlet in modalità POST, ed il server risponderà con una pagina in formato testo: 
Fig. 4 Ambiente Quando visualizzeremo il contenuto della tabella ANAGRAFICA vedremo i dati prima inseriti nelle caselle di testo: 
Fig. 5 Ambiente Lo scopo di questo articolo è quello di eseguire le stesse operazioni viste sopra utilizzando, come client, un dispositivo wireless compatibile j2me. Vediamo dunque come configurare il nostro sistema. Per prima cosa dobbiamo scaricare i vari componenti dal sito http://java.sun.com.
Per una guida dettagliata sul download e l'installazione consultare il link http://www.javaportal.it/docs/midlet1.htm . Una volta installata la suite j2me, utilizziamo il nostro Wireless toolkit per creare un nuovo progetto assegnandogli un nome globale ed un nome per la prima midlet: 
Fig. 6 Ambiente l progetto appena creato ha una struttura di questo tipo: 
Fig. 7 Ambiente che verrà creata nella directory apps, all'interno della directory di installazione del nostro toolkit. Es: C:\j2me1.0.3\apps
Esaminiamo insieme il codice della Midlet incaricata del trasferimento dei dati alla servlet.La midlet verrà inserita nella directory src del nostro progetto:
//Importiamo i package necessari.
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.io.*;
import java.io.*;
/*
Estendiamo la classe MIDLet ed implementiamo l'interfaccia CommandListener che ci permette di gestire gli eventi generati dai vari componenti utilizzando il metodo commandAction()
/**/
public class Inserimento extends MIDlet implements CommandListener
{
/*
Dichiariamo un oggetto Display,
un Form, tre TextField e due command.
/**/ private Display display;
private Form form;
private TextField nome, cognome, indirizzo;
private Command chiama, esci;
public Inserimento()
{
//Prendiamo un riferimento al display del dispositivo.
display = Display.getDisplay(this); //Istanziamo i tre oggetti TextField.
indirizzo = new TextField(
"Indirizzo:",
"http://localhost:8080/Registra/inserisci",
150,
TextField.ANY);
cognome = new TextField("Cognome:", "", 50, TextField.ANY);
nome = new TextField("Nome:", "", 50, TextField.ANY);
//Istanziamo gli oggetti Command ed il form.
chiama = new Command("Chiama", Command.SCREEN, 2);
esci = new Command("Esci", Command.EXIT, 1);
form = new Form("Inserisci i dati");
//Aggiungiamo i componenti all'oggetto form.
form.append(indirizzo);
form.append(cognome);
form.append(nome);
form.addCommand(esci);
form.addCommand(chiama); //Registriamo il form al gestore degli eventi(Questa classe).
form.setCommandListener(this);
}
/*
Ecco i metodi per la gestione del ciclo di vita della midlet.
Notare come nel metodo startApp() appendiamo il form sul display del dispositivo.
/**/
public void startApp(){display.setCurrent(form);}
public void pauseApp(){}
public void destroyApp(boolean unconditional){}
//Metodo per la gestione degli eventi.
public void commandAction(Command c, Displayable s)
{
/*
Se l'utente seleziona il comando chiama viene invocato il metodo callServlet().
/**/
if (c == chiama)
{
try
{
callServlet();
}catch (Exception e)
{
System.out.println(e.toString());
}
/*
Se l'utente seleziona il comando esci vengono invocati i metodi destroyApp() e notifyDestroyed() che permettono l'uscita dall'applicazione.
/**/
}else if (c == esci)
{
destroyApp(false);
notifyDestroyed();
}
} /*
Il metodo che effettua la connessione alla servlet passandogli i parametri.
/**/
private void callServlet() throws IOException
{
/*
Dichiariamo un oggetto HttpConnection che rappresenta una connessione http.
/**/
HttpConnection http = null;
//Dichiariamo un InputStream
InputStream input = null;
/*
Dichiariamo una String che, prendendo i dati dalle TextField, crea dinamicamente una richiesta GET da inviare alla servlet
/**/
String url = indirizzo.getString() +
"?nome=" +
nome.getString() +
"&cognome=" +
cognome.getString();
try
{
/*
Apriamo la connessione http con il metodo open passandogli la stringa url.
/**/
http = (HttpConnection) Connector.open(url);
//Setto la modalità di inviamo dati a GET
http.setRequestMethod(HttpConnection.GET); /*
Da questo punto gestiamo la response del server.
Facciamo un controllo e se la response contiene il codice http 200, l'interazione è andata a buon fine e siamo pronti all'elaborazione dei dati, altrimenti appendiamo al form il codice di errore http visualizzandolo poi sul display.
/**/
if (http.getResponseCode() == HttpConnection.HTTP_OK)
{
//dichiariamo un array di byte vuoto
byte servletData[]=null;
/*
Valorizziamo l'InputStream prima dichiarato ottenendo l'InputStream dalla connessione
/**/
input = http.openInputStream();
//Cerchiamo di ottenere la lunghezza in byte della response
int length = (int) http.getLength();
//Se la lunghezza della response è nota:
if (length > 0)
{
/*
Impostiamo la dimensione dell'array di byte utilizzando la lunghezza in byte della response.
/**/
servletData = new byte[length];
//Effettuiamo la lettura dei dati dall'InputStream sull'array
input.read(servletData);
//Appendiamo al form i dati di output
form.append("\n" + new String(servletData));
//Visualizziamo il form sul display
display.setCurrent(form);
//Se la response è nulla:
}else if(length == 0)
{
form.append("\nLettura fallita");
//Se la lunghezza non è nota:
}else
{
//Istanziamo un oggetto ByteArrayOutputStream
ByteArrayOutputStream output =
new ByteArrayOutputStream();
/*
Leggiamo l'InputStream e inseriamo il contenuto nel ByteArrayOutputStream con il metodo write()
/**/
int ch;
while ((ch = input.read()) != -1)
output.write(ch);
//Valorizziamo l'array di bytes
servletData = output.toByteArray();
//Appendiamo al form i dati di output
form.append("\n" + new String(servletData));
//Visualizziamo il form sul display
display.setCurrent(form);
//Chiudiamo il ByteArrayOutputStream
output.close();
}
}else
{
//Gestione dei vari http status code diversi da 200
form.append("Http exit code: " +
http.getResponseCode() +
"\n");
display.setCurrent(form);
}
}catch (Exception e)
{
//Gestione degli errori di connessione
form.append("Errore di rete:\n");
form.append("Type: "+e);
form.append("Message: "+e.getMessage());
}finally
{
//Chiudiamo le risorse allocate.
if (input != null)input.close();
if (http != null)http.close(); }
}
} Fai il download di Midlet.zip
Completata la midlet, effettuiamo la compilazione utilizzando il tarso Build del Wireless toolkit 
Fig. 8 Ambiente Se la compilazione è andata a buon fine, passiamo alla fase di impacchettamento e preverifica, anch'essa effettuata dal Wireless toolkit alla voce di menu Project/Package: 
Fig. 9 Ambiente Durante questa fase viene creato un pacchetto .jar posizionato nella directory bin. Tale pacchetto può essere portato su dispositivo wireless per essere poi eseguito. Se non si dispone di tale dispositivo è possibile utilizzare uno degli emulatori messi a disposizione dalla SUN Microsystem all'interno del Wireless toolkit.
Per testare l'applicazione ho utilizzato l'emulatore MediaControlSkin, ma un qualsiasi altro andrà bene. Ho lanciato il test cliccando sul tasto Run: 
Fig. 10 Ambiente Il lancio dell'applicazione avviene cliccando nel tasto launch del cellulare. Le librerie grafiche che vengono utilizzate dai componenti della j2me sono nativi del dispositivo, quindi potremmo notare delle differenze a livello grafico fra i vari dispositivi. Ecco come si presenterà l'applicazione: 
Fig. 11 Ambiente Dopo aver inserito i valori nei campi, invochiamo la servlet con l'apposito comando chiama. 
Fig. 12 Ambiente Se la chiamata va a buon fine dovremmo trovarci davanti un risultato di questo tipo: 
Fig. 13 Ambiente Per una ulteriore verifica, possiamo interrogare il DB e noteremo l'arrivo dei nuovi dati. 
Fig. 14 Ambiente Partendo da questa basilare architettura possiamo sviluppare componenti ben più complessi, che ci permettono, utilizzando un dispositivo wireless, di muovere la logica applicativa su un application server. Dobbiamo sempre tener presente che dal nostro "cellulare java" è possibile comunicare con un server utilizzando vari protocolli di trasmissione dati. L'idea di questa applicazione mi è venuta leggendo il libro "Core J2ME tecnology & MIDP" di John W. Muchow ,che vi consiglio caldamente.
|
Documentazione
>
Servlet.zip
