Exchanging objects from mobile to server.

Question

Hi,
I'm working in a project that needs to send and receive objects from a mobile client, i know java me does not suport serialization, so, we do not have ObjectOutputStream and ObjectInputStream classes... but, anyone worked in a project with thats requirements? how you pass objects between server and mobile? we are analizing the possibility of make a framework, this one converts a object in the mobile for a xml and the server parse the xml in a new object, we will need to work with aspectj or something like this to intercept the methods and abstract totally de parsing, but this requires time, and we are very close in the project, can someone tell me what to do?
Thank you
André Martins

Answer 1

The HARD WAY:
The thing you are trying is complicated. First of all, a mechanism to write "any" type of object is very complicated. You have to take
care of any type of Class. There is a way of doing this but you have to work many months.
Java offers a mechanism to extract Class information at runtime by using "Class.Class" type. When you serialize an object, you care about internal fields and not
methods, so you have to extract fields information in triplets : (type, fieldName, value). After you extract all these triplets you define a protocol
of writing fields into a byte array with DataOutputStream;
This is the simplest way, but here rises a problem: what if the fields are not primitive values(float, integer, etc..). These
types are indivisible; but a reference to another object is not an indivisible field. So here comes a recursive way of analyze the
class: For every indivisible field you have to apply the same algorithm. You apply this until no more reference types are found.
At the end, the "map" of one Class will look like a tree data structure, where the root is the class type to serialize and the leafs are
primitive types that are indivisible. Intermediary nodes are references(Class types). By doing so you create a map of the entire Class dependencies.
Another problem rises here: what if references are in cycle? This means that the previous algorithm works in infinite loop. To avoid this you have
to create a hash map and add at recursive reference traversal in the hash map objects already mapped. In this case the references between Class types
creates a graph topology and not a tree topology. By adding this hash of already visited and mapped objects you create a spanning tree over the graph and
avoid infinite looping.
After creating the spanning tree, you apply a traversal algorithm(BFS - Breadth First Search) and for every node you write, using the DataOutputStream object,the
triplets.
In order to separate the objects into the byte stream, you have to add "offset information" for every Class type you write, in order to read at the other end the correct instances. For a real example of coding this offsets and "pointers" try to implement from scratch the DNS protocol(application layer protocol used to translate a domain name into IP address).
The EASY WAY
The easy way is to create a finite number of objects that can be serialized. To do this you have to combine two Design Patterns - Abstract Factory and Memento.
The Abstract Factory pattern is used to instantiate a family of objects into an uniform way and context. The Memento pattern is used to save a specific state of one object or group of objects. So, you define an Abstract Factory that creates Mementos from objects you want to serialize. Of course the number of objects(or families) is limited, but sufficient to fit your communication needs. On Sender you create mementos that encapsulate the state of objects and send them to Receiver that uses the same factory type to recreate the original object from the memento, but you have to do it by hand: for every class type you have to "recreate" the original configuration by telling the meaning of the received bytes. Also, the memento object must have a low complexity, so you can code it, and not to be a representation of a tree with 10 levels.