Welcome!

Victor Rasputnis

Subscribe to Victor Rasputnis: eMailAlertsEmail Alerts
Get Victor Rasputnis via: homepageHomepage mobileMobile rssRSS facebookFacebook twitterTwitter linkedinLinkedIn


Related Topics: Java EE Journal, Java Developer Magazine

J2EE Journal: Article

Multi-Tier Application Development with Adobe Flex

A Complete Application with RPC Communications and JMS

This excerpt describes the process of creating a complete Flex-Java distributed application. Upgrading Flex applications to Java Enterprise Edition applications is done with Flex Data Services. FDS provides transparent access to POJO, EJBs, and JMS and comes with adapters for frameworks like Spring and Hibernate.

These powerful capabilities come free for a single-CPU server, otherwise see your local Adobe dealer. Flex can also invoke any SOAP Web Service or send an HTTP request to any URL via Web Services and HTTPService components. Here we will illustrate Flex controls, HTTPService, RemoteObject, and Consumer via two versions of a stock portfolio application. The first version will show communications between Flash and a plain old Java object (POJO) using Flex remoting. We'll also explain how to use the HTTPService to read the RSS news feed. In the other version we'll add the stock (aka security) price feed using Flex Messaging and the Java Messaging Service (JMS). While explaining the FDS capabilities, we will also walk you through a typical design with Flex containers.

Designing a Stock Portfolio Application
Our goal is to create a Web application that will receive and display a feed containing security prices and the latest financial news as in Figures 1 and 2. This section contains a sort of functional specification of such an application.
We'll populate the top portion of the screen with the stocks included in the user's portfolio. For simplicity's sake, we'll store the user's portfolio in the XML file as in Listing 1.

When the user clicks on a row with a particular stock (i.e., ADBE as in Figure 1), it will populate the lower data grid with the headlines related to the selected stock. The news should be coming from http://finance.yahoo.com/rss/headline. The column Link will contain the URL of the news, and when the user clicks on the link, a new browser window pops up, displaying the selected news article.

The top of the screen contains the toggle buttons Show Grid/Show Chart. When the Show Grid option is selected, the user will see the screen as in Figure 1, and when Show Chart is selected, the top data grid will be replaced with the pie chart (see Figure 2), preserving the same functionality (clicking on the pie slice repopulates the news headlines according to the selected security). The market data is refreshed on the screen every second or so.

The first version of the application will query the server POJO that generates random numbers. Later in this excerpt, we'll subscribe to a JMS topic and consume a real-time data feed from an external Java application.

In this application we'll use the basic MXML and ActionScript from the first chapters of this book. We assume that the reader has a basic knowledge of Java syntax. We've included mini-references on the Java Naming and Directory Interface and JMS. So let's roll up our sleeves...

Adding a Data Grid
We'll start by adding the top grid displaying the stock portfolio. The Flex dataGrid component is a natural choice for data that can be presented as rows and columns. MXML is a great tool for modularizing development. The name of the new .mxml file automatically becomes the name of a new tag that can be reused in other files. For example, the code in Listing 2 assumes that there is an MXML file named PortfolioView1.mxml (in reality it can also be an ActionScript file named PortfolioView1.as or any other file that is assigned to this tag via the component library manifest).

In case of a default namespace (xmlns="*"), our PortfolioView1.mxml from Listing 3 will be co-located in the same directory with the application file portfolio.mxml.
Let's discuss the design of PortfolioView1. It contains DataGrid portfolioGrid in a Flex Panel with the title "Portfolio." XML from Listing 1 is loaded into the portfolioModel e4x object. The list of securities from that file is fed into portfolioGrid via a binding expression {portfolioModel.security}. This expression returns an XMLList of all nodes named "security" that are direct children of the root node (see Listing 3).

Even if we won't add any more code, isn't it impressive that it takes only a dozen lines of code to read the XML file, parse it, and display it in a grid shown in Figure 3? But this application has a static nature: it does not connect to any price quote feed. In other words, you would always see $33.38 as the price for Microsoft, and $82.15 for IBM.

In Listing 3, the curly braces surrounding the expression indicate that this expression is being used as a source in data binding. It is crucial for Flex programming to fully understand the strengths and weaknesses of binding. Binding is based on event listeners automatically generated by the Flex compiler as a response to declarative binding annotations. To initiate binding generation, developers use a combination of curly braces, mx:Binding tags, and [Bindable] metadata directives. (Refer to the Adobe Flex manual for more detail.)

Next, we need to periodically connect to the server for new prices and update the Price and Value columns. So let's use a special Flex component called RemoteObject:

<mx:RemoteObject id="freshQuotes" destination="Portfolio"...> .

The RemoteObject component allows calling methods of a specified remote POJO, which is configured on the server as a destination Portfolio in a special XML file. We'd like to emphasize that Flex transparently calls Java from ActionScript.
The client needs to know the name of the destination and the method to call, for example, getQuotes(). All the dirty work of data marshaling between ActionScript and Java is done for you by the Flex framework. If, for example, a Java method returns an object of the StockQuoteDTO.java type, Flex de-serializes the Java object and builds its ActionScript peer on the client. However, for performance reasons, it's recommended that you create the peer ActionScript class and register it with the framework. Please note that all RPC communications, including RemoteObject, are asynchronous. In other words, we don't exactly call a remote method, but rather send a message to the server, requesting a call of the specific Java method. Not only is the client's request(s) executed asynchronously, but even sending to the server is done asynchronously. If you need to do multiple RemoteObject invocations in your script, Flex will batch them together and send in the end of the script execution.

The results of remote invocations are returned via events. RemoteObject provides the result event for success or fault for failures. You should write the corresponding handler functions. Flex will call these methods, supplying an Event object as a parameter. It's your responsibility to get the information from the event and act accordingly. Friendly advice: you will save yourself hours of time if you supply a fault handler.

In the next code snippet we set concurrency to last, because if Flex decides to batch the outgoing requests, we do not want to send out more then one request in a batch; if a user clicks on the screen sending more than one request in quick succession, the last request will suppress all previous ones. Similarly, when the results are coming back, we are interested only in the one we sent last (see Listing 4).

The tag <mx:RemoteObject> allows using result and fault handling on both the object and method levels. The method settings will take precedence over the RemoteObject's ones. For server-side support, you have to download and install Flex Data Services 2 Express Edition (www.adobe.com/products/flex/), and deploy it as a Web application in the J2EE server of your choice, for example, in Tomcat. FDS comes with a set of XML files, which you will use to configure your server-side objects.

To register a POJO class with a Flex client we need to update the configuration file on the server side. This lets you hide details of the service provider (i.e., actual Java class names) by specifying so-called destinations where you specify access constraints, etc. The following section in Listing 5 has to be added to the remoting-config.xml file.

Clients won't know that the actual name of our POJO is com.theriabook.ro.Portfolio, but they'll be able to refer to it by the nickname Portfolio. Flex looks for classes specified in destination mappings on the Web Application classpath including JARs inside WEB-INF/lib and classes under WEB-INF/classes. The Java class Portfolio.java (see Listing 6) is a simple random number generator simulating market-like real-time price changes for several hard-coded securities.

The StockQuoteDTO.Java (see Listing 7) contains the last price of a particular stock. However, the client can really benefit from knowledge of the structure and the datatypes of the returned DTOs. Listing 8 shows the ActionScript's counterpart for the StockQuoteDTO.java object. While Flex does not need this definition in order to deserialize the Java object that includes member variables of standard types (by default it creates a dynamic object and adds the required properties of the Java object that's being deserialized), it does help performance (since the deserialized object is immediately allocated in memory), ensures the output datatypes, and enforces the type conversion.

More Stories By Victor Rasputnis

Dr. Victor Rasputnis is a Managing Principal of Farata Systems. He's responsible for providing architectural design, implementation management and mentoring to companies migrating to XML Internet technologies. He holds a PhD in computer science from the Moscow Institute of Robotics. You can reach him at vrasputnis@faratasystems.com

More Stories By Yakov Fain

Yakov Fain is a Java Champion and a co-founder of the IT consultancy Farata Systems and the product company SuranceBay. He wrote a thousand blogs (http://yakovfain.com) and several books about software development. Yakov authored and co-authored such books as "Angular 2 Development with TypeScript", "Java 24-Hour Trainer", and "Enterprise Web Development". His Twitter tag is @yfain

More Stories By Anatole Tartakovsky

Anatole Tartakovsky is a Managing Principal of Farata Systems. He's responsible for creation of frameworks and reusable components. Anatole authored number of books and articles on AJAX, XML, Internet and client-server technologies. He holds an MS in mathematics. You can reach him at atartakovsky@faratasystems.com

Comments (0)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.