Für Person A ist es also vollkommen egal, was mit dieser Nachricht gemacht wird und Person B kann total egal sein, wo die Nachricht herkommt. Wichtig ist nur eins: Die Nachricht exisitiert und die Anwendung muss darauf reagieren.

Schritt 1: Versenden von Nachrichten:
Damit ein Objekt Nachrichten versenden kann, muss dem Framework mitgeteilt werden, welche Nachrichten innerhalb der Klasse für die Außenwelt bestimmt sind. Dazu definiert man einfach in einem Metatag die entsprechenden Konstanten.

package  

{

    import flash.events.Event;

    import flash.events.EventDispatcher;



    [ManagedEvents("switchLocale")]

    public class ClassA extends EventDispatcher 

    {

        public function ClassA() 

        {

            //...

        }

        

        public function dispatcher() : void

        {

            dispatchEvent(new Event("switchLocale"));

        }

    }

}

Jetzt leitet parsley alle Events über das MessagingFramework, die in der Klasse dispatcht werden und mit der String-Konstante übereinstimmen. Werden Events dispatcht, die nicht in der Deklaration erwähnt sich, werden sie wie normale Flash-Events behandelt und nicht weiter beachtet. In obigen Beispiel leitet das Framework also das Event “blubb” global weiter, das Event “bla” wird aber nicht weiter beachtet.

Der Lesbarkeit halber sind hier in den Beispielen Strings als Event-Types benutzt. In eigentlichen Anwendungen machen Konstanten vom Typ XYZEvent.HOME natürlich mehr Sinn.

Schritt 2: Empfang von Nachrichten:
Wieder ist zu beachten, dass das Objekt zum Context hinzugefügt wurde – denn ohne Context, keine Verbindungen.

Damit das Event verarbeitet werden kann, muss es vom gleichen Typ sein, der auch in der Funktion angegeben ist. Wird über das Framework ein LoginEvent verschickt und der Handler verarbeitet nur PageEvents, wird die Message ignoriert und nicht an die Funktion übergeben. So wird Typensicherheit sichergestellt.

Beispiel:

package  

{

    import flash.events.Event;



    public class ClassB 

    {

        public function ClassB() 

        {

            //...

        }

        

        [MessageHandler(selector="switchLocale")]

        public function dispatcher(event : Event) : void

        {

            //...

        }

    }

}

Kein Anmelden, einfach ausführen, was gibt es schöneres?

Hier ein einfaches Beispiel:

Ohne parsley:

package

{

  public class OhneParsley

  {

    public var _model : Model;



    public function OhneParsley()

    {

      _model = Model.getInstance();

    }

  }

}

Mit parsley (muss natürlich wieder dem Context hinzugefügt sein):

package

{

  public class MitParsley

  {

    [Inject]

    public var _model : Model;



    public function MitParsley()

    {

    }

  }

}

Spart Zeit, Nerven und verschlankt den Code. Außerdem muss das aktuelle Objekt nicht wissen, wo sich das einzusetzende Objekt befindet, da es von außen injiziert wird. Wie mit einer Spritze. Daher Injection.

Mit [Init] kennzeichnet man Funktionen, die aufgerufen werden sollen, nachdem alle Elemente dem Context hinzugefügt und geladen worden sind. Das hat den Vorteil, dass der Aufruf so lange hinausgezögert wird, bis beispielsweise Sprachvariablen, oder Grafikdaten geladen sind, die zum Funktionsaufruf vorhanden sein müssen. Lästiges Eventlistener registrieren, nachher wieder entfernen und sich darum kümmern, wo der Eventlistener überhaupt registriert werden muss.. fällt alles weg!

Codebeispiel als Ergänzung zum Context aus #1:

Das Objekt wird mittels der Methode aus #1 zum Context hinzugefügt und dann wird anschließend automatisch die init() Methode aufgerufen.

KlasseXYZ.as:

  [Init]

  public function init() : void

  {

    trace("init!");

  }

Metatags funktionieren natürlich ebenfalls in den Klassen, die bereits in der Config instantiiert und mit dem ActionScriptContextBuilder zum Context hinzugefügt wurden.

Auf die gleiche Art und Weise lassen sich die weiteren Funktionen des Frameworks ebenfalls mittels Metatags steuern. Beispiele für Dependency Injection, Messaging und Localisation folgen.

Zuerst zum Verständnis ein paar Infos:
Parsley gibt dem Entwickler keine Struktur vor und wird komplett lose an die Anwendung gekoppelt. Das bedeutet, dass keine vorgegeben Klassen extended werden, sondern man durch das Framework nur Hilfsmittel bekommt, die einem die Entwicklung deutlich vereinfacht.

Anwendung initialisieren:
Damit die einzelnen Komponenten miteinander kommunizieren können und Parsley weiß, dass es sich um deren Verwaltung kümmern muss, läuft die Applikation in einem sogenannten Context. Dieser Context muss entweder über Actionscript, oder über XML initialisiert werden. Ich bevorzuge die Initialisierung über Actionscript und füge die Lokalisierung nachträglich mittels XML hinzu, doch dazu ein anderes mal.

Initialisierung über Actionscript mit dem ActionScriptContextBuilder:

Config.as:

package

{

  public class Config

  {

    public var main : MainView = new MainView;

  }

}

Main.as:

package

{

  import org.spicefactory.parsley.asconfig.ActionScriptContextBuilder;

  import org.spicefactory.parsley.core.context.Context;



  import flash.display.Sprite;



  public class Main extends Sprite

  {

    private var _mainContext : Context;



    public function Main()

    {

      _mainContext = ActionScriptContextBuilder.build(Config);



      addChild(_mainContext.getObjectByType(MainView) as MainView);

    }

  }

}

Objekte nachträglich zum Context hinzufügen:
Da einige Objekte erst zur Laufzeit erstellt werden und ebenfalls mit parsley in Verbindung stehen sollen, müsst ihr sie nachträglich zum Context hinzufügen. Das geht durch zwei einfache Schritte:

Ergänzung der Main.as:

package

{

  import org.spicefactory.parsley.asconfig.ActionScriptContextBuilder;

  import org.spicefactory.parsley.core.context.Context;



  import flash.display.Sprite;



  public class Main extends Sprite

  {

    private var _mainContext : Context;



    public function Main()

    {

      // wir markieren dieses Objekt als ContextRoot mittels "this"

      _mainContext = ActionScriptContextBuilder.build(Config, this);



      addChild(_mainContext.getObjectByType(MainView) as MainView);

    }

  }

}

Dispatchen eines Events im neuen Objekt:

package

{

  import flash.events.Event;

  import flash.display.Sprite;



  public class Objekt extends Sprite

  {

    public function Objekt()

    {

      addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);

    }



    private function onAddedToStage(event : Event) : void

    {

      dispatchEvent(new Event("configureView", true));

    }

  }

}

Jetzt wird das Objekt von parsley verwaltet und reagiert auf Metatags.

Auszug:
Die Sicherheit von Webanwendungen ist nicht nur ein Thema dieses Blogs, sondern wird immer wichtiger, je mehr Anwendungen in das Internet ausgelagert werden. Durch neuste Techniken ist es möglich für nahezu alle herkömmlichen Programme eine Webversion zu entwickeln, die über die gleichen Features verfügt, aber standortunabhängig betrieben werden kann. Da diese Anwendungen über das Internet erreichbar sind, werden sie oft Ziel von Angriffen und benötigen wirkungsvolle Schutzmechanismen…