Mostrando entradas con la etiqueta GWT. Mostrar todas las entradas
Mostrando entradas con la etiqueta GWT. Mostrar todas las entradas

20 dic 2011

GWT: eventos touch


GWT me recuerda a Django, si bien la documentación es muy extensa tiene multitud de trucos y tips que 
leyendo solamente el Javadoc son imposibles de descubrir, el manejo de eventos touch es un ejemplo perfecto por lo que creí oportuno escribir esta micro-guia para manejar esas situaciones. Los dispositivos táctiles como tablets y smartphones son medios de acceso cada vez más habituales a nuestras aplicaciones web por tanto no podemos quedarnos solamente con los eventos relacionados al mouse, algo tan común como mostrar un mensaje al hacer mouseover sobre un elemento de la interfaz simplemente no funciona.
GWT tiene clases especificas relacionadas al touch así que vamos a ver como utilizarlas, básicamente manejaremos los eventos TouchStartEvent, TouchMoveEvent y TouchEndEvent a través de sus handlers TouchStartHandler, TouchMoveHandler y TouchEndHandler, los resultados puedes verlos en el video: 




El ejemplo es muy sencillo, como vemos en el código en el método onModuleLoad está el manejo de los eventos, añadí clear() solo para limpiar los estilos y poder cambiar el fondo del panel que implementa el touch. El gran truco para que funcione es añadir la línea event.preventDefault(), esta cancela la propagación del evento disparado y permite que la aplicación detecte los siguientes, si no lo especificamos la aplicación no puede distinguir cundo pasamos de uno a otro y se queda con el primero detectado, lamentablemente esto no lo vi por ningún lado en la documentación ya que te envía a la Safari Touch Event Documentation donde seguramente no encuentres muchos ejemplos de GWT :)


public class Touch_test implements EntryPoint {

 // utilizamos un FocusPanel para detectar los eventos y un Label para mostrar su nombre  
 private final FocusPanel fpanel = new FocusPanel();
 private final Label lbl = new Label("evento: ");


 // limpiamos los estilos para mostrar cada evento con un color diferente
 private void clear() {
  fpanel.removeStyleName("back_red");
  fpanel.removeStyleName("back_gray");
 }

 
 public void onModuleLoad() {
  
  // le damos alto, ancho y un borde  
  fpanel.setStyleName("fPanel");
  
  // detectamos el evento TouchStartEvent 
  fpanel.addTouchStartHandler(new TouchStartHandler() {
   @Override
   public void onTouchStart(TouchStartEvent event) {
    event.preventDefault(); // IMPORTANTE!!

    lbl.setText("evento: touch");
    clear();
    fpanel.addStyleName("back_red"); // coloreamos de rojo el panel
   }
  });
  
  // detectamos el evento TouchMoveEvent
  fpanel.addTouchMoveHandler(new TouchMoveHandler() {
   @Override
   public void onTouchMove(TouchMoveEvent event) {
    event.preventDefault(); // IMPORTANTE!!

    lbl.setText("evento: move");
    clear();
    fpanel.addStyleName("back_gray"); // coloreamos de gris el panel
   }
  });
  
  // detectamos el evento TouchEndEvent
  fpanel.addTouchEndHandler(new TouchEndHandler() {
   @Override
   public void onTouchEnd(TouchEndEvent event) {
    event.preventDefault(); // IMPORTANTE!!

    lbl.setText("evento: end");
    clear();  // dejamos si estilos el panel
   }
  });

  RootPanel.get().add(lbl);
  RootPanel.get().add(fpanel);
 
 }
}




Los estilos son solo para darle un toque visual:

.fPanel {
 height:200px; 
 width:200px;
 border: solid 1px #CCC;
}

.back_red{
 background-color:red; 
}

.back_gray{
 background-color: #CCC; 
}


Es bastante simple, lo que quiero destacar es asegurarse de agregarle la dichosa línea event.preventDefault() y funciona bastante bien, lo probé en un iPad y un smartphone con Android y en ambos responde de forma similar, otra cosita que sumar a nuestro arsenal de desarrollo.



15 sept 2011

GWT: arrays como argumentos desde Java hacia JavaScript mediante JSNI


Todo un tema el intercambios de datos entre los métodos en JavaScript nativo escritos con JSNI y nuestro código Java, básicamente tenemos solo unos pocos tipos ya que aparentemente esta pensado para intercambiar argumentos simples. Repasemos la documentación a ver que tenemos:


Los más prácticos son los básicos: String, boolean y numéricos, los demás requieren de sintaxis especial o son valores opacos que no se prestan demasiado a la manipulación, pero atentos, tenemos a la vista la solución a nuestro problema: los valores de tipo JavaScriptObject.
La documentación da lugar a confusión, ya que aparentemente solo los podríamos usar como valores de retorno de otro método JSNI, pero si revisamos el Javadoc de los tipos de datos disponibles para manejar JSON, vemos que tanto JSONArray como JSONObject poseen el método getJavaScriptObject que tiene como tipo de retorno JavaScriptObject, precisamente lo que podemos pasar como argumento a nuestro código JSNI. Bien, con esto en mente y como muy probablemente utilicemos JSON para el paso de valores es que llegamos al siguiente ejemplo:

package test.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;

public class TestJSNI implements EntryPoint {

 public void onModuleLoad() {

  // creamos un JSONArray de prueba
  JSONArray jsonArray = JSONParser.parseLenient("['rojo','negro','verde']").isArray();
  
  // pasamos como ragumento su JavaScriptObject
  parseArray(jsonArray.getJavaScriptObject());

 }
 
  
  
 private native void parseArray(JavaScriptObject myArray) /*-{

  // mostramos el valor de la primer posición 
  alert(myArray[0]);

 }-*/; 
 
}


Cortito y simple, creamos un JSONArray (incluir en el XML de módulo la línea <inherits name="com.google.gwt.json.JSON" />) para probar y luego lo utilizamos para llamar al método JSNI, el truco como mencionaba es pasar como argumento su objeto JavaScriptObject subyacente y especificar también de este tipo el argumento de nuestro método nativo. Muy útil, seguro una excelente manera para el pasaje de datos con mucha más flexibilidad.



13 sept 2011

GWT: incluir librerías JavaScript externas


Si bien GWT nos proporciona una cantidad muy interesante de métodos para manipular el DOM directamente desde Java, hay ocasiones que es mucho más práctico incluir JavaScript directamente a través de JSNI, si bien no es aconsejable ya que el código incluido no es verificado ni optimizado por el compilador.
Por otra parte, hay ahí fuera miles de librerías y utilidades súper prácticas que es imposible pasar por alto, algunas insustituibles más teniendo en cuenta que GWT tiene serias carencias en algunas áreas, los efectos son un ejemplo, salvo un manojo de buenas herramientas portadas a Java el abanico es escaso, además no siempre tenemos un equivalente a la altura, varias veces los ports terminan siendo más voluminosos que la solución original y a veces con menos posibilidades.
Todo esto nos lleva a más que escribir unas pocas líneas a través de JSNI vernos tentados a incluir librerías externas completas para tener funcionalidades extra en nuestra aplicación, el tema es como lo hacemos.

Lo más básico es escribir un tag link en nuestro archivo home de HTML referenciando el código externo, opcion esta desaconsejada, no solo perdemos el control ya que confiamos en un recurso externo que no sabemos si invariablemente va a estar cuando hagamos el despliegue (con GWT también se hacen pequeños módulos que podemos distribuir independientemente, no solo apps completas), si no que delegamos en el browser las tareas de control del cache y manejo de errores, estamos jugando con fuego se podría decir.
Lo otro es otra incluirlo en nuestro archivo XML de proyecto utilizando la Automatic Resource Inclusion para incluir código externo de una manera más elaborada, pero en este caso siempre lo incluirá más allá de que finalmente lo necesitemos o no.

Precisamente viendo como podemos hacer todo esto de una manera un poco más elegante es que llegamos a la dimensión desconocida de la interfaz Client Bundle para el manejo de recursos externos. Una de las ventajas que ya nos mencionan es que los recursos incluidos a través de ésta pasan a la categoría de recursos cacheados para siempre (repito la importancia  de tener el control de que se cachea y como), lo cual es muy conveniente para recursos que no cambian con el tiempo, los más obvios y por tanto conocidos son imágenes y archivos CSS. Estos cuentan con soporte exaustivo, desde los prácticos sprites de imágenes a cosas más rebuscadas como soporte RTL, pero... y los archivos JS?
En el caso de archivos JavaScript la cosa es un poco acotada, de los tipos disponibles utilizamos el TextResource, que engloba los recursos de "static text content", una linda manera de referirse al JS de toda la vida. 
Otra cosa muy bienvenida que tenemos desde la release 2.4 es la clase ScriptInjector que nos permite crear un tag SCRIPT sin tener que manejar directamente el DOM lo cual es propenso a errores (por ejemplo si nos salteáramos un paso como incluir el tag sin definir el tipo o similares puede fallar), incluso tenemos algunos métodos extra como definir un setCallback en caso de archivos cargados desde una URL, básico pero nada mal.

Comencemos con un ejemplo así vemos como usar esta técnica que seguro nos ayuda a perder el miedo a incluir recursos externos o hacerlo de una manera más consistente, en este caso estaba tratando de utilizar los features de HTML5 Storage, pero en caso de que esta funcionalidad no estuvieran disponible en el cliente quería ofrecer un método alternativo de almacenar datos en el browser, si bien hay excelentes librerías que chequean exhaustivamente el navegador para ver que tenemos disponible (desde almacenamiento Flash hasta características exclusivas de IE entre otras) me decidí por lo simple y utilicé una vieja amiga como es TaffyDB, una muy buena opción para almacenar info en el cliente con algunos métodos muy útiles: contar, ordenar, filtros y algunas cosillas más.


estructura del ejemplo


Allá vamos entonces, proyecto nuevo en Eclipse y creamos un directorio para almacenar Taffy, en este caso bajo el package client/lib, utilizamos la versión minificada de producción taffy-min.js, menos de 20kb... un lujo.
Ahora lo interesante, para incluirla debemos definir una interface que extienda de ClientBundle y tenga la ruta a la librería como argumento de la anotación @Source y un método para referenciarla por el tipo, en mi caso la llame TaffyDBBundle quedando de la siguiente manera:

package testTaffy.client;

import com.google.gwt.resources.client.ClientBundle;
import com.google.gwt.resources.client.TextResource;

public interface TaffyDBBundle extends ClientBundle {
 @Source("lib/taffy-min.js")
 TextResource taffy();
}

Es bastante descriptiva, como mencioné especificamos la ruta al archivo en @Source y definimos un método para accederla del tipo TextResource, en mi caso taffy();
Ahora en el onModuleLoad vamos integrar todo usando el ScriptInjector, aquí tenemos dos opciones: ScriptInjector.fromString y ScriptInjector.fromUrl (no confundir el tipo de retorno con el nombre del método) en este caso como ya tenemos incluida la librería utilizaremos fromString, que recibe como argumento el contenido de nuestro archivo JS, a este lo accedemos mediante el método getText() de la interfaz TextResource que ya implementamos, quedando así:

package test.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.ScriptInjector;

public class TestDB implements EntryPoint {

 public void onModuleLoad() {

  TaffyDBBundle taffy = GWT.create(TaffyDBBundle.class);
  JavaScriptObject result = ScriptInjector.fromString(taffy.taffy().getText()).inject();
  
 }
 
}

Primero creamos nuestro recurso a través de GWT.create quedando del tipo de nuestra interfaz (TaffyDBBundle), luego utilizamos el ScriptInjector.fromString y le pasamos como argumento el llamado a nuestra instancia mediante el método taffy() (podemos llamarlo como queramos) y luego su contenido mediante .getText(), finalmente incluimos el script al DOM mediante .inject();
Para verificar vamos a crear un par de métodos mediante JSNI para verificar que está funcionando, en este caso definimos una base de datos e ingresamos algunos registros, luego verificamos consultando cuantos cumplen con determinada condición:

    private native void createDB() /*-{

  $wnd.sobrinos = TAFFY([ {"id":1,"user":"Hugo","edad":"12"},
        {"id":2,"user":"Paco","edad":"12"},
        {"id":3,"user":"Luis","edad":"12"}  
                        ]);

 }-*/;

 private native void testDB() /*-{

  alert($wnd.sobrinos({"edad":"12"}).count());

 }-*/;


vale recordar que en GWT siempre es conveniente referirse a las variable a través de el objeto $wnd (window) para evitar problemas, ahora juntamos todo:
package testTaffy.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.ScriptInjector;

/**
 * Entry point classes define onModuleLoad().
 */
public class TestTaffyDB implements EntryPoint {

 public void onModuleLoad() {

  TaffyDBBundle taffy = GWT.create(TaffyDBBundle.class);
  JavaScriptObject result = ScriptInjector.fromString(taffy.taffy().getText()).inject();
  
  if (null != result) {
   createDB();
   testDB();
  }
 }

 private native void createDB() /*-{

  $wnd.sobrinos = TAFFY([ {"id":1,"user":"Hugo","edad":"12"},
        {"id":2,"user":"Paco","edad":"12"},
        {"id":3,"user":"Luis","edad":"12"}  
                        ]);

 }-*/;

 private native void testDB() /*-{

  alert($wnd.sobrinos({"edad":"12"}).count());

 }-*/;
}


Utilizo un JavaScriptObject result para verificar que el tag se creo correctamente, al correrlo obtenemos un mensaje de alerta con 3, efectivamente está funcionando ya que hay 3 usuarios cargados en Taffy con el campo edad igual a 12, bastante accesible, como mencionaba hay más métodos útiles disponibles como setCallback al cargar recursos por URL o setWindow para especificar en que ventana queremos colocar el tag SCRIPT, simple y consistente.

Por último juro que busqué que edad tienen los sobrinos del Pato Donald para el ejemplo pero no encontré nada :)



23 ago 2011

Slide Secrets of the GWT

Comparto un slide diferente sobre GWT de los muchos que hay ya que toca temas que otros más básicos pasan por alto, aunque un poco largo (son 80+) solo es una muestra de algunos tópicos interesantes así que imagínense el mundo que hay detrás de esta herramienta, ya voy más de un año y todos los días aprendo algo nuevo, para no aburrirse.


18 ago 2011

GWT Command para ejecución secuencial

Con GWT hay que estar atentos al hecho de que la programación esta dirigida por eventos y de manera totalmente asíncrona, por lo que no solo debemos basarnos en ellos para hacer fluir la aplicación sino que tampoco podemos fiarnos de que la lógica que necesitemos haya sido correctamente implementada por las sentencias anteriores.

Precisamente esto mismo me paso al realizar una serie de métodos secuenciales: la lógica necesaria para pasar al siguiente método aún no estaba disponible, por lo que al avanzar la cadena de ejecución fallaba miserablemente ya que no verificaba que un paso estuviera totalmente finalizado para avanzar al siguiente.
Una posible solución es que al ejecutar un método si todo esta correcto invoquemos el próximo, pero no queda muy prolijo que digamos, fácilmente podemos tener una ensalada de llamadas por doquier, ni hablar si queremos cambiar el flujo de la aplicación, suerte en pila.

Una solución que da buenos resultados es utilizar los Comandos, con ellos es posible encapsular determinada lógica y luego ejecutarla a demanda, si a esto lo aderezamos con iteradores y ArrayLists, la cosa empieza a tomar otro color, veamos un ejemplo completo y luego lo diseccionamos:

package com.myPackage.client;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.Window;

public class DemoComandos {

	private List<Command> commandsStack = new ArrayList<Command>();
	private Command command_01, command_02;
	private Iterator<Command> cmdIterator;


	public Comandos(){
		loadCommandsStack();
		run();
	}
	

	private void loadCommandsStack(){

		command_01 = new Command() {
			@Override
			public void execute() {
				
				boolean ok_01 = true;
				if(ok_01){
					run();
				}
				else{
					Window.alert("error comando 1");
				}
				
			}
		};

		
		command_02 = new Command() {
			@Override
			public void execute() {

				boolean ok_02 = false;

				if(ok_02){
					run();
				}
				else{
					Window.alert("error comando 2");
				}
				
			}
		};
		
		
		commandsStack.add(command_01);
		commandsStack.add(command_02);
		cmdIterator = commandsStack.iterator();
	}
	
	
	private void run(){
		
		if(!cmdIterator.hasNext()){
			Window.alert("no hay mas comandos");
		}
		else{
			cmdIterator.next().execute();
		}
	}
	
}


Veamos por partes, la idea es encapsular nuestra lógica en comandos y agrupar estos en una lista, para mantenerlo simple dentro de la ejecución de estos no llamaremos métodos externos pero es lo más recomendable para separar la lógica de las sentencias y tenerlas definidas aparte.
Al crear una lista de comandos no solo unificamos ya que ahora todos son del mismo tipo, sino que podemos verificar que un paso esta completo antes de llamar al siguiente, pera hacerlo dinámicamente creamos un iterador que sea invocado por los propios métodos si estos finalizan correctamente, en caso contrario la aplicación se detiene ya que cortamos la cadena de llamadas. Ahora en detalle:

	private List<Command> commandsStack = new ArrayList<Command>();
	private Command command_01, command_02;
	private Iterator<Command> cmdIterator;

aquí creamos la lista que contendrá nuestros comandos, la definimos del tipo ArrayList para manejarlos mejor, luego creamos los comandos y por último definimos un iterador, no lo inicializaremos hasta tener cargados los comandos en la lista.

public Comandos(){
        loadCommandsStack();
        run();
    }


Por sencillez ejecuto en el constructor el método para la carga de los comandos, solo agrupa esta operación para mantenerlo conciso pero podemos colocarlo en cualquier lado, lo hacemos así:


command_01 = new Command() {

	@Override
	public void execute() {
		// aquí ejecutamos la rutina o llamamos a un método aparte
		// si todo es correcto invocamos el método run() y continuamos

			boolean ok_01 = true; // simulamos que todo fué Ok
			if(ok_01){
			    run();
			}
			else{
			    // en caso contrario la aplicación se detiene
			    Window.alert("error comando 1");
			}
				
		}
	};


Como mencionaba para agregarle flexibilidad a la ejecución de la pila de llamadas agregamos los comandos a un ArrayList e inicializamos el iterador:

commandsStack.add(command_01);
commandsStack.add(command_02);
cmdIterator = commandsStack.iterator();


Ahora lo interesante, el iterador posee un método hasNext() que nos indica si hay un comando próximo cargado a ejecutar, si no es el caso quiere decir que completamos la pila de llamadas, este lo encapsulamos en un método run(), al llamarlo por primera vez dispara la secuencia de ejecución, luego esta es mantenida por los resultados de los siguientes métodos, es decir, si estos se efectuan correctamente invocan sucesivamente run() continuando la secuencia, si ocurre un error la cedena de llamadas se detiene y si no todo concluye correctamente.


private void run(){
	
    if(!cmdIterator.hasNext()){
        Window.alert("no hay mas comandos");
    }
    else{
        cmdIterator.next().execute();
    }
}

Inclusive podemos tener una clase maestra que contenga un metodo run()  general y clases inferiores más específicas con la misma estructura, éstas al concluir sus comandos locales si tienen una referencia a la clase maestra pueden invocar al run() general en vez del local y continuar la pila de llamadas a otras clases inferiores.

En mi caso utilizé este planteo con una clase maestra llamada Init que invoca varias clases menores que realizan tareas específicas como chequear la conexión, crear la GUI, obtener JavaScript onDemand u otros, cada una tiene una referencia a Init que luego de realizar todos sus comandos ejecutan Init.run() y pasan la posta a la pila de llamadas contenidas en otra clase.Otra ventaja que vuelvo a mencionar es la facilidad para cambiar el flujo de la aplicación, basta con comentar el commandsStack.add(myCommand) que queramos y todo seguirá fluyendo normalmente salteándose ese paso, creo que solo aporta ventajas así que vale la pena probarlo.

9 ago 2011

Java Generics para argumentos con herencia e interfaces

Este es un ejemplo claro de esas situaciones que fácilmente podemos dedicarle tres o cuatro horas en resolverlo si no tenemos muy en claro algunas cosillas de Java, me refiero concretamente a los Generics y su uso para validar argumentos.
En GWT la herencia es constate, así como el uso profuso de interfaces, por lo que es muy habitual tener métodos que reciben este tipo de objetos como argumento, esto no es problema en si mismo, el tema es cuando tenemos varias clases diferentes que implementan herencia e interfaces en común y queremos ejecutar métodos definidos en ambas, de que tipo definimos nuestro argumento que hace referencia a todas ellas?

Pongamos un ejemplo, estamos creando una clase MiVista que extiende de Composite e implementa una interfaz definida por nosotros para asegurarnos que estén presentes ciertas operaciones, si un método X recibe este tipo de clases como argumento simplemente podemos definirlo del tipo MiVista:

// Interfaz

public interface MyInterface {
    public void hacerAlgo();
}

// Clase personalizada que extiende e implementa

public class MiVista extends Composite implements MyInterface {

    public MiVista(){
        
        // disponible por extender Composite
        initWidget(...); 
    }
  
    // requerido por implementar MyInterface
    public void hacerAlgo() {
        ...
    }
}


// Método en otra clase que recibe MiVista como argumento

public void setearValores(MiVista vista){
    vista.hacerAlgo();
}


Ahora lo interesante, supongamos que tenemos otra clase MiVistaCompact, que define otra serie de características pero también extiende de Composite e implementa MyInterface, de que tipo lo definimos a nuestro argumento vista en el método setearValores?
Si lo definimos como MiVista dejamos fuera a MiVistaCompact y visceversa, si lo hacemos como Composite nos falla ya que esta clase base no implementa MyInterface ni nuestros propios métodos, si nos referimos como MyInterface no tenemos disponibles los métodos de Composite..., y aquí es donde echamos mano de los Generics de Java.
No voy a profundizar en ellos ya que la documentación es abundante, lo que escasea son ejemplos donde lo que queremos es asegurarnos que nuestro tipo de datos posea ambas características, lo redefinimos así:

public <T extends Composite & MyInterface> void setearValores(T vista){
    vista.hacerAlgo();
}


Lo que estamos haciendo es especificar un nuevo tipo de parámetro en la misma definición del método y referirnos a este como tipo para el argumento, nuestro valor T es ahora cualquier objeto (con ciertas limitaciones) que extienda de Composite e implemente MyInterface, por eso podemos utilizarlo indistintamente para referirnos tanto a MiVista como a MiVistaCompact.
Cuidado al detalle de que solo podemos hacer uso de los métodos disponibles en Composite o MyInterface, no a los específicos de MiVista o MiVistaCompact, pero para esto hacemos un casteo y podemos referirnos a ellos asi:

	public <T extends Composite & MyInterface> void setearValores(T vista){

	    vista.hacerAlgo();  // disponible por implementar MyInterface
	    vista.isAttached(); // disponible por extender Composite

        // disponible solo en MiVista
        ((MiVista)vista).metodoXenMiVista();

        // disponible solo en MiVistaCompact
        ((MiVistaCompact)vista).metodoYenMiVistaCompact();
	}


Lo único a tener en cuenta al ejecutar estos métodos específicos es verificar que estamos recibiendo la clase que los defina, ya que en caso contrario fallará, también vale recordar que para nombrar a nuestro nuevo tipo hay algunas convenciones, copypasteo desde Oracle gentypes:

By convention, type parameter names are single, uppercase letters.
...
The most commonly used type parameter names are:
E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types


La sintaxis básica es esta, si utilizamos varias interfaces las separamos por comas y según que implementemos las opciones se multiplican ya que tenemos además comodines y jeroglíficos varios, pero para todo eso hay muy buenas guías disponibles y una búsqueda corta seguro nos da para leer un buen rato, aunque repito, en este caso concreto me costo un poco encontrarle la vuelta, no queda otra que leerse unos cuantos tutoriales, impacientes abstenerse.

Solo para los más duros una pequeña guía: GenericsFAQ


20 jun 2011

Evitando SOP en GWT

Cuando desarrollamos aplicaciones web una de las tares mas básicas es la comunicación cliente servidor, y si bien GWT nos proporciona diferentes mecanismos (RPC, JSONP, etc) , uno de los mas habituales es la realización de peticiones HTTP al servidor.
Para esto se nos proporciona la clase HTTP cliente mediante la cual creamos y recibimos requests, siempre bajo las restricciones que impone la política de SOP (same origin policy) de los navegadores, que evita que el código cliente interactue con recursos de otros dominios previniendo potenciales problemas de seguridad.
Por otro lado, una de las formas mas prácticas de desarrollar en GWT es el llamado modo desarrollo, en el cual las aplicaciones corren sobre la máquina virtual de Java, pero quedamos restringuidos a realizar peticiones HTTP al dominio en el cual estamos ejecutando, del tipo "http://127.0.0.1:8888/MyApp.html?gwt.codesvr=127.0.0.1:9997".
Dicho esto nada mas cómodo que trabajar en modo desarrollo y realizar desde ahí las consultas al server, pero lamentablemente estos dos panoramas son totalmente incompatibles, quizás podríamos crear resultados de retorno simulados para las peticiones, también compilar todo cada tanto para verificar que todo funciona como esperamos, pero aun así cualquiera de las dos opciones es bastante impráctica, sobre todo compilar que ya de por si se lleva su tiempo, otra posible solución es cambiar todo esto por el uso de JSONP, pero no es lo que queremos, eso es solo otro hack al navegador, yo quiero Modo Desarrollo mas peticiones HTTP.

Leyendo precisamente en Wikipedia sobre SOP, encontré un enlace a una técnica un poco desconocida llamada CORS (Cross-Origin Resource Sharing) la cual habilita la posibilidad de realizar peticiones evitando el SOP de los navegadores, y claro, vi la luz al final del tunel.
Básicamente se trata de agregarle a la respuesta del servidor una serie de cabeceras que especifiquen el uso de esta técnica, soportada por varios navegadores modernos (ok, ok,  solo probé en Chrome y FF4, si alguien desarrolla con otro browser largo de aquí).

Para ver como funciona, realizaremos una aplicación de prueba con GWT y Python, recuerden que el uso de esta técnica es solo para desarrollo, nunca para codigo en produccion.
Este metodo fue probado con Python sobre WSGI y PHP, los navegadores son Firefox 4.0 y Chrome 6.0.472.63 sobre una caja Kubuntu 10.04.2 LTS.

Primero, abrimos Eclipse y realizamos un nuevo proyecto GWT, vacío, asi observamos bien el funcionamiento de esta técnica, luego creamos una petición HTTP (recordar de agregar al archivo XML del módulo la linea  <inherits name="com.google.gwt.http.HTTP" />) y la apuntamos a un dominio diferente al que corremos la aplicación, quedando de tal manera:


package cors.test.client;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
import com.google.gwt.user.client.Window;
/**
* Entry point classes define onModuleLoad().
*/
public class CORS_test implements EntryPoint {
 public void onModuleLoad() {
  
  String url = "http://localhost/CORS_test.wsgi";
  RequestBuilder builder = new RequestBuilder(RequestBuilder.GET, URL.encode(url));
  
  try{
   Request request = builder.sendRequest(null, new RequestCallback() {
    
    @Override
    public void onResponseReceived(Request request, Response response) {
     
     if(200 == response.getStatusCode()){
      Window.alert(response.getText());
     }
     else{
      // handle the error
      Window.alert("failed petition");
     }
    }
    
    @Override
    public void onError(Request request, Throwable exception) {
     Window.alert("CORS... sure");
    }
   });
   
  }
  catch(RequestException e){
   Window.alert("Couldn't connect to server");
  }
  
 }
}

Luego, creamos el archivo de respondera a la petición, en este caso CORS_test.wsgi y lo colocamos en nuestro localhost:

def application(environ, start_response):
    status = '200 OK'
    response_headers = [('Content-type','text/plain')]
    start_response(status, response_headers)
    return ['Hello world from Python!']

apuntamos nuestro navegador a http://localhost/CORS_test.wsgi y debemos ver el mensaje "Hello world from Python!"
Ahora, corremos nuestra aplicación GWT en modo desarrollo, recibimos el siguiente mensaje: "failed petition", efectivamente SOP nos esta bloqueando las peticiones, por lo que agregamos las siguientes cabeceras en la respuesta:

# CORS_test.wsgi

def application(environ, start_response):
    status = '200 OK'
    response_headers = [
        ('Content-type','text/plain'),
        ('Access-Control-Allow-Origin','http://127.0.0.1:8888'),
        ('Access-Control-Allow-Methods','GET, POST')
    ]
    start_response(status, response_headers)
    return ['Hello world from Python!']

y probamos nuevamente, obteniendo el mensaje: "Hello world from Python!"
Fácil verdad, lo importante es que la cabecera "Access-Control-Allow-Origin" especifique nuestro dominio, en este caso "127.0.0.1:8888", aunque también podríamos haber colocado *  e igual funcionaría, ahora toca en nuestro querido PHP, recordemos cambiar el valor de la URL por: String url = "http://localhost/CORS_test.php".

# CORS_test.php

<?php

header("Content-type:text/plain");
header("Access-Control-Allow-Origin:http://127.0.0.1:8888");
header("Access-Control-Allow-Methods:GET, POST");
echo "Hello world! from PHP";

?>

cuidado con los espacios en blanco de la etiqueta header, pueden hacer que la aplicación falle, ahora al correrlo veremos el mensaje: "Hello world! from PHP".
Bueno, esta es la técnica básica, los invito a leer la  especificación  , y ahora si: podemos volver a desarrollar dignamente.