We still work on some additional tools for easy handling of the framework and to support the developer at his work. I think we need some more time to complete a version that we can give away without any doubts.

Please be patient and give us the extra time to increase the power of the j2flex framework.

One of the main goals for j2flex was to keep things simple. For a default installation this means, that you do not have to code a single line of server side code to persist you date (of course you can do this if you want by using the server side Java API, but basic CRUD functionality is already inplemented for you). So let's see how this works.

j2flex comes as a compiled ActionScript libraray (SWC) that has to be added to the project's build path. The main class you're working with in the client side code is called J2FlexService. To create an instance of the service class in your Flex application you just do:

If you've been working with RemoteObjects or DataServices in Flex before this should look familiar. Actually, j2flex 1.0 requires an existing installation of Adobe's LiveCycle Data Services (LCDS) product so under the hood it uses the same messaging and transport infrastructure as LCDS (i.e. AMF3 over HTTP and/or RTMP).

Next, say we want to fetch a list of products from the database. Lets assume the products are stored inside a virtual table called products in the meta database. A list of objects is typically wrapped by an ArrayCollection in Flex, so just create one (in MXML in this case, could be ActionScript 3 as well, of course):

To display the list of products lets create a DataGrid control and bind it to products ArrayCollection:

Now, the final bits are to send a j2flex SQL statement to j2flex and populate the ArrayCollection. To execute a query you use the getObjects() method of the J2FlexService class. You can also pass in a ListCollectionView instance which will be automatically filled with the data returned by the server:

That's it - Flex will contact the server side J2FlexService class, fetch the data from the meta database and return the data as a list of objects to Flex. The ArrayCollection will update automatically, thus the DataGrid will display the records.

If you want to update existing data this is as simple as picking an object from the ArrayCollection, update properties of the object and finally send the object back to j2flex by calling the updateItem() method on the J2FlexService instance:

To create a new product you simply create a new Object instance (or Product subclass if you use typed Value Objects), set the object type (which is a static ID actually provided by j2flex in the moment you created the server side object definition), populate it with data and persist it:

Deleting objects works exactly the same - just pass the object that should get deleted to the deleteObject() method and you're done.

Important to note here: these operations will only execute successfully, if the current user is allowed to do it - so for every action, by default j2flex checks the effective user's rights against the object rights set. This is true for all read and write operations by default!

These are the basic CRUD operations directly built into j2flex. More details on additional features will be posted soon!

Dirk.

The main concept in j2flex is something called a "meta database", an object-oriented data model stored in a relational database system like MS SQL Server or Oracle. So, how does this compare to a "traditional" approach? For example, imagine you want to build a CRM application with Organizations and Contacts. From a data model point of view a Contact typically stores information like a name, an email address and a birth date. In a traditional database you would probably create a table "contact" with columns like NAME of type VARCHAR and BIRTHDATE of type DATE and so on. The identity (primary key) of the Contact could be an INTEGER and so on. In an object-oriented data model you would not persist everything in one single table but store the different data values in different tables and every table is made to store data of a certain type only. In the above case the NAME and EMAIL columns would be stored in the OBJ_TEXT table (a table which only stores VARCHAR data) and the BIRTHDATE data would get stored in the OBJ_DATE table and so on. So every row in every table only stores single aspects of a whole object. Of course, to re-assemble an object, we need a unique key again. In the world of j2flex every object stores an OBJ_ID and an OBJ_TYPE value. Both of the are numeric and together they a unique primary key to lookup date from the several tables.

This approach allows us to persist pretty complex data definitions very easily and without much hassle, including 1-1, 1-n and n-m relationships. Due to this dynamic persistance schema, new object types (i.e. business entities) can be added to the system pretty easily without modifying the physical database model. Also, it's super-easy to modify existing object definitions. On the other hand, if you already have a full-blown physical database model in place, it's quite easy to make it work with j2flex. All you have to do is to add OBJ_ID and OBJ_TYPE columns to your physical data model.

Now that you know how data gets persisted in j2flex the next question is what to use to query this "meta database"? Well, SQL of course! Probably the best thing in j2flex' core engine is the SQL Parser. This allows you to use pseudo-SQL statements to query the database. Why pseudo? Because it is no "real" SQL. The SQL you send to j2flex is parsed on the server side into real SQL before the data is fetched from the database. Why's that? As said above, when a Contact gets persisted, the real data gets stored in several physical tables. The SQL Parser allows you to query the database as if the Contacts would be stored in a table called CONTACT- This is because when you create a new data type "Contact" a virtual table of that name gets created, think of it as the class name in terms of OOP. So querying all Contacts becomes as simple as

select * from CONTACT

Doesn't sound too complicated, does it? The neat thing is that with j2flex you can send those queries directly from a Flex client to the server. As they are no real SQL queries there's no danger of SQL injections as everything gets handled by the SQL Parser. Also, the SQL Parser only allows SELECT statements, so you cannot call INSERT/UPDATE/DELETE on it. To create, update or delete objects (data) you use a special API which we will see in the next article.

So what's it all about: When we started with Flex 1.0 back in 2004 we realized quickly that although Flex facilitates integrating with Service Oriented Architectures (SOA) of course not every customer is able or willing to create such an infrastructure just for the sake of using Flex. With Flex 2.0 this is even more true - a lot of smaller shops start evaluating Flex 2.0 but then realize that they do not know how to integrate Flex with their data store. Some of them even do not have a dedicated data store in place and say: "Ohh, Flex is soo cool - but how do I connect to a database?"

This is one of the areas where j2flex offers a simple yet powerful solution: j2flex allows Flex beginners to quickly setup a powerful persistence store for Flex applications. With j2flex you can directly read data from and save data your database without too much worrying about how this works - and without writing server side code. It just works. Sounds nice? Well, it really is

But j2flex also offers a solution for integrating a Flex application into an existing J2EE infrastructure - including mapping the physical data model to the Flex world, dedicated authentication and authorization, workflow support and much more.

If that's still not enough, you can easily extend j2flex to meet your needs, either through the Flex/ActionScript 3 or Java API. It conforms to Flex 2 Framework standards, can be used with Cairngorm and gives nice integration with the Data Management Services of LiveCycle Data Services.

This was just a little teaser - I'll be posting more information, samples and resources during the next weeks so stay tuned. Btw, the first public demonstration of j2flex will take place at MAX Barcelona at our booth in the exhibition hall.