Experimentando o Apache Tapestry

Recentemente começamos um projeto de evolução de uma aplicação web escrita em Apache Tapestry. Já fazia um tempo que não ouvia falar a seu respeito (uns seis anos pelo menos), então esta foi a oportunidade perfeita (e necessária) para que finalmente eu estudasse um pouco a seu respeito, e o que estou aprendendo tenho achado muito interessante.

Nota importante: este é um post escrito por um iniciante no assunto (eu). Sendo assim toda correção é bem vinda!

O que é o Apache Tapestry e minhas primeiras impressões

Uma definição bem vagabunda: “é framework para desenvolvimento de aplicações web, baseado em componentes, voltado para a plataforma Java”. Isto não incita ninguém a correr atrás da ferramenta, especialmente se levarmos em consideração que não vemos muitos artigos escritos a seu respeito nos últimos anos. Sendo assim neste post vou escrever uma aplicação de exemplo que ilustra seu funcionamento.

Meu primeiro contato com Tapestry foi através de artigos na Internet e revistas em 2004/2005: anos mais tarde, lá por 2011, trabalhei em uma empresa que tinha alguns projetos baseados neste framework, mas eu mesmo jamais tive qualquer contato com estes projetos. Como nunca fui fã de frameworks que fossem baseados em componentes, torci o nariz para o projeto, até este mês (agosto/2017), quando precisei estudá-lo.

O que gostei no Tapestry

• Altíssima produtividade – o projeto implementa um mecanismo de carregamento automático de classes que nos possibilita modificar o código fonte (Java) e ver as mudanças imediatamente na aplicação em execução, sem qualquer necessidade de reiniciar a aplicação.
• O modelo de desenvolvimento – uma aplicação escrita em Tapestry essencialmente é um conjunto de páginas (este não é um framework voltado para a escrita de APIs REST). Uma página é basicamente uma classe Java e um arquivo de Template que reflete o estado dos objetos instanciados desta classe.
• POJO puro (ou quase) – você não precisa implementar interfaces neste framework. Classes Java simples (e portanto fáceis de serem testadas) fazem todo o trabalho, e ainda há um container de IoC embutido que cuida de todo o ciclo de vida destes objetos.
• É muito rápido – o desempenho é inacreditável. O carregamento dinâmico de classes que mencionei acima, por exemplo, é praticamente instantâneo.
• Gestão interessante de sessões – o modo como Tapestry lida com sessões do usuário é muito bacana. Você não tem um objeto “session” ou algo similar: ao invés disto, os atributos das páginas que mencionei acima são tratados como tal de uma forma completamente transparente para o desenvolvedor.
• É extensível – pelo pouco que pude ver na documentação oficial do projeto, é possível integrá-lo com o Spring, o que abre um universo de possibilidades. Este link mostra algumas extensões publicadas além da documentação instruindo como aplicar o Spring e Hibernate no projeto.
• Baseado em Maven (e Gradle) – isto é ótimo, pois me possibilita abrir o código fonte em praticamente todas as IDEs Java do mercado hoje.
• A documentação oficial – é boa, apesar dos problemas que vou citar a seguir (talvez este ponto seja uma contradição). Ela quebra o galho, mas não é ideal.
• Bom suporte no Eclipse – há bons plugins para o projeto (estou usando o Tapestry Tools). Neste link há algumas opções, mas você as encontra fácil no Eclipse Marketplace.
• Convenções sobre configuração – você quase não precisa editar arquivos de configuração no Tapestry, basta seguir as convenções que o framework oferece, mas sem te prender a uma forma pré-fixada: é possível mudar, até onde pude ver, qualquer comportamento do framework.
• Desenvolvimento do projeto continua ativo – apesar de não ouvir falar do Tapestry já faz um bom tempo, fiquei muito feliz ao ver na página de release notes que sai pelo menos um (no máximo 2) release importante por ano do framework.
  (talvez seja um release por ano pelo fato do projeto já estar maduro, o que é um ponto bastante positivo)

O que não gostei

• Alguns problemas na documentação – No momento da escrita deste post a documentação do framework (especialmente a sessão “Tutorial“) estava quebrada, e os trechos que envolvem o código fonte não estava muito legível, o que dificulta a vida de quem está dando os primeiros passos.
  O “Getting Started”, por exemplo, está desatualizado (durante a escrita deste post), e você não conseguirá criar o projeto se seguir o passo a passo.
• Ausência de uma comunidade brasileira – no site oficial estão listadas algumas mailing lists, mas apenas em inglês. Infelizmente não encontrei muitos artigos escritos em português, o que, por mais que muitos não creiam, dificulta a adoção da ferramenta em território nacional.
  (sobre a falta de artigos em português, comecei a fazer minha parte. Conforme vou aprendendo mais sobre o Tapestry posto por aqui).
• Comunidade mundial pouco ativa – ao menos esta foi minha impressão. No Facebook, por exemplo, só encontrei um grupo contendo seis membros, e na mailing list de usuários há poucos posts novos por mês também.
• Poucas issues no Jira do projeto e ausência de um roadmap para as próximas versões – este é um ponto de atenção: não vi muitas issues abertas no Jira da comunidade que digam respeito a novas funcionalidades, especialmente no que diz respeito à próxima versão, que será a 5.5.0.
  Também não encontrei um roadmap para as próximas versões: o máximo que encontrei foi um antigo documento (marcado inclusive como desatualizado) para a versão 5.0 do projeto.
  Estes pontos levantam dúvidas a respeito da evolução do projeto e se ele estará acompanhando as próximas tendências do mercado, o que conta como ponto negativo na sua adoção para novas aplicações.
• Não é bom para se escrever uma API REST – o objetivo do Tapestry claramente é a criação de aplicações no sentido “páginas interativas”, não para a escrita de APIs. Na documentação oficial, por exemplo, você não vê qualquer menção ao desenvolvimento deste tipo de projeto (ao menos esta foi a impressão, enquanto iniciante, que tive do projeto).

Notas sobre a popularidade do framework e se você deve adotá-lo ou não com base nisto.

Tapestry, assim como Grails, Wicket, Play e outros não é o que podemos chamar de uma opção “mainstream”, tal como o Spring (aliás, de todos os frameworks fora do Java EE, talvez o único mainstream seja o Spring) ou Java EE (puro,o que inclui o JSF). Sendo assim, quaisquer comparações em relação a estas opções é descabida de fundamentação.

No caso do Java EE, ainda mais, especialmente se levar em consideração o fato de que todos os demais frameworks dependem deste para funcionar (o que consequentemente o tornará sempre o mais popular).

O que levo em consideração na adoção destes frameworks (que são verdadeiras armas secretas) é a atividade da comunidade que possuem e a quantidade de releases anuais. Normalmente quando não ocorrem releases por mais de um ano levanto o sinal amarelo.

A propósito, já escrevi sobre este tópico neste link alguns anos atrás, mantenho minha opinião e já está na hora de escrever outro post a respeito.

(e ei, se você curte uma tecnologia e não escreve sobre ela por não ser tão popular, só tenho uma coisa a te dizer: SHAME ON YOU!)

“Olá Mundo” com Tapestry

O código fonte pode ser baixado neste repositório do GitHub.

O que você vai precisar

• Maven 3 – http://maven.apache.org 
• Java (JDK) 1.8 (para a versão 5.3.8 pra frente do framework. As anteriores tem de usar o Java 7 ainda)
• Qualquer IDE que ofereça suporte a Maven (o projeto vai abrir em qualquer uma, no meu caso estou usando o Eclipse junto com o plug-in Tapestry Tools.

É uma aplicação bem simples, só pra mostrar os conceitos de páginas, componentes e o modus operandi do framework, sendo assim não esperem muita coisa daqui.

Criando o projeto com Maven

No link “Getting Started” do projeto você lerá que deve executar o comando a seguir:

mvn archetype:generate -DarchetypeCatalog=http://tapestry.apache.org

Não funcionará com o Maven 3: você topará com a seguinte mensagem de erro:

[ERROR] Failed to execute goal org.apache.maven.plugins:maven-archetype-plugin:3.0.1:generate (default-cli) on project standalone-pom: archetypeCatalog 'http://tapestry.apache.org' is not supported anymore. Please read the plugin documentation for details. -> [Help 1]

Isto é fácil de resolver: basta usar uma versão anterior do plug-in archetype do Maven, tal como a 2.4 no exemplo a seguir:

mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate -DarchetypeCatalog=https://repository.apache.org/content/repositories/staging -Dfilter=org.apache.tapestry:quickstart

Após metade da Internet ser baixada para seu computador, serão aprsentadas 10 opções de arquétipos a serem escolhidos. Para o nosso exemplo adotei a opção “20” que equivale à última versão disponível do Tapestry (5.4.3).

Na sequência você precisará responder algumas perguntas:

• O nome do grupo (groupId) – no exemplo: br.com.itexto
• O nome do artefato (artifactId) – no exemplo: inicio-tapestry
• Sua versão
• O pacote no qual o código fonte se encontra (isto é importante e veremos mais a respeito mais à frente) – no exemplo: br.com.itexto

Respondidas as perguntas, será criado um diretório cujo nome equivale ao artifactId do projeto. Para testar o projeto, mude seu diretório corrente para o criado pelo projeto e execute o comando abaixo:

mvn jetty:run

Será iniciado o servidor Jetty, embarcado no projeto. Sim, seu ambiente de desenvolvimento está pronto. Acessando a URL http://localhost:8080, exposta na saída do prompt, você se deparará com a seguinte página:

clique sobre o link: ele aponta para uma URL similar ao artifactId que você forneceu ao criar o projeto. Agora você verá a página de boas vindas do Tapestry.

Dica: dá pra criar o projeto de uma forma muito mais simples usando o Eclipse, tal como descrito neste link.

A estrutura do projeto

Importe o projeto Maven para a IDE de sua preferência, pois iremos alterar levemente este código fonte para expor o funcionamento do Tapestry. O arquétipo do Maven cria alguns sub-pacotes que são importantes: neste post falarei apenas de dois:

• br.com.itexto.pages – contém as páginas do projeto
• br.com.itexto.components – contém os componentes

E na pasta “src/main/resources” também são criados alguns diretórios interessantes:

• src/main/resources/br/com/itexto/pages – contém os templates das páginas (falaremos mais sobre isto mais a frente)
• src/main/resources/br/com/itexto/pages/components

Os mesmos nomes dos pacotes se repetem nas pastas criadas em “src/main”. Como disse no início deste post, uma aplicação Tapestry é composta essencialmente por páginas. Uma página, por sua vez, tem duas faces:

• O código fonte Java que representa o “controlador” do projeto.
• Um arquivo de template, que deve ter exatamente o mesmo nome da classe que a representa, na pasta “src/main/resources”. Estes templates tem a terminação “.tml”

Com base no exemplo acima, alterei o código fonte do arquivo “Index.java” para que fique tal como o exposto a seguir:

package br.com.itexto.pages;package br.com.itexto.pages;

public class Index{

public String getRandomico() {
return java.util.UUID.randomUUID().toString();
}
}

Note que é uma classe Java simples, sem a necessidade de realizar qualquer implementação de interfaces ou uso de anotações. Alterei também levemente o arquivo de template relacionado (src/main/resources/br/com/itexto/pages/Index.tml) para que fique tal como no exemplo a seguir:

<html t:type="layout" title="inicio-tapestry Index"
xmlns:t="http://tapestry.apache.org/schema/tapestry_5_4.xsd"
>
<p>Randomico como ${randomico}</p>
</html>

(Quando acessamos a URL do projeto, é a página Index que será renderizada para o visitante. Se você quiser experimentar, crie páginas com o nome “Teste” (contendo o código Java e o de template) e acesse as URLs diretamente para brincar.)

O template é a outra face da página: é o conteúdo HTML que será renderizado. No caso do Tapestry, é XHTML que usamos na realidade (HTML formatado como XML). Em seu interior, incluímos uma expressão: ${randomico}, que irá renderizar o valor retornado pela função getRandomico(), definido na classe Index.java. Tapestry usa a especificação JavaBeans do Java para definir as expressões que serão usadas na renderização das páginas.

Coloque a aplicação para executar em sua IDE usando o comando “mvn jetty:run” para ver o resultado, que será similar ao exposto na imagem a seguir:

Recarregamento dinâmico de classes

Agora, com a aplicação ainda em execução, faça o seguinte experimento: modifique a função getRandomico() da classe Index para que retorne diferentes valores, sem parar a aplicação. Carregue novamente a página: a mudança é instantânea.

Vá além: crie outros “getters” para novas propriedades e vá incrementando o arquivo de template. Note como mesmo novos métodos são detectados instantaneamente na aplicação sem precisar realizar qualquer tipo de reinicialização. Isto dá muita produtividade no desenvolvimento. A propósito, observou a velocidade com que a aplicação é iniciada?

E os componentes?

Bom, vendo a última imagem você deve ter notado que é renderizada uma barra de navegação, mas não a digitamos no código fonte do template. Notou? Então vou repetir o código aqui:

<html t:type="layout" title="inicio-tapestry Index"
xmlns:t="http://tapestry.apache.org/schema/tapestry_5_4.xsd"
>

<p>Randomico como ${randomico}</p>
</html>

O template define que ele é de um dado tipo: “layout”. Você notou que existe uma pasta chamada “components” em “src/main/resources” e também um pacote chamado “components”? Se você abrir o código fonte do arquivo “src/main/resources/br/com/itexto/components/Layout.tml” verá que a barra de navegação, assim como o rodapé e toda a identidade visual está aí. E também vai achar um trecho similar ao exposto a seguir:

<div class="container">
<t:body />
<hr />
<footer>
<p>&copy; Your Company 2015</p>
</footer>
</div> <!-- /container -->

Sabe esta tag <t:body/>? Ela inclui o conteúdo da página Index no interior do Template. É um mecanismo muito similar ao Sitemesh do Grails! Na realidade é um pouco mais que isto, mas para este post inicial, creio que esta definição será o suficiente.

Código fonte do exemplo

O código fonte deste projeto pode ser encontrado neste link. Talvez eu o evolua no futuro conforme novos posts surjam no blog.

O que o Tapestry não tem e não é

É importante salientar que este não é um framework full stack tal como o Grails ou Spring Boot (dependendo da configuração). Quando criamos um novo projeto ele não vem com a camada de persistência pré-configurada. É necessário realizar esta configuração manualmente, tal como exposto na própria documentação.

O projeto já vêm com algumas configurações prontas, tal como o mecanismo de logging e algum CSS, baseado no bootstrap, mas não muito mais do que isto.

Também é importante observar o seu foco: são aplicações web que contenham páginas interativas, não APIs REST. É possível configurar no mesmo projeto um segundo framework para prover estas funcionalidades, tal como o JAX-RS ou mesmo o Spring, mas não recomendo isto.

Sei que não mencionei neste post nada relativo à gestão de sessões, mas este é outro aspecto interessantíssimo do Tapestry: não é um destes frameworks no qual você tem a sessão explícita. Lidamos com ela de uma forma indireta através de anotações que incluímos em nossas classes (@Persistent). Sendo assim, para projetos que precisem lidar diretamente com sessões (cada vez menos o caso), Tapestry também não se aplica.

Conclusões finais sobre este contato inicial

Neste post mostrei apenas o básico do básico do básico do Tapestry (quase nada pra ser sincero). Muita coisa ficou de fora, tal como a forma como é realizada a navegação entre as páginas, gestão de sessão, formulários, inversão de controle, etc.

Meu objetivo foi apenas gerar algum interesse pelo framework e, talvez, criar o post inicial que me permita ir detalhando aos poucos como o Tapestry funciona conforme vou avançando nossos estudos a seu respeito.

Estou achando uma solução muito interessante: mais interessante que o JSF na minha opinião, pois é mais fácil de aprender e oferece uma produtividade muito superior. Isto sem mencionar no desempenho, que foi um dos fatores que mais me surpreendeu.

(tal como mencionado no início deste POST, para implementar APIs REST não é uma solução interessante. Aliás, nem sei se faria sentido, dado ser focado em componentes, e não em ações, tal como ocorre no Grails e Spring MVC)

Dado o estado atual da comunidade (ao menos minha percepção inicial), não sei se o recomendaria para iniciar novos projetos, mas em relação a este aspecto apenas o tempo me dará uma resposta satisfatória. Entretanto, se o tempo mostrar que ainda há gás nesta comunidade, sem sombra de dúvidas que o incluirei em nosso radar.

Visto que tão pouco se escreve a respeito do Tapestry ultimamente, creio que no mínimo estes meus posts servirão para atrair interessados a seu respeito. Mesmo que você jamais o use, as ideias que ele trás já valem à pena conhecer.

Mais fontes sobre Tapestry

Talvez você tenha se interessado pelo framework. A documentação oficial apesar de boa não é suficiente. Sendo assim, seguem alguns links que estão me ajudando no aprendizado:

Tapestry Jumpstart – quase um cookbook de Tapestry

Wiki do projeto – tem algumas informações que não constam na documentação oficial

Este tutorial da Tutorials Point – no formato PDF, é um complemento bem interessante para o tutorial oficial

Tutorial oficial – apesar de estar quebrado o HTML, me ajudou bastante