Tutorial GWT: creiamo un servizio GWT RPC

Dopo aver installato il plugin di GWT per Eclipse (in questo articolo) ed il plugin per GWT Designer (in questo articolo), vediamo come effettuare una chiamata a procedura remota (RPC) tramite le API fornite dal framework GWT. La Remote Procedure Call è una tecnica utilizzata per costruire applicazioni Client-Server. Essa si basa sull’estendere la nozione convenzionale di chiamata a procedura locale,  in modo che non sia necessario che la procedura chiamata sia nello stesso spazio di indirizzamento della procedura chiamante. In altre parole il meccanismo di RPC consente ad un programma di eseguire funzioni “a distanza” su computer remoti (cioè accessibili attraverso una rete).

Per poter sfruttare questo meccanismo all’interno del framework GWT, dobbiamo essenzialmente definire 3 elementi (tra classi e interfacce) per definire un Servizio RPC, notiamo inoltre che il framework raccomanda di seguire delle convenzioni specifiche per i nomi di essi:

  1. una interfaccia Service che implementi RemoteService: in questa interfaccia definiamo il metodo che vogliamo utilizzare del nostro servizio (lato client). Questa è la definizione sincrona del servizio e la implementazione server-side deve implementare poi questo servizio, per convenzione si aggiunge il suffisso Service al nome scelto per l’interfaccia, ad esempio MyService;
  2. una interfaccia Service Asynchronous: deve avere lo stesso metodo definito nell’interfaccia sincrona di prima, ma è necessario includere nella sua lista di parametri un oggetto di tipo AsyncCallback e non deve ritornare alcun valore (sarà di tipo void), seguendo la convenzione dei nomi questa interfaccia avrà come nome quello dell’interfaccia sincrona seguito dalla parola Async, ad esempio MyServiceAsync;
  3. una classe Service Impl: questa sarà l’implementazione del servizio lato server ed estenderà la RemoteServiceServlet ed implementa l’interfaccia Service, come nome si utilizza il nome dell’interfaccia sincrona col suffisso Impl, ad esempio MyServiceImpl.

Lo sviluppo di questo codice è semplificato se abbiamo installato il plugin per il GWT Designer, infatti se clicchiamo col tasto destro sul package client della nostra applicazione GWT  e selezioniamo Google Web Toolkit vediamo comparire la voce GWT Remote Service:

Creiamo un Gwt Remote Service

Indichiamo il nome del servizio, sarà il tool a generare gli altri elementi seguendo le convenzioni che abbiamo specificato sopra:

Indichiamo il nome del nostro servizio

Cliccando su Finish verranno create le due interfacce e la classe Server di cui abbiamo discusso sopra:

Le interfacce e la classe generate

Modifichiamo l”interfaccia LoginService inserendo la firma del nostro metodo:

package it.appuntisoftware.client;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;

@RemoteServiceRelativePath("LoginService")
public interface LoginService extends RemoteService {
	/**
	 * Utility class for simplifying access to the instance of async service.
	 */
	public static class Util {
		private static LoginServiceAsync instance;
		public static LoginServiceAsync getInstance(){
			if (instance == null) {
				instance = GWT.create(LoginService.class);
			}
			return instance;
		}
	}
	//Il nostro metodo di esempio
	public Boolean isAdmin(String username, String password);
}

L’IDE ci segnalerà un errore sul nostro metodo, in realtà ci chiede di definire un metodo nell’interfaccia LoginServiceAsync:

L'IDE provvede a generare il codice per l'interfaccia LoginServiceAsync

Viene generato il seguente metodo nell’interfaccia LoginServiceAsync:

package it.appuntisoftware.client;
import com.google.gwt.user.client.rpc.AsyncCallback;
public interface LoginServiceAsync {
	void isAdmin(String username, String password,
			AsyncCallback callback);
}

Anche nella classe Server LoginServiceImpl verrà generato il metodo isAdmin:

package it.appuntisoftware.server;

import it.appuntisoftware.client.LoginService;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;

public class LoginServiceImpl extends RemoteServiceServlet implements LoginService {

	public Boolean isAdmin(String username, String password) {
		// TODO Auto-generated method stub
		return null;
	}
}

Inseriamo il codice di esempio all’interno della classe LoginServiceImpl:

public Boolean isAdmin(String username , String password) {
		if(username.equals("admin")&&password.equals("admin"))
			return true;
		else return false;

	}

Esso semplicemente ritorna true se lo username e password inseriti sono uguali ad “admin”.

Chiamiamo ora questo servizio remoto dal nostro client:

public void onClick(ClickEvent event) {
	if (textBoxUsername.getText().length() == 0 || textBoxPassword.getText().length() == 0) {
		Window.alert("Lo Username o la password sono vuote!!!");
		}
	else{
	    LoginService.Util.getInstance().isAdmin(textBoxUsername.getText(),textBoxPassword.getText(),  new AsyncCallback() {
	    public void onFailure(Throwable caught) {
		  //to-do
	    }

	    public void onSuccess(Boolean result) {
		DialogBox mydialog = new DialogBox(true);
		if(result){
			mydialog.setText("Benvenuto Admin");
		}else{
			mydialog.setText("Lo Username o la Password inserite sono errate");
                }
	        	mydialog.center();
			mydialog.show();
		}
		});
	}
}

Proviamo la nostra applicazione cliccando su Run as -> Web Application:

La nostra applicazione in esecuzione

1 Stella2 Stelle3 Stelle4 Stelle5 Stelle (2 voti, media: 3,50 di 5)
Loading...
You can leave a response, or trackback from your own site.

Leave a Reply

*