Parsley – #4 – Messaging

Parsley Tutorial Nummer 4: Messaging ist meiner Meinung nach eines der nützlichsten Features von parsley. Das Framework stellt die Möglichkeit bereit, global und vollständig voneinander entkoppelt Nachrichten zu versenden. Entwickelt Person A beispielsweise die Hauptnavigation, müssen von dort aus nur Nachrichten versendet werden, welcher Inhalt auf der Seite angezeigt werden soll. Person B entwickelt den ContentContainer und weiß, dass irgendwann die Nachricht “HOME” kommt. Trifft diese Nachricht ein, muss der aktuelle Inhalt ausgeblendet und der Inhalt mit dem Namen “HOME” angezeigt werden.

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?

Parsley – #3 – Dependency Injection

Ein weiteres Feature von parsley ist Dependency Injection. Das klingt erstmal komplizierter, als es eigentlich ist. Hier zum Verständnis ein einfaches parsley Tutorial dazu – eigentlich bloß ein selbsterklärender Codeschnipsel.

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.

Parsley – #2 – Metatags

Nachdem wir im parsley Tutorial Teil #1 den Context der Anwendung initialisiert haben, wollen wir nun das Framework natürlich auch nutzen. Dazu müssen wir zuerst verstehen, wie parsley arbeitet. Parsley funktioniert über Metatags, die vor Variablen oder Funktionen gestellt werden und das Framework anweisen, etwas zu tun. Als erstes Beispiel nutzen wir das [Init] Metatag. Weitere Tags findet ihr in der Dokumentation, die selbsterklärend sein sollten, sobald man verstanden hat, wie man sie benutzen kann.

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.

Parsley – #1 – Context

Da ich selbst keine deutschsprachigen Tutorials zum Thema parsley gefunden habe und es generell für reine Actionscript Entwickler nur sehr wenige Anlaufstellen gibt, hier ein paar kleine Code Schnipsel, die den Einstieg in das Framework vereinfachen sollten.

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.

Anomalieerkennung in Webanwendungen

Seminararbeit 2008 Klick.

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…