When working with RemoteObjects (ROs) in the Flash Player via a server-side library like BlazeDS, LCDS, or WebORB, there are several simple stumbling blocks that often lead to the case where you receive back untyped, generic ActionScript (AS) Object objects as opposed to the mapping you set up between your AS objects and your Java objects. I’ll note the most common issues quickly and move on to provide additional explanation where necessary.

Common Issues

• Incorrect spelling / mapping of Java class in RemoteClass metadata in AS object: [RemoteClass(alias="fullyQualifiedJavaClass")]
• Incorrect spelling / capitalization of properties.
• Not providing empty constructors in Java object.
• Not using formal getter / setters methods for properties in Java object.
• AS mapped object not compiled into the SWF. This happens when using ArrayCollections and the item isn’t referenced anywhere in the application and thus not compiled into the SWF.

Nonexistent or Incorrect ActionScript Mapping
In order to tell the Flash Player to serialize your Java Data Transfer Objects (DTOs) to your explicit AS objects you’ll need to make sure you include the all important [RemoteClass(alias="fully qualified Java class we're mapping to")] metadata.

The most common culprit here is usually a simple misspelling of the fully qualified Java object in your RemoteClass metadata, but here’s a list of other common things to note before we look at an example:

REQUIRED:

• You must include the metadata [RemoteClass(alias="fullyQualifiedJavaClass")]. Make sure the name of Java object is the fully qualified name.
• The properties you want to map must be public.
• The properties you want to map must be spelled and capitalized exactly the same as they appear in your Java class.
• If your Java object extends another object and you want the properties in the super class also mapped to your AS object, you must either a) create that class in AS and map it to the base Java object or b) add those properties directly into your AS object.
• If your AS object contains complex objects that exist in the Java side and you want that object mapped correctly you’ll need to create that class in AS and map its corresponding Java object.
• If your AS object contains an Array or ArrayCollection that will be populated with objects you expect to be mapped, you’ll need to a) ensure the corresponding AS object is mapped and b) is compiled into the application. A simple trick to ensure that your AS object is compiled into the app is to declare ArrayCollections like so: public var foos:ArrayCollection = new ArrayCollection();Foo; This also helps you and other developers see what kind of AS object is expected in the list like a Java generic. The compiler and player obviously won’t throw errors or complain if the objects aren’t of that type, but from a readability perspective it’s quite helpful.

OPTIONAL/MISNOMER

• You can specify your public properties as either regular, old public properties or using the getter and setter functions.
• The package of your AS object does not need to match the package of your Java object. The aforementioned RemoteClass metadata takes care of that for you.
• You do not need a constructor in your AS object.
• You can have extra, non-mapped properties in your AS object.
• You do not need to implement the same interface as your Java object. In fact, you can use additional, client-side only interfaces to extend your AS object and it will not effect the mapping.
• You do not need to annotate the class with the [Bindable] metadata. It’s often the case where it is because you’re using the object as a doman/model/vo on the client and want other things to bind to it, but it’s not required.
• You can have methods in your AS obj that do not map to methods in your Java object.

package com.webappsolution.myapp.model
{
	[RemoteClass(alias="com.webappsolution.myapp.dto.PersonDTO")]
	public class PersonModel extends FooModel implements IUniqueItem
	{
		public function PersonModel()
		{
			super();
		}

		// mapping using getter ans setter functions for public properties
		// also implements IUniqueItem interface
		private var _id:String;
		public function get id():String
		{
			return _id;
		}
		public function set id(value:String):void
		{
			_id = value;
		}

		public var age:int = 0;
		public var firstName:String = "";
		public var lastName:String = "";
		public var birthDate:Date = new Date();
		public var isBeerDrinker:Boolean = true;
		public var complexObject:ComplexObject = new ComplexObject();

		// put in the references to the types of items we exopect in the collection
		// to ensure that they are compiled into the swf. this also provides a
		// nice readability clue as well to other developers.
		public var foos:ArrayCollection = new ArrayCollection();Foo;

		// not mapped
		public var isDisabled:Boolean;
		protected var uid:int;

		// not mapped
		public function getFullName():String
		{
			return this.firstName + " " + this.lastName;
		}

	}
}

Java Object Issues
There’s a couple quick gotchas here that should be noted when creating Java objects that you wish to map to AS objects, as many of the important issues are covered above in the AS section — I’ll list these quickly followed by a small example.

REQUIRED:

• You must provide an empty constructor.
• You must use formal getters and setters for your properties. You cannot just list out public properties in Java like we do in AS.

OPTIONAL:

• While an empty constructor is required, it’s ok to override it and provide multiple constructors as well.
• You can have extra, non-mapped properties in your Java object.
• You can implement interfaces in your Java object that do not exist in your AS object.
• Considering using the DTO pattern on the Java side to pass objects across the wire as opposed to allowing AS objects to map to domain/entity objects in your Java tier. This can be especially important when using domain/entity objects that are mapped to a database via Hibernate — there are lazy loading issues here that can cause less than fully populated object graphs to come across the wire to your Flex app. Instead, put a service layer in front of your domain object layer that returns DTOs.

package com.webappsolution.myapp.dto;

import ...

public class PersonDTO implements IStuff
{
	private String id;
	private int age;
	private String firstName;
	private String lastName;
	private Date birthDate;
	private boolean isBeerDrinker;
	private ComplexObject complexObject;

	public PersonDTO()
	{
	}
	public PersonDTO(String fName, String lName)
	{
		this.firstName = fName;
		this.lastName = lName;
	}
	public PersonDTO(String fName, String lName, int age)
	{
		this.firstName = fName;
		this.lastName = lName;
		this.age = age;
	}

	public long getId()
	{
		return id;
	}

	public void setId(long id)
	{
		this.id = id;
	}

	public String getFirstName()
	{
		return firstName;
	}

	public void setFirstName(String firstName)
	{
		this.firstName = firstName;
	}

	public String getLastName()
	{
		return lastName;
	}

	public void setLastName(String lastName)
	{
		this.lastName = lastName;
	}

	// omitting the rest of the public getters / setters for brevity, but you'd
	// need one for each property you want to map
}

For more information on RemoteObjects, please visit the Adobe Flex documentation: Using RemoteObject components

Tweet This Post