Padrão de projeto Singleton - por Rafael Lima

Primeiramente o que é um padrão de projeto?
Um padrão de projeto (em inglês Design Patterns) pode ser definido com uma solução para um problema em contexto. Isto indica que, os padrões oferecem soluções prontas para utilizarmos em determinados problemas que podemos encontrar quando desenvolvemos um software seguindo o paradigma da programação orientada a objeto!

Os padrões de projetos são desenvolvidos diante de uma experiência entre programador e software, o que significa que os mesmos são descobertos ao longo do tempo.
Podemos classificar os padrões de projetos de várias formas. É comum classificá-los de acordo com os tipos de problemas que eles se propõem a resolver. Baseado nesse critério, os padrões podem ser de criação (que focam os problemas de criação de objetos), estruturais (focam em atribuição de responsabilidade aos objetos) e entre outros.

O padrão de projeto singleton é um padrão de criação de objetos. O objetivo do mesmo é assegurar que uma classe (objeto) vai ter apenas uma única instancia acessível.


Mas qual é a verdadeira vantagem desse padrão?

Suponhamos que você precise fazer um sistema de cadastro bem grande.
E o mesmo eventualmente vai executar conexões ao banco de dados (DB). E dependendo
desse sistema pode ser que o mesmo precise fazer centenas e centenas de conexões ao DB por minuto. :S  O mesmo não seria viável a termos de performance que cada solicitação ao DB tivéssemos que criar uma nova conexão(objeto) ao mesmo.

Nisso é ai que entra o singleton :)
Caso não usássemos o singleton no exemplo acima, teríamos que criar vários objetos de conexão a cada nova conexão requisitada pelo usuário.Agora imagina cria centenas e centenas de OBJETOS de CONEXÂO? E ainda por cima, por minuto? Sua memória vai explodir (rsssssss).

Com o singleton ao invés de criar centenas de objetos de conexão eu crio apenas um objeto que retorna a conexão, ou seja, retorna a ele mesmo. Fazendo com que eu possa ter centenas e centenas de REFEFENCIAS (novas conexões) apontando para o mesmo objeto (o objeto conexão).

Parece complexo, mas não é!
Mas é com o tempo que os padrões de projetos entram nas cabeças das pessoas não é de um dia pra noite. Acredito que muitos aqui há alguns meses ou anos, vão voltar a ler isso (caso ainda esteja aqui) e vão compreender o que eu to citando! 
Já outros compreendem facilmente logo de primeira.
Mas chega de balela e vamos ao exemplo no Action Script 3.0.


Antes de começarmos vamos deparar com um problema não muito grave no ActionScript 3.0.  O mesmo impede de criar construtores privados (“meuda”)

Com um construtor privado nos asseguramos que nenhuma outra classe vai criar uma nova instancia de sua classe que utiliza o singleton no momento!  É uma pena que no AS3.0 não
da pra fazer isso. :(

Mas, há um método para tal feito! :)
Vamos usar um truquizinho para imitar esse comportamento no AS3

Veja o código abaixo:
Singleton.as

package
{
    public class Singleton
    {
        // Atributo instancia que aponta para a classe
        private static var instancia:Singleton = new Singleton();
       
        // Atributo de nome teste usado para testar a Singleton
        private var teste:String;
       
        public function Singleton()
        {
            // Caso haja uma nova Instancia...
            if(instancia)
            {
                // ...imprime no painel Debug a string abaixo indicando erro.
                throw new Error("Não pode criar uma instancia para essa classe");   
            }
        }
       
        public static function get Instancia():Singleton
        {
            // Retorna a instancia
            return instancia;
        }
       
        public function Teste(teste:String):String
        {
            // Imprime o valor do parametro
            trace(teste);
           
            /*
            * retorna o valor do parametro teste
            * lembrando que this referencia o atribudo
            * (propriedade) da classe Singleton.
            */
            return this.teste = teste;
        }
       
    }
   
}


UsandoSingleton.as

package
{
    import flash.display.MovieClip;
    import Singleton;
   
    public class UsandoSingleton extends MovieClip
    {
                        // Provocando um erro. 
        //public var novaSingleton:Singleton = new Singleton();
       
        public function UsandoSingleton()
        {
            // usando o método Teste da classe que contem o Singleton
            Singleton.Instancia.Teste("Flash Pédia");
        }
       
    }
   
}


Agora crie um documento.fla no actionscript 3.0 e salve com qualquer nome. Não se esqueça de colocar no mesmo diretório das classes (UsandoSingleton.as e Singleton.as).
Feito isso, vá ao painel de propriedade no campo Documents class coloque o nome da classe UsandoSingleton (sem o .as). E aperte o Control+Enter para testar.

Bem galera, não vou explicar linha por linha até porque a intenção e explicar apenas o  padrão. E é desnecessário, pois as classes já estão comentadas. 

Mais pra frente quando eu arrumar um tempinho vou criar aqui mesmo nesse tópico um mini tutorial mostrando a real utilidade na pratica com exemplos utilizando movieclips e objetos! :)

Abraços!

 

0
Your rating: Nenhum

Comentários

Muito bom!

Gostei muito deste artigo, eu sempre ficava imaginando como seria em um projeto grande tantas conexões, agora ficou mais claro :D Obrigado.

Comentar

O conteúdo deste campo é privado não será exibido ao público.