155 lines
4.5 KiB
Markdown
155 lines
4.5 KiB
Markdown
|
---
|
|||
|
title: Singleton
|
|||
|
localeTitle: Solteirão
|
|||
|
---
|
|||
|
O singleton é um padrão de design que restringe a instanciação de uma classe a um objeto. É útil quando você quer dar a um único objeto a capacidade de coordenar ações em todo o seu aplicativo.
|
|||
|
|
|||
|
## Singleton no Android
|
|||
|
|
|||
|
Singleton é um padrão de design usado frequentemente no Android. É facilmente mal utilizado e por isso pode dificultar a manutenção da aplicação. É útil no Android porque eles vivem em fragmentos, atividades e rotações.
|
|||
|
|
|||
|
* Singletons são frequentemente usados no Android para armazenar dados temporários
|
|||
|
* Eles permitem que o aplicativo tenha um proprietário dos dados e fornece uma maneira fácil de passar dados entre as classes do controlador
|
|||
|
* Singletons são destruídos quando o Android remove seu aplicativo da memória
|
|||
|
* Singletons podem dificultar a unidade testar seu aplicativo
|
|||
|
|
|||
|
```java
|
|||
|
public class DataStore {
|
|||
|
private static DataStore sDataStore;
|
|||
|
private List<Data> mData;
|
|||
|
|
|||
|
public static DataStore get(Context context) {
|
|||
|
if (sDataStore == null) {
|
|||
|
sDataStore = new DataStore(context);
|
|||
|
}
|
|||
|
return sDataStore;
|
|||
|
}
|
|||
|
|
|||
|
// Make constructor private to prevent other classes from creating a DataStore instance
|
|||
|
private DataStore(Context context) {
|
|||
|
mData = new ArrayList<>();
|
|||
|
}
|
|||
|
|
|||
|
// The only way for other classes to get data from DataStore
|
|||
|
public List<Data> getData() {
|
|||
|
return mData;
|
|||
|
}
|
|||
|
}
|
|||
|
```
|
|||
|
|
|||
|
## Singleton em PHP
|
|||
|
|
|||
|
> Um construtor privado é usado para impedir a criação direta de objetos da classe. A única maneira de criar uma instância da classe é usando um método estático que cria o objeto somente se ele já não tiver sido criado.
|
|||
|
|
|||
|
```php
|
|||
|
Class Singleton {
|
|||
|
|
|||
|
// Hold the class instance
|
|||
|
private static $instance = null;
|
|||
|
|
|||
|
/**
|
|||
|
* The constructor is private
|
|||
|
* it is ensure the class can be initialized only from itself
|
|||
|
*/
|
|||
|
private function __construct(){}
|
|||
|
|
|||
|
/**
|
|||
|
* Return the singleton instance of this class
|
|||
|
*
|
|||
|
* @return Singleton
|
|||
|
*/
|
|||
|
public static function getInstance()
|
|||
|
{
|
|||
|
if (self::$instance == null)
|
|||
|
{
|
|||
|
self::$instance = new Singleton();
|
|||
|
}
|
|||
|
|
|||
|
return self::$instance;
|
|||
|
}
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
$obj1 = Singleton::getInstance();
|
|||
|
$obj2 = Singleton::getInstance();
|
|||
|
```
|
|||
|
|
|||
|
## Solteirão em C
|
|||
|
|
|||
|
A versão mais elegante, simples e de alto desempenho do padrão usando [System.Lazy \\](http://msdn.microsoft.com/en-us/library/dd642331.aspx) tipo de .NET 4.0 ou superior.
|
|||
|
|
|||
|
```csharp
|
|||
|
public sealed class Singleton
|
|||
|
{
|
|||
|
private static readonly Lazy<Singleton> lazy = new Lazy<Singleton>(() => new Singleton());
|
|||
|
|
|||
|
public static Singleton Instance { get { return lazy.Value; } }
|
|||
|
|
|||
|
private Singleton()
|
|||
|
{
|
|||
|
}
|
|||
|
}
|
|||
|
```
|
|||
|
|
|||
|
## Singleton em Python3
|
|||
|
|
|||
|
Podemos usar metaclasse para implementar o Singleton no Python3.
|
|||
|
|
|||
|
```python
|
|||
|
class Singleton(type):
|
|||
|
# Mapping from a class to its singleton instance
|
|||
|
_instances = {}
|
|||
|
|
|||
|
def __call__(cls, *args, **kwargs):
|
|||
|
if cls not in Singleton._instances:
|
|||
|
Singleton._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
|
|||
|
|
|||
|
return Singleton._instances[cls]
|
|||
|
|
|||
|
|
|||
|
class MyClass(metaclass=Singleton):
|
|||
|
pass
|
|||
|
```
|
|||
|
|
|||
|
### Testando
|
|||
|
|
|||
|
```python
|
|||
|
obj_0 = MyClass()
|
|||
|
obj_1 = MyClass()
|
|||
|
|
|||
|
In [2]: obj_0
|
|||
|
Out[2]: <__main__.MyClass at 0x111130da0>
|
|||
|
|
|||
|
In [3]: obj_1
|
|||
|
Out[3]: <__main__.MyClass at 0x111130da0>
|
|||
|
```
|
|||
|
|
|||
|
## Singleton no iOS
|
|||
|
|
|||
|
```Swift4
|
|||
|
class Singleton {
|
|||
|
static let sharedInstance = Singleton()
|
|||
|
|
|||
|
init() {
|
|||
|
print("Singleton has been initialized")
|
|||
|
}
|
|||
|
|
|||
|
//write your functions here
|
|||
|
func sampleFunction() {
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
//Uses
|
|||
|
Singleton.sharedInstance.sampleFunction()
|
|||
|
```
|
|||
|
|
|||
|
Esse código simples está todo lá para implementar um padrão de design singleton no iOS usando o Swift. Colocamos `static` porque é uma propriedade de tipo e sua funcionalidade é criar apenas uma instância de um objeto e impede que seus métodos sejam substituídos. O uso de `let` garante que o valor de sharedInstance não será alterado.
|
|||
|
|
|||
|
Uma coisa importante a notar é que `static` propriedades e métodos `static` são lazy initialize por padrão, o que significa que não será instanciado até que esteja sendo chamado, portanto, fornece alguma otimização.
|
|||
|
|
|||
|
## Mais Informações
|
|||
|
|
|||
|
Para mais informações, visite os seguintes links:
|
|||
|
|
|||
|
* [MSDN: Implementando Singleton em C #](https://msdn.microsoft.com/en-us/library/ff650316.aspx)
|
|||
|
* [C # em profundidade. Implementando o padrão singleton em c #](http://csharpindepth.com/Articles/General/Singleton.aspx)
|