Artigo Java Magazine 26 - Iniciando com Commons

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 {

    public boolean execute(Context context) throws Exception {

         System.out.printlnl(

             “2. Obter lista de produtos adquiridos, quantidade e valor”);

          return false;

     }

}

CalcularFrete.java

------------------------------------------------------------------------------------------- package jm.chain;

// ... imports

public class CalcularFrete implements Command {

      public boolean execute(Context context) throws Exception {

           System.out.println(“3. Calcular o frete”);

            return false;

     }

}

ConcluirCompra.java

------------------------------------------------------------------------------------------- package jm.chain;

// ... imports

public class ConcluirCompra implements Command {

        public boolean execute(Context context) throws Exception {

              System.out.println(“4a. Concluir a compra e despachar a mercadoria”);

              System.out.println(“4b. Fechada a compra do cliente “

                   + context.get(“codigoCliente”));

               return false;

         }

}

No exemplo, o comando ObterDados adiciona o código do cliente ao contexto com o método put(); os outros comandos da cadeia recuperam o código a partir do contexto com get().

O passo seguinte é criar uma classe com a chamada dos comandos na ordem de execução  desejada, implementando a interface Chain. No exemplo, estendemos a classe de implementação fornecida, chamada ChainBase (do pacote org.apache.commons.chain.impl). Veja a Listagem2.

Há muitos outros recursos do Commons Chain que não ilustramos no exemplo; por

exemplo:

• Definir a seqüência de execução num arquivo XML.

• Chamar uma cadeia de comandos a partir de outra.

• Automatizar o comportamento do contexto para integração com objetos Java comuns (POJOs).

• Definir filtros customizados para interromper a cadeia num ponto específico.

O Commons Chain é usado em vários projetos da Apache, entre eles o Struts e o Axis, e oferece uma maneira eficaz de desacoplar os objetos que enviam uma solicitação dos que as executam.

Commons HttpClient

O pacote java.net do J2SE fornece o essencial para acessar recursos via http e outros protocolos, mas operações mais complexas com http ainda exige muita codificação. Um exemplo de facilidade não suportada diretamente na API do J2SE é simular o fluxo de navegação, mantendo cookies entre as requisições.

O Commons HttpClient implementa todos os métodos HTTP (GET, POST, HEAD etc.), além de possibilitar a realização de tarefas como o acesso a conteúdos protegidos com diversos tipos de autenticação, o gerenciamento de cookies e  acesso a recursos WebDAV2. O exemplo da Listagem 3 simula o fluxo de navegação ao realizar uma busca no Google.

O HttpClient depende do Commons Codec. Você vai precisar baixar este componente e torná-lo acessível no classpath para testar o exemplo.

Listagem 2. Commons Chain, passo 2: uso do Commons Chain                            

package jm.chain;

import org.apache.commons.chain.impl .ChainBase;

import org.apache.commons.chain.impl .ContextBase; ...