Community

Home Community

What is GraniteDS? – A Technical Overview.

A Powerful Application Client Container

GraniteDS is a set of libraries and tools that allow you to develop your client application very much like if it was running on your server.

You basically don’t need to care about how your end users authentify, how your application calls remote services or how your data are sent, retrieved and merged with existing values: GraniteDS brings a high level and security aware Java EE API to the client-side and lets you focus on the most important part of your application, its business logic.

A Cross Client Framework

GraniteDS lets you create your application with your favorite client framework:

Whichever your choice is, you will get the same API on the client-side and you will be able to leverage the most advanced features of your Java EE server: authentication and secured access, dependency injection, type-safe remote calls, transparent lazy-loading, bean validation, etc.

A Cross Server Framework

GraniteDS lets you leverage all major JavaEE technologies, transparently:

  • Application Servers: Tomcat, Jetty, JBoss, GlassFish, WebLogic and WebSphere.
  • Component Frameworks: Spring, EJB, CDI, JBoss Seam.
  • JPA Engines: Hibernate, EclipseLink, OpenJPA and DataNucleus.
  • JMS Servers: Apache ActiveMQ, HornetQ and all other JMS compliant servers.

Your client application will never need to know what server technologies you are actually using, unless you need to use an advanced feature which is specific to your chosen server setup.

A Cross Device Framework

GraniteDS lets you create feature rich applications for the vast majority of connected platforms:

  • Desktop applications: Flex/Air (Windows, MacOSX) - JavaFX (Windows, MacOSX),
  • Mobile applications: Flex/Air (iOS, Android, Blackberry) – Android (native API),
  • Web Browser applications: Flex (Windows, MacOSX) - JavaFX (Windows, MacOSX).

The same high-level and cross-framework API can be used with all these devices.

Non-Blocking Server Calls

Server calls through GraniteDS never block, your application gives a smooth user experience.

GraniteDS provides a server API which is by default asynchronous: results are available through event handlers and your application’s GUI never freezes.

Moreover, as soon as your client application gets a result, it is merged in a global context where your UI data bindings are pointing to: you don’t need to do anything to refresh displayed data, they are transparently updated as soon as something new is available.

Fast and Compact Serialization Formats

GraniteDS provides two fast and compact serialization formats, specifically designed for Java and Flex applications:

  • AMF (Action Message Format): a binary serialization format for Flex/Air applications.
  • JMF (Java Message Format): a binary serialization format, inspired by AMF but even more compact, designed for Java, JavaFX and Android applications.

These two formats are used for the communication between your Java EE server and your client application, and greatly reduce bandwidth usage and serialization time. They both deal correctly with complex data graphs, including circular references.

Real-Time Messaging

GraniteDS lets you create collaborative applications where concurrent modifications are automatically made visible for all connected users.

Real-time messaging is based, at your convenience, on the following technologies:

  • Comet (Asynchronous Servlet): long-polling, available for all application servers and standardized through the Servlet 3.0 specification.
  • WebSocket: a newer, lighter and faster implementation of real-time messaging, available in the last versions of all major application servers and web browsers.
  • UDP (User Datagram Protocol): the lightest and fastest real-messaging implementation, suitable when getting the last available data is more important than getting all data.

You can even mix these different kinds of channels in the same application.

Code Generation Tools

With the help of our code generation tools, your entire server-side data model and services are replicated client-side:

  • Generated persistent classes on the client-side retain the state of their JPA counter-parts and allow transparent initialization of lazy-loaded properties.
  • Generated service classes allow strong type checking at compilation time and event-driven result handling.

All generated classes, either entities or services, are made independent from their server-side dependencies: you can use the same client-side generated code with different server-side frameworks (eg. Hibernate or OpenJPA, Spring or EJB).

— “I’d like to see it in action”

Check our Getting Started Section

— “I’d like to know even more”

Check our Extensive Documentation