Artigo Java Magazine 26 - Iniciando com Commons

Iniciando com Commons

Produtividade com os componentes do Jakarta

O Jakarta Commons traz soluções para tarefas do dia-a-dia que geralmente não são alvo principal dos projetos, e permite concentrar-se nas atividades essenciais.

O Jakarta Commons é um projeto open source da Apache Software Foundation (ASF) dedicado ao desenvolvimento de componentes reutilizáveis em Java, comprovados em muitos projetos importantes em todo o mundo. Com o Commons você tem a garantia de estar usando, na maior parte, componentes evoluídos e seguros.

Em vez de aplicações completas, o Jakarta Commons enfoca soluções para tarefas específicas, e atualmente engloba 33 componentes (além de 22 em incubação), organizados em subprojetos. Os componentes permitem realizar operações tão diversas como cálculos matemáticos avancados, processamento de XML, upload de arquivos em aplicações web, acesso a dados com JDBC, entre muitas outras (veja o quadro “Seleção do Commons”).

Neste artigo vamos apresentar, com exemplos, alguns dos principais componentes desse projeto da ASF.

Commons Chain

Se você precisa executar uma série de tarefas numa ordem específica, o Commons Chain pode trazer mais organização para seu sistema e facilitar a manutenção. Esse componente implementa os padrões de projeto Template Method e Chain of Responsibility (ambos do catálogo de padrões GoF¹), e facilita a implementação de soluções procedurais num modelo

orientado a objetos.

Para ilustrar o uso do Commons Chain, vamos considerar o processo de fechamento de uma compra num site típico de comércio eletrônico, onde executamos uma série de procedimentos de forma ordenada; por exemplo:

1. Obter dados do cliente.

2. Obter lista de produtos adquiridos, quantidade e valor.

3. Calcular o frete.

4. Concluir a compra e despachar a mercadoria.

Esse é um caso em que o Commons Chain se aplica perfeitamente. o primeiro passo é adaptar as classes usando o pattern Command (também do GoF). Criamos uma classe para cada uma das ações,implementando a interface org.apache.commons.Command. O único método dessa interface, execute(), retorna um booleano indicando se a cadeia deve continuar (false) ou terminar naquele comando (true). Se nenhum comando retornar true no execute(),a seqüência da cadeia terminará no último comando.

A Listagem 1 mostra as classes dos quatro comandos – ObterDados, ObterProdutos,

CalcularFrete e ConcluirCompra. Para simplificar o exemplo e manter o foco no Chain, as

classes apenas imprimem uma descrição da ação a ser executada.

Um dos objetivos do encapsulamento em comandos e permitir a execução em vários chains (=cadeias) simultaneamente. Assim, os comandos devem ser thread-safe; particularmente, eles não devem armazenar valores em atributos. Os valores são portanto armazenados num contexto, que fica disponível para todos os comandos inseridos no chain.

Listagem 1. Commons Chain, passo 1: organização em comandos

ObterDados.java

-------------------------------------------------------------------------------------------

 package jm.chain;

import org.apache.commons.chain.Command;

import org.apache.commons.chain.Context;

public class ObterDados implements Command {

public boolean execute(Context context) throws Exception {

System.out.println(“1. Obter dados do cliente”);

context.put(“codigoCliente”,new Integer(123456));

return false; // false indica que a cadeia deve continuar.

 }

}

ObterProdutos.java

-------------------------------------------------------------------------------------------

package jm.chain;

// ... imports

public class ObterProdutos implements Command {