Christophe Herreman http://www.herrodius.com/blog Thoughts from a software developer Wed, 15 Feb 2012 21:29:11 +0000 en hourly 1 http://wordpress.org/?v=3.3.2 GradleFX @ Belgian Flex Usergroup (live blog) http://www.herrodius.com/blog/400 http://www.herrodius.com/blog/400#comments Wed, 15 Feb 2012 16:56:55 +0000 Christophe http://www.herrodius.com/blog/?p=400 Yennick Trevels is speaking about GradleFX this evening. The session starts at 19:00 CET. Check back here for updates and feel free to ask questions in the comments. Please use the #beflug hashtag when tweeting about this event.

GradleFX

What is GradleFX

From the website: “GradleFx is a Gradle plugin for building Flex and Actionscript applications. It provides a set of useful tasks that will make building your project a breeze. All the build logic is encapsulated by the plugin and all you need to do is some configuration. Because GradleFx uses the convention-over-configuration principle it has a set of sensible defaults for most configuration properties, so you only need to specify those if you want to deviate from the convention.”

More info: http://gradlefx.github.com/

What is Gradle

From the website: “Gradle is build automation evolved. Gradle can automate the building, testing, publishing, deployment and more of software packages or other types of projects such as generated static websites, generated documentation or indeed anything else.

Gradle combines the power and flexibility of Ant with the dependency management and conventions of Maven into a more effective way to build. Powered by a Groovy DSL and packed with innovation, Gradle provides a declarative way to describe all kinds of builds through sensible defaults. Gradle is quickly becoming the build system of choice for many open source projects, leading edge enterprises and legacy automation challenges.”

More info: http://gradle.org/

Session notes (live)

19:20 Here we go! About 15 people in the room.

19:25 Yennick explains Gradle before diving into GradleFX. Show of hands of Ant and Maven users. Most have used both. Gradle combines the best of both worlds Yennick states.

Gradle has built-in tasks for compiling and testing etc, but you can create your own tasks as well. Everything is written in Groovy. Gradle uses Configuration Injection instead of configuration inheritance like Maven for subprojects.

19:30 Yennick shows how to create a simple task in Gradle and how you can configure existing tasks. Executing a task: command line > “gradle {taskName}”

19:35 Example of a custom task class in Groovy. You can extend DefaultTask and provide custom task logic.

Default properties in the build scripts allow you to have small build scripts if you use the conventions.

Remote repositories can be used from Ivy and Maven repositories. You can add mavenCentral(), mavenLocal(), or a custom repository in the “repositories” section.

19:40 Gradle has a 3-phase build: initialization, configuration, execution.

You can use project.afterEvaluate to add extra tasks or properties after the configuration is read. This allows you to add certain tasks conditionally, e.g. add package task only if the project is an AIR application.

ant.java allows you to execute Ant code from Gradle. You can use ant.properties to read Ant defined properties.

19:45 Maven support in Gradle: you can locally install artifacts to your Maven repository.

Gradle Wrapper is a shell script that run Gradle even if you don’t have Gradle installed. You can specify the Gradle version to make sure people build your project with the correct Gradle version. Use “gradlew” to execute.

19:50 Now to GradleFX. Adds tasks to compile SWF, SWC and AIR, running unit tests and generating HTML wrappers.

Tasks: clean, compile, package, copyResources, publish, createHtmlWrapper, test

19:55 Setup: specify FLEX_HOME environment variable or set the flexHome convention property.

The GradleFX dependency is org.gradlefx.gradlefx, currently version 0.4.1

20:00 You can also generate AIR descriptor files and certificates in PKCS12 format, a password is required.

FlexUnit support: specify the FLEXUNIT_HOME and the FLASH_PLAYER_EXE environment variable.

20:05 Taking a short break. Demo time when we return.

20:25 Demo time.


]]> http://www.herrodius.com/blog/400/feed 0 Introducing AS3Commons AOP http://www.herrodius.com/blog/382 http://www.herrodius.com/blog/382#comments Thu, 15 Sep 2011 21:50:30 +0000 Christophe http://www.herrodius.com/blog/?p=382 The AS3Commons AOP library offers a core API with functionality to implement Aspect Oriented Programming (AOP) concepts in your application or framework. The library uses standard API terminology so that developers who are already familiar with AOP should feel immediately comfortable.

What is AOP?

For those new to AOP, here is a short explanation of the general idea. (If you are already familiar with AOP concepts, you might want to skip this part and go directly to the examples).

The basic idea behind AOP is that an application can be broken down into functional parts that can be conditionally applied to existing code. A classic example is logging, where debug information about certain methods is written to the console in order to get runtime information about the execution of the code. One approach might be to add log statements at the beginning and the end of the methods that you would like to debug. This is quite a tedious task as you need to manually add code to several places. If you ever wanted to get rid of the log statements, you would have to remove the log statements again. With AOP, you can write the logging code in a separate class and then use that class as an Advice on the class that you want to debug. You can then easily reuse the logging code on other methods of other classes.

Terminology

  • Aspect: the general concept of a cross-cutting concern. Logging, Error Handling, Method Run-Time Monitoring are useful examples.
  • Advice: an extra piece of code that needs to be applied. E.g. writing a log statement to the console.
  • Pointcut: a rule about when an Advice should be applied. For instance: all public methods of a class, all methods starting with "load", all methods that take a String parameter, ...
  • Advisor: the combination of an Advice and a Pointcut. This term is not general AOP vocabulary. It was introduced in the Spring AOP framework and is also used in AS3Commons AOP.
  • Joinpoint: a single point in the execution of the code where Advice is applied because the rule of a Pointcut has been satisfied.

Types of Advice

Advice comes in different forms, depending on what and when you want to intercept. The general types are listed below and can be applied to a Constructor, a Method or an Accessor (Getter/Setter):

  • Before: executes before the invocation
  • After: executes after the invocation
  • After Throwing: executes after the invocation threw an error
  • After Returning: executes after normal invocation (when no error was thrown)
  • Around: combines all of the above

The AS3Commons AOP library contains interfaces for all of these kinds of advice. This makes it fairly easy to implement specific advice. Interceptors can also be created that give the developer more control over the invocation than the basic advice interfaces.

How does this work?

Applying Advice to existing code is done at run-time. For this, we create a typed-proxy (also at run-time) of a class or instance that is basically a decorator (or wrapper) around the original class or object that we created. A client then works with the proxy object instead of the original object, which is completely transparent to the caller. Calls to the proxy object are then redirected to the inner (original) object during which extra logic can be executed.

Note: Creating typed-proxies at run-time is made possible by the AS3Commons-Bytecode library.

Example

Consider the following MessageWriter class, which takes an optional message as a constructor argument and has a method to write the message to the console.

PLAIN TEXT
Actionscript:
  1. public class MessageWriter {
  2.  
  3.   private var _message:String;
  4.  
  5.   public function MessageWriter(message:String = "") {
  6.     _message = message;
  7.   }
  8.  
  9.   public function writeMessage():void {
  10.     trace("Message: '" + _message + "'");
  11.   }
  12.  
  13. }

We can now create an advice that writes an extra message to the console whenever the writeMessage() method is called. This type of advice is "method before" advice, for which the IMethodBeforeAdvice interface can be implemented.

PLAIN TEXT
Actionscript:
  1. public class MethodTracerAdvice implements IMethodBeforeAdvice {
  2.  
  3.   public function MethodTracer() {
  4.   }
  5.  
  6.   public function beforeMethod(method:Method, args:Array, target:*):void {
  7.     trace("* before '" + method.name + "'");
  8.   }
  9.  
  10. }

We can now create a simple application where a proxy is created for the MessageWriter class and the MethodTracerAdvice is applied.

PLAIN TEXT
Actionscript:
  1. var factory:AOPProxyFactory = new AOPProxyFactory();   
  2. factory.target = MessageWriter;
  3. factory.addAdvice(new MethodTracerAdvice());
  4.  
  5. var handler:Function = function(event:OperationEvent):void {
  6.   var messageWriter:MessageWriter = factory.getProxy(["Hello World!"]);
  7.   messageWriter.writeMessage();
  8. };
  9.  
  10. var operation:IOperation = factory.load();
  11. operation.addCompleteListener(handler);

The console output would be as follows:

PLAIN TEXT
Actionscript:
  1. * before 'writeMessage'
  2. Message: 'Hello World!'

Notice the following things:

  • The target of the AOPProxyFactory is a class. For now, only classes can be proxied but it will also be possible to proxy existing instances.
  • The MethodTracerAdvice class implements the IMethodBeforeAdvice interface. This allows the framework to know when the advice must be executed, namely before the method invocation.
  • There is an asynchronous step in loading the proxy factory, after which the proxy can be requested. If you want to create proxies for more classes, consider using the AOPBatchProxyFactory instead. Note that even with the AOPProxyFactory, you can get multiple instances of a proxy.
  • You can pass constructor arguments to the proxy factory that will be used when creating the proxy. Although not shown in this example, it is possible to intercept and change the constructor arguments using an IConstructorBeforeAdvice.

Example with Pointcut

The previous example applies the "method before" advice on every method call. If we would add another method to the MessageWriter class, say "writeAnotherMessage", then the advice would also be invoked on that method. To control when this advice is applied, we can specify a Pointcut that will instruct the framework about when to apply the advice.

Here is the modified MessageWriter class and example.

PLAIN TEXT
Actionscript:
  1. public class MessageWriter {
  2.  
  3.   private var _message:String;
  4.  
  5.   public function MessageWriter(message:String = "") {
  6.     _message = message;
  7.   }
  8.  
  9.   public function writeMessage():void {
  10.     trace("Message: '" + _message + "'");
  11.   }
  12.  
  13.   public function writeAnotherMessage():void {
  14.     trace("Message: 'Konnichiwa!'");
  15.   }
  16.  
  17. }

PLAIN TEXT
Actionscript:
  1. var factory:AOPProxyFactory = new AOPProxyFactory();   
  2. var pointcut:IPointcut = new MethodNameMatchPointcut("writeMessage");
  3. var advice:IAdvice = new MethodTracerAdvice();
  4. factory.addAdvisor(new PointcutAdvisor(pointcut, advice));
  5. factory.target = MessageWriter;
  6.  
  7. var handler:Function = function(event:OperationEvent):void {
  8.   var messageWriter:MessageWriter = factory.getProxy(["Hello World!"]);
  9.   messageWriter.writeMessage();
  10.   messageWriter.writeAnotherMessage();
  11. };
  12.  
  13. var operation:IOperation = factory.load();
  14. operation.addCompleteListener(handler);

The console output would now be as follows:

PLAIN TEXT
Actionscript:
  1. * before 'writeMessage'
  2. Message: 'Hello World!'
  3. Message: 'Konnichiwa!'

Notice the following:

  • A Pointcut is defined to specify that advice should only be applied if the method name is "writeMessage"
  • The Advice and Pointcut are defined separately and then combined with a PointcutAdvisor. This allows us to reuse Pointcuts and Advice in other scenarios.

Other Types of Advice

The examples shown above only show IMethodBeforeAdvice, but there are a lot more advice interfaces that you can use. As mentioned earlier you can also intercept after invocation. This is not limited to method invocations, but you can also do this for Constructors, Getter and Setters. (Note that there are still some glitches in the alpha code concerning these types of advice.)

Conclusion

The current code is not production ready, but is certainly worth a look if you are interested in using AOP in your application or framework. We will release a first alpha release in the coming days with some samples and documentation. You can already check out the code at the AS3Commons Google Code site.

It is still early in the development so the API might change a bit before the official 1.0 release. If you have any ideas or comments about certain implementations, we're always eager to hear from you.

Some of the things on the roadmap that should make it into the release:

  • AspectJ expression language for pointcuts
  • Composite Pointcuts
  • Proxying of existing object instances

Looking forward to hearing your thoughts and enjoy coding!


]]> http://www.herrodius.com/blog/382/feed 11 Programmaticaly sorting a column in an AdvancedDataGrid http://www.herrodius.com/blog/374 http://www.herrodius.com/blog/374#comments Mon, 14 Feb 2011 13:08:26 +0000 Christophe http://www.herrodius.com/blog/?p=374 Here's a quick tip: If you want to sort a column of an AdvancedDataGrid, without having to set up a sort on the dataprovider, you can dispatch an AdvancedDataGridEvent of type AdvancedDataGridEvent.SORT from the datagrid.

This can be useful if you have a custom sort function on a datagrid column and you want the datagrid to be sorted initially without requiring the user to click the column header.

PLAIN TEXT
Actionscript:
  1. var sortEvent:AdvancedDataGridEvent = new AdvancedDataGridEvent(AdvancedDataGridEvent.SORT);
  2. sortEvent.columnIndex = 0; // first column
  3. dataGrid.dispatchEvent(sortEvent);


]]> http://www.herrodius.com/blog/374/feed 0 Spring ActionScript 1.1 Released http://www.herrodius.com/blog/368 http://www.herrodius.com/blog/368#comments Thu, 28 Oct 2010 20:20:09 +0000 Christophe http://www.herrodius.com/blog/?p=368 Dear community,

We're pleased to announce that Spring ActionScript 1.1 is now available.

Download | API Documentation | HTML Docs | Changelog

Besides a series of bugfixes, this release adds the following new features and enhancements:

Component Scanning & Context XML Namespace

Just like XML and MXML configuration, component scanning is a way to configure objects to be used in the application context. This is done by adding [Component] metadata to classes that you want to expose as objects to the container. The container will then scan all classes or the classes in a package you specify and create object definitions for the classes that have Component metadata. This means that you can configure your application with a minimum of XML or MXML configuration.

The newly added "context" namespace currently contains a "component-scan" and a "metadata-config" element. The first one enables component scanning as described above. The "metadata-config" registers common metadata processors and reduces the configuration needed to use these processors.

PLAIN TEXT
XML:
  1. <context:component-scan/>
  2. <context:metadata-config/>

For more info, see the documentation: Component Scanning

Test Framework

The Spring ActionScript integration testing support framework provides several abstract support classes that can simplify writing integration tests. These base test classes provide well defined hooks into the testing framework. Currently, only FlexUnit 4 is supported.

More info can be found in the Test Framework section of the documentation.

PostConstruct, PreDestroy and Inject Metadata

To be in line with industry standards, we added support for the PostConstruct, PreDestroy and Inject metadata.

PostConstruct and PreDestroy are annotations that allow you to call methods in a specific phase in the lifecycle of a component. The Inject metadata is used as an alias for the Autowired metadata.

More Information

For more general information on the Spring ActionScript framework, please see the following links:

Enjoy this release and have fun coding!


]]> http://www.herrodius.com/blog/368/feed 3 Spring ActionScript 1.0 Released http://www.herrodius.com/blog/350 http://www.herrodius.com/blog/350#comments Mon, 13 Sep 2010 06:30:21 +0000 Christophe http://www.herrodius.com/blog/?p=350 Dear community,

We're pleased to announce that Spring ActionScript 1.0 is now available.

Download | API Documentation | HTML Docs | Changelog

Spring ActionScript is an offshoot of the Java Spring Framework written in ActionScript 3.0. The framework contains the following core features:

  • Inversion of Control container, configurable with XML or MXML
  • EventBus supporting loose communication between application components
  • Metadata/annotation processing used for autowiring, event handling, ...
  • Operation, Command and Task API
  • Utilities for abstracting server communication
  • Support for Modules
  • Extensions for the Cairngorm and PureMVC frameworks

The Spring Actionscript team would like to take this opportunity to thank everyone who took the time to report bugs, give suggestions and help out in any other kind of way. Without the dedicated Spring community behind us, the framework would not be where it is today. Thank all of you!

We would also like to thank the nice folks at SpringSource and especially Jeremy Grelle, our project sponsor, and Russel Miles, the Spring Extensions lead. Thanks guys for the support and the opportunity that you gave us.

As always, we're on the look out for new members to join the team. If you are willing to invest some of your spare time to write documentation, sample applications, fix bugs or develop new functionality then please don't hesitate to get in touch with us!

For the full list of changes please check the changelog. If you have any suggestions for new functionality or improvements to the existing code base, then please use JIRA to submit a feature request.

More Information

For more information on the Spring ActionScript framework, please see the following links:

Enjoy this release and have fun coding!


]]> http://www.herrodius.com/blog/350/feed 2 Speaking at the Flex on Java eXchange in London http://www.herrodius.com/blog/344 http://www.herrodius.com/blog/344#comments Thu, 10 Jun 2010 19:06:03 +0000 Christophe http://www.herrodius.com/blog/?p=344

I'll be speaking at the first Flex on Java eXchange in London on June 16th. My talk will be an introduction to the Spring ActionScript framework, along with other presentations on Flex and Java connectivity and enterprise Flex development.

From the Skills Matter website:

Skills Matter is pleased to organise the first Flex on Java eXchange. This Annual Flex and Java conference brings together the leading experts on RIA, Flex, Java, Spring and Grails with London's JEE and web development community, for an informal day of deep technical insight and friendly discussion.

Come learn about Java and Flex integration technologies, MVC frameworks, tools, plugins, best practices and innovative ideas from the creators of those technologies and from the industry's innovators.

In case you're in the neighborhood, be sure to join!

More info: http://skillsmatter.com/event/java-jee/flex-on-java-exchange-2010


]]> http://www.herrodius.com/blog/344/feed 0 Join us at the AUG RIA event http://www.herrodius.com/blog/334 http://www.herrodius.com/blog/334#comments Wed, 28 Apr 2010 11:32:39 +0000 Christophe http://www.herrodius.com/blog/?p=334 Just a quick note to inform you about the Adobe Usergroup RIA event that is happening Thursday, April 29th in Brussels.

Besides some interesting presentations there will also be a panel discussion on Flex frameworks in which I will participate.

Adobe LiveCycle ES2 Mosaic
Marc Meewis, Adobe
Marc will talk about Mosaic, one of the new products in LiveCycle ES2 for creating contextual workspaces using Flex and AIR.
http://www.adobe.com/products/livecycle/mosaic/

Interaction Design
Namahn
Namahn is a Human-Centered Design consultancy agency from Brussels and will talk about the methods and techniques they use when Designing for user interaction.
http://www.namahn.be/

Workflow
Paul Reijnierse, De Monsters
The Monsters from Amsterdam are Interaction Designers and Paul will talk about how they work and the products they develop.
http://www.demonsters.com/

Flex Frameworks Panel Discussion
Christophe Herreman, Roland Zwaga, Steven Peeters, Ferdi Koomen, Jan Van Coppenolle, …
It’s quite a jungle out there if you need to pick a reliable framework for large Flex applications. This panel of community members will discuss architecture, best practices and the tools they use in their everyday projects.

Doors open at 17:30, sessions start at 18:00.

Date: don, 29/04/2010 - 17:30
Location: Hogeschool Universiteit Campus Stormstraat - Stormstraat 2, 1000 Brussel

For more info and reservations see http://www.adobeusergroup.be/events/ria-sig-event


]]> http://www.herrodius.com/blog/334/feed 1 Spring ActionScript: Café Townsend sample application http://www.herrodius.com/blog/307 http://www.herrodius.com/blog/307#comments Sun, 07 Mar 2010 14:42:59 +0000 Christophe http://www.herrodius.com/blog/?p=307 A new Spring ActionScript sample application is now available. This is the Café Townsend application, originally created as a sample application for the Cairngorm framework, that we ported to Spring ActionScript. This should make it easier to compare this implementation with the implementations of some of the other frameworks.

Open the Café Townsend sample.
(Be sure to check the source by right-clicking and choosing "View Source" from the context menu, click here to go to the source directly.)

Download the Flex/Flash Builder project and sources.

Discussion

In what follows, we will discuss the implementation details and motivate certain choices made in this design.

Package Structure

The first thing you might notice is the package structure, that might seem a bit odd at first since it is different from what most frameworks use or prescribe. This example follows the Layered Architecture, described by Eric Evans in the book Domain-Driven Design: Tackling Complexity in the Heart of Software (recommended reading). This architecture makes it easy to detect and apply the different layers of the application and forces us somewhat to have a clean separation of the responsibilities of each layer.

The layered architecture consists of four layers, as shown on the image below:

  • Presentation Layer: contains the user interface (the view component and in this example the presentation models)
  • Application Layer: coordinates the application and forms a communication channel between the UI and the domain
  • Domain Layer: the core of the software. This layer defines the entities and repositories/services that form the business logic of the application. For the most part only the interfaces for the services will be written here. This layer does not contain any implementation details.
  • Infrastructure Layer: provides implementation details for all other layers. Concrete implementations of services will be put here.

Note that it is certainly not needed to structure your application like this. Spring ActionScript does not impose or prescribe this structure, but we certainly think it is useful and wanted to introduce it in this example. Also note that while we have applied this architecture as packages in the same application, you might want to create different swc's or libraries for each of these layers so that they can easily be reused.

Presentation Layer & Presentation Models

This example uses the Presentation Model (PM) as the main presentation pattern for the UI layer. The PM allows us to extract all state and controller logic for the view into a separate class that is view agnostic. A view component contains a reference to its corresponding PM and delegates all UI actions to it. The view component can either instantiate the PM directly, or it can be given one, either by a parent component or by having it "injected" by the Spring ActionScript framework. The process of automatically injecting properties into a (view) component is known as "Autowiring" in Spring ActionScript. Note that since the PM is not a UI component and does not know anything about the view, it can be easily unit tested.

An example of autowiring can be found in the EmployeeLogin.mxml class:

PLAIN TEXT
Actionscript:
  1. [Autowired]
  2. [Bindable]
  3. public var presentationModel:EmployeeLoginPresentationModel;

The PMs used in this example will either delegate directly to the business logic (for instance for loading the employees) or will delegate to the Application Layer (for instance for logging the user out of the application). Here again, there is no strict rule to follow, but you can decide for your own what approach seems the bests.

Note that autowiring is disabled by default. This is because in bigger applications, there might be a significant performance hit when autowiring is used. It is adviced to finetune the autowiring by configuring the autowire processor to include or exclude certain classes. To enable autowiring, simply add the following to the XML configuration:

PLAIN TEXT
XML:
  1. <object id="autowiringStageProcessor" class="org.springextensions.actionscript.stage.DefaultAutowiringStageProcessor"/>

Application Layer

In some cases, the UI will delegate responsibilities to the Application Layer. Since the UI does not know about this layer, it needs a loosely coupled way of communicating with it. The communication channel that provides this capability in Spring ActionScript is the EventBus. It is implemented on top of Flash's event dispatching capability and forms a centralized medium for component and layer interaction.

In the example, the code behind the Logout button will dispatch an event via the EventBus. The application controller listens for this event and will handle it by invoking the logout method on the authentication service. Notice that the application controller takes the authentication service as a constructor argument and that the service is typed to the interface IAuthenticationService. The actual instance is provided in the (XML) configuration, were both the application controller and the authentication service and defined and linked to eachother.

Notice that the application controller does not explicitely listen for the logout event. Instead, it is sufficient to create a method and annotate it with the [EventHandler] metadata. Spring ActionScript will then introspect the controller, pick up all annotated methods and link them automatically with the event received from the EventBus.

Here's what the logout method looks like in the application controller:

PLAIN TEXT
Actionscript:
  1. [EventHandler]
  2. public function logout():void {
  3.   var operation:IOperation = _authenticationService.logout();
  4.   operation.addCompleteListener(logout_completeHandler);
  5. }

Notice that the name of the logout method corresponds to the event being dispatched, namely "logout" (see the ApplicationEvents class for that). You can however also choose the name of this method as you like and specify the name of the event as an attribute of the EventHandler metadata.

As with autowiring, the processing of the EventHandler metadata is not enabled by default. If you want to use this in your application, simply add the following to the XML configuration:

PLAIN TEXT
XML:
  1. <object id="eventHandlerProcessor" class="org.springextensions.actionscript.ioc.factory.config.EventHandlerMetaDataPostProcessor"/>

For more information on the EventBus, please refer to the documentation.

Domain Layer

The domain for this application is extremely simple. All it contains is an Employee entity and an employee service in the form of the IEmployeeService. Except for the actual entities of the domain, this layer does not contain any implementation details for the services it provides, but merely defines the interfaces for those services.

Infrastructure Layer

The infrastructure layer is where the technical details of the applications live. This layer provides the actual implementation of the services found in the other layers. Depending on the different contexts the application needs to be able to run in, you might provide different implementations of the services here. The implementations used in the application can then be defined the a Spring ActionScript Application Context. As an example, think of an application that needs to be able to connect to a set of services using Remote Objects in one scenario and needs to connect to a set of Webservices in another scenario. If we provide both implementations, we can easily reconfigure the application by changing the XML configuration of the application context.

Application Context

Once we have all components, we can bundle them together and prepare them to be used in the application. By doing this, we are configuring the context of the application. In Spring ActionScript this is done by instantiating a FlexXMLApplicationContext (in case you are working with Flex).

The application context in this example is configured using XML, but it could just as easily be configured using an MXML configuration. Both approaches have there pros and cons and you should decide what fits best for you project.

Looking at the Main.mxml class, which is the entry point of the application, we can see that a FlexXMLApplicationContext is instantiated and given the path to the external XML file (application-context.xml) that forms the application context's configuration. Now all we need to do is wait for the context to load before starting the application.

Conclusion

This example contains significantly less code than the original Cairngorm version. This is mainly because Spring ActionScript does not impose any strict architectural rules and provides the developer with plenty of choice for architecting things that best fit the application being developed. What might work in application A might not necessarily work well for application B or C. Being given so much freedom and choice might feel awkward at first, but you will notice that this is actual a good thing and you will benefit greatly from it.

If you have any remarks on this post, please leave them in comments or contact me. Whether they are errors, things that are unclear, or general questions... all feedback is welcome.

General information and document about Spring ActionScript can be found at http://www.springactionscript.org/

Related articles:


]]> http://www.herrodius.com/blog/307/feed 11 Spring ActionScript: The Operation API http://www.herrodius.com/blog/284 http://www.herrodius.com/blog/284#comments Thu, 04 Mar 2010 20:39:50 +0000 Christophe http://www.herrodius.com/blog/?p=284 Introduction

As Flex and Flash developers, we are used to working with asynchronous code. Whenever we load data from a server for instance, we need to wait for the result to come back as we can't just read the result of such a call directly. The way in which we wait for these asynchronous calls to complete differs from API to API. There are events, async tokens, callback functions, ... The fact that there is no unified approach to this, is a core problem in our opinion of Flash. It is not only confusing to developers, but it also prevents us from easily integrating these various techniques and abstracting away their details.

Consider a service that manages User objects by providing basic operations on these entities like create, read, update and delete (CRUD). If you plan on creating an interface for this user service so you can vary the implementation easily, what return type would the methods have?

PLAIN TEXT
Actionscript:
  1. public interface IUserService {
  2.   function addUser(user:User): ? ;
  3.   function deleteUser(user:User): ? ;
  4.   function saveUser(user:User): ? ;
  5.   function loadAllUsers(): ? ;
  6. }

We could either:

  • return nothing and wait for events to be dispatched by the service when its methods have executed: this has the disadvantage that there is no real contract on the method.
  • return nothing and pass in a Responder or result and fault handler callback functions: this has the disadvantage that it blurs the signature of the service method with technical details.
  • return an AsyncToken: this is a stricter contract, but it would tie our code to the Flex framework and it would only work if you create implementations that support AsyncToken

In general, the biggest problem is that there is no standard way of defining an asynchronous execution in the Flash Player.

Operation API

The solution Spring ActionScript provides comes in the form of the Operation API. This is a set of interfaces and classes that enables developers to work with asynchronous processes in a uniform fashion. An "operation" in Spring ActionScript vocabulary is the term used for an asynchronous execution and is defined by the IOperation interface. Once an operation is created, it executes immediately and when it is done executing, it either dispatches a "complete" event or an "error" event.

Going back to our user service, this means that we would type all return types of its (asynchronous) methods to IOperation:

PLAIN TEXT
Actionscript:
  1. public interface IUserService {
  2.   function addUser(user:User):IOperation;
  3.   function deleteUser(user:User):IOperation;
  4.   function saveUser(user:User):IOperation;
  5.   function loadAllUsers():IOperation;
  6. }

Whether you now have an implementation that uses Remote Objects, Webservices, locally loaded XML data, a local SQLite database, ... clients working with the user service should not know and care about implementation details. All that they know is that asynchronous methods return an operation to which they can attach listeners to for dealing with the result or error of the call.

A client calling one of these methods might to something like the following, considering there is a userService of type IUserService:

PLAIN TEXT
Actionscript:
  1. var user:User = new User("John", "Doe");
  2. var operation:IOperation = userService.saveUser(user);
  3. operation.addCompleteListener(saveUser_completeHandler);
  4. operation.addErrorListener(saveUser_errorHandler);
  5.  
  6. function saveUser_completeHandler(event:OperationEvent):void {
  7.   // user was saved
  8.   // event.result contains an optional result of the asynchronous method
  9. }
  10.  
  11. function saveUser_errorHandler(event:OperationEvent):void {
  12.   // user was not saved, since an error occurred
  13.   // event.error contains error information
  14. }

Notice that each operation has the convenience methods "addCompleteListener" and "addErrorListener" for listening to the events dispatched by the operation. The handlers for these events receive an instance of the OperationEvent which contains either the result or the error details.

We have also included some base classes that make it easy to create operations and services. The AbstractOperation class for instance provides a basic implementation of the IOperation interface and implements the event dispatching functionality. You might want to extend this class if you create your own operations.

Here's an example of a custom operation:

PLAIN TEXT
Actionscript:
  1. public class MyOperation extends AbstractOperation {
  2.  
  3.   public function MyOperation() {
  4.     // execute something asynchronously
  5.     // the resultHandler and errorHandler deal with the result of fault
  6.   }
  7.  
  8.   private function resultHandler(aResult:Object):void {
  9.     dispatchCompleteEvent(aResult);
  10.   }
  11.  
  12.   private function errorHandler(anError:Object):void {
  13.     dispatchErrorEvent(anError);
  14.   }
  15.  
  16. }

Notice that we call the "dispatchCompleteEvent" and "dispatchErrorEvent" on either success or failure. We pass in the result or the error we received. These will internally be set on the operation so that clients can request them via the OperationEvent.

The Spring ActionScript framework also contains a series of operation implementations for working with Remote Objects, NetConnections, etc.

Combining Operations into Services

Taking this a step further, we also provide base classes for creating services that consist of operations. Going back to our user service, we might create an implementation that uses RemoteObject by subclassing the RemoteObjectService class. This class provides basic functionality for delegating to the underlying Remote Object. Here's an example:

PLAIN TEXT
Actionscript:
  1. public class UserService extends RemoteObjectService implements IUserService {
  2.  
  3.   public function UserService(remoteObject:RemoteObject) {
  4.     super(remoteObject);
  5.   }
  6.  
  7.   public function addUser(user:User):IOperation {
  8.     return call("addUser", user);
  9.   }
  10.  
  11.   public function deleteUser(user:User):IOperation {
  12.     return call("deleteUser", user);
  13.   }
  14.  
  15.   public function saveUser(user:User):IOperation {
  16.     return call("saveUser", user);
  17.   }
  18.  
  19.   public function loadAllUsers():IOperation {
  20.     return call("loadAllUsers");
  21.   }
  22.  
  23. }

Notice how easy it is to abstract away the use of a remote object and make clients unaware of this by only providing them with the IUserService interface. The "call" method is a very convenient method to forward the call to the remote object, without having to take care of AsyncTokens and Reponders.

Progress Operations

For operations that take longer to execute the IOperation interface has a subinterface called IProgressOperation. This might for instance be the loading of a sound file, a module, etc. Implementations of this interface can let clients know about the progress the operation made by dispatching progress events at certain intervals. When listening for these events, via the "addProgressListener" method, a ProgressOperationEvent is received that contains a "progress" and "total" property.

PLAIN TEXT
Actionscript:
  1. var loadSoundOperation:IProgressOperation = new MyLoadSoundOperation("aSoundFile.mp3");
  2. loadSoundOperation.addProgressListener(loadSoundOperation_progressHandler);
  3.  
  4. function loadSoundOperation_progressHandler(event:ProgressOperationEvent):void {
  5.   trace("Loaded " + event.progress + " of " + event.total + " bytes");
  6. }

Batch Operations

When you are in a scenario where you need to execute several operations and you don't care about the order in which they finish, you might want to use the OperationQueue class. This is an implementation of the IProgressOperation interface that lets you add operations to a queue and receive information about the progress of the complete execution. Since this also is an IOperation, we can listen to the completion of the queue via the "addCompleteListener" method.

PLAIN TEXT
Actionscript:
  1. var queue:OperationQueue = new OperationQueue();
  2.  
  3. // setup event listeners
  4. queue.addCompleteListener(queue_completeHandler);
  5. queue.addProgressListener(queue_progressHandler);
  6.  
  7. // add operations to the queue
  8. queue.addOperation(new AnOperation());
  9. queue.addOperation(new AnotherOperation());
  10. queue.addOperation(new YetAnotherOperation());
  11.  
  12. function queue_completeHandler(event:OperationEvent):void {
  13.   trace("Queue is done executing.");
  14. }
  15.  
  16. function queue_progressHandler(event:ProgressOperationEvent):void {
  17.   trace("Executed " + event.progress + " of " + event.total + " operations");
  18. }

Mocking Operations

During development it is often good to have mock or stub implementations of the services that normally connect to a backend. The main reason is that this provides a way of (unit) testing the use of the services without the backend running. Spring ActionScript provides a class called MockOperation for this purpose. Its constructor takes the following arguments:

  • result: the result returned by the operation
  • delay (optional): the time the operations waits before completing, in milliseconds (default = 1000)
  • returnError (optional): a flag indicating wether or not the operation should return an error at random times (default = false)

If you would mock the user service, you could do this as follows (only one method is implemented):

PLAIN TEXT
Actionscript:
  1. public function loadAllUsers():IOperation {
  2.   var users:ArrayCollection = new TypedCollection(User);
  3.   users.addItem(new User("John", "Doe"));
  4.   users.addItem(new User("Mitch", "Hedberg"));
  5.   return new MockOperation(users);
  6. }

Conclusion

The Operation API provides a neat way of abstracting away technical details and makes it easier to swap implementations without affecting any code. It unifies asynchronous programming for the Flash Player into a simple set of interfaces and base classes. You will also see that it is the basis for other APIs in the Spring ActionScript framework such as the Command and Task API.

For more information on Spring ActionScript, refer to www.springactionscript.org


]]> http://www.herrodius.com/blog/284/feed 2 Spring ActionScript 1.0RC1 Released http://www.herrodius.com/blog/273 http://www.herrodius.com/blog/273#comments Mon, 01 Mar 2010 19:53:52 +0000 Christophe http://www.herrodius.com/blog/?p=273 Dear community,

I'm pleased to announce that the first release candidate for Spring ActionScript 1.0 is now available.

Download | API Documentation | HTML Docs | Changelog

This release is considered feature complete and announces the final stage before moving to a final 1.0 release.

Amongst the many updates and fixes, these are the most important ones:
- Operation API (docs, blog)
- EventBus (docs)
- Task API (docs)
- MXML Configuration (docs)

These changes will be discussed in a couple of follow-up blogposts, so please check back soon for that. In the meantime, please refer to the documentation provided for more information.

I would like to thank all of you who have given us valuable feedback and provided interesting ideas, sent in patches, reported bugs or helped us out in whatever way possible. Your support has been priceless in the development of this framework and it would not be as rich as it is now without you.

Special thanks go out to Martino for mastering the Maven build system and fixing a lot of the problems that stopped us from releasing earlier, and to Roland who has written 99,9% of the AWESOME documentation and took a natural lead in the development of 1.0RC1. You guys rock!

Enjoy this release and have fun coding!

Spring ActionScript 1.0RC1 Changelog

  • fixed constructor-arg type attribute was not declared in spring-actionscript-objects-1.0.xsd.

    config reference link

  • added unregisterStageProcessor() method to the IStageProcessorRegistry interface.

    ASDoc link

  • added DefaultFlexAutowireProcessor that handles binding using the [Autowired(name="objectName",property="property.chain")] metadata.

    documentation link

  • added PureMVC documentation section.

    puremvc documentation link

  • added autowiring support for injecting external property values using [Autowired(externalProperty="propertyName")].

    documentation link

  • added parent context support to IObjectFactory interface and AbstractObjectFactory implementation.

    documentation link

  • added skip-postprocessor and skip-metadata support for ObjectDefinition.

    skip-metadata link

    skip-postprocessor link

  • added name and value attribute support to the property XML element, for defining external properties directly in the configuration instead of an external properties file.

    docs link

  • added parent properties support to XMLObjectFactory.

    docs link

  • added IStageProcessorRegistry interface and FlexStageProcessorRegistry implementation to support stage wiring in a multi-module situation (Thanks to Arnoud for helping debug this).

    docs link

  • added extra functionality to the CairngormFrontController that enables to add commands that are being created by the application context (basically using the context as a commandFactory).

    cairngorm docs link

  • renamed SASCairngormEvent to SASCairngormModuleEvent.

    cairngorm docs link

  • ObjectUtils no longer has a dependency on the Flex framework.
  • added core.* package containing the Operation API.

    operation docs link

  • added core.event.* package containing the EventBus classes.

    eventbus docs link

  • added EventHandlerMetaDataPostProcessor for automatic handling of EventBus events.

    eventbus docs link

  • added parallel or sequencential execution to CompositeCommand class.

    operation docs link

  • added core.task.* package.

    operation docs link

  • added support for property chain retrieval in the FieldRetrievingObjectFactory, for example: Application.application.systemManager.stage can now be retrieved.
  • added support for compound property names in XML config.
  • added support for factory-object in AbstractObjectFactory..

    link

  • added TaskNamespaceHandler for core.task.* package.

    link

  • added createInstance(clazz:Class, constructorArguments:Array = null) method to the IObjectFactory interface to enable a factory to create objects with only annotations and have no object definition.

    link

  • added operation and service for remoting via NetConnection.

    link

  • added support for vector type in XML configuration..

    link

  • Allow adding mx.flash.Event items to EventSequence and facilitate custom trigger calculation. (Thanks Jurgen).
  • Added modulePolicy of type ModulePolicy to FlexStageProcessorRegistry that determines how modules will be handled.
  • Minor documentation fixes. (Thanks Mark).
  • added RouteEventsMetaDataPostProcessor to re-route events from arbitrary objects through the EventBus.

    link

  • Added IApplicationDomainAware and ApplicationDomainAwarePostProcessor to automatically inject the context's application domain in objects that need a reference.
  • Added MethodInvokingFactoryObject to be able to inject method results from other objects.

    link

  • Added util:invoke element as a configuration shortcut for the MethodInvokingFactoryObject.

    link

  • Added support for injecting the application context by using ref="this" in the configuration.

    link

  • Added Maven mojo to generate a flex-config file from an application context (Thanks Ryan).

    link


]]> http://www.herrodius.com/blog/273/feed 5