Agile Enterprise Application Development with Flex

How the Book Is Organized

Even though the chapters in this book don’t have to be read in any particular order, in some places we develop code samples or custom components based on materials presented earlier. Following is a brief book outline, from which you can decide your own starting point:

Chapter 1, Comparing Selected Flex Frameworks

The goal of any framework is to make the process of software development and maintenance easier; however, the ways of achieving this goal differ. Some people prefer working with frameworks that are based on the Model-View-Controller (MVC) pattern, and others like dealing with class libraries of components. Each approach has its pros and cons. In this chapter, you’ll learn how to build the same application using the MVC frameworks Cairngorm 2, Mate, and PureMVC. You’ll also see a different, non-MVC approach for generating the code of a create, read, update, and delete (CRUD) application with components from the open source framework Clear Toolkit.

Chapter 2, Selected Design Patterns

Design patterns suggest solutions to common problems that arise during software development. Flex is a domain-specific tool that’s aimed at creating a rich UI for the Web, and in this chapter we’ll discuss the specifics of selected design patterns when applied to the creation of a UI with Flex, namely:

• Singleton

• Proxy

• Mediator

• Data transfer object

• AsyncToken

• Class factory

Chapter , Building an Enterprise Framework

For the majority of the enterprise applications, development comes down to a few major activities:

• Creating data grids

• Working with forms

• Validating data

In this chapter, you’ll learn how to build components for your enterprise framework that simplify dealing with these activities. We’ll identify some of the issues with Flex 3 SDK components and show you how to extend and enhance them.

Chapter 4, Equipping Enterprise Flex Projects

Typical enterprise RIA projects are developed by mixed teams of client- and server-side developers. This chapter is essentially a laundry list of topics that development managers and team leaders face:

• What skillsets are required for the project

• How to automate creation of build and deployment scripts

• What tools to use for testing

• What continuous integration is

• How to arrange for logging

• Which third-party component libraries might come in handy

Chapter 5, Customizing the Messaging Layer of LCDS or BlazeDS

This chapter starts with a quick example of how to perform the push by making a direct call to a MessageBroker, which comes with LCDS and BlazeDS. It continues with a discussion of the existing world of custom adapters and message channels. You’ll see how to implement a messaging layer with guaranteed message delivery and take care of the proper sequencing of messages using BlazeDS implementation of the Action Message Format (AMF) protocol.

Chapter 6, Open Source Networking Solutions

Open sourcing of Flex framework in general, and its communication protocols and server-side components in particular, play an important role in the adoption of Flex by enterprises. Although large-scale applications are most likely powered by LCDS, smaller ones will find open source server-side components very useful. This chapter will unleash the power of AMF and provide illustrations of how to create a robust platform for development of a modern RIA without paying hefty licensing fees. It will discuss polling and server-side push techniques for client-server communications, as well as how to extend the capabilities of BlazeDS. You’ll also learn how to create a BlazeDS-based solution similar to LCDS’s Data Management Services, where you’ll be creating ChangeObject, Assembler, and DAO classes that will take care of automated data synchronization between Flex clients and Java servers.

Chapter 7, Modules, Libraries, Applications, and Portals

This chapter suggests an approach to creating every Flex application as a modularized portal that loads and communicates with independently built and compiled modules and subapplications. You’ll learn how to work with module loaders and the difference between application, child, and sibling domains. We’ll explain how to properly design module-to-module communications. You’ll get familiar with an original technique for compiling Runtime Shared Libraries (RSLs) that are self-initialized, and finally, you will learn how to integrate existing Flex applications as legacy JEE portals.

Chapter 8, Performance Improvement: Selected Topics

This chapter continues the conversation started in Chapter 7. We’ll talk about actual versus perceived performance of RIA and discuss the use of application preloaders to make the first page of your RIA appear as soon as possible. We’ll also describe how to improve the process of initial loading of RSLs, which serves the same goal: minimizing the amount of code that travels from the server to the client computer. You’ll learn how to build every application as a portal while providing an independent testing environment for multideveloper teams. The chapter ends by focusing on issues that affect the performance of most Flex applications.

Chapter 9, Working with Adobe AIR

Adobe AIR is a cross-platform development environment and runtime that adds an API required for desktop applications, comes with a local database management system (DBMS), and substantially simplifies embedding HTML into RIA by offering a full-featured embedded web browser engine. This chapter starts by covering the basics of AIR development, but quickly turns into a project for a fictitious pharmaceutical company that demonstrates a solution for data synchronization between local and remote databases when the network is not always available but the application must remain operational. This solution works with occasionally connected AIR/BlazeDS as well as AIR/LCDS applications. As a bonus, the sample application also demonstrates how to integrate Google Maps into an AIR application.

Chapter 10, Developing Flex Applications for LiveCycle Enterprise Suite

LiveCycle is an service-oriented architecture (SOA) platform that runs on Java EE application servers, and this chapter is about creating enterprise workflows using this tool. You will learn how to use a web browser–based UI written in Flex to streamline the part of the workflow that requires user interaction. We’ll cover the process of extending LiveCycle with your application-specific services and the creation of complex PDF documents. The larger portion of this chapter explains how to integrate LiveCycle ES functionality with your existing Flex-based applications.

Chapter 11, Printing with Flex

Printing is often one of the most time-consuming tasks in developing Flex enterprise applications. Just using the Flex printing API would require allocation of substantial budget and human resources. In this chapter, we’ll discuss an open source solution for generating PDF documents on the client. This printing functionality will be applied to the sample pharmaceutical application introduced in Chapter 9.

Chapter 12, Model-Driven Development with LCDS ES2

In this chapter, you’ll see how to create a CRUD application in which Flex talks to a remote database via recently released LCDS 3.0. The good part is that no programming is required. You’ll create a data model and the rest of the code will be generated automatically.