Getting Started with Cairngorm – Part 1

Posted by David Tucker in Cairngorm, FlexOct 7th, 2007 | 104 responses

I spoke about Cairngorm 2.2 in the Flex Bootcamp at Max this week. Many people were interested in Cairngorm, but I only had about 10 minutes to explain the basics of Cairngorm. I guess the easiest way to assist these people is to do a quick blog series on the benefits of Cairngorm. This series will combine articles with "code-along" videos.

Disclaimer: I do not claim the be "the expert" on Cairngorm - I am far from it. However, I have used Cairngorm on several large projects (both at Georgia Tech and in my own business). I am certainly open to corrections if you see that I have made an error on this project. If you want "the experts" check out: Steven Webster, Alistair McLeod, Alex Uhlmann, and Peter Martin.

Note: The guys at Adobe Consulting (that developed Cairngorm) are currently investigating some new things with the framework as a whole. It is possible (actually probable) that some of these things will change in the future. One of the very specific areas of change is the Model Locator.

Part 1 – Getting Started By Using a Model Locator

The Model Locator pattern is used in Cairngorm, but you don't have to have a full Cairngorm Implementation to use the pattern. First, let's cover what benefits that you get from using a Model Locator.

A Model Locator is a centralized repository for all of the data that is needed across your application. Your data will exist inside of a "singleton class". This "class" can only have one instance of itself. Why is this important? Let me give you an example.

We have great mini-notepads at work that I use to write down data while I work. However, sometimes, I lose a notepad – get a new one, and then find the old one. After both have been heavily used – it is really hard to find out which notepad I used to write down a piece of information from one week ago. That is a simple example – but imagine if I had 20 notepads? This could get crazy.

In the same way you could have a "class" that gets "instantiated" 20 times within your application (even if you don't mean for it to). The easiest way to eliminate this problem is to use a "singleton". A singleton is a class that is never "created" in the traditional way. It has one main rule – no more than one of itself can exist at any point in time. How does it do this? I will show you in the Model Locator example.

PLAIN TEXT
Actionscript:
  1. package net.davidtucker.CairngormSample.model {
  2.  
  3.     import com.adobe.cairngorm.model.IModelLocator;
  4.    
  5.     [Bindable]
  6.     public class ModelLocator implements IModelLocator {
  7.        
  8.         // Single Instance of Our ModelLocator
  9.         private static var instance:ModelLocator;
  10.  
  11.         public function ModelLocator(enforcer:SingletonEnforcer) {
  12.  
  13.         if (enforcer == null) {
  14.                 throw new Error( "You Can Only Have One ModelLocator" );
  15.             }
  16.         }
  17.         
  18.         // Returns the Single Instance
  19.         public static function getInstance() : ModelLocator {
  20.                
  21.             if (instance == null) {
  22.                 instance = new ModelLocator( new SingletonEnforcer );
  23.             }
  24.             return instance;
  25.         }
  26.        
  27.         //DEFINE YOUR VARIABLES HERE       
  28.        
  29.     }
  30. }
  31.  
  32. // Utility Class to Deny Access to Constructor
  33. class SingletonEnforcer {}

This code may look a bit daunting in the beginning, but trust me that it is not as difficult as it may appear. First, we have our package definition and we import some classes. Right now we know that we will need the IModelLocator interface. To use this you will need the Cairngorm SWC that can be found here: Cairngorm. Also note - you could build a model locator without Cairngorm, and I do this frequently on small projects (you just leave out the 'implements IModelLocator' and 'import com.adobe.cairngorm.model.IModelLocator' code from the Model Locator).

PLAIN TEXT
Actionscript:
  1. [Bindable]
  2. public class ModelLocator implements IModelLocator {
  3.        
  4.      // Single Instance of Our ModelLocator
  5.      private static var instance:ModelLocator;

Next we have our class definition. It is important that you use the Bindable metatag directly above your class definition. This will allow all of our variables that we define inside of the Model Locator to be used for binding. We also will go ahead and create one variable. It will be called "instance" and it will be of type ModelLocator. This will be the variable where we will store our one instance of our class. It will also be denoted as a "static" property. If you are not sure what a "static" property is, it's ok - we will discuss that in our next lesson.

PLAIN TEXT
Actionscript:
  1. public function ModelLocator(enforcer:SingletonEnforcer) {
  2.      if (enforcer == null) {
  3.           throw new Error( "You Can Only Have One ModelLocator" );
  4.      }
  5. }

This is followed by the constructor. The constructor takes on argument - "enforcer". You will notice that this "enforcer" has a type of "SingletonEnforcer" which is defined directly after our class. Here is the logic behind that:

  • When you put a class in an Actionscript file below the main class, it is only available to that class. Many people refer to these as "utility classes" (although many people use that term in a much broader scope).
  • If the constructor requires this argument - then only our main class can create an instance of itself, because we do not have access to the "SingletonEnforcer" class - only the main class has this access.
  • We will not access our class in the normal way by using the "new" statement because we can't call the constructor (I will show you how we will do it in a bit).

Once we get inside of the constructor, we have a few lines that make sure things work as planned. The "if" statement ensures that we had a valid "enforcer" passed in. If there wasn't it throws an Error stating that "You Can Have Only One ModelLocator".

PLAIN TEXT
Actionscript:
  1. // Returns the Single Instance
  2. public static function getInstance() : ModelLocator {
  3.      if (instance == null) {
  4.           instance = new ModelLocator( new SingletonEnforcer );
  5.      }
  6.      return instance;
  7. }

The "getInstance" function is how we will access our ModelLocator from our application. This function simply passes back the "instance" of the class. If it doesn't exist yet, it creates it. We can now get the ModelLocator by using the following code:

PLAIN TEXT
Actionscript:
  1. var model:ModelLocator = ModelLocator.getInstance();

Video Example - Getting Started and Building a Contact List


Cairngorm - Part 1 Screenshot

Application Code
Download (418 kB)




104 Responses to “Getting Started with Cairngorm – Part 1”

  1. teaching guides says:
    June 22, 2010 at 3:15 am

    This blog is very informative too. I love blogging when it is for or about something I believe in. I also read news blogs often and find that it makes me feel more intelligent every time I read them. I will definitely put your site on my speed dial.

  2. Deba says:
    July 28, 2010 at 12:46 am

    can anybody tell me how event is dispatched from command to view

  3. Harry says:
    August 1, 2010 at 3:56 pm

    Any plans to write a tutorial for cairngorm 3.
    A modular application.

  4. gesse says:
    August 3, 2010 at 6:18 am

    thanks, I was looking it

    From Brasil

« Older Comments

Leave a Reply