Aug 20

Padrão observer em ActionScript 3

ActionScript

Antes de mostrar como é o sistema de eventos no ActionScript 3, gostaria de falar um pouco sobre a necessidade do Padrão Observer num software.

O Padrão Observer foi desenvolvido para suprir a dependência um-para-muitos entre objetos de modo que quando acontece algo, todos os dependentes de um certo objeto são notificados do ocorrido. Suponha que temos um sistema de gerenciamento de um supermercado e existe vários sub-gerenciamentos, como estoque, preferências dos clientes, etc.

Quando é efetuado uma compra, o sistema de gerenciamento principal dispara um evento “avisando” que foi efetuado uma compra. Os ouvintes, vulgo listeners, que são os pequenos sistemas de sub-gerenciamento, recebem esse aviso e a informação é processada de acordo com os interesses de cada dependente.

A fim de resolver esse problema de forma limpa utilizando as boas práticas de programção orientada a objetos, usa-se o Padrão Observer. Vamos lá por a mão na massa!

Bem, a imagem representa a UML de como o sistema em si funcionará. Temos um despachador de eventos (Event dispatcher), objetos resultantes dos eventos (Event object) e por último os ouvintes (Listeners) que são os objetos que escutarão o despachador. A estrutura é fácil de ser interpretada como vocês veêm. Vamos construir então os objetos.

Dispatcher:

// DispatcherObject.as
 
package net.vitoravelino.observer {
    import flash.events.EventDispatcher;
    import flash.events.Event;
 
    public class DispatcherObject extends EventDispatcher {
        public function DispatcherObject() {
        }
 
        public function dispatch():void {
            this.dispatchEvent(new Event("testEvent"));
        }
    }
}

Código que representa o objeto que vai ser responsável por despachar o evento para todos os listeners cadastrados no mesmo. A função do DispatcherObject é observar o que acontece ao seu redor e caso aconteça algo, ele despache para quem o escuta (listeners).

Listener:

// ListenerObject.as
 
package net.vitoravelino.observer {
    import flash.events.IEventDispatcher;
    import flash.events.Event;
 
    public class ListenerObject {
        public function ListenerObject(dispatcher:IEventDispatcher) {
            this.addDispatcher(dispatcher);
        }
 
        private function addDispatcher(dispatcher:IEventDispatcher):void {
            dispatcher.addEventListener("testEvent", testEventHandler);
        }
 
        private function testEventHandler(evt:Event):void {
            trace("Event arrived from " + evt.target.toString());
        }
    }
}

Código que representa o objeto que vai ser responsável por receber os eventos vindo do DispatcherObject. No método construtor é passado o dispatcher, nesse caso DispatcherObject, e o listener já irá cadastrar-se nele chamando o método addDispatcher.

Observe que só é utilizado nas classes acima um só evento, porém é possível disparar vários eventos no método dispatch de DispatcherObject e existirem vários listeners que também podem escutar a vários eventos distintos. Como uma boa prática de programação é recomendado que crie-se uma interface para os listeners e daí cada um implementa-a do seu modo.

Para uma melhor compreensão de como isso ocorre, abaixo temos um exemplo simples de como tudo isso funciona:

Main:

// Main.as
 
package net.vitoravelino {
    import net.vitoravelino.observer.DispatcherObject;
    import net.vitoravelino.observer.ListenerObject;
 
    public class Main {
        public function Main() {
            var dispatcher:DispatcherObject = new DispatcherObject();
            var listener1:ListenerObject = new ListenerObject(dispatcher);
            var listener2:ListenerObject = new ListenerObject(dispatcher);
 
            dispatcher.dispatch();
        }
    }
}

O que acontece acima é o seguinte: é instanciado um dispatcher (observer) e dois listeners; os dois listeners cadastram-se no dispatcher; e em seguida o dispatcher dispara o evento que será capturados pelos listeners cadastrados no mesmo.

Espero que tenha conseguido deixar claro como funciona o Padrão Observer em ActionScript 3. Como diria meu colega Vedovelli, ActionScript é também uma linguagem orientada a eventos e se soubermos tirar proveito disso, o código ficará mais limpo e desacoplado. Quem não entendeu muito bem como funciona o sistema de disparo e captura de eventos, recomendo o screencast feito pelo Vedovelli.

Como este é um dos primeiros tutoriais, estou aceitando sugestões para melhorias futuras nos próximos que estão por vir.

[]’s
Vítor Avelino

Base para o tutorial: http://www.communitymx.com/content/article.cfm?page=2&cid=76FDB