BlazeDS vs. GraniteDS [closed]

Question

Anyone have any experience evaluating BlazeDS and GraniteDS? I'm curious about which is better at integrating with Spring/Hibernate.

Answer 1

A few side notes on Cliff's comments:

1. GraniteDS was created late 2006, about one year before BlazeDS. It is widely used in demanding production environments and could be at least considered as mature and proven than BlazeDS.
2. GraniteDS messaging was introduced in the 1.0 release (late 2007, few weeks after the first BlazeDS release), it is now very mature and proven as well in demanding production environments.
3. The Flash player exceptions encountered by Cliff are generally caused by failing to compile all generated AS3 classes in the SWF. It is only a matter of using a Flex compiler option that forces the inclusion of these missing classes, which are part of the data graph model and required at deserialization time but not explicitly used in the MXML/AS3 code.
4. Most of the GraniteDS users are coming from BlazeDS/LCDS because these two frameworks are not dealing correctly with complex data models (no or faulty lazy-loading support, bad transaction isolation, etc.)

So, IMHO, unless you are developing a small application with a rather trivial data model, you should go to GraniteDS.

Answer 2

If you are just looking for simple RPC and messaging, I would go with Blaze. The implementations are more mature and better proven, especially with respect to messaging. The messaging in Granite is based on Comet and still pretty new from what I remember. More details below...

Blaze DS is basically a stack that includes RPC and some simple messaging services over HTTP. Integration with Spring is achieved easily using the SpringFactory implementation of FlexFactory: just google the class name and you'll find the code. It doesn't offer any additional support for things Hibernate-related.

Granite DS is growing rapidly in terms of features. It competes more with LCDS than Blaze DS. It includes the ability to parse Hibernate object graphs and deal with lazy proxies in a clean fashion. They also have a tool called "Tide" that creates an analog of a Session in the Flex client to ensure uniqueness of entities. They also have explicit support for services exposed via Spring, EJB3 and Seam. Granite also has a utility for generating AS3 classes from your Java classes (although this not hard to write yourself if you want to).

I worked with Granite about a year ago and had some problems getting it properly parse object graphs; the Flash Player would throw some nasty low-level exceptions. My guess is that the documentation and implementation have matured since so that these are no longer issues. However, I'm still a bit hesitant to recommend it since I ran into issues and switching to Blaze immediately resolved them with no trouble at all.