Programmazione.it v6.4
Ciao, per farti riconoscere devi fare il login. Non ti sei ancora iscritto? Che aspetti, registrati adesso!
Info Pubblicità Collabora Autori Sottoscrizioni Preferiti Bozze Scheda personale Privacy Archivio Libri Corsi per principianti Forum
Greenpeace
Realizzare una chat con un'implementazione Comet per GWT (2/5)
Scritto da Francesco Carotenuto il 03-11-2010 ore 08:45
Intel Parallel Studio XE
Nel precedente articolo abbiamo introdotto l'approccio Comet e una sua implementazione per GWT, da questo articolo in poi, invece utilizzeremo questi elementi per poter realizzare una semplice chat.

Per prima cosa dovremo stabilire i servizi utilizzati dal client per poter comunicare in chat. Tali servizi verranno effettivamente implementati nel prossimo articolo. Nel dettaglio definiremo questi servizi come un'interfaccia, denominata ChatService, in cui definiamo i servizi di login, logout, send e il servizio getUsername, indispensabile per controllare se la sessione di chat iniziata al momento del login è ancora attiva oppure no. Di seguito diamo il codice dell'interfaccia appena descritta.
  1. public interface ChatService extends RemoteService {
  2.  
  3.         public String getUsername() throws ChatException;
  4.  
  5.         public void login(String username) throws ChatException;
  6.  
  7.         public void logout(String username) throws ChatException;
  8.  
  9.         public void send(String message) throws ChatException;
  10.  
  11. }
A questo punto possiamo cominciare a costruire l'entryPoint ChatEntryPoint, che rappresenterà il front-end della chat e a cui dedicheremo l'intero articolo. I compiti principali di ChatEntryPoint sono essenzialmente due: instaurare e gestire una comunicazione con il server, utilizzando un'istanza della classe CometClient; acquisire e stampare sullo schermo tutti i messaggi che intercorrono nella comunicazione.

Tralasciando quest'ultima parte, vediamo le parti salienti dell'instaurazione della comunicazione con il server. Partendo da ChatEntryPoint, si può vedere nel codice riportato sotto che al caricamento dell'applicazione, si effettua la verifica immediata della presenza di una sessione di comunicazione già attiva, attraverso il richiamo del servizio getUsername; in caso contrario si procederà ad aprire la finestra per effettuare il login.
  1. ...
  2. public class ChatEntryPoint implements EntryPoint {
  3.  
  4.         private ChatServiceAsync chatService;
  5.         private CometClient cometClient;
  6.  
  7.         private String username;
  8.         ...
  9.         @SerialTypes( { ChatMessage.class})
  10.         public static abstract class ChatCometSerializer extends CometSerializer {
  11.         }
  12.  
  13.         //Stampa di un messaggio ricevuto
  14.         public void output(String text, String color) {...}
  15.         //Finestra di dialogo per il login
  16.         private void showLogonDialog() {...}
  17.  
  18.         public void onModuleLoad() {
  19.                 chatService = GWT.create(ChatService.class);
  20.                 chatService.getUsername(new AsyncCallback<String>() {
  21.  
  22.                         public void onSuccess(String username) {
  23.                                 if (username == null) {
  24.                                         showLogonDialog();
  25.                                 }
  26.                                 else {
  27.                                         loggedOn(username);
  28.                                 }
  29.                         }
  30.  
  31.  
  32.                         public void onFailure(Throwable caught) {
  33.                                 output(caught.toString(), "red");
  34.                                 showLogonDialog();
  35.                         }
  36.                 });
  37. ...
Inoltre con l'annotazione @SerialType e la definizione della classe astratta ChatCometSerializer, definiamo quali sono i messaggi inviati dal server (nel nostro caso ChatMessage) che vogliamo serializzare in modo da utilizzarli allo stesso modo anche nel client. Di seguito, è riportato il codice necessario per l'invio di un messaggio verso il server e per il logout.
  1. ...     
  2. final TextBox input = new TextBox();
  3. Button send = new Button("Send", new ClickHandler() {
  4.  
  5.                         public void onClick(ClickEvent event) {
  6.                                 sendMessage(input.getValue());
  7.                         }
  8.                 });
  9.                 Button logout = new Button("Logout", new ClickHandler() {
  10.  
  11.                         public void onClick(ClickEvent event) {
  12.                                 logout();
  13.                         }
  14.                 });
  15.  
  16.                 ...                
  17.         }
  18.         ...
Il codice seguente invece è relativo al metodo sendMessage, che effettua la chiamata all'omonimo servizio posto sul server:
  1. ...
  2. private void sendMessage(String message) {
  3.     chatService.send(message, new AsyncCallback<Void>() {
  4.  
  5.               public void onSuccess(Void result) {}
  6.  
  7.               public void onFailure(Throwable caught) {
  8.                           output(caught.toString(), "red");
  9.                         }
  10.                 });
  11. }
  12. ....
Manda ad un amico Aggiungi ai preferiti Sottoscrivi la discussione Stampa
Commenta
Precedente: Un laser invertito come nuovo sensore ottico
Successiva: Gestire la taskbar in Windows 7
Copyright Programmazione.it™ 1999-2013. Alcuni diritti riservati. Testata giornalistica iscritta col n. 569 presso il Tribunale di Milano in data 14/10/2002. Pagina generata in 0.669 secondi.