Muito tem-se discutido sobre a importância de os servidores web cada vez mais serem capazes de suportar a grande quantidade de funcionalidades e recursos que executam junto a eles no mundo web. Falando especificamente do Java, é possível hoje fazer uma análise mais sucinta dos servidores e containers disponíveis no mercado. Por exemplo, o usuário iniciante que se depara com a complexidade de um servidor, como o Glassfish, muitas vezes se perde no montante de configurações ou até mesmo de opções, a grande maioria delas desconhecida ou inexplorada pelo mesmo. O mesmo vale para outros servidores que implementam a especificação JEE, tais como Oracle WebLogic, IBM WebSphere, etc.
Partindo do ponto de vista de desempenho, o Tomcat (container Servlet da Apache) é muito mais leve que os demais, isso porque o número de recursos carregados na sua inicialização e uso é muito menor. O JBoss AS (da Red Hat), por sua vez, tem um recurso considerado inovador e essencial para o aumento da produtividade Java Web: o hot deployment, através do qual é possível compilar classes modificadas em tempo de execução do servidor sem a "velha" necessidade de reiniciar o mesmo.
Todas essas evoluções e/ou criações são ótimas e importantes para a comunidade open source que as utiliza. Entretanto, o container preferido da maioria dos desenvolvedores deixava a desejar. Ele não executa tudo do JEE, e cada vez mais é necessário executar tudo do JEE.
O Apache TommEE não é um produto novo, mas sim um conjunto de projetos de Tomcat e da Apache Java EE (tais como OpenEJB, OpenJPA...) feitos pela própria equipe da Apache OpenEJB. O lote é certificado como um servidor Web Profile Java EE 6. O TommEE é também leve (24Mb) e pode funcionar de forma integrada, agrupando um conjunto de componentes, como o listado abaixo:
- EJB OpenEJB
- CDI OpenWebBeans
- JSP/Servlet Tomcat
- JSF MyFaces
- JPA OpenJPA
- JTA Geronimo Transaction
- JavaMail Geronimo JavaMail
O foco deste artigo é implementar um tutorial básico de implementação usando a mesma tecnologia.
Instalando e Configurando
Assim como na versão do Tomcat, o TomEE tem sua versão disponibilizada em um arquivo zip, através de um executável para o seu sistema operacional. Baixe a versão compactada e descompacte-a em um local de preferência. Vide Seção Links para acessar o link de download. No momento da escrita deste artigo, a versão mais recente é a 1.6.0. Uma vez baixado, extraia o arquivo zip em algum lugar em sua máquina. Se você der uma olhada na estrutura de pastas, provavelmente você vai notar imediatamente como o TomEE é semelhante ao Tomcat. O script usual catalina shell/batch está na pasta bin/, os arquivos de configuração do TomEE estão na pasta conf/ e os aplicativos são implantados por cópias dos arquivos .war no diretório webapps/. O modo de inicialização do TomEE pode ser modificado no diretório /bin e executado através do comando ./catalina.sh run (ou catalina.bat run, se você estiver usando o Windows).
Ao executar o arquivo em questão, o TomEE deve começar em questão de segundos para uma máquina com processamento e memória razoáveis. Uma vez iniciado, abra um navegador e navegue até o endereço "http://localhost:8080". Se tudo iniciou corretamente, o aplicativo padrão Tomcat vai ser exibido na tela (Figura 1). Lembrando que esta URL é padrão para acesso às telas de administração da maioria dos servidores JEE, mudando apenas as portas de cada um. Há um botão adicional nesta aplicação que liga ao console do TomEE, que por sua vez, fornece além de algumas páginas onde você pode verificar se a sua configuração está funcionando corretamente, um navegador JNDI (Java Naming and Directory Interface).
Figura 1. Tela de administração do Apache Tomcat (TomEE 7.0)
Observação: Se tiver dificuldades de processamento ou se sua IDE/Java/Servidor estiverem lentos, consulte formas de acréscimo de memória à JVM e Eclipse.
Configurando o ambiente no Eclipse
Obviamente, o processo de desenvolvimento sem a utilização de uma IDE se torna mais complicado e complexo. Efetue o download e instalação da versão para desenvolvimento web mais recente do Eclipse (vide seção Links). Se não gostar do Eclipse e se sentir mais à vontade com outra IDE, como o Netbeans ou IntelliJ IDEA, por exemplo, fique à vontade para usar. Com o pacote Java EE do Eclipse, que inclui o WTP (Eclipse Web Tools Platform), pode iniciar-se um número de diferentes servidores, implantar o código para eles e automaticamente reimplantar as alterações feitas. A configuração do TomEE no Eclipse segue a mesma linha de processo que você usaria para configurar o Tomcat.
Para começar, selecione a perspectiva "Java EE" no topo do Eclipse. Isso nos possibilitará trabalhar com todos os recursos do JEE no ambiente integrado. Lá embaixo, selecione a aba "Servers" e logo após a opção "new server wizard...", tal como demonstrado na Figura 2.
Figura 2. Aba de criação de novo servidor
Na janela que se abrir selecione a pasta “Apache > Tomcat v7.0 Server”, como na Figura 3.
Figura 3. Tela de seleção do tipo do servidor
Clique em “Next”. No próximo passo selecione o local onde você descompactou o tomcat através da opção “Browse”, que será preenchida no campo “Tomcat installation directory” (Figura 4).
Figura 4. Diretório de instalação do TomEE
Se você não tiver efetuado o download do Tomcat, poderia utilizar a opção “Download and Install...”, entretanto, essa opção iria fazer a instalação apenas do Tomcat comum, portanto siga os passos anteriores para que o processo seja feito corretamente.
Selecione “Next” novamente e na última tela, que representa o passo de adição de projetos, clique em “Finish”, pois ainda não temos nenhum projeto a ser adicionado.
Ao concluir, você ainda necessita fazer outra configuração para que o TomEE funcione corretamente a nível de workspace. Dê dois cliques no servidor e uma página igual à da Figura 5 irá abrir. Selecione a opção marcada na mesma figura.
Figura 5. Configurações em nível de workspace do TomEE
Essa configuração permite que o TomEE acesse os caminhos de deploy do próprio servidor, ao invés dos caminhos do workspace, o que ocasionaria erros e outros problemas. Não se esqueça de salvar. Inicie o servidor e faça o mesmo teste na tela para ver se o mesmo servidor inicializou.
Ajustes opcionais
Se você tiver configurado o Eclipse para usar metadados do workspace ao invés de assumir a instalação do TomEE, é uma boa ideia copiar os arquivos do diretório conf/ do pacote do TomEE para o workspace. Ao ser executado neste modo, os arquivos de configuração são lidos do diretório conf/ na área de trabalho em vez do diretório conf do TomEE. O plugin WTP prestativamente copia um número de arquivos de configuração do Tomcat para o espaço de trabalho automaticamente, mas não enxerga os arquivos tomee.xml ou system.properties.
Para copiar os arquivos necessários para o workspace, clique com o botão direito do mouse sobre a pasta localhost-config no âmbito do projeto “Servers”, que foi criado automaticamente pelo Eclipse e está disponível na aba “Project Explorer”. Importe os arquivos do diretório /conf.
Por padrão, o TomEE não tem o conjunto de parâmetros de desenvolvimento para a compilação de JSPs no arquivo web.xml, o que significa que as JSPs não irão atualizar em tempo real quando você salvar as alterações para eles. Para mudar isso, abra o arquivo web.xml em “Servers > Tomcat v7.0 Server at folder localhost-config” no “Project Explorer”, e modifique o JSP servlet, assim, o modo de desenvolvimento é definido como verdadeiro, como mostrado na Listagem 1.
Listagem 1. Modo de configuração para JSPs no web.xml do TomEE
<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet
</servlet-class>
<init-param>
<param-name>fork</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>xpoweredBy</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>development</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>3</load-on-startup>
</servlet>
Aplicação Simples no TomEE
Agora vamos dar uma olhada em um exemplo de uma aplicação simples e como ela atua junto ao servidor TomEE. Ele vem com uma série de exemplos de aplicações que demonstram um número de diferentes recursos disponíveis no Java EE. Atualmente, existem mais de 100 exemplos e estes podem servir como excelente ponto de partida para a aprendizagem de novos recursos do Java EE. Estes mesmos projetos estão disponíveis no repositório Subversion do TomEE. Vamos usar como ponto de partida o exemplo chamado “MovieFun” para embasar os entendimentos daqui pra frente. O mesmo projeto está disponível na URL da seção Links. Esse exemplo é uma aplicação web simples usando alguns dos recursos disponíveis no Web Profile.
Para começar, o aplicativo tem um POJO simples que representa um objeto Filme, e isso é usado pelo JPA para armazenar e recuperar um filme do banco de dados. A Listagem 2 mostra um POJO Filme que tem como atributos: titulo, diretor, genero, ano e avaliacao.
Observação: As entidades usadas no exemplo estão listadas de forma traduzida para facilitar o entendimento. Portanto, não confundam quando forem executar em suas máquinas.
Listagem 2. Entidade Filme
@Entity
public class Filme implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private long id;
private String diretor;
private String titulo;
private int ano;
private String genero;
private int avaliacao;
public Filme() {
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getDiretor() {
return diretor;
}
public void setDiretor(String diretor) {
this.diretor = diretor;
}
public String getTitulo() {
return titulo;
}
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public int getAno() {
return ano;
}
public void setAno(int ano) {
this.ano = ano;
}
public String getGenero() {
return genero;
}
public void setGenero(String genero) {
this.genero = genero;
}
public int getAvaliacao() {
return avaliacao;
}
public void setAvaliacao(int avaliacao) {
this.avaliacao = avaliacao;
}
}Essa listagem fornece a criação de um objeto simples que pode ser persistido no banco de dados usando JPA. Para fazer isso, um contexto de persistência pode ser injetado em um EJB simples ou bean CDI, e que pode ser usado para recuperar e persistir objetos do tipo Filme no banco de dados.
O Apache TomEE fornece suporte para EJB na sua versão 1 até a versão 3.1. O EJB 3.0 fez com que a criação de EJBs ficasse muito mais simples do que as versões anteriores, e a 3.1 melhorou isso ainda mais. Uma das novas funcionalidades é a visão "sem-interface", o que significa que um bean de sessão EJB não precisa fornecer uma interface. Isso é inovador do ponto de vista programático, uma vez que não mais serão necessárias tantas interfaces como antes.
A Listagem 3 mostra um EJB de sessão stateless, que pode gerenciar o armazenamento e recuperação de dados usando JPA 2. Este EJB é um POJO simples, que foi anotado com @Stateless (o que é necessário para torná-lo um EJB) e tem um gerenciador de entidade injetado pelo TomEE usando a anotação @PersistenceContext.
Listagem 3. Exemplo de implementação de um session bean usando JPA2
@Stateless
public class FilmesBean {
@PersistenceContext(unitName = "filme-unit")
private EntityManager entityManager;
public Filme find(Long id) {
return entityManager.find(Filme.class, id);
}
public void addFilme(Filme filme) {
entityManager.persist(filme);
}
public void removerFilme(Filme filme) {
entityManager.remove(filme);
}
public void deleteFilmeId(long id) {
Filme filme = entityManager.find(Filme.class, id);
removerFilme(filme);
}
public List<Filme> getFilmes() {
CriteriaQuery<Filme> cq =
entityManager.getCriteriaBuilder().createQuery
(Filme.class);
cq.select(cq.from(Filme.class));
return entityManager.createQuery(cq)
.getResultList();
}
}Essa classe fornece alguns métodos simples: em primeiro lugar temos métodos de busca, adição e exclusão que delegam para o gerenciador de entidades (EntityManager). O método getFilmes() recupera o conjunto completo de filmes a partir do banco de dados através da construção de uma consulta simples JPA2. Observe que não há declarações transacionais de commit ou rollback aqui. Os métodos dos EJBs são transacionais por padrão, de modo que este não é mais necessário. O TomEE já está economizando tempo!
Este bean fornece uma API simples para interagir com o banco de dados. Agora precisamos de algo para usá-lo. Então, vamos dar uma olhada na interface do usuário do FilmeFun. Há uma série de maneiras que uma interface front-end web pode interagir com este EJB - por exemplo, ele pode ser referenciado por um ManagedBean do JSF ou você pode procurar o EJB a partir de outro framework MVC. Para mantê-lo simples, esse exemplo usa um servlet como mostrado na Listagem 4, que interage com o EJB e encaminha o resultado para uma JSP.
Como era de se esperar, como o TomEE tem o Tomcat 7 como núcleo, ele suporta a especificação 3.0 dos Servlets. Isso nos permite criar uma classe que estende javax.servlet.http.HttpServlet e anotá-la com @WebServlet. Servlets e beans gerenciados podem ter EJBs injetados em seus campos usando a anotação @EJB no campo e o bean CDI pode ser injetado usando a anotação @Inject. O TomEE também suporta @Inject do construtor para Servlets, uma característica que foi adicionada ao JavaEE 7.
Listagem 4. Exemplo de Servlet com session bean injetado
@WebServlet("/filmefun/*")
public class ActionServlet extends HttpServlet {
private static final long serialVersionUID =
-5832176047021911038L;
@EJB
private FilmeBean filmesBean;
@Override
protected void doGet(HttpServletRequest
request, HttpServletResponse response)
throws ServletException, IOException {
List<Filme> filmes = filmesBean.getFilmes();
request.setAttribute("filmes", filmes);
request.getRequestDispatcher
("WEB-INF/filmefun.jsp").forward
(request, response);
}
}O código da Listagem 5 mostra como exibir os valores em resultado ao redirecionamento feito no servlet da Listagem 4.
Listagem 5. Exemplo de JSP para renderizar os filmes
<div>
<table>
<thead>
<tr>
<th>Título</th>
<th>Diretor</th>
<th>Gênero</th>
<th>Ano</th>
<th>Avaliação</th>
</tr>
</thead>
<tbody>
<c:forEach items="${filmes}" var="filme">
<tr>
<td><c:out value="$
{filme.titulo}" /></td>
<td><c:out
value="${filme.diretor}" /></td>
<td><c:out
value="${filme.genero}" /></td>
<td><c:out
value="${filme.ano}" /></td>
<td><c:out
value="${filme.avaliacao}" /></td>
</tr>
</c:forEach>
</tbody>
</table>
</div>Assim, com apenas três classes e uma JSP estamos quase prontos para executar. Precisamos de um arquivo extra, o META-INF/persistence.xml, que irá fornecer algumas informações básicas sobre a unidade de persistência que será injetada no EJB.
O exemplo do arquivo “persistence.xml” mostrado na Listagem 6 indica as classes @Entity sendo usadas (org.superbiz.moviefun.Filme neste caso), e especifica que o OpenJPA deve construir o esquema no banco de dados automaticamente se ele ainda não existir.
Listagem 6. Arquivo persistence.xml da aplicação
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
<persistence-unit name="filme-unit">
<jta-data-source>filmeDatabase</jta-data-source>
<non-jta-data-source>filmeDatabaseUnmanaged
</non-jta-data-source>
<class>org.superbiz.moviefun.Filme</class>
<properties>
<property name="openjpa.jdbc.SynchronizeMappings"
value="buildSchema(ForeignKeys=true)"/>
</properties>
</persistence-unit>
</persistence>Deploying da aplicação
Para efetuar o deploy da aplicação no servidor TomEE, o processo é igual ao do Tomcat. Basta clicar com o botão direito do mouse no servidor e selecionar a opção “Add and Remove...” e adicionar o projeto em questão ao servidor. Não se esqueça de que após isso, precisa popular a base para ver os valores listados ou usar a aplicação para tal.
Você vai notar que tudo está em um módulo que só vai ser empacotado em um único arquivo WAR. Não há necessidade de construir um arquivo EAR com o EJB separado em seu próprio JAR, como tem sido o caso com versões anteriores do Java EE. Esta é uma característica que se originou a partir do TomEE, que teve por vários anos, e foi um de suas primeiras contribuições para o Java EE.
Muitas outras configurações são ainda possíveis de ser feitas no TomEE para maximizar o poder de uso do mesmo, tais como configurações de banco de dados, configurações de segurança, etc. Essa foi apenas uma amostra do poder desse servidor e do quão robusto e produtivo ele pode ser para o seu projeto.
Links
Página Oficial de Download do TomEE - http://tomee.apache.org/downloads.html
Página Oficial de Download do Eclipse - http://eclipse.org/downloads
Página de Download do projeto MovieFun - http://tomee.apache.org/examples-trunk/moviefun/README.html
