Padrões de Projeto 1: Singleton

22 10 2007

Hoje as coisas estão um bocado apertadas, mas se esse post não sai hj, não sei quando sai. Foi uma semana de muito trabalho, muita burocacia (pra me inscrever no mestrado) e agora que consegui a inscrição, tenho logo de colocar esse post q já estava esperando por ser publicado a uma semana!

Singleton é um padrão de criação bem simples, e o problema endereçado é o de criar uma única instância de uma classe. Isso pode ser uma necessidade para garantir desempenho do sistema (não criando objetos demais que poderiam ser reaproveitados em outros momentos), uma exigência de usabilidade de tela ou mesmo uma regra de negócio.

Há uma discussão interessante em [1] e [2] sobre os problemas de singleton como um padrão de projeto. O fato ocorre pois (como você vai ver mais a frente) o singleton utiliza de recursos de implementação que não são considerados boas práticas de POO, além de também ser considerado prejudicial para a organização da arquitetura da aplicação se usado exageradamente.

Em C++:

class MyClass{
	private:
		MyClass() {}
 	public:
		static MyClass* getInstance()
       		{
			static MyClass *instance = 0;
			return instance ? instance : (instance = new MyClass());
		}
};

Em Java:

 public class MyClass{
	private MyClass instance = null;
 	private MyClass(){
	}

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

[1] Perils of the Singleton – http://www.softwarereality.com/design/singleton.jsp

[2] The One: A Singleton Discussion – http://www.gamedev.net/reference/articles/article1825.asp

[3] Problems with design pattern “Singleton” – http://www.theserverside.com/blogs/thread.tss?thread_id=41546

[4]Singleton Pattern #3: Problems with Singleton, Thread-Safe Singleton Class – http://www.kamalmeet.com/wordpress/2007/02/15/singleton-pattern-3-problems-with-singleton-thread-safe-singleton-class/





Padrões de Projeto 0: Introdução

4 10 2007

Desenvolver software é algo complicado. É necessário compreender de tecnologia , do negócio do cliente, e ainda ser ajuizado o suficiente para manter todo o conhecimento ali produzido documentado da melhor maneira possível, para que outros possam continuar o projeto.

Uma das formas de documentação do conhecimento produzido em um processo de desenvolvimento de software que surgiu naturalmente como iniciativa comunitária, foram os padrões de projeto. E o que são padrões de projeto? Existem algumas definições as quais podemos recorrer:

Def. 1: (GoF) Um padrão de projeto sistematicamente nomeia, motiva e explica um projeto genérico, que endereça um problema de projeto recorrente em sistemas orientados a objetos. Ele descreve o problema, a solução, quando é aplicável e quais as conseqüências do seu uso.
Def.2: (Coplien) Um padrão (de projeto) é uma peça de literatura que descreve um problema de projeto e a solução geral para o problema em um contexto particular.
Def.3: (Budinsky, Finnie, Vlissides e Yu) Padrões de projeto capturam a experiência na construção de software orientado a objetos.

Budisky et al. põem uma importância enorme aos padrões de projeto na sua definição. Capturar a experiência é algo naturalmente difícil e extremamente útil.

Mas, como surgiram os padrões de projetos para a computação? Isso nos leva ao ano de 1987, quando Ward Cunninghan e Kent Beck propuseram (implementados em Smalltalk) os primeiros 5 padrões e os apresentaram na OOPSLA. Num trabalho paralelo a sua tese de doutorado, Eric Gamma nota a importância dos padrões repetitivos em projetos, levando o tema a discussão em conferência integrada da OOPSLA e ECOOP em 1990, junstamente com Bruce Anderson e Richard Helm. A partir de então, o tema ganha mais importância, com a prublicação de livros como “Advanced C++ Programming Styles and Idioms” (Coplien, 1992), ou “Design Patterns: Elements of reusable object-oriented software” da gangue dos quatro (1995) e vários outros.

Existem alguns critérios para que uma solução torne-se um padrão:

  1. Devem descrever e justificar as soluções para problemas concretos e bem definido, i.e., não são estratégias ou princípios de implementação;
  2. As soluções descritas devem estar comprovadas, i.e., devem ter sido previamente experimentadas e testadas;
  3. O problema tratado por um padrão deve ocorrer em diferentes contextos, ou seja, se a solução não tem aplicação em diferentes situações, então não é um padrão;
  4. Usualmente os padrões de projeto descrevem relações entre os conceitos, mecanismos e estruturas existentes nos sistemas;
  5. Os padrões de projeto devem ser capazes de capturar a evolução e o aprimoramento das soluções, assim como equilibrar os pontos fortes e fracos encontrados, sendo assim, não são soluções óbvias ou triviais;
  6. Os padrões devem ser utilizados em conjunto com outros padrões, compondo uma linguagem de padrões.

Podemos dividir os padrões em três categorias:

  • Padrões de Criação: Ligados ao processo de instanciação;
  • Padrões Estruturais: Observam as formas de composição dos objetos e/ou classes;
  • Padrões Comportamentais: Observam a maneira com que classes e objetos podem interagir.

O que vou fazer aqui é descrever e comentar um pouco sobre os padrões que conheço e/ou mais populares, acrescentando códigos em Java (talvez em C++) para ilustrar a utilização.

É importante notar que os padrões não são o grande canivete suíço que resolverá todos os seus problemas, mas constituem uma ferramenta extra muito útil nas situações do dia-a-dia, e certamente facilitará a vida de quem os conhece.

À medida que for comentando os padrões, colocarei seus links neste artigo, que servirá como índice e introdução ao tema.

Singleton