Padrões de Projeto (Design Patterns): Singleton, Factory e Observer na prática.

Introdução

Os padrões de projeto, conhecidos como Design Patterns, são soluções repetidas para problemas comuns no desenvolvimento de software. Esses padrões proporcionam benefícios significativos em termos de reutilização de código, manutenibilidade e escalabilidade das aplicações.

Nas últimas décadas, os padrões de projeto tornaram-se essenciais na indústria do desenvolvimento de software, pois permitem que os desenvolvedores focem no domínio específico da aplicação em questão, ao invés de se preocuparem com problemas genéricos como criação e gerenciamento de objetos.

Neste artigo, vamos explorar três dos padrões mais utilizados: Singleton, Factory e Observer. Vamos discutir suas definições formais, quando utilizar cada um deles, além de exemplos práticos que ilustram a aplicação desses padrões em contextos reais.

Ao final deste artigo, você estará capacitado a identificar situações onde esses padrões são úteis e a implementá-los efetivamente em seu próprio código, reduzindo assim o tempo de desenvolvimento e melhorando a qualidade da aplicação.

O que é e por que importa

O Singleton é um padrão de projeto criado para garantir que uma classe tenha apenas uma instância e forneça um ponto de acesso global a essa instância. Em outras palavras, o Singleton permite que uma única instância de uma classe seja compartilhada entre diferentes partes do sistema.

A motivação por trás do Singleton é resolver o problema da injeção de dependência em sistemas com grande complexidade. Quando um sistema tem muitas classes interconectadas e cada classe depende de outra, pode ser difícil gerenciar as instâncias dessas classes. O Singleton fornece uma solução para essa problemática, permitindo que os desenvolvedores criem apenas uma instância de uma classe e a compartilhem em todo o sistema.

Outra motivação importante para o uso do Singleton é evitar a sobrecarga de memória causada pela criação de múltiplas instâncias de uma mesma classe. Em sistemas com recursos limitados, como dispositivos móveis ou embutidos, a redução da sobrecarga de memória é crucial para garantir o desempenho e estabilidade do sistema.

O Singleton resolve esses problemas fornecendo um ponto de acesso global e exclusivo à instância da classe. Isso permite que os desenvolvedores:

• Garantam a unicidade da instância da classe, evitando a criação desnecessária de múltiplas instâncias.
• Facilitam a injeção de dependência, permitindo que as classes sejam mais flexíveis e fáceis de manter.
• Reduzem a sobrecarga de memória, otimizando o uso dos recursos do sistema.

Em resumo, o Singleton é um padrão essencial para garantir a unicidade da instância de uma classe, facilitar a injeção de dependência e reduzir a sobrecarga de memória em sistemas complexos.

Como funciona na prática

Criando a Instância Única

• Classe Singleton: A classe é criada com um método de acesso público que retorna uma referência para a instância única.

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

• Instânciando a Classe: A classe é instanciada somente uma vez, quando o método getInstance() é chamado pela primeira vez.

Garantindo a Unicidade

• Método getInstance(): O método getInstance() verifica se a instância já foi criada. Se não houver, cria e retorna a instância única.
• Synchronized: Em linguagens como Java ou C#, o método getInstance() pode ser sincronizado para garantir que apenas uma thread possa criar a instância de cada vez.

public synchronized static Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
}

Exemplo de Uso

• Classe que Utiliza o Singleton: Uma classe pode utilizar a instância única do Singleton para realizar operações específicas.

public class UsandoSingleton {
    private static final Logger LOGGER = LoggerFactory.getLogger(UsandoSingleton.class);
    
    public void fazerAlgo() {
        Singleton singleton = Singleton.getInstance();
        // fazer algo com a instância do Singleton
        LOGGER.info("Fiz algo com o Singleton");
    }
}

Essa é uma visão geral simplificada do funcionamento interno do padrão Singleton. Lembre-se de que existem várias variantes e implementações desse padrão, dependendo das necessidades específicas do seu projeto.

Exemplo Real

Um exemplo real de utilização do padrão Singleton é no gerenciamento de uma conexão com um banco de dados. Considere o seguinte cenário:

// Implementação de uma classe que representa a conexão com um banco de dados.
public class ConexaoBancoDeDados {
    private static final String NOME_BANCO_DE_DADOS = "meu_banco_de_dados";
    private static final String USUARIO_BANCO_DE_DADOS = "meu_usuario";
    private static final String SENHA_BANCO_DE_DADOS = "minha_senha";

    // Padrão Singleton implementado para garantir que exista apenas uma conexão com o banco de dados.
    public static ConexaoBancoDeDados conexao;

    public void conectar() {
        System.out.println("Conectando ao banco de dados...");
        // Código para estabelecer a conexão
    }

    public void fecharConexao() {
        System.out.println("Fechando a conexão com o banco de dados...");
        // Código para fechar a conexão
    }
}

// Exemplo de como instanciar e utilizar a classe ConexaoBancoDeDados.
public class ManipuladorDeDados {
    public void manipularDados() {
        ConexaoBancoDeDados.conexao = ConexaoBancoDeDados.getConexao();
        if (ConexaoBancoDeDados.conexao != null) {
            ConexaoBancoDeDados.conexao.conectar();
            // Executar operações no banco de dados
            ConexaoBancoDeDados.conexao.fecharConexao();
        }
    }

    public static void main(String[] args) {
        ManipuladorDeDados manipulador = new ManipuladorDeDados();
        manipulador.manipularDados();
    }
}

Nesse exemplo, a classe ConexaoBancoDeDados é instanciada apenas uma vez através do método estático getConexao(), garantindo que exista sempre uma conexão única com o banco de dados. A classe ManipuladorDeDados demonstra como utilizar essa conexão para realizar operações no banco de dados.

Boas práticas

Utilize Singleton para recuperação de recursos caros ou escassos

O Padrão Singleton é útil quando você precisa garantir que apenas uma instância de uma classe seja criada, especialmente em cenários onde a criação de múltiplas instâncias pode ser ineficiente ou até mesmo impossível.

Implemente um método getInstance() para obtenção da instância única

Ao invés de utilizar um construtor privado e criar uma variável estática que armazena a instância, é mais comum implementar um método getInstance() que retornará a instância única. Isso permite que você adicione comportamento adicional se necessário.

Use o Singleton para gerenciamento de objetos caros

Se você tiver objetos que são muito caros em termos de recursos (como conexões de banco de dados ou sockets) e que só precisam ser criados uma vez, o Singleton é uma boa escolha para garantir que apenas um desses objetos seja criado.

Considere a implementação do Padrão Factory

O Padrão Factory pode ser mais flexível que o Singleton quando você precisa criar diferentes tipos de objetos e não quer restringir-se à criação de apenas um tipo de objeto.

Armadilhas comuns

Problemas de concorrência e multithreading

Um dos principais problemas do Singleton é a possibilidade de problemas de concorrência, especialmente em ambientes multithreading. Para evitar isso, é importante garantir que o método getInstance() seja thread-safe, seja através da utilização de um mecanismo de mutual exclusion ou utilizando uma variável de classe inicializada.

Inflexibilidade

O Singleton pode ser muito inflexível, dificultando a troca de comportamento e difícil manutenção. Se você precisar alterar o comportamento do Singleton, pode acabar reescrevendo o padrão de projeto todo, tornando-o menos escalável e mais complicado.

Problemas de testabilidade

O Singleton pode tornar difícil a testagem, pois é difícil criar um objeto em um ambiente isolado. Isso pode levar a problemas de acoplamento alto entre classes e dificuldade de manutenção do código.

Possibilidade de uso incorreto

Se não for utilizada corretamente, o Singleton pode se tornar um problema, especialmente se você não precisar da instância única ou se ela for difícil de trocar.

Conclusão

Em resumo, os padrões de projeto Singleton, Factory e Observer são ferramentas poderosas para resolver problemas comuns em software, mas devem ser utilizados com cuidado para evitar armadilhas comuns como problemas de concorrência, inflexibilidade e dificuldade de testabilidade. É importante considerar as necessidades específicas do projeto ao escolher o padrão certo. Para aprofundamento, é recomendável estudar os exemplos práticos de implementação desses padrões em linguagens de programação como Java, C# ou Python. Além disso, é fundamental entender a importância da documentação e manutenção do código para garantir que o software seja escalável e fácil de manter ao longo do tempo.

Referências

• Fowler, M. Patterns of Enterprise Application Architecture. Disponível em: https://martinfowler.com/eaaCatalog/. Acesso: 2024.
• Gamma, E.; Helm, R.; Johnson, R.; Vlissides, J. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Professional, 1995.
• Martin Thompson. Factory Pattern in Java. Disponível em: https://www.baeldung.com/java-factory-pattern. Acesso: 2024.
• "Singleton" do MDN Web Docs. Disponível em: <https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/singleton>.
• "Observer Pattern" da ThoughtWorks. Disponível em: https://www.thoughtworks.com/en/blog/design-patterns-beyond-code#observer.
• Pratique 3 - Construa com threads seguras do 12factor.net. Disponível em: https://12factor.net/pt-br/building-with-thrds.