Origem: Wikipédia, a enciclopédia livre.
Diagrama UML de uma classe singleton.
Singleton, é um padrão de projeto de software (do inglês Design Pattern). Este padrão garante a existência de apenas uma instância de uma classe, mantendo um ponto global de acesso ao seu objeto.
Nota linguística: O termo vem do significado em inglês quando se resta apenas uma carta nas mãos, num jogo de baralho.
Muitos projetos necessitam que algumas classes tenham apenas uma instância. Por exemplo, em uma aplicação que precisa de uma infraestrutura de log de dados, pode-se implementar uma classe no padrão singleton. Desta forma existe apenas um objeto responsável pelo log em toda a aplicação que é acessível unicamente através da classe singleton.
Índice
[esconder] 1 Onde Usar
2 Exemplos 2.1 Em Java
2.2 Em C++
2.3 Em Delphi
2.4 Em PHP
2.5 Em Ruby
2.6 Em VB.NET
2.7 Em ActionScript 3
2.8 Em c# (utilizando Generics)
3 Benefícios
4 Referências
[editar] Onde Usar
Quando você necessita de somente uma instância da classe, por exemplo, a conexão com banco de dados, vamos supor que você terá que chamar diversas vezes a conexão com o banco de dados em um código na mesma execução, se você instanciar toda vez a classe de banco, haverá grande perda de desempenho, assim usando o padrão singleton, é garantida que nesta execução será instânciada a classe somente uma vez. Lembrando que este pattern é considerado por muitos desenvolvedores um anti-pattern, então, cuidado onde for utilizá-lo. [1]
[editar] Exemplos
[editar] Em Java
Segue um exemplo em Java de uma classe Singleton.
public final class MySingleton {
// Instancia estática privada que será acessada
private static final MySingleton INSTANCE = new MySingleton();
// Construtor privado. Suprime o construtor público padrao.
private MySingleton() {
// Operações de inicialização da classe
}
// Método público estático de acesso único ao objeto!
public static MySingleton getInstance(){
return INSTANCE;
}
}
[editar] Em C++
Segue um exemplo em C++ da implementação de uma classe Singleton:
class MyClass
{
private:
// atributo estático da "instância única"
static MyClass *instance = 0;
//construtor privado, não pode ser utilizado fora da classe
MyClass() {}
public:
// Função-membro que retorna sempre a mesma instância do objeto
static MyClass& getInstance()
{
if (!instance) instance = new MyClass();
return *instance;
}
};
[editar] Em Delphi
Abaixo segue um exemplo de como implementar uma classe Singleton:
Por exemplo, numa classe Fachada, onde se encontra todos os métodos disponíveis para a interface da aplicação, pode ser criado um método dinâmico para que todos os que visualizam essa classe, não criarem mais instâncias da mesma.
class function TFachada.ObterInstancia: TFachada;
begin
If FInstance = nil Then
FInstance := Cliente.Fachada.TFachada.Create();//objeto instanciado através do Finstance
Result := FInstance;//retorna o objeto
end;
[editar] Em PHP
<?php
class Singleton
{
private static $_instance;
// Evita que a classe seja instanciada publicamente
private function __construct() { }
// Evita que a classe seja clonada
private function __clone() { }
public static function getInstance()
{
if (!isset(self::$_instance)) { // Testa se há instância definifa na propriedade, caso sim, a classe não será instanciada novamente.
self::$_instance = new self; // o new self cria uma instância da própria classe à própria classe.
}
return self::$_instance;
}
}
[editar] Em Ruby
class Classe
include Singleton
end
[editar] Em VB.NET
Public Class MyClass
Private Shared _instancia As MyClass
Private Shared objetoSincronia As New Object
Private Sub New()
End Sub
Public Shared Function getInstancia() As MyClass
If _instancia Is Nothing Then
SyncLock objetoSincronia
If _instancia Is Nothing Then _instancia = New MyClass
End SyncLock
End If
Return _instancia
End Function
End Class
[editar] Em ActionScript 3
package{
public class ExemploSingleton {
private static var instance:ExemploSingleton;
public function ExemploSingleton(enforcer:SingletonEnforcer) : void {
if (enforcer == null)
throw new Error("Só pode haver uma instância de ExemploSingleton");
}
public static function getInstance() : ExemploSingleton {
if (instance == null)
instance = new ExemploSingleton( new SingletonEnforcer );
return instance;
}
}
}
//Para bloquear o acesso ao constructor.
class SingletonEnforcer {
}
[editar] Em c# (utilizando Generics)
public sealed class GenericSingleton<T> where T : class, new()
{
private static T _instance;
public static T GetInstance()
{
lock (typeof(T))
{
if (_instance == null)
_instance = new T();
return _instance;
}
}
}
// Teste do padrão Singleton
public class Car { public int Color { get; set; } }
public class Person { public string Name { get; set; } }
class Program
{
static void Main(string[] args)
{
Car car = GenericSingleton<Car>.GetInstance();
car.Color = 1;
Person per = GenericSingleton<Person>.GetInstance();
per.Name = "John";
Car car2 = GenericSingleton<Car>.GetInstance();
car.Color = 2;
}
}
Obs: Esta solução não impede a criação de múltiplas instâncias das classes Car e Person. Como a classe genérica GenericSingleton obriga que as classes passadas no parâmetro T tenham um construtor público, é possível criar instâncias em qualquer trecho de código através de construções do tipo: Car car3 = new Car();.
[editar] Benefícios
Permite o controle sobre como e quando os clientes acessam a instância.
Várias classes singleton podem obedecer uma mesma interface, permitindo assim que um singleton em particular seja escolhido para trabalhar com uma determinada aplicação em tempo de execução.
Com apenas uma implementação interna do singleton pode-se fazer com que o singleton crie um número controlado de instâncias.
É mais flexível que métodos estáticos por permitir o polimorfismo.
Postado por: Hélio Marcus, ADS - 6º Período.
