Frame communication

[Netsurfer]

In order to accomplish frame communication I've tryed an interesting
approach that I can share with the community.

The goal is to serialize an object into an econded String directly on
client side, pass through this data to an internal frame that expose a
javascript method to do it.
The frame that is a GWT application call a service that decode the
encoded String into the correct object.

You can use this method to restore an history status with contents
stored in a separated internal frame, to pass contents between frames
with only one server call.

Example code:

Class SharedObject:

package frame.communication.client;

import com.google.gwt.user.client.rpc.IsSerializable;

public class SharedObject implements IsSerializable {

private String name;

private String surname;

SharedObject() {
}

public SharedObject(String name, String surname) {
setName(name);
setSurname(surname);
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSurname() {
return surname;
}

public void setSurname(String surname) {
this.surname = surname;
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((surname == null) ? 0 : surname.hashCode
());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
SharedObject other = (SharedObject) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (surname == null) {
if (other.surname != null)
return false;
} else if (!surname.equals(other.surname))
return false;
return true;
}

}


Class FrameCommunication:

package frame.communication.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.rpc.SerializationException;
import com.google.gwt.user.client.rpc.SerializationStreamFactory;
import com.google.gwt.user.client.rpc.SerializationStreamWriter;

public class FrameCommunication implements EntryPoint {

public void onModuleLoad() {
SharedObject sharedObject = new SharedObject("John", "Doe");

try {
String encodedRequest = clientSerialization(sharedObject);
decodeClientSerialization(sharedObject, encodedRequest);
} catch (SerializationException e) {
Window.alert(e.getMessage());
}
}

public String clientSerialization(SharedObject sharedObject)
throws SerializationException {
SerializationStreamFactory factory = GWT
.create(SharedObjectService.class);
SerializationStreamWriter writer = factory.createStreamWriter();
writer.writeString(SharedObject.class.getName());
writer.writeObject(sharedObject);
return writer.toString();
}

public void decodeClientSerialization(final SharedObject
sharedObject,
String encodedRequest) {
SharedObjectService.Util.getInstance().decode(encodedRequest,
new AsyncCallback<SharedObject>() {
public void onFailure(Throwable caught) {
Window.alert(caught.getMessage());
}

public void onSuccess(SharedObject result) {
boolean sameObject = sharedObject.equals(result);
Window.alert("Successful: " + sameObject);
}
});
}

}


Class SharedService:

package frame.communication.client;

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

public interface SharedObjectService extends RemoteService {

public static final String SERVICE_URI = "SharedObjectService";

public static class Util {

public static SharedObjectServiceAsync getInstance() {

SharedObjectServiceAsync instance = (SharedObjectServiceAsync) GWT
.create(SharedObjectService.class);
ServiceDefTarget target = (ServiceDefTarget) instance;
target.setServiceEntryPoint(GWT.getModuleBaseURL() + SERVICE_URI);
return instance;
}
}

public SharedObject decode(String encoded)
throws SerializationDecodeException;
}

Class SharedServiceImpl:

package frame.communication.server;

import com.google.gwt.user.client.rpc.SerializationException;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import
com.google.gwt.user.server.rpc.impl.ServerSerializationStreamReader;

import frame.communication.client.SerializationDecodeException;
import frame.communication.client.SharedObject;
import frame.communication.client.SharedObjectService;

public class SharedObjectServiceImpl extends RemoteServiceServlet
implements
SharedObjectService {

public SharedObject decode(String encodedRequest)
throws SerializationDecodeException {
ClassLoader classLoader = Thread.currentThread()
.getContextClassLoader();

ServerSerializationStreamReader streamReader = new
ServerSerializationStreamReader(
classLoader, null);

try {
streamReader.prepareToRead(encodedRequest);
String className = (String) streamReader
.deserializeValue(String.class);
return (SharedObject) streamReader.deserializeValue(Class
.forName(className));
} catch (SerializationException e) {
throw new SerializationDecodeException(e.getMessage());
} catch (ClassCastException ccExc) {
throw new SerializationDecodeException(ccExc.getMessage());
} catch (ClassNotFoundException e) {
throw new SerializationDecodeException(e.getMessage());
}
}

}