Issuu on Google+

Lidando com Software: Ferramentas Gratuitas para todo o Ciclo de Vida Este texto apresenta uma coleção de ferramentas a serem usadas por equipes de desenvolvimento de software. Contemplam as atividades de análise, gerência de configuração, comunicação entre membros de uma equipe e outras. Todas as ferramentas apresentadas estão disponíveis para uso gratuito e, em boa parte, também são open source. Quando o tema é codificação, a opção foi Java(tm) e, portanto, espere ferramentas para análise de código escrito em Java(tm), em vez de C, C++ ou outra, por exemplo. O texto deveria auxiliar na escolha de ferramentas para emprego em um projeto. Ou seja, se você tem alguma sugestão, ela será bem-vinda e a comunidade alvo de leitores compreende gerentes de projetos, analistas, projetistas e outros especíalistas. Não se tem a pretensão de apresentar “as melhores”, nem mesmo ferramentas que foram avaliadas. Tenha em mente que a definição de ferramentas a serem empregadas em um projeto não é uma tarefa trivial e que este texto não elimina o esforço correspondente.

http://creativecommons.org/ Fábio Nogueira de Lucena Instituto de Informática (UFG) Contato: fabio@inf.ufg.br Telefone: (62) 3521-1510

Índice 1

Introdução...................................................................................................................................................................................... 3 1.1. Software livre........................................................................................................................................................................ 4 1.2. Principais fontes de software livre........................................................................................................................................ 4 1.3. Sistema Operacional..............................................................................................................................................................5 1.4. Orientação a Objetos............................................................................................................................................................. 6 1.5. Programação.......................................................................................................................................................................... 6 1.6. Linguagem Java..................................................................................................................................................................... 6 1.7. Classificação das ferramentas................................................................................................................................................8

2

Ferramentas básicas de programação.............................................................................................................................................8 2.1. Escrevendo código (editores e IDEs).................................................................................................................................... 8 2.2. Compiladores.........................................................................................................................................................................9 2.3. Máquinas Virtuais Java (MVJs) e interpretadores.............................................................................................................. 10

1


Creative Commons (cc) Fábio Nogueira de Lucena

2.4. Bibliotecas Java............................................................................................................................................................10 2.5. Manipulando bytecode.................................................................................................................................................11 2.6. Algoritmos e estruturas de dados em Java................................................................................................................... 11 2.7. Análise de código.........................................................................................................................................................11 2.8. Análise de desempenho, consumo de memória, ......................................................................................................... 12 2.9. Construção, automação e documentação..................................................................................................................... 12 2.10. Testes......................................................................................................................................................................... 13 3

Ferramentas geralmente empregadas....................................................................................................................................15 3.1. Configuração................................................................................................................................................................15 3.2. Logging........................................................................................................................................................................ 15 3.3. Ajuda (help)................................................................................................................................................................. 16 3.4. Interface gráfica............................................................................................................................................................16 3.5. Implantação, instalação e execução de aplicação........................................................................................................ 17

4

Ferramentas de propósitos específicos................................................................................................................................. 18 4.1. Descompilador............................................................................................................................................................. 18 4.2. Proteção........................................................................................................................................................................18 4.3. Execução de expressões matemáticas.......................................................................................................................... 18 4.4. Execução de regras.......................................................................................................................................................19 4.5. Geração de código em tempo de execução.................................................................................................................. 19 4.6. Desenhando gráficos.................................................................................................................................................... 19 4.7. Busca, extração, localização ... (de texto em documentos)..........................................................................................19 4.8. Acesso remoto (remoting) e distribuição..................................................................................................................... 20 4.9. Worflow....................................................................................................................................................................... 21

5

Web.......................................................................................................................................................................................21 5.1. Serviços web................................................................................................................................................................ 21 5.2. Navegadores.................................................................................................................................................................21 5.3. Clientes de email/news.................................................................................................................................................22 5.4. Clientes e servidores de FTP........................................................................................................................................22 5.5. Gerenciamento de aplicações.......................................................................................................................................22 5.6. Servidor Web e contêiner Servlet/JSP......................................................................................................................... 22 5.7. Cliente HTTP............................................................................................................................................................... 23 5.8. Servidor TCP, testando e monitorando conexões TCP .............................................................................................. 23

6

Gerenciamento de dados.......................................................................................................................................................23 6.1. Modelagem...................................................................................................................................................................23 6.2. SGBD........................................................................................................................................................................... 24 6.3. Clientes SQL................................................................................................................................................................ 24 6.4. Relatórios..................................................................................................................................................................... 24 6.5. Camada de persistência................................................................................................................................................ 25

7

Aplicações corporativas........................................................................................................................................................25 7.1. Softwares para gestão...................................................................................................................................................25 7.2. Infra-estrutura de desenvolvimento............................................................................................................................. 26 7.3. Internacionalização...................................................................................................................................................... 26 7.4. Barramentos de serviços corporativos (ESB).............................................................................................................. 26 7.5. Camada de apresentação.............................................................................................................................................. 27 7.6. Gerência de conteúdo...................................................................................................................................................27 7.7. Armazenando senhas....................................................................................................................................................28 2 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

7.8. Segurança..................................................................................................................................................................... 28 8

XML e serviços Web............................................................................................................................................................28 8.1. Serialização.................................................................................................................................................................. 29 8.2. Editores........................................................................................................................................................................ 29 8.3. Processamento..............................................................................................................................................................29 8.4. Emprego de XML em negócios................................................................................................................................... 31

9

Ferramentas para equipes..................................................................................................................................................... 31 9.1. Processo de software....................................................................................................................................................31 9.2. Modelagem...................................................................................................................................................................32 9.3. Gerência de requisitos..................................................................................................................................................33 9.4. Gerência de projeto de software...................................................................................................................................33 9.5. Sistemas de gestão empresarial.................................................................................................................................... 34 9.6. Gerência de configuração.............................................................................................................................................35 9.7. Acompanhamento de erros, issues, requisitos, ........................................................................................................... 35 9.8. Comunicação................................................................................................................................................................35 9.9. Documentação e sistemas de gerência de documentos................................................................................................ 36

10

Miscelânea..........................................................................................................................................................................37

11

Índice remissivo................................................................................................................................................................. 38

1

Introdução

Desenvolvimento de software para a Web é um tópico quente. Há grande interesse da sociedade pelo emprego de serviços de computação através do uso da internet. Satisfazer este interesse exige, além das dificuldades que já existiam para o desenvolvimento de software tradicional, outras típicas para a construção de software distribuído. Felizmente há uma rica variedade de tecnologias disponíveis. Neste texto Java™ é o ponto de referência para as tecnologias apresentadas. Esta escolha não é fruto de um resultado obtido com exaustivas análises e nem um comprometimento definitivo com Java™, nem mesmo a aprovação incondicional do que é apresentado. Outras abordagens, também úteis, poderiam ser empregadas. A ênfase em Java é complementada por outra dirigida para ambientes Linux. Isto não significa que outros ambientes operacionais não sejam contemplados pelas ferramentas apresentadas. De fato, boa parte delas possuem implementações para os mais variados ambientes. Mac OS(tm) e Windows(r) são alguns deles. Independente da tecnologia empregada há hoje grande quantidade de ferramentas de suporte, algumas de “domínio público” ou “livres” e outras ditas proprietárias. À semelhança da opção por Java e tecnologias associadas, há aqui preferência por ferramentas não proprietárias sem que isso represente uma negação da qualidade de produtos proprietários. Naturalmente, em situações específicas, é possível encontrar produtos proprietários mais adequados do que os de domínio público disponíveis e vice-versa.

3 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

Agora já é possível definir o que segue no restante do texto: apresentação de ferramentas não proprietárias para o desenvolvimento de software para web. Isto deve ser interpretado como uma fonte onde identificar software de domínio público, cujo uso e distribuição é assegurado sem a exigência de pagamento, mesmo quando são empregadas para fins comercias, voltada para a construção de software que será utilizado por usuários através de um browser. Há uma considerável quantidade de opções para cada um dos itens identificados. Não existe nenhuma pretensão de apresentar uma lista exaustiva (mesmo que seja possível) nem a “melhor” lista. Cada ferramenta aqui apresentada deverá ser avaliada antes de ser empregada para o fim pretendido. Neste sentido, este texto apenas facilita a tarefa ao apresentar uma compilação de ferramentas.

1.1. Software livre Free Software Foundation (http://www.fsf.org), também conhecida simplesmente por FSF, talvez seja a organização mais conhecida no universo de software livre. A FSF juntamente com o portal OpenSource (http://www.opensource.org) oferecem informações indispensáveis sobre este modelo de produção de software. Dúvidas surgirão acerca do significado e repercussão de uso de software livre. O portal OpenBar (http://open-bar.org/) auxilia nestes casos. Software Freedom (http://www.softwarefreedom.org/) oferece representação legal para a proteção de software de código livre.

1.2. Principais fontes de software livre Neste texto são apresentados inúmeros softwares voltados para a construção de software. Há exceções. Alguns são produtos finais, prontos para o uso por não desenvolvedores. Os softwares que podem ser construídos com as ferramentas aqui citadas não estão restritos a um domínio específico, por exemplo, gestão de empresas ou outro. Há, contudo, inclinação para o desenvolvimento para a web. As ferramentas citadas, salvo engano, são exclusivamente gratuitas. Ou seja, o uso delas não exige nenhum tipo pagamento desde que o resultado obtido também seja disponibilizado gratuitamente. Algumas licenças permitem até mesmo a exploração comercial sem nenhum tipo de pagamento. Isto terá que ser verificado, contudo, ferramenta por ferramenta, através da licença correspondente. Boa parte das ferramentas, além de gratuitas, são acompanhadas do código fonte correspondente, ou seja, são open source, o que assegura a possibilidade de alteração que se fizer necessária e a independência tecnológica em relação ao produto considerado. Existem muitos tipos de licenças para estes produtos, conforme o parágrafo acima sugere. Só porque o autor abre mão de receber pela sua obra não significa que tudo pode ser feito com o que é

4 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

oferecido. Tenha o cuidado de ler a licença disponível para cada ferramenta que desejar fazer uso. Abaixo seguem os principais portais pertinentes a software livre. Se está procurando por um software livre, sugiro que faça busca nestes portais: •

Sourceforge.net (http://sourceforge.net)

GNU (http://ww.gnu.org)

Apache Software Foundation (http://www.apache.org)

Open Software (www.opensource.org/)

ObjectWeb (http://www.objectweb.org/)

FreshMeat (http://freshmeat.net/)

Open Source Technology Group, ou OSTG (http://www.ostg.com/) e

Open Source Dir (http://ww.osdir.com)

As opções acima apresentam grande variedade de softwares. Outras inciativas são dirigidas para softwares específicos. Por exemplo: •

Tigris (http://www.tigris.org) visa fornecer um conjunto coerente de softwares livres para

apoiar atividades de engenharia de software. •

CodeHaus (http://www.codehaus.org/) é outra iniciativa que enfatiza código livre com

ênfase em Java, embora o foco não seja tão bem definido como no caso anterior. Estas e outras iniciativas hospedam projetos nos quais os softwares são construídos. •

Java-Source (http://java-source.net/) apresenta uma compilação dos mais variados

softwares livres disponíveis que oferecem serviços a desenvolvedores em Java. As ferramentas citadas não passaram por uma análise criteriosa onde supostamente apenas aquelas que apresentaram bons resultados foram selecionadas. Este simplesmente não é o caso. Se tem a pretensão de usá-las, faça por sua própria conta e risco, caso considere adequado. Antes de prosseguirmos com o que de fato interessa, vários países como o Brasil, por exemplo, têm demonstrado crescente atenção a software livre, conforme pode ser constado no Portal do Software Livre do Brasil (http://www.softwarelivre.gov.br/).

1.3. Sistema Operacional Há debates calorosos sobre distribuições do Linux (http://www.linux.org), motivados pela qualidade cada vez maior da interface gráfica oferecida aos usuários, além da facilidade também crescente de instalação. Após experimentar algumas delas, mas sem a pretensão de fazer uma análise, estou satisfeito com a Suse (http://www.suse.com) e Debian (http://www.debian.org). OpenBSD (http://www.openbsd.org) é reconhecido pela segurança que oferece, além da compatibilidade com binários para Linux e outras plataformas. FreeBSD (http://www.freebsd.org/) é um sistema operacional também derivado do BSD. Solaris(tm) por muito tempo foi um sistema proprietário e está entre os sistemas operacionais Unix mais respeitados, mas agora é livre: OpenSolaris(tm) (http://www.opensolaris.org/os/). 5 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

Há outras iniciativas livres. JNode (http://jnode.sourceforge.net) é um sistema operacional feito em Java. Há algumas poucas linhas em Assembly, o empréstimo de um mecanismos de boot do Linux e o resto todo em Java. Knoppix (http://www.knoppix.net/) é uma distribuição Linux conhecida pelo fato de ser executado a partir de um CD-ROM, sem que esta distribuição tenha que ser instalada. De fato, atualmente há várias distribuições com este recurso.

1.4. Orientação a Objetos Orientação a objetos, segundo definições clássicas, é uma abordagem empregada para perceber e tratar problemas como uma coleção de objetos, cada um deles uma combinação de dados e comportamentos. Confronte com a abordagem estruturada (análise e projeto estruturados de sistemas). Há abundante literatura sobre ambas. Identificar qual a melhor não faz sentido, pois cada uma possui pontos fortes e fracos em relação a um contexto investigado. Por ser amplamente comentada, o que é diferente de ser empregada corretamente, tanto em ambientes acadêmicos e industriais, o leitor observará que a maioria das ferramentas fornecidas referem-se à orientação a objetos. As fontes de informações sobre a tecnologia de orientação a objetos é extensa. Uma visão (http://ww.ootips.org/) e questões freqüentes (www.objectfaq.com/oofaq2/) podem ser úteis. Há algumas propostas para os iniciantes. Dentre elas, talvez o BlueJ (http://www.bluej.org/) seja a mais conhecida para aqueles que desejam conhecer a orientação a objetos e, em particular, através de Java. Este aprendizado é facilitado pelo livro de Bruce Eckel, Thinking in Java (http://mindview.net/Books), que pode ser obtido gratuitamente.

1.5. Programação O que é chamado aqui de programação está associado às tarefas realizadas por quem converte modelos de software em software capaz de ser executado. Implementação e codificação são outros termos também empregados. Não inclui um conjunto bem nítido de tarefas, pois abaixo seguem ferramentas que podem ser classificadas como sendo de fases vizinhas da programação, por exemplo, projeto detalhado e testes. Não há dúvidas, contudo, de que tais ferramentas são aquelas que de fato são utilizadas na construção direta de software.

1.6. Linguagem Java Especificação da linguagem Java Modelos de software são imprescindíveis em desenvolvimentos atuais, contudo, os benefícios destes só poderão ser usufruídos se convertidos em código. Uma linguagem de programação que oferece

6 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

suporte ao emprego de orientação a objetos, além de gozar de prestígio no meio acadêmico e industrial é a linguagem JavaTM (http://java.sun.com/docs/books/jls/). Não confunda a sugestão JavaTM com um compromisso incondicional. Um software pode exigir o emprego de várias linguagens, cada uma delas explorada no que possui de melhor. Convém ressaltar: o sucesso de um software depende sim do emprego adequado de uma linguagem de programação, mas depende ainda mais dos resultados da concepção deste software (análise e projeto).

Aprendendo a programar em Java Há muitos portais destinados ao tema. Você os encontrará com facilidade. Talvez o mais conhecido seja o The JavaTM Tutorial (http://java.sun.com/docs/books/tutorial/). Ainda incluo os portais abaixo como auxiliares e excelentes fontes para consultas rápidas e de referência. Para aquele que está realizando os primeiros passos, talvez seja interessante fazer uso de ferramentas que simplifiquem o contato inicial, em vez de fazer uso de ambientes sofisticados como Eclipse e outros, comentados em outra parte deste documento. Para estes, sugiro DrJava (http://drjava.org/). JavaPractices (http://www.javapractices.com/) oferece volumoso conjunto de exemplos, devidamente explanados. JExamples (http://www.jexamples.com/) é uma compilação de exemplos de ferramentas open source bem conhecidas. Facilita, portanto, o aprendizado através de exemplos de código efetivamente empregado. Exemplos em Java e open-source (http://java-source.net) não faltam. Uma extensa coleção de exemplos em Java, abrangendo parte significativa e amplamente empregada da biblioteca Java pode ser encontrada no Almanac Java (http://javaalmanac.com). Muitos gostam de participar de comunidades, dizem que se sentem estimulados e, se for em português, ainda melhor. Para estes SouJava (https://soujava.dev.java.net/) é uma opção.

Mantendo-se informado Para se manter informado acerca do que de mais relevante ocorre no mundo Java você deverá consultar JavaRSS (http://www.javarss.com) com freqüência. Alguns portais são particularmente úties como Java-Channel (http://www.java-channel.org/), jGuru (http://www.jguru.com), JavaPro (http://www.fawcette.com/javapro/), Java Technology (http://www-106.ibm.com/developerworks/java/),

Java.Net

(http://www.java.net/),

FTPOnline

(http://www.ftponline.com) e OnJava (http://www.onjava.com/). Você deverá se tornar um usuário contumaz daquele que mais te agrada. A linguagem Java é atrativa particularmente pelo seu rico conjunto de classes. A documentação da biblioteca Java pode ser obtida gratuitamente (http://java.sun.com/). Procurar por toda a biblioteca Java não é uma tarefa simples, dado que atualmente mais de 2000 classes estão disponíveis. Adicionando-se a estas um conjunto praticamente infindável de bibliotecas, temos um universo onde é difícil a localização de itens relevantes. O portal Jdocs (http://www.jdocs.com) nos oferece a oportunidade de procurar por classes, métodos e outros elementos no universo de

7 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

bibliotecas Java. Neste sentido, Kickjava (http://kickjava.com/) é uma alternativa.

Evolução da linguagem Java Java conta com uma comunidade ativa, conhecida por Java Community Process, ou JCP (http://www.jcp.org), que é responsável por evoluções desta plataforma. Esta comunidade é aberta, o que assegura um progresso sólido e não dominado por interesses particulares.

Ferramentas para o desenvolvimento em Java Este documento apresenta várias ferramentas para o desenvolvimento de software empregando Java, além de outras ferramentas de propósitos gerais. Alguns portais, por outro lado, estão concentrados especificamente em Java. Javatools (http://www.javatools.org) é voltado para a evolução das ferramentas de apoio ao emprego de Java. JavaToolbox (http://javatoolbox.com/) é outro portal com propósitos similares. Estas iniciativas oferecem àqueles que estão migrando para esta linguagem um atestado de saúde invejável e a segurança de um futuro a perder de vista respaldado por toda uma comunidade. Há todo um conjunto de ferramentas open source construídas em Java ou para serem usufruídas através de Java. Java Open Source Software (http://java-source.net/) é um deles.

1.7. Classificação das ferramentas Bom seria uma mera listagem das ferramentas aqui apresentadas e que isto não significasse nenhum problema da perspectiva dos leitores. Na prática, algum esquema de classificação tem que ser empregado com o propósito de, pelo menos, facilitar a localização. Dificilmente isto será obtido neste ou em outro texto e que agrade a todos os leitores. Se serve de consolo, também não estou satisfeito.

2

Ferramentas básicas de programação

2.1. Escrevendo código (editores e IDEs) Editores Embora existam muitos ambientes integrados de desenvolvimento, há quem prefira, por exemplo, o controle e a rapidez oferecida por um simples editor acrescido de alguns serviços típicos. Bluefish (http://bluefish.openoffice.nl/) e Scite (http://www.scintilla.org/) oferecem, por exemplo, recursos para edição de arquivos XML, Java, C, C++ e um vasto conjunto de outras linguagens. Também permitem a impressão destes arquivos com linhas numeradas, a sintaxe é ressaltada com o emprego de cores e a geração de arquivos PDF, entre outras. No mundo GNU editor é Emacs (http://www.gnu.org/software/emacs/). Trata-se de uma opção com considerável conjunto de

8 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

recursos. Muitas vezes o Emacs é empregado como “ambiente de desenvolvimento” por oferecer mecanismos similares para várias linguagens como C e Java, entre outras.

Ambientes integrados de desenvolvimento Edição, compilação, depuração e outras atividades, quando integradas em um ambiente, tornam mais simples o trabalho do desenvolvedor. O IDE (Integrated Development Environment) baseado no Eclipse (www.eclipse.org/) oferece estes serviços e permite, através da disponibilidade de amplo conjunto de plug-ins (http://www.eclipse.org/community/plugins.html), contemplar outras atividades típicas do desenvolvimento de sistemas complexos.

Outro conjunto de plugins, muitos deles

gratuitos, podem ser encontrados em Eclipse Plugin Central (http://www.eclipseplugincentral.com/). Um IDE concorrente fornecido pela Sun™ é o NetBeans (http://www.netbeans.org). Ainda há vários ambientes, embora contando com um número menor de ferramentas que aqueles comentados acima. jEdit (http://www.jedit.org/) apresenta características que não são encontradas facilmente mesmo em ambientes proprietários e considerados de qualidade. Redwood (http://www.cs.unr.edu/dt/) oferece uma forma creativa de apresentação do código.

2.2. Compiladores Embora o Eclipse contemple as ferramentas necessárias para a codificação de programas em Java, inclusive um compilador incremental, há outros serviços não inclusos e também necessários, como a máquina virtual Java e bibliotecas, além de documentação. Estes podem ser obtidos de um JDK (Java Development Kit). O JDK (java.sun.com/j2se/) fornecido pela Sun™ é a referência principal. O compilador Java fornecido pela IBM®, famoso pela eficiência com que produz bytecodes é o Jikes™ (www-124.ibm.com/developerworks/opensource/jikes/). Ainda mais rápido, talvez o mais célere deles, é o que acompanha o que é conhecido pelo Eclipse (http://www.eclipse.org). Entre as ferramentas GNU também se encontra o compilador GCJ (gcc.gnu.org/java/) que, além de produzir bytecodes, também gera código de máquina nativo, seja diretamente de código em Java ou de bytecodes. Java2XML (https://java2xml.dev.java.net/) é outro compilador, embora não tão comum, que recebe como entrada código fonte em Java e produz, como saída, documentos XML correspondentes. A conversão é tal que a volta, ou seja, a obtenção do código fonte a partir do documento XML anteriormente, é possível sem nenhuma perda de informação. Nos parágrafos anteriores foram apresentados compiladores com tarefas muito bem definidas. Algumas aplicações beneficiam-se de serviços típicos de compiladores. Por exemplo, processar um arquivo de entrada pode exigir a disponibilidade de um analisador léxico e outro sintático. Reconhecedores, compiladores e tradutores contendo ações em Java podem ser construídos com o apoio de ANTLR (http://www.antlr.org/). Esta framework oferece suporte para a construção de árvores sintáticas e percurso nestas árvores. Há várias gramáticas disponíveis para o emprego de 9 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

ANTLR, inclusive para a linguagem Java 5.0. Ou seja, ao menos em teoria é fácil escrever código que recebe como entrada um arquivo em Java e produz como saída, por exemplo, a razão entre a quantidade de linhas de comentários e o número de sentenças. Analisadores sintáticos, por exemplo, podem ser produzidos para tratar um determinado arquivo

de

entrada

pelo

custo

da

especificação

do

formato

deste

arquivo.

JavaCC

(https://javacc.dev.java.net/) é uma das ferramentas mais conhecidas para o desenvolvimento de analisadores sintáticos em Java.

2.3. Máquinas Virtuais Java (MVJs) e interpretadores Código em bytecodes são produzidos para serem executados por máquinas Java. Dado que são poucas as máquinas que compreendem bytecodes, é mais provável o emprego de uma máquina virtual para executar bytecodes. O software que implementa uma máquina virtual é conhecido por Máquina Virtual Java (MVJ). Há disponibilidade de MVJs para as mais várias plataformas de hardware e software, o que assegura a significativa portabilidade de código desenvolvido em Java. A MVJ fornecida pela Sun(tm) como parte do JDK (http://java.sun.com) talvez seja a mais empregada. JRockit (http://dev2dev.bea.com/wljrockit/) é uma referência quando desempenho é considerado. Kaffe (http://www.kaffe.org), Jikes (http://jikesrvm.sourceforge.net/), SableVM (http://sablevm.org/) são algumas do vasto conjunto de opções. Esta lista de MVJ pode ser estendida com muitas outras e não significa uma reprovação daquelas não citadas. Criar scripts em Java em um ambiente “leve” é o propósito de BeanShell (http://www.beanshell.org/). Pela facilidade com que sentenças podem ser executadas, este ambiente pode servir até mesmo para o aprendizado ou experimentação de recursos oferecidos pela biblioteca Java. Código fonte em Java também pode ser diretamente executado pela ferramenta DynamicJava (http://koala.ilog.fr/djava/).

2.4. Bibliotecas Java Máquinas virtuais geralmente são acompanhadas de implementações da biblioteca padrão Java. Outras bibliotecas apresentam características peculiares e serviços particulares. Algumas delas são comentadas nesta seção. Há de se destacar, contudo, projetos de iniciativa ampla, abordandos vários objetivos que dão origem a várias bibliotecas. Talvez o principal deles seja o Jakarta Commons (http://jakarta.apache.org/commons/). Neste projeto você encontrará muitas bibliotecas que oferecem serviços variados e de grande utilidade.

Biblioteca padrão Javolution (http://javolution.org/) oferece implementação para sistemas “embutidos” e de tempo real para várias classes da biblioteca Java.

10 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

GNU Classpath (http://www.gnu.org/software/classpath/) é uma implementação GPL das principais bibliotecas de classe para Java.

Unidades de medida Sistemas fazem uso de conjunto variável de unidades de medida como o metro, o litro e muitas outras. A JSR 275 (http://jcp.org/en/jsr/detail?id=275) especifica pacotes para a modelagem e uso de unidades de medidas. Esta JSR substitui a JSR-108. Interessados em unidades, um amplo conjunto delas, e as relações entre elas podem consultar o portal SI (http://physics.nist.gov/cuu/Units/). Neste sentido, contudo, a referência mais respeitada sobre unidades de medidas e as fórmulas envolvendo elas é o padrão ISO 31-0. Infelizmente este padrão não é público. JScience (http://jscience.org/) oferece uma implementação da JSR-108.

2.5. Criando e manipulando bytecode em tempo de execução ASM (http://asm.objectweb.org/) permite a geração de classes dinamicamente, diretamente em bytecodes. BCEL (http://jakarta.apache.org/bcel/) e Serp (http://serp.sourceforge.net/), juntamente com Javassist (http://www.csg.is.titech.ac.jp/~chiba/javassist/) formam as opções mais conhecidas.

2.6. Algoritmos e estruturas de dados em Java JDSL (http://www.jdsl.org) oferece extensa biblioteca contendo a implementação de vários algoritmos e estraturas de dados em Java. Algoritmos que trabalham sobre grafos estão disponíveis em JgraphT (http://jgrapht.sourceforge.net/).

2.7. Análise de código JavaNCSS (http://www.kclee.de/clemens/java/javancss/) é uma opção. Métricas, dependências entre pacotes e várias outras informações úteis para se assegurar a qualidade de software produzido podem ser obtidas com Dependency Finder (http://depfind.sourceforge.net/). Análise de código exige, principalmente quando a base de código é extensa, algum mecanismo

para

consulta

eficiente

ao

código,

como

oferecido

por

CodeCrawler

(http://codecrawler.sourceforge.net/). O restante desta seção, contudo, apresenta outras ferramentas que fornecem informações relevantes da perspectiva de qualidade de software. Uma importante fonte de informação sobre a qualidade de código pode ser obtida através da aplicação de métricas. Para a linguagem de programação Java e código orientado a objetos, a ferramenta Metrics (metrics.sourceforge.net/) oferece um rico conjunto de métricas. Em particular, esta ferramenta é um plug-in para o Eclipse. Outra ferramenta disponível é JMetric (http://www.it.swin.edu.au/projects/jmetric/products/jmetric/), 100% Java. A agência espacial americana é a responsável pelo desenvolvimento da ferramenta Java 11 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

PathFinder (http://javapathfinder.sourceforge.net/) que inclui uma MVJ devidamente modificada para capturar erros em programas Java e, em particular, aqueles decorrentes de programação concorrente. Ferramentas como FindBugs (http://findbugs.sourceforge.net) visam localizar possíveis erros assim como PMD (http://pmd.sourceforge.net). Auxiliar uma equipe a seguir um padrão de codificação além de alertar o desenvolvedor de práticas inadequadas é uma tarefa que é bem realizada e altamente configurável pela ferramenta Checkstyle (http://checkstyle.sourceforge.net/). Inspeções e revisões de código são práticas cuja literatura sugere apresentar bons resultados. A existência de ferramentas que possam auxiliar ou até mesmo automatizar esta tarefa, em conseqüência, é desejável. Hammurapi (http://www.hammurapi.org) é uma delas, além de oferecer várias métricas, inclusive através do emprego de gráficos. QJ-Pro (http:qjpro.sf.net) oferece serviços similares. A revisão de código também é uma excelente ferramenta para melhorar a qualidade de um software. Codestriker (http://codestriker.sourceforge.net) é uma ferramenta que auxilia a tarefa de revisores.

2.8. Análise de desempenho, consumo de memória, ... Para se analisar o desempenho de uma aplicação em Java podem ser utilizados os recursos da máquina virtual Java da Sun(tm) através da opção -Xprof ou ferramenta jconsole que também acompanha o JDK. Há, contudo, várias outras ferramentas disponíveis com propósitos similares. Quando se deseja identificar quais as partes de uma aplicação que mais consomem CPU o Eclipse Profiler Plug-in (http://eclipsecolorer.sourceforge.net/index_profiler.html) é uma opção. JRat (http://jrat.sourceforge.net/) e EJP (http://ejp.sourceforge.net/) são propostas similares a Cougaar Profiler (http://cougaar.org/projects/profiler/). JMemProf (http://oss.metaparadigm.com/jmemprof/) são algumas das opções enfatiza o consumo de memória, assim como JMP (http://www.khelekore.org/jmp/), que permite acompanhar o consumo de memória por objeto.

2.9. Construção, automação e documentação A tríade gerência de versões, testes de unidade e automação são elementos relevantes para o que é conhecido por eXtreme Programming. Destes elementos, a automação visa acompanhar continuamente os resultados das atualizações feitas por desenvolvedores. Ou seja, é necessário realizar de forma repetida, conforme a freqüência desejada, um conjunto de passos que permita, ao resultado deles, obter uma visão do progresso de uma equipe. Uma ferramenta que oferece este recurso é o CruiseControl (http://cruisecontrol.sf.net). Esta ferramenta é bem simples, apenas dispara a execução de tarefas em

12 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

instantes predefinidos. O emprego do CruiseControl geralmente é acompanhado do emprego de várias outras ferramentas que oferecem, por exemplo, a possibilidade da geração de código “executável” automaticamente através de uma descrição dos elementos de um software. Para desenvolvedores Java, a ferramenta de construção número um é

Ant (http://ant.apache.org). Antelope

(http://antelope.tigris.org) é uma interface gráfica para o Ant. A visualização das dependências em um arquivo de entrada (build.xml) do Ant pode ser feita pelo Grand (http://www.ggtools.net/grand/). Outra ferramenta cujo emprego é crescente, talvez pelo rico conjunto de recursos que oferece é Maven (http://maven.apache.org). Usuários do Eclipse beneficiam-se dos plugins Mevenide (http://mevenide.codehaus.org/) e Maven Workshop (http://www.binamics.com/mavenworkshop/). Ivy (http://www.jayasoft.fr/org/modules/ivy/) é um gerenciador de dependências. Ivy permite gerenciar

dependências

entre

componentes

que,

quando

não

disponíveis,

são

obtidos

automaticamente. Javadoc (http://java.sun.com/j2se/javadoc/) é comumente empregada para a documentação de código em Java. Doxigen (http://www.stack.nl/~dimitri/doxygen/) é um sistema de documentação que permite a geração de arquivos em formato como Latex, RTF e outros, a partir de documentação fornecida em código fonte em várias linguagens de programação, inclusive Java.

2.10. Testes Depuração de código (debugging) perdeu espaço para a produção de casos de testes. Isto não deve significar a inexistência de ferramentas de excelente qualidade para a depuração de código nem que esta é uma prática a ser banida. Desenvolvimento baseado em testes (Test-Driven Development), também conhecido pela sigla em inglês TDD, defende o emprego de testes freqüentes, o que só pode ser viabilizado com o emprego de ferramentas adequadas. De fato, TDD sugere que testes sejam criados antes do código que estes visam testar. TestDriven (http://www.testdriven.com) fornece detalhes.

Depuração Praticamente todo ambiente integrado de desenvolvimento é acompanhado de um depurador e, portanto, é apresentada um outro tipo de ferramenta que pode ser empregada com esta finalidade. JOI (http://www.programmers-friend.org/JOI/) permite investigar o estado de um objeto Java em determinado ponto da execução de um programa.

Testes A famosa ferramenta para testes de unidade conhecida por JUnit (http://www.junit.org) também possui portal com extensa documentação sobre o assunto, bem como a ferramenta correspondente.

13 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

Java também conta com JMock (http://www.jmock.org), útil para a criação de objetos “ocos” com o propósito de facilitar a realização de testes quando componentes não disponíveis ou que não se tem o interesse de serem usados no processo de teste, podem ser simulados por outros, desenvolvidos exclusivamente com esta finalidade com o apoio desta ferramenta. Programadores ainda se beneficiam de MockObject (http://www.mockobjects.com) e EasyMock (http://www.easymock.org/). TestGen4j (http://www.spikesource.com/projects/testgen4j/) é uma ferramenta que visa a geração automática de casos de teste em Java. Testes de unidade também precisam ser produzidos com qualidade. Particularmente em projetos maiores é necessário identificar quanto do código que está sendo desenvolvido é testado pelos testes de unidade, o que é conhecido por cobertura. Há várias ferramentas que fornecem estas informações, seja em arquivos txt, XML e até páginas com agradável aparência. Entre elas: Cobertura (http://cobertura.sourceforge.net), NoUnit (http://nounit.sf.net), Quilt (http://quilt.sf.net) e EMMA (http://emma.sf.net). Existem opções como InsectJ (http://insectj.sf.net). À medida que um software cresce, aumenta também o conjunto de cenários de teste e, com estes, a dificuldade de gerenciá-los. Testlink (http://testlink.sf.net) visa gerenciar via web casos de teste. Embora não seja exatamente uma ferramenta para cobertura de testes de unidade, Jester (http://jester.sourceforge.net) encontra código que não é coberto por casos de testes. Merece destaque porque código considerado pelos casos de teste, ou seja, código que as ferramentas de cobertura fornecidas acima consideram como testados podem ter sido apenas executados e não realmente testados. Outras ferramentas correlatas podem ser úteis. JUnitPerf (http://www.clarkware.com), por exemplo, permite obter informações sobre desempenho dos testes de unidade.

Testes de aceitação Enquanto as ferramentas acima estão direcionadas para equipes de desenvolvimento, outras como Jamelon (http://jameleon.sourceforge.net/) podem ser empregadas para a documentação, manutenção e execução de testes de aceitação. Fitnesse (http://www.fitnesse.org) é uma alternativa que oferece um portal web (wiki) passível de ser editado por usuários finais que fazem isto com a finalidade de acrescentar casos de teste e, automaticamente, verificar os resultados oferecidos pela aplicação.

Testes para tecnologias específicas HttpUnit (http://httpunit.sourceforge.net/) emula partes relevantes do comportamento de um browser e, dessa forma, cria a possibilidade de realização de testes sem intervenção humana. Testar aplicações web que fazem uso de HTTP pode exigir o emprego de ferramenta similar à WebInject (http://www.webinject.org/). Os testes, nesta ferramenta, são escritos em XML. Cada arquivo XML é

14 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

então executado e a aplicação correspondente, ao fornecer as respostas, é validada conforme o conteúdo em XML. Jwebunit (http://jwebunit.sourceforge.net) é uma outra opção. Cactus (http://jakarta.apache.org/cactus/) é uma alternativa geralmente sugerida por desenvolvedores para testes de código de aplicações web (lado do servidor). JMeter (http://jakarta.apache.org/jmeter/) pode ser empregada com propósitos similares, embora seja particularmente indicada para testes de carga. Para assegurar que um documento XML apresenta uma determinada estrutura pode ser empregado o XMLUnit (http://xmlunit.sourceforge.net). Aplicações web trocam requisições via HTTP entre os seus componentes. Antater (http://aft.sf.net) visa auxiliar a execução de testes deste tipo de aplicação através do emprego de Ant (13). SocketTest (http://sockettest.sourceforge.net/) oferece recursos para testes de conexões socketes. Há também ferramentas como JFCUnit (http://jfcunit.sourceforge.net/) voltada para o desenvolvimento de casos de teste para interfaces gráficas baseadas no Swing (16).

3

Ferramentas geralmente empregadas

3.1. Configuração Aplicações oferecem, em geral, um conjunto de serviços que podem ser configurados conforme o hardware utilizado, o SGBD empregado ou até mesmo as preferências pessoais dos usuários. JConfig (http://www.jconfig.org) é uma ferramenta que pode ser empregada com este propósito. Há crescente emprego do que é conhecido por IoC (Inversion of Control) ou ainda Dependency Injection para a configuração de aplicações Java. Ao se empregar este padrão de projeto, um objeto não mais precisa gerenciar as dependências que possui de outros objetos. Em vez disso, as dependências são configuradas e fornecidas ao objeto dependente por um elemento externo, o contêiner. PicoConteiner (http://www.picocontainer.org/) e Spring (http://www.springframework.org) estão entre os contêineres mais comentados para esta tarefa. Alternativas: Excalibur (http://excalibur.apache.org/), Gravity (https://gravity.dev.java.net/) e Jice (http://jicengine.sourceforge.net/), por exemplo.

3.2. Logging Quanto mais sofisticado um software, maiores são as necessidades de se acompanhar a correspondente execução. Esta tarefa é geralmente acompanhada pelo emprego do que é conhecido

15 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

por logging, que pode ser definido como o processo de armazenamento de informações sobre eventos relevantes. Em Java há várias opções para logging. Uma delas é “oficial”, ou seja, oferecida através do pacote java.util.logging. Provavelmente a mais empregada e considerada por muitos a melhor pelo conjunto de facilitadas que oferece é Log4j (http://logging.apache.org/log4j). Para esta existem ferramentas sofisticadas como ChainSaw (http://logging.apache.org/log4j/docs/chainsaw.html), que permite visualizar registros de logging produzidos pelo Log4j. jLo (http://jlo.jzonic.org/) e Simple Log (https://simple-log.dev.java.net/) são opções. Cada uma delas oferece, em geral, benefício não contido em outras, tornando o conjunto único. Em conseqüência,

surgiram

várias

iniciativas

para

produzir

uma

interface

única.

SLF4J

(http://www.slf4j.org/) talvez seja a mais conhecida. O objetivo é empregar o padrão de projeto Façade para encapsular o acesso a várias ferramentas que oferecem serviços de logging.

3.3. Ajuda (help) A produção de material de apoio a usuários de sistemas de informação não é uma tarefa simples. JavaHelp (http://java.sun.com/products/javahelp/) é um sistema com o propósito de divulgar informações de ajuda independente de plataforma. Documentação via web é uma das opções de JavaHelp. Uma alternativa relativamente recente é DocBook (http://www.docbook.org/), cujo conteúdo é fornecido em XML e do qual podem ser gerados os formatos HTML, RTF e outros.

3.4. Interface gráfica Toolkits e bibliotecas de componentes Duas bibliotecas destacam-se na construção de interfaces: Swing (http://java.sun.com/products/jfc/) e SWT. SWT é parte do ambiente Eclipse (http://www.eclipse.org). JFC/Swing conta com a comunidade JavaDesktop (http://community.java.net/javadesktop/), através da qual ferramentas, técnicas, novidades e outros serviços úteis são fornecidos aos interessados, além de farta literatura. Há também bibliotecas que visam tornar o look and feel de interfaces gráficas desenvolvidas em Java mais atraente. Jgoodies (https://jgoodies.dev.java.net/) é uma delas. Alguns recursos não fazem parte do Swing, como por exemplo um componente para seleção de datas. Felizmente há opções. NachoCalendar (http://nachocalendar.sourceforge.net/), Jcalendar (http://toedter.com/en/jcalendar/) e MSeries (http://web.ukonline.co.uk/mseries/) são exemplos.

Construtores de interfaces Aplicações em Java podem possuir interfaces gráficas sofisticadas, cujo desenvolvimento é considerado, em geral, oneroso. Para amenizar este problema existem ferramentas conhecidas por construtores de interfaces (ou interface builders). Comumente estas ferramentas permitem que o 16 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

usuário através de recursos como arrastar-e-soltar realize boa parte do projeto de interação, cujo código correspondente é automaticamente gerado. Menus, barras de ferramentas e caixas de diálogo geralmente podem ser desenvolvidas sem a necessidade de se escrever código quando estas ferramentas são empregadas. ThinLet (http://thinlet.sourceforge.net)

e WiSer (https://wiser.dev.java.net/) são opções.

XAMJ (http://html.xamjwg.org/) é uma aplicação de XML usada para descrever interfaces gráficas para Java e executada em browser próprio. Se isto não é uma restrição, então a opção fornecida pelo Mozilla, o XUL (http://www.mozilla.org/projects/xul/) deve ser considerada para a criação de interfaces ricas. Várias outras ferramentas oferecem serviços para a construção de interfaces gráficas usando o Swing: NetBeans (http://www.netbeans.org), Vep Eclipse Plugin (http://www.eclipse.org/vep/) e XMLGUI (http://xmlgui.tigris.org/). JNDC (https://jdnc.dev.java.net/) visa reduzir o esforço e a habilidade necessários para a construção de interfaces gráficas ricas em elementos de interação. Também há abordagens como XUI (http://xui.sourceforge.net/) que combina Java e XML para tornar o desenvolvimento de interfaces gráficas mais eficiente. Propósito similar também é oferecido por Hierarchy (http://chrriis.brainlex.com/projects/uihierarchy/) e Gui4j (http://www.gui4j.org/) são opções. Aqueles interessados em fazer uso de interfaces usando o Swing através de um contêiner web podem fazer uso de SwingWeb (http://swingweb.sourceforge.net/). OpenLaszlo (http://www.openlaszlo.org/) oferece recursos gráficos de aplicações desktop, similares àquelas discutidas acima através de um browser convencional. FormLayoutMaker (http://formlayoutmaker.sourceforge.net/) é para aqueles que desejam criar interfaces gráficas em Java e ainda não encontraram uma forma elegante de organizar o leiaute de formulários. Abeille (https://abeille.dev.java.net/) é uma alternativa para organização de formulários.

Visualização A visualização

de grafos é contemplada

por respeitadas

ferramentas

como Graphviz

(http://www.graphviz.org/) e JGraph (http://www.jgraph.com/).

3.5. Implantação, instalação e execução de aplicação IzPack (http://www.izforge.com/izpack/) é um instalador de aplicações para a plataforma Java. O usuário do IzPack deve possuir uma máquina virtual Java devidamente instalada. Há ainda NSIS (http://nsis.sourceforge.net) para Windows e EPM (http://www.easysw.com/epm) para Linux. Commons Launcher (http://jakarta.apache.org/commons/launcher/) não é exatamente uma ferramenta para instalação, mas para disparar a execução de uma aplicação Java devidamente

17 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

preparada para tratar as diferenças de ambientes onde a aplicação Java será executada. Commons Launcher torna desnecessário o uso de extensos e complexos scripts que algumas vezes são necessários para iniciar a execução de uma classe Java. Launch4j (http://launch4j.sourceforge.net/) permite que um arquivo .jar seja executado em ambiente Linux ou Windows como se fosse uma aplicação nativa de um destes sistemas. One-JAR (http://one-jar.sourceforge.net/) oferece serviços para implantação de uma aplicação Java através de um único arquivo JAR. JWizard (http://flib.sourceforge.net/JWizard/doc/) também pode ser empregado para gerar instaladores.

4

Ferramentas de propósitos específicos

4.1. Descompilador Há várias ferramentas para obter código fonte em Java a partir de código em bytecodes. JODE (http://jode.sourceforge.net/) e JreversePRO (http://jrevpro.sourceforge.net/) são algumas delas. Jad (http://kpdus.tripod.com/jad.html), HomeBrew (http://www.pdr.cx/projects/hbd/), Mocha (http://www.brouhaha.com/~eric/software/mocha/) e CavaJ (http://www.bysoft.se/sureshot/cavaj/) são opções. Observe que ferramentas para proteção de código em Java, veja seção seguinte, visam reduzir a qualidade do processo de descompilação.

4.2. Proteção Resultados satisfatórios da engenharia reversa, obtenção de código fonte a partirde código em bytecodes, preocupam alguns. ProGuard (http://proguard.sourceforge.net) é um obfuscador, o que torna praticamente ininteligível para seres humanos o resultado do emprego de ferramentas como decompiladores, comentados acima. A empresa yWorks oferece o yGuard (http://www.yworks.com/).

4.3. Execução de expressões matemáticas A avaliação de expressões matemáticas é um requisito comum em vários sistemas. Muitos deles fazem uso de expressões escritas em código e, quando as expressões devem ser alteradas, código deve ser alterado, recompilado e assim por diante, dificultanto a manutenção. Aplicações mais dinâmicas, contudo, precisam da flexibilidade oferecida quando a expressão só é conhecida em tempo de execução, como as planilhas de cálculo podem comprovar. JEP (https://sourceforge.net/projects/jep/) é um analisador e avaliador de expressões matemáticas escrito em Java. Java Expression Library ou JEL (http://galaxy.fzu.cz/JEL/) é uma 18 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

alternativa para expressões de uma única linha. BeanShell (http://www.beanshell.org/) também possui um interpretador que pode ser utilizado com a mesma finalidade.

4.4. Execução de regras Drools (http://drools.org/) é uma implementação totalmente compatível com a máquina de regras JSR-94. JSRs podem ser consultados no portal da comunidade Java ou JCP (http://www.jcp.org/). O desenvolvimento de aplicações baseadas em regras ou aplicações de regras de negócio conta com informações disponíveis pela comunidade Javarules.org (http://javarules.org).

4.5. Geração de código em tempo de execução Em alguns casos é necessário acrescentar serviços a classes e interfaces em tempo de execução. CGLIB (http://cglib.sourceforge.net/) é uma das ferramentas mais empregadas para Java.

4.6. Desenhando gráficos Aplicações em Java que manipulam dados podem fazer uso dos mais variados tipos de gráficos (pizza, histograma, série e outros). JFreeChart (http://www.jfree.org/jfreechart/) é uma biblioteca para a geração de gráficos com variado e rico conjunto de opções.

4.7. Busca, extração, localização ... (de texto em documentos) Lucene (http://jakarta.apache.org/lucene/) é uma ferramenta para busca em texto, escrita em Java. Empregando este recurso aplicações podem realizar consultas empregando expressões lógicas e obter como resultado arquivos que satisfazem os critérios de busca indicados. DocSearcher (http://docsearcher.sourceforge.net) faz uso de Lucene para oferecer o serviço de busca de texto em documentos em vários formatos (.doc, .pdf e outros). Com o propósito de especificamente localizar há ferramentas como XTF (http://xtf.sourceforge.net/), que contempla formatos como XML, PDF e Word. CompassFramework (http://compass.sourceforge.net/) faz uso de Lucene (fornecida acima) para permitir a localização de informações em dados de aplicações que fazem uso de Hibernate e Spring, por exemplo. Letras, dígitos e outros caracteres são manipulados por um computador através de um número atribuído para cada um deles. Um conjunto destas atribuições é conhecido por code page ou charset encoding. Quando uma aplicação precisa manipular arquivos, por exemplo, obtidos da Internet, pode ser necessário identificar o code page empregado na construção do arquivo para que o processamento dele possa ser realizado de forma correta. A ferramenta cpdetector (http://cpdetector.sf.net) pode ser utilizada para esta finalidade.

19 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

Multivalent (http://multivalent.sourceforge.net/) permite extrair texto de arquivos em vários formatos (PDF, HTML e outros), além de realizar várias operações de manipulação de arquivos nestes formatos. Jpedal (http://www.jpedal.org) e PDFBox (http://www.pdfbox.org/) também permite extrair

textos

de

arquivos

PDF,

unir

tais

arquivos,

realizar

busca

e

outras.

PJ

(http://www.etymon.com/epub.html) permite manipular de várias formas arquivos no formato PDF. Várias bibliotecas (http://schmidt.devlib.org/java/document-libraries.html) para manipulação de arquivos em vários formatos, não apenas PDF, inclua aí .doc e .ppt encontram-se disponíveis.

4.8. Acesso remoto (remoting) e distribuição Conforme Martin Fowler em Patterns of Enterprise Application Architecture, AddisonWesley, 2003, a primeira lei da computação distribuída é: “não distribua seus objetos”. Esta é uma clara orientação para evitar o emprego de objetos distribuídos, exceto quando forem realmente necessários. Quando serviços oferecidos por uma aplicação, contudo, precisam ser usufruídos através de um cliente remoto, torna-se necessário para estes clientes ou para clientes em outros processos, a disponibilidade de uma forma de conexão com os serviços oferecidos. Observe que isto não significa que a aplicação que oferece os serviços é distribuída, mas apenas o acesso a estes é feito remotamente. Há várias propostas para este tipo de conexão. Um protocolo leve de acesso remoto baseado em HTTP é oferecido pela companhia Caucho (http://www.caucho.com). Um deles é o Hessian (http://www.caucho.com/hessian/), mais leve que o já leve Burlap (http://www.caucho.com/burlap/). Ambos são alternativas para chamadas remotas de método onde objetos encontram-se distribuídos. Este serviço é oferecido através de RMI (http://java.sun.com/products/jdk/rmi/). Esta e outras abordagens como CORBA são consideradas heavyweight. NailGun (http://www.martiansoftware.com/nailgun/) é uma opção que oferece cliente (escrito em linguagem C), protocolo e servidor onde código em Java é executado. O cliente assume que a interação com o servidor é realizada exclusivamente através da entrada e saída padrãos. Páginas em HTML contendo JavaScript também pode fazer uso de objetos remotos através de DWR (http://www.getahead.ltd.uk/dwr/), que emprega um conjunto de tecnologias conhecido por AJAX.(http://en.wikipedia.org/wiki/Ajax_(programming)). O emprego de AJAX também ocorre em Echo2 (http://www.nextapp.com/products/echo2/) e AjaxTags (http://ajaxtags.sourceforge.net/). Ainda há outras opções como AjaxAnywhere (http://ajaxanywhere.sourceforge.net/). Para facilitar o emprego de AJAX tem Taconite (http://taconite.sourceforge.net/). XINS (http://xins.sourceforge.net/) é apresentada como alternativa para SOAP, WSDL e UDDI. Detalhes destas tecnologias em W3C (http://www.w3.org/). Ao contrário de abordagens como aquelas acima, que visam oferecer uma possibilidade de acesso remoto, Crispy (http://crispy.sourceforge.net/) oferece uma “interface” única através da qual várias das possibilidades de conexão podem ser exploradas sem que isto altere o código que requisita 20 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

os serviços remotos. Mantaray (http://sourceforge.net/projects/mantaray/) é um sistema para troca de mensagens sem a presença de um servidor. JGroups (http://www.jgroups.org/) comunicação multicast confiável.

4.9. Worflow The State of Workflow de Tom Baeyens, publicado pela TheServerSide.COM em http://www.theserverside.com/articles/article.tss?l=Workflow, oferece uma abrangente visão do que se conhece por workflow. A gerência de processos de negócio, business process management, é um requisito relevante de aplicações modernas. Tão relevante que há várias iniciativas com o propósito de facilitar o desenvolvimento de gerenciadores destes processos de forma simplificada. A JSR-207 (http://www.jcp.org/en/jsr/detail?id=207) é uma delas, que tem como propósito facilitar a programação de processos de negócios em Java. Há muitos workflow engines de domínio público que devem ser investigados. Por exemplo, OpenWFE (http://www.openwfe.org), entre outros. jBPM (http://jbpm.org/) é um sistema de gerência de workflows. Flow4J (http://flow4jeclipse.sf.net) é uma ferramenta empregada para modelar processos e, dos modelos produzidos, automaticamente gerar código fonte em Java correspondente.

5

Web

5.1. Serviços web Axis (http://ws.apache.org/axis) é uma implementação de SOAP (Simple Object Access Protocol). Para a inspeção de serviços e invocação de serviços Soapui (http://www.soapui.org/) oferece uma interface gráfica através da qual a invocação de um web service torna-se uma tarefa simples. Desenvolvedores J2EE que fazem uso do Eclipse encontram várias ferramentas de apoio no projeto WTP (http://eclipse.org/webtools/). Lomboz (http://lomboz.objectweb.org/) é uma alternativa.

5.2. Navegadores A infra-estrutura oferecida pelo que é conhecido por web torna-se acessível aos seres humanos através de navegadores, também conhecidos por browsers. Da perspectiva de aplicações web a identificação dos navegadores para os quais suporte será oferecido é relevante. Isto porque nem todos oferecem os mesmos recursos, nem o mesmo desempenho nem a mesma segurança, o que torna a compatibilidade uma questão a ser observada. Firefox (http://www.mozilla.org/products/firefox/) tem se destacado recentemente. Disponível para as principais plataformas e “mais seguro”. No momento em que escrevo este texto já 21 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

foram baixadas mais de 45 milhões de cópias do Firefox. NetScape (http://channels.netscape.com/ns/browsers/), Konqueror (http://www.konqueror.org) e Slim Browser (http://www.flashpeak.com/sbrowser/) são opções. Embora a maioria dos usuários espere por gráficos, há navegadores exclusivamento em texto. Lynx (http://lynx.isc.org) é um dos mais conhecidos.

5.3. Clientes de email/news Thunderbird (http://www.mozilla.org/projects/thunderbird/) possui distribuição para os principais sistemas operacionais, inclusive uma versão para o Windows. Possui fama de seguro e vários recursos desejados por usuários. Columba (http://columba.sourceforge.net/) é uma opção recente, escrita totalmente em Java. RSSOwl (http://rssowl.org/) é um leitor RSS totalmente escrito em Java e baseado no SWT. Há muitos comentários favoráveis à qualidade da interface oferecida.

5.4. Clientes e servidores de FTP Um serviço de uso comum e eficiente para troca de arquivos é através do protocolo FTP. Existem vários clientes que fazem uso deste protocolo. QuickDownloader (http://www.quickdownloader.com) é uma opção escrita 100% em Java. Filezilla (http://filezilla.sourceforge.net/) é uma opção muito empregada por usuários dos sistemas operacionais da Microsoft(tm). Quanto a servidores, o Vsftpd (http://vsftpd.beasts.org/) diz-se ser seguro.

5.5. Gerenciamento de aplicações Aplicações web, em particular, oferecem seus serviços através de um conjunto considerável de ferramentas que trabalham em conjunto. Nestes casos, gerenciar os vários componentes da aplicação é uma atividade que não pode ser desprezada. JMX (http://java.sun.com/jmx/) é uma tecnologia que inclui ferramentas para a construção de aplicações web, soluções modulares e monitoramente de dispositivos e aplicações, entre outros. A Sun(tm) oferece uma implementação de referência JMX RI (http://java.sun.com/jmx/). XMOJO (http://www.xmojo.org), MX4J (http://mx4j.sourceforge.net/) e JBoss MX (http://www.jboss.org) são opções. Para acompanhar visualmente a execução de aplicações que são gerenciadas via JMX pode ser empregada a ferramenta MC4J (http://mc4j.sourceforge.net/), que oferece um sofisticado painel de controle.

22 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

5.6. Servidor Web e contêiner Servlet/JSP Uma aplicação web exige a existência de um servidor Web. Apache (http://httpd.apache.org/) é o servidor mais empregado atualmente. O sucesso do servidor Apache deixa pouco espaço para outros. Contudo, há casos especiais. Por exemplo, NanoHTTPD (http://elonen.iki.fi/code/nanohttpd/), como o próprio nome indica, trata-se de um servidor realmente pequeno, contido em um único arquivo Java. No universo dos “pequenos” também podem ser citados TJWS (http://tjws.sourceforge.net/), Ravenous (http://ravenous.solidosystems.com/) e Jetty (http://jetty.mortbay.org), todos escritos 100% em Java. Jetty é um contêiner Servlet/JSP, mas é o Tomcat (http://jakarta.apache.org/tomcat/) a implementação de referência oficial das tecnologias Servlet e JavaServer Pages. Servidores web são excelentes para a apresentação de páginas estáticas, que são insuficientes para as exigências dos sistemas de informação usufruídos pela web. Estender as funcionalidades de um servidor web é o objetivo de Servlets (http://java.sun.com/products/servlet). A tecnologia Servlet é empregada, em geral, em conjunto com JavaServer Pages ou JSP (http://java.sun.com/products/jsp). De forma simplificada, pode-se dizer que Servlet está mais direcionado para o “controle” de uma aplicação como verificação de autorização para realizar determinada tarefa, enquanto JSP fundamentalmente oferece mecanismos para a criação de páginas dinâmicas sem exigir habilidades de programação. Ou seja, JSP permite “isolar” projetistas de páginas (web designers) das complexidades de programação. As especificações mais recentes de Servlet e JSP podem ser obtidas a partir dos portais supracitados. Sysdeo (http://www.sysdeo.com/eclipse/tomcatPlugin.html) é um plug-in para o ambiente Eclipse a partir do qual o emprego do Tomcat é facilitado.

5.7. Cliente HTTP Para simular o emprego de um browser, tarefa muitas vezes exigida durante o desenvolvimento de uma aplicação web pode se empregar HttpClient (http://jakarta.apache.org/commons/httpclient/).

5.8. Servidor TCP, testando e monitorando conexões TCP O desenvolvimento de algumas aplicações exige a disponibilidade de conexões TCP para múltiplos clientes, que requisitam serviços concorrentemente. QuickServer (http://www.quickserver.org/) é uma

biblioteca

Java

que

permite

agiliza

a

criação

de

tais

aplicações.

SocketTest

(http://sockettest.sourceforge.net/) pode ser útil para testes. Para monitorar conexões TCP existe o projeto Apache TCPMon (https://tcpmon.dev.java.net/). Esta ferramenta permite observar o tráfego entre cliente e servidor.

23 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

6

Gerenciamento de dados

6.1. Modelagem DBDesigner4 (http://www.fabforce.net/dbdesigner4/) é uma ferramenta para projeto visual de bases de dados. A ferramenta inclui o projeto, modelagem, criação e manutenção.

6.2. SGBD Felizmente não faltam opções de sistemas gerenciadores de bancos de dados de domínio público e open source. HSQLDB (http://hsqldb.sourceforge.net/) é 100% Java, assim como Derby (http://db.apache.org/) e Berkeley DB (http://www.sleepycat.com/). Não são os únicos com tais características. McKoi (http://mckoi.com/database/) e One$DB (http://www.daffodildb.com/) são opções. Fora do universo de SGBDs desenvolvidos em Java, MySQL (http://www.mysql.com) e PostgreSQL (http://www.postgresql.org) são opções muito conhecidas. Há ainda o FireBird (http://firebird.sourceforge.net/). As opções acima incluem apenas SGBDs relacionais. db4o (http://www.db4o.com/) é uma opção orientada a objetos.

6.3. Clientes SQL Há várias opções de clientes que acessam bases de dados via SQL. O HSQLDB (http://hsqldb.sourceforge.net) é acompanhado de um cliente para esta e vários outros SGBDs. Convém ressaltar que cada SGBD oferece, em geral, seu próprio cliente. Fazer uso de um único, por outro lado, desonera o conhecimento de várias ferramentas. O IDE Eclipse oferece vários plug-ins para os interessados em interagir com bases SQL. JFaceDBC (https://sqlexplorer.dev.java.net/) e Quantum (http://quantum.sourceforge.net) são dois deles. PKLite SQL Client (http://pklite.sourceforge.net/) é uma opção.. Também há o iSQL-Viewer (http://isql.sourceforge.net/) de sofisticada interface. SQuirrel SQL (http://squirrel-sql.sourceforge.net/) é outra ferramenta. Em geral, permitem a execução de sentenças SQL e interação com a base de dados através de uma interface amigável. Além destes serviços e com facilidades para definir e documentar bases de dados tem-se a ferramenta Druid (http://druid.sourceforge.net/).

6.4. Relatórios ObjectVisualizer (http://objectvisualizer.com/) facilita a construção de consultas, relatórios e a

24 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

geração de gráficos. Em conjunto com OpenReports (http://oreports.com/) usuários podem dinamicamente gerar relatórios através de um browser. Há várias alternativas para a geração de relatórios. DataVision (http://datavision.sourceforge.net/) é uma ferramenta que possui os mesmos propósitos

do conhecido

Crystal

Reports.

JERT

(http://jert.sourceforge.net/), JfreeReport

(http://www.jfree.org/jfreereport/) e iText (http://www.lowagie.com/iText/) são algumas das opções. JasperReports (http://jasperreports.sourceforge.net/) talvez seja uma das mais conhecidas e possui um visualizador de relatórios JasperViewer (http://jasperassistant.com/jasperviewer.html) e construtores de relatórios como o iReport (http://ireport.sourceforge.net/), que permite a elaboração do design de relatórios. Eclipse/BIRT (http://www.eclipse.org/birt) permite a definição de leiaute, acesso a base de dados e scripts tudo integrado ao ambiente Eclipse.

6.5. Camada de persistência Sistemas de informação atuais quase sempre são rotulados como “orientados a objetos” e, ao mesmo tempo, empregam um SGBD relacional para a persistência de informações. Qualquer sistema que faça uso real destes dois modelos terá que construir uma “camada de persistência”, responsável por ser o intermediário entre estes dois modelos, em ambos os sentidos. Ou seja, obtém objetos e os armazena na forma de registros sobre tabelas e, no sentido oposto, recupera informações disponíveis em tabelas e as converte para os objetos de interesse. Há ferramentas que auxiliam nesta onerosa tarefa. JDO ou Java Data Objects (http://java.sun.com/products/jdo/) é uma API que pode ser empregada com esta finalida. TJDO (http://tjdo.sourceforge.net/) e JPO (http://jpox.sourceforge.net/) são implementações de JDO. ObjectRelationalBridge (http://db.apache.org/ojb/) é outra opção que, embora implemente JDO, também é compatível com ODMB 3.0. Crescente em popularidade pelos recursos, qualidade e desempenho oferecidos encontra-se Hibernate (http://www.hibernate.org/). Usuários do Hibernate que também fazem uso do Eclipse têm um auxílio extra, o Hibernate Synchronizer (http://www.binamics.com/hibernatesync/), que agiliza a execução de algumas tarefas. Apesar destes benefĩcios, também existem outras ferramentas voltadas para o mapeamento de objetos em tabelas. Cayenne (http://objectstyle.org/cayenne/) é uma delas.

25 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

7

Aplicações corporativas

7.1. Softwares para gestão Existe software livre disponível para os mais variados setores de atuação. Por exemplo, OpenUSS (http://openuss.sourceforge.net) é um software livre voltado para faculdades e universidades. Alguns softwares oferecem extenso suporte a atividades de gestão empresarial. Naturalmente, apenas alguns casos podem imediatamente se beneficiar destes produtos como disponíveis. Em todos os demais são necessárias personalizações. Contudo, de custo bem inferior ao desenvolvimento completo que teria que ser realizado sem a existência destas ferramentas. Algumas ferramentas ERP (Enterprise Resource Planning) incluem: •

Open for Business (http://www.ofbiz.org/)

Compiere (http://www.compiere.org)

TinyERP (http://tinyerp.org/)

OpenCRX (http://opencrx.sourceforge.net).

7.2. Infra-estrutura de desenvolvimento Sistemas para a web exigem a disponibilidade de vários serviços como troca de mensagens, segurança, transação e outros. A plataforma J2EE (http://java.sun.com/j2ee) é um conjunto de especificações que fornecem tais serviços. Uma das implementações mais respeitadas de J2EE é o JBoss (http://www.jboss.org). O uso dos serviços oferecidos pelo Jboss podem ser realizado através do plug-in JBOSS-IDE para o Eclipse (http://www.jboss.org/developers/projects/jboss/jbosside). JOnAS (http://jonas.objectweb.org/) é outra implementação de código fonte livre e, em particular, é uma implementação certificada como compatível com J2EE. Recentemente, Geronimo (http://geronimo.apache.org/) tem recebido considerável atenção. A organização de aplicações corporativas para a web exige considerável atividade de projeto. Uma das abordagens geralmente empregadas encontra-se o padrão MVC. A implementação deste padrão é facilitada pela existência de frameworks. Struts (http://jakarta.apache.org/struts/) é um deles. Servidores de aplicação J2EE são considerados por muitos ferramentas “pesadas”. Ao contrário destes

servidores, vários frameworks considerados “leves” têm surgido. Spring

(http://www.springframework.org/) é um deles. Liferay (http://www.liferay.com/) e exoPlatform (http://www.exoplatform.com) são algumas das alternativas.

26 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

7.3. Internacionalização Aplicações em Java que oferecem suporte para internacionalização, também conhcida pela sigla em Inglês i18n, pelo fato de existirem 18 letras entre a letra inicial i e a final n do termo nesta língua, geralmente empregam arquivos de propriedades. Attesoro (http://ostermiller.org/attesoro/) é uma ferramenta que auxilia a tradução destes arquivos de propriedades. Em muitos casos a tradução envolve vários formatos além de arquivos de propriedades. Nestes casos, o projeto Open Language Tools (https://open-language-tools.dev.java.net/) fornece várias ferramentas.

7.4. Barramentos de serviços corporativos (ESB) Recentemente vários serviços têm sido oferecidos por ferramentas sobre a designação de Enterprise Service Bus (ESB): ServiceMix (http://servicemix.org/), Mule (http://mule.codehaus.org/), Lingo (http://lingo.codehaus.org) e Celtix (http://celtix.objectweb.org/) são algumas delas. O objetivo principal é facilitar a integração de componentes de negócio.

7.5. Camada de apresentação Código responsável por interpretar ações dos usuários e transformá-las em requisições aos serviços oferecidos por um sistema e, no sentido inverso, converter os resultados produzidos pelo sistema em um formato que seja de fácil consumo por seremos humanos, está logicamente reunido na camada de apresentação. MVC (Model View Controller) é a ferramenta mais empregada para organizar o código da camada de apresentação. Ao empregar MVC, o código deve ser organizado em três papéis distintos: modelo (model), visão (view) e controlador (controller). De forma simplificada, modelo encapsula a camada de negócio, na qual a lógica de uma aplicação, pertinente ao domínio em questão é executada. A visão é responsável por converter dados em representações visuais (ou outra forma) para uso humano, por exemplo, um valor de temperatura pode ser convertido em um termômetro com o devido indicador do valor corrente. O controlador reage às ações dos usuário. É este quem interpreta ações dos usuários como tarefas cuja execução é exigida. Há variantes do modelo MVC e fontes em abundância onde detalhes podem ser obtidos. Você pode iniciar por OOTIPS (http://ootips.org/mvc-pattern.html). São várias as implementações disponíveis de MVC. A opção por uma em detrimento das demais deve ser baseada no cenário que se tem em questão. Àquele que não dispõe de tempo para investigação merecida, sugiro o Spring MVC (http://www.springframework.org). Se você deseja pelo menos uma opção para o Spring MVC, cujos benefícios não são aqui citados, então inicie pelo WebWork (http://www.opensymphony.com/webwork). Também há o amplamento conhecido Struts (http://jakarta.apache.org/struts). Uma alternativa que promete conquistar espaço é conhecida por JavaServer(tm) Faces (JSF). Uma implementação é MyFaces (http://myfaces.apache.org/).

27 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

As sugestões acima trabalham com as tecnologias Servelt (23) e JSP (23). Para aplicações web de tamanhos consideráveis, a conformidade com padrões de apresentação pode se tornar um pesadelo. SiteMesh (http://www.opensymphony.com/sitemesh) visa amenizar este problema. Há uma considerável quantidade de tecnologias associadas à camada de apresentação. Portlets, descrita através da JSR-168 (http://jcp.org/en/jsr/detail?id=168) é uma delas. JetSpeed2 (http://portals.apache.org/jetspeed-2/) é uma implementação de portles.

7.6. Gerência de conteúdo Recursos computacionais atualmente disponíveis fomentaram a disponibilidade de serviços importantes como a gerência de conhecimento de uma empresa através da sua intranet, por exemplo. Há várias opções para gerência de conteúdo. Talvez a mais conhecida e empregada seja o Zope (http://www.zope.org). Contudo, há opções: InfoGlue (http://www.infoglue.org) e Magnolia (http://www.magnolia.info/), que implementa a JSR-170. Alternativas que não aderem, por enquanto à JSR-170 incluem OpenCms (http://www.opencms.org) e Apache Lenya (http://lenya.apache.org/). Recentemente tem crescido a comunidade de usuários Mambo (http://www.mamboserver.com/).

7.7. Armazenando senhas Sistemas atuais exigem considerável quantidade de senhas empregadas por um único indivíduo. Há senhas para servidores, contas de e-mail, SGBDs e vários outros serviços. Felizmente há algumas aplicações disponíveis. Secure Data Manager ou SDM (http://sdm.sourceforge.net) permite gerenciar suas senhas organizadas em uma hierarquia.

7.8. Segurança Acegi (http://acegisecurity.sourceforge.net/) é uma proposta para segurança de aplicações muito comentada. Há outras propostas: Seraph (http://opensource.atlassian.com/seraph/) e JOSSO (http://www.josso.org/) são duas delas. Squid (http://www.squid-cache.org/) é um web proxy amplamente empregado. JOSSO (http://www.josso.org/) é uma solução de autenticação de usuário centralizada e independente de plataforma

desenvolvida

em

Java,

para

ambiente

típico

da

Internet.

SSL-Explorer

(http://sourceforge.net/projects/sslexplorer/) é uma solução VPN SSL de código aberto. Não é suficiente prover mecanismos de segurança apenas para aplicações. Também é importante cuidar do ambiente onde aplicações são executadas. Portas são mecanismos empregados para comunicação entre computadores que, em geral, quanto menos delas existirem abertas, menores são as vulnerabilidades da máquina em questão. Nmap (http://www.insecure.org/nmap/), Nessus (http://www.nessus.org/) e Ethereal (http://www.ethereal.com/) são algumas ferramentas que podem ser empregadas neste sentido para detectar vulnerabilidas. Há toda uma coletânia de ferramentas 28 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

disponívels no THC (http://www.thc.org) para especialistas em segurança. Há um vasto conjunto de ferramentas para usuários Linux. Felizmente, iniciativas como WinPCap (http://www.winpcap.org) oferece ferramentas semelhantes para usuários Windows. OpenSSH (http://www.openssh.com/) é uma implementação do famoso SSH. Esta e outras ferramentas

também

estão

disponíveis

no

Windows(r)

através

de

SSHWindows

(http://sshwindows.sourceforge.net/). BouncyCastle (http://www.bouncycastle.org/) é uma biblioteca para criptografia em Java. Oferece vários serviços como JCE, JCA e outros.

8

XML e serviços Web XML (http://www.w3.org/XML/) ou eXtensible Markup Language é o padrão de fato para

marcação de dados.

8.1. Serialização JiBX (http://jibx.sourceforge.net/) é uma das mais eficientes ferramentas para conversão de objetos em documentos XML e vice-versa. O primeiro lugar é disputado com Javolution (http://www.javolution.org/). Esta última ainda oferece vários outros serviços. XStream (http://xstream.codehaus.org/) é uma opção. Também é possível fazer a conversão de um objeto para outro, provavelmente quando se deseja transferir informações em um objeto cujo estado é obtido de outros. Dozer (http://dozer.sourceforge.net/) é uma ferramenta que auxilia esta tarefa.

8.2. Editores Butterfly XML (http://butterflyxml.org/) é um editor com um conjunto rico de recursos para aqueles que precisam criar documentos XML. KxmlEditor (http://kxmleditor.sourceforge.net/) possui funcionalidades similares, embora específicas para o ambiente KDE.

8.3. Processamento Há ferramentas de propósito “geral” como Nux (http://dsd.lbl.gov/nux/), com recursos para validação, serialização e outros. Muitas, contudo, dedicam-se a um conjunto menor de serviços. JAXP (http://java.sun.com/xml/) é a API Java para o processamento de XML. JAXP permite aplicações Java analisar (parsing) e transformar documentos XML usando uma API que é independente de qualquer processador de informações em XML. Quando analisados, documentos XML são representados em um estrutura hierárquia em

29 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

forma de árvore. Para construir estas árvores em memória o W3C recomenda o emprego do modelo DOM

(Document

Object

Model).

Analisadores

baseados

no

modelo

DOM

(http://www.w3.org/DOM/) oferecem uma API (Application Programming Interface) que permite que dados do documento XML possam ser manipulados como nós em uma árvore DOM, o que não exige um processamento seqüencial do arquivo texto correspondente ao documento XML. XSL, acrônimo de eXtensible Stylesheet Language (http://www.w3.org/TR/xsl/), permite a descrição de regras para formatar documentos XML, por exemplo, com o propósito de transformar um documento XML em um formato "agradável" aos olhos humanos quando processado por browsers como XHTML (sucessor de HTML para descrever conteúdo para a web). Para que esta transformação seja possível é necessário a disponibilidade de um processador XSLT, ou seja, XSL Transformations (http://www.w3.org/TR/xslt). XSLT pode ser empregada de forma independente de XSL, embora tenha sido projetada para ser utilizada como parte de XSL. O principal foco de padrões para os serviços web são os protocolos de comunicação e descrição de serviços web. Tanto clientes quanto servidores fazem uso de mensagens XML para estabelecer uma comunicação entre pontos remotos. XML-RPC e SOAP são duas propostas para mensagens XML que podem ser empregadas. Para que um serviço web seja usufruído pelo menos duas entidades devem existir: o cliente e o serviço web disponibilizado ao primeiro. O serviço web é requisitado pelo cliente através de um mensagem XML, ou seja, uma mensagem SOAP ou invocação XML-RPC.

Esta

mensagem

XML

é

enviada,

em

geral,

via

protocolo

HTTP

(http://www.w3.org/Protocols/). Conforme especificação do W3C, SOAP (Simple Object Access Protocol) é um protocolo leve para troca de informações em um ambiente descentralizado e distribuído. Apache Axis (http://xml.apache.org/axis/) é uma implementação de SOAP (http://www.w3.org/TR/SOAP). Serviços web devem ser descritos de tal forma que clientes possam requisitar os serviços correspondentes. Para realizar descrição existe um vocabulário XML próprio, denominado de WSDL, acrônimo de Web Services Description Language (http://www.w3.org/TR/wsdl). A validação de documentos

WSDL

pode

ser

feita

via

Eclipse,

através

do

plug-in

WSVT

(http://www.eclipse.org/wsvt/). Os serviços disponibilizados por uma aplicação são, em geral, acompanhados de um documento WSDL, que descreve a funcionalidade oferecida pela aplicação, os endereços dos serviços e como clientes podem trocar mensagens com estes serviços. O endereço de um serviço é um URL (http://www.w3.org/Addressing/URL/), ou Uniform Resource Locator. Um URL pode ser visto como uma extensão de um sistema de arquivos, onde um arquivo pode estar em um dado diretório localizado em um ponto qualquer de uma rede. Para que serviços web se tornem uma realidade, deve existir algum mecanismo que permita a clientes encontrar e conhecer serviços web disponibilizados. UDDI, acrônimo de Universal Description, Discovery and Integration (http://www.uddi.org/), é uma proposta para publicar informações sobre serviços web. Clientes podem consultar registros UDDI para localizar informações

30 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

acerca dos serviços disponibilizados. UDDI é uma espécie de "páginas amarelas" das listas telefônicas, onde fornecedores apresentam seus serviços e produtos para clientes interessados. SOAP, UDDI e WSDL são tecnologias centrais empregadas em interações com serviços web. Em conjunto, o emprego delas permite o a comunicação entre aplicações independente das linguagens em que estas foram desenvolvidas, sistemas operacionais e plataformas de hardware. JAX-RPX é uma API simples para criar e interagir com serviços web. Esta API, baseada no protocolo RPC (Remote Procedure Call), oculta detalhes das comunicações SOAP e descrições WSDL correspondentes. Quem desenvolve serviços web empregando JAX-RPC não precisa saber em que linguagem de programação os clientes são escritos. No sentido inverso, clientes de serviços web que fazem uso de JAX-RPC não precisam de detalhes da implementação do serviço web correspondente. Em interações B2B (business-to-business) ou B2C (business-to-consumer) há a necessidade de se conhecer os serviços disponíveis e outras informações relevantes. Todas elas são disponibilizadas através de registros XML. Atualmente há dois tipos de registros XML bem conhecidos: UDDI e ebXML. JAXR é uma API que padroniza uma abordagem de acesso a registros, seja do tipo UDDI ou ebXML, para aplicações Java. Todas as tecnologias comentadas acima são, em geral, empregadas por uma equipe.

8.4. Emprego de XML em negócios UBL (http://docs.oasis-open.org/ubl/cd-UBL-1.0/) ou Universal Business Language é uma proposta de formato XML para documentos típicos de negócios como ordens de compra, cotações e outros. A adoção de UBL generalizada pode significar, por exemplo, a redução do esforço de desenvolvimento para integrar vários formatos definidos por cada empresa envolvida em uma transação. hyperModel (http://www.xmlmodeling.com/) é uma ferramenta que permite, como um plugin para o Eclipse, editar especificações em UML que representam esquemas XML como aqueles propostos pelo UBL. Neste processo, esta ferramenta oculta do usuário toda a necessidade de conhecer detalhes de esquemas XML, por exemplo.

9

Ferramentas para equipes

9.1. Processo de software Code and fix foi o processo de software mais empregado no início da computação. Esta abordagem reflete mais a ausência de formalidade do que o resultado da definição de como administrar o desenvolvimento de software. A idéia é simples, um mínimo de informações é suficiente para iniciar a criação de código, cuja execução seria exposta aos clientes, que revelariam os

31 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

problemas a serem corrigidos pelos desenvolvedores. Estas atividades se repetiam indefinidamente, até o fim da operação do software. Muitas outras propostas ressaltaram os vários inconvenientes de code and fix e se posicionaram como alternativas mais adequadas. Alguns processos apresentam ênfase na construção de modelos ao longo da execução de um significativo conjunto de atividades como o Unified Process. Com os mesmos propósitos e defendendo a idéia de um desenvolvimento com mais rapidez e menos burocracia se apresentam métodos que se autodenominam de ágeis, onde a definição de modelos deve ser mínima e a cooperação entre os membros de uma equipe um aspecto valorizado. Apesar do interesse e investimento atuais na melhoria de processos, não é razoável depositar os atuais infortúnios exclusivamente à falta de disciplina de equipes de desenvolvimento. Não se tem aqui a pretensão velada de subvalorizar a importância que processos desempenham no desenvolvimento de software, mas de identificar os elementos destes que produzem resultados efetivos. MacCormack et al, em Trade-offs between Productivity nad Quality in Selecting Software Development Practices, IEEE Software, sept/oct 2003, págs. 78-85, realizam análise do emprego de vários processos e fornecem uma orientação: (a) construção de protótipos logo no início do desenvolvimento; (b) revisões de projeto e (c) testes de regressão e integração para cada incremento. Ainda mostram que duas abordagens podem significar mais da metade da variação em produtividade de uma equipe de desenvolvimento: •

Construção de protótipos logo no início do desenvolvimento e

Gerações diárias de código executável. Embora as evidências fornecidas por este trabalho não sejam suficientes para definir um

processo de software, estes são os elementos principais a serem observados ao longo do desenvolvimento do estudo de caso trabalhado neste curso.

9.2. Modelagem UML Antes que código seja construído é necessário, particularmente para sistemas complexos, uma modelagem prévia. O objetivo é analisar o sistema, validar os requisitos com os usuários e especular possibilidades de organização da arquitetura do software e do projeto antes que o código correspondente seja produzido. Ou seja, isto só é possível através da confecção de modelos. A linguagem de modelagem unificada, ou UML (www.uml.org/), é o esperanto de engenheiros de software, o padrão de fato empregado tanto pela academia quanto pela indústria para registrar modelos de software.

32 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

Ferramentas para criação de modelos em UML A edição de modelos na UML exige o emprego de ferramentas apropriadas, que oferecem mais do que editoração de um gráfico. JUDE (http://jude.esm.jp/) é a minha ferramenta preferida. ArgoUML (argouml.tigris.org) é muito conhecida e dá origem a produtos proprietários. FUJABA (http://www.fujaba.de) e UMLet (http://qse.ifs.tuwien.ac.at/~auer/umlet/) são 100% Java assim como a ArgoUML. Dia (www.lysator.liu.se/~alla/dia/) permite a edição de vários tipos de diagramas, além daqueles da UML. Umbrello UML Modeller (http://uml.sourceforge.net/) é uma opção conhecida por usuários Linux. Em alguns cenários é relevante obter a modelagem a partir de código Java disponível. ESSModel (http://essmodel.sourceforge.net/) gera diagramas de classe (UML) para código em Java e até mesmo para bytecodes (.class). Boa parte das ferramentas que permitem a edição de diagramas UML também oferece o recurso de engenharia reversa para código escrito em Java, por exemplo, a partir do qual os diagramas correspondentes são automaticamente obtidos.

Modelagem de domínio Enquanto as ferramentas que permitem a criação de modelos UML podem se empregadas para a criação de modelos de domínio, ou modelos de negócio, há ferramentas que dirigidas especialmente para esta atividade. Protegé (http://protege.stanford.edu/) é uma delas.

9.3. Gerência de requisitos Há muitas ferramentas para modelagem usando UML, conforme outra seção deste texto. Um dos diagramas da UML é o diagrama de casos de uso, que tem pouca utilidade se não acompanhado das descrições correspondentes. De fato, casos de uso são essencialmente textos e não de diagramas. Também existem ferramentas gratuitas e open source para registro de requisitos. Entre elas, UCDD (http://www.itbrain.com.mx/ucdd/) e Xmlbasedsrs (http://xmlbasedsrs.tigris.org). SRS Plugin (http://eclipsesrs.sourceforge.net) é um Eclipse plugin que faz uso da ferramenta Xmlbasedsrs. Rambutan (http://rambutan.sourceforge.net/) é uma ferramenta que pode ser empregada para a edição de especificações de requisitos de software.

9.4. Gerência de projeto de software Quase sempre o tempo para a conclusão de um projeto é exíguo e o ambiente de desenvolvimento convive com pressões. Alocar de forma efetiva os recursos disponíveis é imprescindível. •

Ganttproject (http://ganttproject.sourceforge.net/) é uma dentre muitas outras.

Project Planning and Tracking System ou PPTS (http://ses-ppts.sourceforge.net)

OpenPSA (http://www.openpsa.org/)

33 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

ProjectBench (http://projectbench.sourceforge.net/)

XPlanner (http://www.xplanner.org)

é uma ferramenta para gerência de projeto

(planejamento e acompanhamento). •

Hipergate (http://www.hipergate.org) e

DotProject (http://www.dotproject.net) são opções.

Algumas ferramentas oferecem serviços para relacionamento com clientes (CRM): •

CRM (http://crm-ctt.sf.net)

SugarCRM (http://www.sugarcrm.com/).

Reuniões, lista de bugs em aberto e tarefas, entre outros recursos, são oferecidos por •

TUTOS (http://www.tutos.org/).

TeamWork (http://www.twproject.com) é outra dentre um considerável conjunto de

opções. •

NetOffice (http://netoffice.sf.net) também oferece serviços para gerência de projetos.

• •

Double

Choco

Latte

(http://dcl.sourceforge.net/)

é parte

do

GNU Enterprise

(http://www.gnuenterprise.org). •

Achievo (http://www.achievo.org/)

Project/Open (http://www.project-open.org/).

Projectory (http://projectory.sourceforge.net/)

Webcollab (http://webcollab.sourceforge.net/)

Gforge (http://gforge.org/) é uma ferramenta que auxilia a execução de várias tarefas ao

longo do ciclo de vida de um sistema. Comunicação entre membros da equipe, controle de versão e outras tarefas típicas. Se existem atividades a serem organizadas ao longo do tempo então há um indicador do esforço que será necessário no empreendimento em questão. Para estimar: •

Construx Estimate (http://www.construx.com) é uma solução gratuita conhecida.

Conjunto

de

ferramentas

para

estimativa

(http://www.engin.umd.umich.edu/CIS/tinytools/). Alguns sistemas oferecem serviços de contato com clientes que podem ser empregados com a finalidade de acompanhamento de erros, por exemplo.

9.5. Sistemas de gestão empresarial Principais frameworks Alguns softwares oferecem extenso suporte a atividades de gestão empresarial. Naturalmente, apenas alguns casos podem imediatamente se beneficiar destes produtos como disponíveis. Em todos

34 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

os demais são necessárias personalizações. Contudo, de custo bem inferior ao desenvolvimento completo que teria que ser realizado sem a existência destas ferramentas. Algumas ferramentas ERP (Enterprise Resource Planning) incluem: •

OfBiz ou Open for Business (http://www.ofbiz.org/)

Compiere (http://www.compiere.org)

TinyERP (http://tinyerp.org/)

OpenCRX (http://opencrx.sourceforge.net).

Código de barras A geração de códigos de barra é facilitada pela existência de várias ferramentas. Em geral, oferecem como serviço básico uma entrada correspondente a um código e o respectivo padrão e produzem, como saída, a imagem correspondente. Barcode4J (http://barcode4j.krysalis.org/) oferece grande flexibilidade de padrões e vários formatos em que os códigos podem ser gerados. JBarcodeBean (http://jbarcodebean.sourceforge.net/) fornece suporte a cerca de dez formatos de códigos de barra. Barbecue (http://barbecue.sourceforge.net) é outra opção escrita em Java, assim como as anteriores.

9.6. Gerência de configuração Gerência de configuração de software é um dos principais processos de suporte realizados ao da vida de um software. Este processo é auxiliado por várias ferramentas que auxiliam desde tarefas mais sofisticadas como o controle de mudança até aquelas “mais simples” como gerência ou controle de versões. Subversion (http://subversion.tigris.org) é apontada como o sucessor da conhecida e amplamente empregada CVS (veja parágrafo seguinte). Ambas oferecem um ambiente para controle de versões. Clientes gráficos para o Subversion são vários e podem ser encontrados no próprio portal do Subversion, que é acompanhado de um cliente baseado em linha de comandos. Entre os clientes gráficos destaca-se o Rapidsvn (http://rapidsvn.tigris.org) disponível para várias plataformas e o Subclipse (http://subclipse.tigris.org) que é um plugin para o Eclipse (9). Código em Java também é um tipo de cliente de um repositório gerenciado pelo Subversion. Isto é possível através da biblioteca como JavaSVN (http://tmate.org/svn/). CVS (http://www.cvshome.org/), ou Concurrent Versions System, é uma ferramenta amplamente empregada para o controle de versão de software. Para ambiente Windows a implementação correspondente é conhecida por CVSNT (http://www.cvsnt.org/). O cliente jCVS (http://www.jcvs.org/) é um cliente com interface gráfica.

9.7. Acompanhamento de erros, issues, requisitos, ... Para acompanhamento de erros a ferramenta provavelmente mais empregada em todo o

35 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

planeta é o Bugzilla (http://www.bugzilla.org/). Vários projetos open-source consagrados fazem uso do Bugzilla. Scarab (http://scarab.tigris.org/), ITracker (http://sourceforge.net/projects/itracker) e GNATS (http://www.gnu.org/software/gnats/) são opções de instalação bem mais simples que aquela do Bugzilla. Trac (http://projects.edgewall.com/trac/) é uma alternativa que também oferece interface para serviços oferecidos pelo Subversion. Convém ressaltar que várias das ferramentas da seção Gerência de Projetos também podem ser empregadas de forma similar àquelas citadas no parágrafo anterior e vice-versa. Em conseqüência, fique atento, sistemas de acompanhamento de requisições de usuários, relatos de erros e outras, estão apoiados por conjunto considerável de ferramentas e não apenas aquelas acima.

9.8. Comunicação Membros de equipes de desenvolvimento precisam de constante interação. Quando são numericamente pequenas e compartilham um mesmo espaço físico, a comunicação é facilitada. Caso contrário, será necessário fazer uso de artifícios que viabilizem a comunicação. Yahoo! (http://messenger.yahoo.com) e Messenger (http://messenger.msn.com.br) são duas conhecidas opções para trocas de mensagens instantâneas. Para usufruir desta oportunidade de comunicação é necessário o emprego de clientes, disponíveis nas mais variadas plataformas. Para o MSN Messenger tem-se o AMSN Messenger (http://amsn.sourceforge.net/), disponível para inúmeras distribuições do Linux, Mac OS e inclusive o Windows(r). As opções são muitas e, em geral, a escolha é estabelecida conforme preferências pessoais. Gaim (http://gaim.sourceforge.net/) é um cliente que atende vários protocolos e está disponível para várias plataformas. A comunicação via texto e/ou imagens pode ser estendida com recursos de voz. Neste caso, uma ferramenta comumente empregada é o Skype (http://www.skype.com/). Trabalho cooperativo também conta com várias opções. Em geral, quase todas elas incluem troca de mensagens instantâneas, troca de arquivos, envio de e-mails e outras tarefas, inclusive de forma segura. Lucane (http://www.lucane.org/EN) é uma destas ferramentas.

9.9. Documentação e sistemas de gerência de documentos Quanto mais crítico um desenvolvimento, mais formal este deverá ser, o que pode ser detectado pelo conjunto bem definido de artefatos a serem produzidos. Contudo, mesmo sistemas relativamente simples precisam de um mínimo de documentação onde, por exemplo, requisitos e uma visão geral do sistema são estabelecidos. Embora seja comum a documentação de sistemas de modelos registrados em UML, texto em linguagem natural também desempenha um papel fundamental. OpenOffice (http://www.openoffice.org.br/) compreende um conjunto de ferramentas de para edição de textos, apresentação, planilha de cálculo e outras. Quando são necessárias figuras mais

36 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

sofisticadas, pode-se empregar GIMP (http://www.gimp.org/). Várias notações podem ser empregadas na construção de diagramas com Dia (http://www.lysator.liu.se/~alla/dia/). É crescente o emprego de DocBook (http://www.docbook.org/oasis/intro.html) para editoração de conteúdo de computação, inclusive documentação de código, o que pode ser útil ao seu projeto. Documentos e/ou voz são instrumentos importantes, mas as interações que empregam estes meios perdem facilmente no tempo e no espaço o conteúdo trocado. Há opções para persistir o que flui entre membros de uma equipe. MoinMoinWiki (http://moinmoin.wikiwikiweb.de/) é uma das mais simples de serem utilizadas. Convém ressaltar que estas ferramentas oferecem a opção de acrescentar documentos, criação de links e registro dos mais variados tipos de informação que, de outra forma, poderiam ser “perdidos”. Após produzidos, documentos precisam ser gerenciados, principalmente se o número deles é significativo. Ferramentas como DocMGR (http://docmgr.sourceforge.net/) e OpenDocMan (http://www.opendocman.com) auxiliam na gerência de documentos. Document Manager (http://sourceforge.net/projects/docman/).

10

Miscelânea ESTE TEXTO ENCONTRA-SE EM CONSTRUÇÃO. NEM MESMO UMA LIBERAÇÃO

PÚBLICA FOI PRODUZIDA, EM CONSEQÜÊNCIA, VÁRIOS AJUSTES DEVERÃO SER REALIZADOS. SUGESTÕES SÃO BEM-VINDAS: fabio@inf.ufg.br. Dublin Core Metadata Initiative (http://dublincore.org/) visa facilitar o acesso a informação. JVoiceXML (http://jvoicexml.sourceforge.net/) é uma implementação de VoiceXML 2.0 (http://www.w3.org/TR/voicexml20/), uma aplicação de XML projetada para o desenvolvimento de diálogos de áudio, sintetização de voz e reconhecimento de voz, entre outros recursos. JavaService (http://javaservice.objectweb.org/) é um programa executável que permite a execução de qualquer classe em Java como um serviço do sistema operacional Windows NTTM. James é acrônimo de Java Apache Mail Enterprise Server (http://james.apache.org/), que contém um servidor SMTP, POP3 e NNTP escrito 100% em Java. A visualização do fluxo de mensagens pode ser obtida através de HermesJMS (http://www.hermesjms.com/). Java Message Service ou simplesmente JMS (http://java.sun.com/products/jms/) é o serviço Java que permite a troca de mensagens entre softwares. ActiveMQ (http://activemq.codehaus.org/) é uma implementação de JMS. Jencks (http://jencks.org/) é um contêiner JCA leve que fornece um

37 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

message driven classe. Em alguns casos é importante não apenas poder obter dados de um servidor mas também enviá-los. O upload de um arquivo através de página HTML com o apoio de um Servlet é comentado em

Servlets.com

(http://www.servlets.com/cos/)

e

OOP-Research

(http://www.oop-

reserch.com/mime_example_1.html). Clientes implementados exclusivamente com o apoio de HTML podem não despertar o interesse dos usuários, acostumados com as interfaces tradicionais coloridas e ricas na interação. Javascript é uma opção que permiter enriquecer a experiência do usuário sem grande comprometimento da portabilidade. Comandos para abrir uma caixa de diálogo, por exemplo, é tão simples quanto <html><form><input type=”file”></form></html>. Para salvar podese empregar a sentença . Estes e muitos outros recursos podem ser dominados com tutorais. Javascript Tutorial é um deles (http://wp.netscape.com/eng/mozilla/3.0/handbook/javascript/). O serviço de validação de marcação (http://validator.w3.org) pode ser empregado gratuitamente para validar a conformidade de páginas HTML e XHTML com as recomendações do consórcio W3C (http://www.w3.org). O processamento de conteúdo no formato HTML a partir de aplicações em Java pode ser feito

por

ferramentas

como

HTMLParser

(http://htmlparser.sourceforge.net/)

e

Jericho

(http://jerichohtml.sourceforge.net/). Servetec

(http://www.servertec.com/)

oferece

considerável

conjunto

de

ferramentas

para

desenvolvedores Java, desde servidores de aplicação, software servidor para upload de arquivos, recursos para acesso a serviços nativos como portas de I/O, variáveis de ambiente e outros. Ferramentas para manipulação de arquivos no formato CSV (http://ostermiller.org/utils/CSV.html). Uma alternativa é Opencsv (http://opencsv.sourceforge.net/). Cacic (http://www.governoeletronico.gov.br/cacic/sisp2/) é um configurador e coletor automático de informações computacional.

11

Índice remissivo

A

Almanac Java · 7

AJAX · 20 AjaxAnywhere · 20 AjaxTags · 20 DWR · 20 Echo2 · 20 Taconite · 20 AjaxAnywhere · 20 AjaxTags · 20

análise de código · Checkstyle · 12 Dependency Finder · 11 PMD · 12 Ant · 13 Apache · 23 API · 30 ASM · 11

38 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

B

CruiseControl · 12

Barbecue · 35

CSV · CSV · 38

Barcode4J · 35

Opencsv · 38

BCEL · 11 BeanShell · 10

CVS · 35

BouncyCastle · 29

D

Bugzilla · 36

DataVision · 25

builds freqüentes ·

Dependency Finder · 11

CruiseControl · 12

Dependency Injection · 15

Mevenide · 13

documentação ·

bytecode ·

Doxigen · 13

ASM · 11

Javadoc · 13

BCEL · 11

Jdocs · 7

Javassist · 11

Kickjava · 8

Serp · 11

C

DOM · 30 Doxigen · 13

Celtix · 27 ChainSaw · 16 Checkstyle · 12 CMS ·

Dozer · 29 DWR · 20 DynamicJava · 10

E

InfoGlue · 28

Echo2 · 20

Magnolia · 28

Eclipse · 9

Zope · 28

Eclipse plug-ins ·

cobertura de testes ·

Lomboz · 21

EMMA · 14

Mevenide · 13

NoUnit · 14

Eclipse Profiler · 12

Quilt · 14

EMMA · 14

código de barras ·

ERP ·

Barbecue · 35

Compiere · 35

Barcode4J · 35

OfBiz · 35

JBarcodeBean · 35

OpenCRX · 35

Compiere · 35 compilador ·

TinyERP · 35 ESB ·

Java2XML · 9

Celtix · 27

compiladores ·

Lingo · 27

JDK · 9

Mule · 27

configuração ·

ServiceMix · 27

Dependency Injection · 15

ESS-Model · 33

Excalibur · 15

Excalibur · 15

Gravity · 15

Exemplos ·

Inversion of Control · 15

Almanac Java · 7

JConfig · 15

JavaPractices · 7

Jice · 15 Spring · 15 CRM · 34

F FindBugs · 12 Fitnesse · 14

39 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

FTPOnline · 7

Java-Channel · 7

G

Java.Net · 7

gerência · CRM · 34 Geronimo · 26 grafos ·

Java2XML · 9 Javadoc · 13 JavaPro · 7 JavaScript · 20 DWR · 20

Graphviz · 17 JGraph · 17 Graphviz · 17 Gravity · 15

Javassist · 11 JAXP · 29 JBarcodeBean · 35 JBoss · 26

H Hibernate · 25 Hibernate · ObjectVisualizer · 24 HTML · HTMLParser · 38 Jericho · 38 HTMLParser · 38 HTTP · 30

I

JBoss MX · 22 JConfig · 15 JCP · 8 JDK · 9 Jericho · 38 JERT · 25 Jetty · 23 JfreeReport · 25 JGraph · 17 jGuru · 7

i18n · Attesoro · 27

Jice · 15 JMX ·

IDE · 9

JBoss MX · 22

InfoGlue · 28

JMX (especificação) · 22

interpretadores ·

JMX RI · 22

BeanShell · 10

MC4J · 22

DynamicJava · 10

MX4J · 22

inversão de controle · PicoConteiner · 15

XMOJO · 22 JMX (especificação) · 22

Inversion of Control · 15

JMX RI · 22

iReport · 25

JOnAS · 26

iText · 25

JSP ·

IzPack · 17

Jetty · 23

J

JUnit · 13

Jamelon · 14

K

JasperReports · 25

Kickjava · 8

JasperViewer · 25

L

Java · 7 Java EE · Geronimo · 26 JBoss · 26 JOnAS · 26 Java Open Source Software · 8 Java Technology · 7

Lingo · 27 linguagem de programação · JavaTM · 7 JavaTM · 7 Log4j · 16 logging · ChainSaw · 16

40 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

Log4j · 16

requisitos ·

M

Rambutan · 33 SRS Plugin · 33

Magnolia · 28

UCDD · 33

Mapeamento ·

Xmlbasedsrs · 33

Dozer · 29 Maven · 13 Mevenide · 13

S Scarab · 36

MC4J · 22

SDM · 28

Mevenide · 13

Segurança ·

modelos · 32

BouncyCastle · 29

Mule · 27

SDM · 28

MX4J · 22

Senha ·

N

SDM · 28

NanoHTTPD · 23

Serialização · Dozer · 29

NoUnit · 14

Serp · 11

O ObjectVisualizer · 24 OfBiz · 35 OnJava · 7 OpenCRX · 35 OpenReports · 25

P

ServiceMix · 27 Servlet · Jetty · 23 SOAP · 30 Spring · 15 SRS Plugin · 33 Subversion · 35, 36

persistência ·

Subversion ·

Hibernate · 25 PicoConteiner · 15 PMD · 12 ProGuard · 18 proteção ·

Trac · 36

T Taconite · 20 testes · Fitnesse · 14

ProGuard · 18

Jamelon · 14

Q

TinyERP · 35

Quilt · 14

TJWS · 23

R

Tomcat · 23

Rambutan · 33

Trac · 36

Ravenous · 23

tracking · CRM · 34

relatórios ·

Trac · 36

DataVision · 25 iReport · 25

U

iText · 25

UCDD · 33

JasperReports · 25

UDDI · 30

JasperViewer · 25

URL · 30

JERT · 25

W

JfreeReport · 25 ObjectVisualizer · 24 OpenReports · 25

Web · Jetty · 23

41 de 42


Creative Commons (cc) Fábio Nogueira de Lucena

web server ·

MoinMoinWiki · 37

Apache · 23

WSDL · 30

NanoHTTPD · 23

X

Ravenous · 23 TJWS · 23 Tomcat · 23 web tier · Tomcat · 23 wiki · Fitnesse · 14

XHTML · 30 XML-RPC · 30 Xmlbasedsrs · 33 XMOJO · 22 XPlanner · 34

Z Zope · 28

42 de 42


teste