Design Patterns com Java: Uma visão geral do Padrão Singleton

O Padrão Singleton é um dos padrões de projeto mais populares em Java, que garante que apenas uma instância de uma classe seja criada em toda a aplicação, e fornece uma maneira fácil de recuperá-la. Isso é especialmente útil em situações em que criar várias instâncias de uma classe pode levar a problemas de desempenho ou de integridade de dados.

Existem três maneiras comuns de implementar o padrão Singleton em Java: Lazy Initialization, Eager Singleton e Lazy Holder Singleton. Cada abordagem tem seus próprios benefícios e desvantagens, e a escolha da abordagem correta dependerá dos requisitos específicos da sua aplicação.

Na abordagem Lazy Initialization, a instância é criada apenas quando necessário. Isso pode ajudar a economizar recursos de memória, mas pode resultar em um pequeno atraso no tempo de inicialização da instância.

public class Singleton {
  private static Singleton instance;

  private Singleton() {}

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

Na implementação Eager Singleton, a instância é criada logo na declaração da variável, tornando a criação da instância mais rápida. Essa abordagem é ideal quando você precisa que a instância esteja disponível imediatamente.

public class EagerSingleton {
 private static final EagerSingleton instance = new EagerSingleton();

 private EagerSingleton() {}

 public static EagerSingleton getInstance() {
    return instance;
 }
}

A abordagem Lazy Holder Singleton é uma variação da abordagem Lazy Initialization, onde a instância é encapsulada em uma classe privada que é carregada somente quando a instância é chamada pela primeira vez. Isso combina os benefícios das abordagens Lazy Initialization e Eager Singleton e é geralmente considerada a melhor abordagem para implementar o padrão Singleton em Java.

public class LazyHolderSingleton {
 private LazyHolderSingleton() {}


 private static class SingletonHolder {
    private static final LazyHolderSingleton instance = new LazyHolderSingleton();
 }


 public static LazyHolderSingleton getInstance() {
    return SingletonHolder.instance;
 }
}

Para ajudar a ilustrar como funciona o padrão Singleton, apresento um diagrama de classes UML. Como podemos ver no diagrama, a classe Singleton tem apenas uma instância, e essa instância é criada internamente pela própria classe Singleton. A instância é então recuperada sempre que necessário usando o método getInstance(). (Na imagem de capa, tem a representação gráfica).

classDiagram
class Singleton {
  - instance: Singleton
  - Singleton()
  + getInstance(): Singleton
}
Singleton --> "1" Singleton : <<creates>>

Embora o padrão Singleton seja amplamente utilizado em aplicativos Java, é importante lembrar que a implementação incorreta do padrão Singleton pode levar a problemas de segurança e desempenho. Portanto, é importante seguir as melhores práticas e diretrizes recomendadas ao implementar o padrão Singleton em sua aplicação Java.

Meu artigo no linkedin: https://www.linkedin.com/feed/update/urn:li:linkedInArticle:7052609544807415808/