Alberto Leal

Photo: http://static.howstuffworks.com/gif/teen-bedroom-decorating-ideas-2.jpg

O último livro que terminei de ler era sobre Design Pattern. Então, resolvi fazer alguns posts contendo algumas implementações. O padrão de projeto da vez é o Decorator.

——–

O poder da composição

Têm quem ame, e têm quem odeie herança. Existem casos que não há como fugir da herança, mas, sempre que possível, prefira composição a herança. Quando utilizamos herança em uma parte da nossa aplicação, e alguns comportamentos são herdados, estes  são definidos estaticamente em tempo de compilação. Por outro lado, se você estender o comportamento de um objeto por meio de composição, você consegue fazer isso dinamicamente, ou seja, consegue compôr os objetos de forma dinâmica. Com isso, se torna fácil adicionar novas funcionalidades escrevendo um código novo ao invés de alterar o código existente. Isso é bacana, pois o comportamento anterior não é modificado, assim as chances de introdução de erros no código que já estava funcionando é menor. Se algo der errado, basta remover a nova classe que foi criada, por exemplo. Resumindo, mantenha as classes abertas para extensão e fechadas para alteração.

O padrão de projeto decorator anexa novas responsabilidades em um objeto dinamicamente, utilizando  do poder da composição.

Vamos ver como isso funciona na prática. O exemplo que lhe será apresentado é a construção de uma pizza. No momento do pedido, o cliente poderá pedir ao Pizzaiolo que adicione  novos ingredientes na pizza, tais como: orégano e tomate. Exemplo simples e direto, apenas para ilustrar.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package br.eti.albertoleal.decorator;
 
public abstract class Pizza {
 
private String description = "Unknown Pizza";
 
public void setDescription(String desc) {
description = desc;
}
 
public String getDescription(){
return description;
}
 
public abstract double cost();
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package br.eti.albertoleal.decorator;
 
public class Cheese extends Pizza {
 
	public Cheese(){
		setDescription("Cheese Pizza")
	}
 
	@Override
	public double cost() {
		return 19.90;
	}
 
}

As classes decorator devem ser espelhos das classes que elas vão decorar. Vamos utilizar da herança em nossos objetos do tipo CondimentDecorator. O motivo de se usar herança na classe Decorator é  pelo simples fato de se ter o mesmo tipo dos objetos que vão ser decorados. O uso de herança é justamente para atingir  essa correspondência de tipo.

1
2
3
4
5

package br.eti.albertoleal.decorator;
 
public abstract class CondimentDecorator extends Pizza {
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package br.eti.albertoleal.decorator;
 
public class Oregano extends CondimentDecorator {
	Pizza pizza;
 
	public Oregano(Pizza pz) {
		pizza = pz;
	}
 
	@Override
	public String getDescription() {
		return pizza.getDescription() + ", Oregano";
	}
 
	@Override
	public double cost() {
		return .50 + pizza.cost();
	}
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package br.eti.albertoleal.decorator;
 
public class Tomato extends CondimentDecorator {
	Pizza pizza;
 
	public Tomato(Pizza pz){
		pizza = pz;
	}
 
	@Override
	public String getDescription() {
		return pizza.getDescription() + ", Tomato ";
	}
 
	@Override
	public double cost() {
		return .10 + pizza.cost();
	}
 
}

Se você estava atento reparou que a cada condimento que é adicionado na pizza um valor correspondente ao condimento é somado ao valor da pizza. Essa é a idéia do decorator. Estou decorando um objeto pizza com diversos outros componentes. Um outro exemplo, bastante comum de se encontrar pela internet, são as janelas gráficas. O ato de decorar uma janela gráfica com diversos componentes de apresentação, tais como: barra de rolagem, campos de texto e por aí vai.

Chegou a hora de testarmos o nosso código, criar uma pizza e adicionar alguns condimentos a ela e constatar se a nossa “decoração” funciona:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package br.eti.albertoleal.decorator;
 
public class Pizzaiolo {
 
	public static void main(String[] args) {
 
		Pizza pz = new Cheese();
 
		pz = new Tomato(pz);
		pz = new Tomato(pz);
		pz = new Oregano(pz);
		pz = new Tomato(pz);
		pz = new Oregano(pz);
		pz = new Tomato(pz);
 
		System.out.println(pz.getDescription());		
 
	}
 
}

Concluindo:

• A herança é uma maneira de estender comportamentos, mas não é a melhor maneira de obter flexibilidade;
• Composição e delegação são boas maneiras de se adicionar funcionalidades em tempo de execução;
• A utilização de um componente decorator é simplesmente decorar um objeto, e o objeto decorado não precisa conhecer os decoradores;
• É muito importante que os objetos decoradores sejam espelhos do objeto que vão decorar, justamente para ter uma correspondência de tipo.

Falando em Java 2009: O que falar do evento desse ano de 2009? Sem sombra de dúvidas, o evento foi adorado por todos da comunidade, por todos aqueles que estavam presentes.

Confesso  que o evento superou as minhas expectativas. Esperava um bom evento, como pude constatar pelos comentários em blogs e fóruns de discussão relacionados aos anos anteriores. Mas, em minha opinião, o evento foi ótimo! Extremamente profissional, palestras de altíssimo nível, além de uma ótima organização. Acredito que todo o esforço por parte da Caelum não foi em vão, afinal, o evento teve uma boa aceitação por parte da comunidade.

Nesse ano, o evento contaria com duas palestras internacionais: A primeira com Jim Webber da Thoughtworks e Bill Burke. Porém,  Bill Burke não pôde marcar presença no evento devido a problemas com visto. Mas, nem por isso deixamos de ter uma excelente palestra sobre web services. Jim Webber deu conta do recado e conduziu a palestra no lugar de Bill Burke. Muito simpático e bem-humorado (a galera se divertiu de montão com suas piadas), Jim Webber nos presenteou com duas ótimas palestras: a primeira “Guerrilha SOA” e a segunda “Web services Rest”.

As demais palestras foram comandadas, basicamente, pelos integrantes do time da Caelum. Paulo Silveira e Rafael Cosentino mandaram ver na palestra “O profissional Java Efetivo”. Foram bastante felizes com os exemplos apresentados. Além de divertidos, prenderam facilmente a atenção do pessoal. Falaram, dentre diversas coisas,  quais as melhores técnicas para se fazer a integração entre sistemas, onde se deve analisar cada necessidade e escolher a técnica que  melhor se aplica.

A palestra de Alessandro Lazarotti e Ricardo Nakamura, “JBoss Seam e WebBeans”, contou com exemplos práticos, codificados ali mesmo, na hora. Onde a dupla apresentou como JBoss Seam trabalha com DI -Dependency Injection.

A palestra de Felipe Sabella e Guilherme Silveira sobre a nova versão do “VRaptor3 foi bem interessante. Ambos apresentaram as novas melhorias que estarão disponíveis no framework. Melhorias estas retiradas do trabalho do dia a dia. Fábio Kung também falou um pouco. Falou que um dos frameworks que inspirou algumas mudanças, como roadmap, foi o Rails. Existe, também, a possibilidade de se escolher o que será retornado para o usuário: xml, atom, html..Bem rails-like.

Guilherme Moreira e Sergio Lopes apresentaram a palestra “Arquitetura para aplicações Java de médio porte”. Apresentaram diversos erros comuns que desenvolvedores cometem quando estão trabalhando com Hibernate. Além de mostrar exemplos com cluster, load balance.

Para onde vai a Plataforma Java? Linguagens dinâmicas, JavaTV, JavaFX e além!” Essa palestra foi maestrosamente apresentada por Anderson Leite e Fabio Kung. Impressionante a forma como a dupla apresentou as novas mudanças que surgirão na plataforma Java. Uma frase de Fábio que me chamou bastante atenção foi: “[ ...]a idéia é tornar a plataforma Java  uma casa melhor para as linguagens dinâmicas[...]“.

O evento foi palco de muitas novidades. Uma delas foi que o pessoal da Caelum está escrevendo um livro com o seguinte título: “Arquitetura e Design de Software”. Sem dúvidas, este livro será de altíssimo nível. Não tenho o hábito de ler livros em português. O que me impulsou a ter essa postura foi a má qualidade das traduções. Mas esse livro será, com certeza, um dos melhores livros sobre arquitetura e design escrito em português. Basta acompanhar o que essa galera faz pela comunidade em geral para ter certeza disso. Assim que sair, quero garantir o meu! Para maiores informações, acesse: http://www.arquiteturajava.com.br/

Com certeza estarei presente nos próximos anos! E, espero poder re-encontrar toda a galera do CEJUG, ESJUG, Gujeiros e twitteros. Até lá, pessoal…

Acontecerá no próximo dia 24 o Falando em Java 2009. O evento já está em sua terceira edição. Infelizmente, não pude participar dos eventos anteriores. Mas, neste ano, estarei presente.

O evento contará com boas palestras, e promete ser bem interessante. Além de que, será uma ótima oportunidade de conhecer, pessoalmente, uma galera que já venho conversando pela internet - twitter, gtalk, msn e fóruns.

Então, nos vemos lá!

Como já leram aqui no blog, escolhi o Mentawai para desenvolver um projeto em Java. Mas, como nem tudo são flores, meses atrás eu tive um problema com a utilização de “template” no menta. Por acreditar que outras pessoas já passaram pelo mesmo problema, vou passar adiante uma dica que o felipowsky me passou lá no fórum.

Para conhecer como funciona o recurso de template, basta acessar o site aqui. O próprio site do mentawai explica passo a passo, portanto, não mostrarei aqui como criar um template simples.

O PROBLEMA

Quando se trabalha com “template” no mentawai é permitido configurar a extensão dos arquivos e a forma como serão acessados (Desde que não seja “jsp”, senão ele lança exceção).

Ao acessar uma página com a extensão que foi definida, o recurso de template do framework incluirá a página dentro das tags definidas. Porém, se o usuário renomear na barra de endereço a extensão, passando “.JSP”, o arquivo será acessado e exibido sem qualquer formatação de layout.

A SOLUÇÃO

Tentei de “n” maneiras resolver este problema, e como sou marinheiro de primeira viagem não tive muito sucesso.

A idéia passada pelo felipowsky foi a seguinte:

Cria-se uma classe que estende ConventionController, chame-a de CustomConventionController:

import org.mentawai.template.ConventionController;

public class CustomConventionController extends ConventionController {

@Override
public String getRoot() {
return "/WEB-INF/Administracao";
}
}

E, no TemplateManager, ao invés de chamar ConventionController, chama-se a classe customizada ConventionControllerCustom:

import org.mentawai.template.Page;

import com.mentawaiexe.template.CustomConventionController;

public class TemplateManager extends org.mentawai.template.TemplateManager {

private static final String WEBINF_FOLDER = "/WEB-INF/";
private static final String DEFAULT_JSP_FOLDER = WEBINF_FOLDER + "Administracao/";

public void configurePages() {
Page page = new Page("Administracao/.*", DEFAULT_JSP_FOLDER + "home.jsp",  CustomConventionController.class);
add(page);
}
}

Está foi a solução que utilizei no meu projeto, e funciona perfeitamente.

Valeu felipowsky!

Estava desenvolvendo um projeto web utilizando a linguagem PHP. O mesmo encontrava-se 65% concluído. Foi então que, no início da semana passada resolvi parar e re-começar o projeto.

Alguns devem estar me chamando de louco! “O cara tem 65% de um projeto concluído e vai jogar na lata do lixo?! Esse cara é louco!”.

Eu tenho uma explicação para isso: Primeiramente, trata-se de um projeto particular, o que “não requer” $ de investimento no início. E, relativamente, grande. No início do projeto foi decidido usar um framework - que eu nunca havia usado. Tempo vai, tempo vem e começaram a aparecer algumas dúvidas na utilização do framework. Busquei suporte e não encontrava muita coisa na internet, já que se tratava de uma ferramenta “nova” (nem na versão 1.0 estava) e consequentemente, apareceram alguns POG’s (arghhhh). Sem contar que o framework era lento demais.

Semana passada, no meu “enorme” apartamento, comecei a pensar no bendido projeto( O que irá me render milhões de dólares [rs] ) e decidi refatorar o modelo que tinha em mãos e re-começar o projeto em Java.

Começaram as pesquisas por um framework web MVC. E o escolhido foi……MENTAWAI!

Para persistência, estou utilizando o Hibernate com Annotations..

Hoje o projeto ainda não tem nem 10% do que tinha antes, mas posso garantir que está bem mais estruturado. Os beans já estão mapeados e já tem até alguns CRUD’s [rs]

Aqueles que estão pensando em qual framework MVC utilizar na web, deêm uma olhada no mentawai, é uma ótima ferramenta e o suporte da comunidade é muito bom!

Espero, em breve, postar novas notícias do projeto…