LiveCycle Data Services ES — in depth
Creating rich Internet applications (RIAs) requires a level of data integration that goes beyond the traditional request/response model. Providing a richer, more engaging experience often requires more data-intensive interaction and introduces new challenges in managing data between the client and server tiers. Using Adobe® LiveCycle® Data Services ES software, you can build applications that add rich data capabilities—with information flowing between tiers — to enable an ever-increasing array of innovative customer experiences that can be offered through RIAs.
How it works
Message Service
The Message Service provides support for publish and subscribe messaging using standard concepts and terminology. Adobe Flex™ and Ajax clients receive pushed messages from the server by subscribing to one or more topics. When client or server code publishes a message to one of these topics, it is received by all clients who have subscribed to that topic. The management of subscriptions and publishing of messages is performed by a messaging adapter. Adapters are provided for routing messages between Flex clients and between Flex clients and the Java™ Message Service (JMS). You also can write your own message adapter by writing Java code to perform custom message processing or subscription management.
Flex provides two components, Producer and Consumer, you can use to publish and subscribe to a topic. To subscribe to a topic, you use the subscribe method of the Consumer class. When a message is published to a topic you subscribed to, the message event is triggered on the Consumer. You can configure clients to use either real-time channels or channels that retrieve messages from the server using polling. Provide a list of channels to connect to, and the Flex client will use the first channel that succeeds in connecting to the server. The messaging and real-time infrastructure enables you to build collaboration and data push applications in a scalable and reliable manner while preserving the lightweight web deployment model. Application code can be written easily to work without knowledge of the specific protocol being used by a given client.
Data Management Service
The Data Management Service provides an innovative programming model to manage client-server data synchronization. The changes made to the data at the client side are tracked automatically using property change events. When the user is ready to submit these changes, they are sent to a service running in the application server. This service then passes the changes to a server-side adapter, which checks for conflicts and commits the changes. The adapter may be an interface you write to use your existing code, or it may be one of the supplied adapters that work with a standard persistence layer such as SQL or Hibernate. After the changes are committed, they are pushed to any clients looking at the same data.
This system supports complex domain models, on-demand paging of large collections for a fast initial load, loading of referenced objects automatically as they are accessed, and offline caching of data — all in a scalable and robust manner.
RPC service
The Remote Procedure Call (RPC) service is designed for applications in which a call-and-response model is a good choice for accessing external data. The RPC service lets you make asynchronous requests to remote services that process the requests and then return data directly to your Flex application. You can access data through client-side RPC components that include HTTP GET or POST (HTTP services), SOAP (web services), or Java objects (remote object services) using the more efficient AMF3 protocol.
You use RPC components when you want to provide enterprise functionality, such as proxying of service traffic from different domains, client authentication, whitelists of permitted RPC service URL's, server-side logging, localization support, and centralized management of RPC services. LiveCycle Data Services ES lets you use RemoteObject components to access remote Java objects without configuring them as SOAP-compliant web services.
LiveCycle Remoting
The LiveCycle Remoting service is an extension of the RPC service that lets Flex clients call LiveCycle services by making RemoteObject invocations. It supports synchronous and asynchronous service invocation without having to worry about any of the plumbing involved. LiveCycle Remoting performs much faster than web services by using the more efficient AMF3 binary protocol.
RIA-to-PDF file generation
LiveCycle Data Services ES provides the ability for Flex applications to generate PDF documents from predefined templates that include Flex or Flash® based graphical assets, such as charts and graphs or text data. You can use Adobe LiveCycle Designer ES software to create an Adobe XML Data Package (XDP) document that contains Adobe XML Forms Architecture (XFA) templates. The document object model bound to the XFA template is used to design the model that captures data in a Flex client application. The data is sent to a remote object, and the received data is added as an XML input stream to a loaded XDP document for PDF file generation.
Key capabilities
Data synchronization
LiveCycle Data Services ES removes the complexity and potential for error by providing a robust, high-performance data synchronization engine between client and server. It also easily integrates with existing persistence solutions to provide an end-to-end solution.
LiveCycle Remoting
Flex clients can call operations on LiveCycle ES Foundation services without going through the LiveCycle Foundation web services layer. Using the standard LiveCycle Data Services ES remote object feature, Flex developers can call LiveCycle services without having to worry about the plumbing involved—while leveraging a more efficient binary protocol.
RIA-to-PDF file generation
Users can generate template-driven PDF documents that include graphical assets from Flex applications such as graphs and charts. These PDF documents can be used in combination with other LiveCycle services and can be protected to ensure access by only those with authorization.
Data paging
LiveCycle Data Services ES allows for the automatic paging of large data sets, paging of data accessed rather than full query result set, and on-demand paging directly to the database, as long as clients are kept up to date with the latest changes. Data paging speeds application response times and allows developers to focus on core application business logic, instead of worrying about basic data management infrastructure.
Occasionally connected client
LiveCycle Data Services ES automatically handles temporary disconnects, ensuring reliable delivery of data to and from the client application, providing support for the development of offline and occasionally-connected applications running in a browser or on the desktop. LiveCycle Data Services ES will take advantage of the scalable local SQLite database in the Adobe Integrated Runtime (Adobe AIR™) cross-operating-system runtime as a way to store data, synchronize it back to the server, and rationalize any changes or conflicts.
Data push
LiveCycle Data Services ES offers data-push capability, enabling data to be automatically pushed to the client application without polling. This highly scalable capability can push data to thousands of concurrent users, providing up-to-the-second views of critical data such as stock trader applications, live resource monitoring, shop floor automation, and more.
Publish and subscribe messaging
LiveCycle Data Services ES provides a publish/subscribe messaging infrastructure that integrates with existing messaging systems such as JMS and enables messages to be exchanged in real time between browser clients and the LiveCycle Data Services ES server. It lets Flex clients publish and subscribe to message topics with the same reliability, scalability, and overall quality of service as traditional thick-client applications. This allows creation of critical, more-complex applications such as logistics handling, inventory control, stock trading, and more.
Collaboration
LiveCycle Data Services ES frees client applications to concurrently share data with other clients or servers. This model allows new application concepts like "co-browsing" and synchronous collaboration, which allow users to share experiences and work together in real time.
