Criando uma Enterprise Application (EAR) com Eclipse

Introdução

Ola pessoal, o objetivo deste post é demonstrar como criar um projeto J2EE no Eclipse.

O J2EE é a especificação Java para aplicações corporativas. É uma especificação bem completa e avançada que aborda temas específicos para o desenvolvimento de aplicações em larga escala e com alta escalabilidade, segurança, dentre outros requisitos não funcionais.

Obviamente cabe ao desenvolvedor utilizar a plataforma de uma maneira eficiente para manter todos estes requisitos.

Uma das partes da especificação trata do EJB (Enterprise Java Bean) que são componentes (classes) que o servidor de aplicação gerencia para o desenvolvedor tornando muito mais simples e produtivo construir aplicações.

Neste exemplo, vamos criar uma aplicação que ira receber uma requisição Web através de uma Servlet. Esta Servlet encaminhará a requisição para o EJB que simplesmente modificará a String recebida. É um exemplo bem simples mas que vai demonstrar todo o fluxo de dados de uma aplicação bem como a simplicidade de criarmos estes componentes.

Vou utilizar neste exemplo, a versão 3.0 do Dynamic Web Module num servidor Jboss AS 7. A versão do eclipse utilizada é a Juno.

Servidor de aplicação X Container WEB

Inicialmente, vamos definir a diferença entre um container WEB e um servidor de aplicação. A especificação J2EE define diversas normas que um servidor de aplicação deve implementar, como por exemplo, gerenciar um EJB, tratar de requisições via web-service, etc. Desta forma, um servidor de aplicação homologado deve implementar totalmente a especificação e por isso, torna-se um software robusto e complexo. Como exemplo de servidores, podemos citar o Glassfish que é o servidor oficial e que possui uma implementação padrão do J2EE, o JBOSS, o WebLogic.

Já um container WEB implementa uma parcela da especificação e por isso é muito mais leve e simples. Como exemplo, podemos citar o Tomcat e o Jetty.

Outra diferença fundamental é que os containeres WEB executam apenas arquivos WAR (Web application ARchive) e os servidores de aplicação podem rodar também os EAR (Enterprise application ARchive) que são as aplicações mais completas e robustas.

Criando um projeto WEB

Nosso primeiro passo é criar um projeto WEB que normalmente contem as nossas servlets, filters, JSP, javascript, css, etc.
Para isso devemos seguir alguns passos.

Primeiro, no eclipse, selecione o menu File->New->Other. Ou digite o atalho Ctrl+N.
Agora digite Dynamic Web. Na listagem de templates abaixo, selecione o Dynamic Web Project e pressione Next.

Criando Dynamic Web Project

Na próxima tela, vamos começar a configurar nossa aplicação. Digite um nome para a aplicação, no meu caso chamei de CriandoEARWeb. O sufixo Web é para separar logicamente o nome das aplicações criadas.

Configurando um Dynamic Web Project

No meu caso, selecionei para que o projeto fosse salvo no meu workspace default, mas você pode configurar isso.
Como target selecionei o JBoss e no Dynamic Web Version selecionei a versão 3.0.
Observe que no item Configuration, o Eclipse possui templates para diferentes tipos de aplicações, como o JSF. Mas vamos manter a opção de Default Configuration for JBoss 7.1 Runtime. Clique em Next.

Dica: Caso você não tenha o JBoss na lista de servidores, aconselho a instalar o plugin JBoss Tools que é muito bom.

A próxima tela configura a pasta de fontes e onde devem ficar os arquivos compilados. Normalmente não se modifica esta configuração. Clique em Next.

Por fim, vamos configurar o context root, que é o nome que sua aplicação receberá dentro do servidor e como vamos acessá-la no browser. A configuração de WebContent define o nome da pasta onde estarão os nossos arquivos web (javascript, css, etc) e por fim, marque a checkbox para que o eclipse gere um arquivo web.xml default para você.

Configurando o Dynamic Web Project

Você deve ter uma estrutura parecida com a da imagem abaixo. A diferença é que já foi criado um package br.com.coffeecode.servlet. Crie este package onde vamos adicionar nossas servlets.

Estrutura do Projeto Dynamic Web Project

Note que as configurações anteriores estão representadas nesta imagem, o nome da pasta onde ficam os insumos web é a WebContent e o arquivo web.xml foi gerado e esta localizado dentro da pasta WEB-INF.

Criando um Servlet

Agora vamos criar um servlet que irá encaminhar a requisição para um EJB e retornar para a tela o parâmetro alterado. Então crie uma nova classe Java dentro do pacote que criamos. A classe criada é esta e vamos explicá-la em seguida:

package br.com.coffeecode.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/echo")
public class EchoServlet extends HttpServlet {

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	     String text = req.getParameter("text");
	}

}

Esta classe é um servlet por herdar da classe HTTPServlet e possuir a annotation @WebServlet. Nesta annotation configuramos qual a url para acessar a nossa servlet. No nosso caso, é o nome da nossa aplicação mais a palavra echo. Dentro da servlet vamos esperar um parâmetro text.

Criando uma aplicação EJB

Criar uma aplicação EJB é igualmente simples. Dentro desta aplicação devemos incluir todas as nossas classes relacionadas ao domínio ou negócio. Logo, é nesta aplicação que fica a camada de model. É comum uma aplicação conter mais de um projeto EJB para aumentar a separação de domínios.

Utilize o atalho do eclipse Ctrl+N e digite na caixa de busca EJB. A primeira opção deve ser EJB Project. Selecione esta opção e clique em Next.

Criando aplicação EJB

Na próxima tela configure um nome para a aplicação. Novamente você pode selecionar a localização do projeto e a versão do EJB a ser utilizada. Note que novamente coloquei a terminação EJB no nome do projeto, uma forma simples de identificar que se trata de um EJB Project.

Nomeando um EJB Project

Na próxima tela, novamente podemos selecionar a pasta de arquivos fontes, clique em Next.

Na última tela, podemos pedir para o eclipse gerar um arquivo de configuração. Deixe desmarcada a opção e clique em Finish.

Criando um projeto EJB

Você deve ter uma estrutura de projeto parecida com a da imagem. Apenas acrescentei um pacote onde ficarão os EJB’s criados.

Estrutura do Projeto EJB

Criando um EJB

Neste nosso exemplo, vamos criar um EJB Stateless.
A diferença entre EJB’s Stateless e Statefull, é que os EJB Stateless não guardam estado. Isso significa que você deve imaginar que a cada nova requisição, você terá um EJB novo.
Na prática você não deve utilizar variáveis de instância como forma de poder recuperar dados a cada nova requisição. O próprio servidor pode criar um pool de EJB e nada garante que a instância que você irá receber a cada requisição é a mesma. Requisições Stateless devem receber os parâmetros necessários para o processamento e executá-lo sem necessitar de dados de navegação anteriores. Se necessitar, deve acessar estes dados de uma forma indireta, sem possuir estado no próprio EJB. Uma forma comum de fazer isso, é acessar um banco de dados.

Para criarmos um EJB precisamos criar uma interface Remote ou Local. A diferença entre as duas é que a interface Remote é utilizada para chamadas Remotas outras aplicações e a Local para chamadas internas (mesma aplicação). Como nós iremos encapsular numa mesma aplicação o projeto WEB e EJB, vamos utilizar a interface Local.

package br.com.coffeecode.ejb;

import javax.ejb.Local;

@Local
public interface TesteEjbLocal {

	public String addPipe(String text);

}

No código acima, criamos uma interface e marcamos ela com a annotation @Local. Além disso criamos um método addPipe que deverá ser implementado no EJB. Esta interface sera também a forma como a aplicação WEB acessará o nosso EJB, como veremos adiante.

Vamos agora implementar esta interface, criando o EJB que irá atender a requisição.

package br.com.coffeecode.ejb;

import javax.ejb.Stateless;

@Stateless
public class TesteEjb implements TesteEjbLocal {

	public String addPipe(String text) {
		return "|"+text+"|";
	}
}

No exemplo acima, criamos uma classe chamada TesteEjb e marcamos ela com a anotação Stateless. Como implementamos a interface que criamos anteriormente o método addPipe é implementado.

Criando um Enterprise Aplication R

Falta agora criarmos um projeto que irá encapsular estes dois como uma só aplicação J2EE. Para isso, vamos novamente utilizar o Ctrl+N do Eclipse e digitar Enterprise Application na caixa de busca.

Criando um projeto EAR

Selecione o Enterprise Application Project e clique em Next.

Na próxima tela, iremos configurar o nome da aplicação e outras configurações. Repare que criei o nome da aplicação sem sufixo nenhum, pois este é o projeto que encapsula todos os outros. As configurações adicionais são semelhantes as anteriores, clique em Next.

Configurando Projeto EAR

Agora devemos selecionar quais os projetos devem fazer parte deste EAR, selecione os dois projetos criados anteriormente e clique em Finish.

EAR Configurando aplicações

O projeto criado será aquele que vamos incluir no servidor para executar. Falta agora fazermos a ligação entre o projeto WEB e o projeto EJB.

O arquivo application.xml é importante pois nele é informado todos os módulos da aplicação e qual a URL que a aplicação vai ser acessada, no nosso caso, EAR:

<?xml version="1.0" encoding="UTF-8"?>
<application xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" 
 xmlns:application="http://java.sun.com/xml/ns/javaee/application_5.xsd" 
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/application_6.xsd"  id="Application_ID" version="6">
  <display-name>CriandoEAR</display-name>
  <module>
    <ejb>CriandoEAREJB.jar</ejb>
  </module>
  <module>
    <web>
      <web-uri>CriandoEARWeb.war</web-uri>
      <context-root>EAR</context-root>
    </web>
  </module>
</application>

Injetando o EJB

O próximo passo é adicionar a dependência do projeto EJB no projeto WEB. Para isso clique com o botão direito sobre o projeto WEB e selecione a opção Properties. Dentro da janela que irá se abrir, seleciona o item Java Build Path e clique na aba Projects. Clique em ADD e selecione o seu projeto EJB.

Projeto Web – Adicionar dependencia de outro projeto

Vá até a servlet que criamos anteriormente e atualize a mesma para o arquivo abaixo:

package br.com.coffeecode.servlet;

import java.io.IOException;

import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import br.com.coffeecode.ejb.TesteEjbLocal;

@WebServlet("/echo")
public class EchoServlet extends HttpServlet {

	@EJB
	private TesteEjbLocal testeEjb;

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
			throws ServletException, IOException {
		String text = req.getParameter("text");
		String newText = testeEjb.addPipe(text);
		resp.getWriter().print(newText);
	}

}

Note que agora adicionamos uma variável de instância que é do tipo da interface Local que criamos no projeto EJB. A annotation @EJB é muito importante pois ela instrui o servidor a buscar um EJB desta interface e injetá-lo dinamicamente em nossa servlet. Note que NÃO EXISTE um new para esta variável. Mas fique tranquilo, estaremos livres do NullPointerException graças ao servidor de aplicação.

Agora nos resta testar a aplicação, para isso adicione ela ao ser servidor e inicie o mesmo:

Configurando servidor

Note que no log do servidor, é informado que um EJB foi encontrado:

java:global/CriandoEAR/CriandoEAREJB/TesteEjb!br.com.coffeecode.ejb.TesteEjbLocal
	java:app/CriandoEAREJB/TesteEjb!br.com.coffeecode.ejb.TesteEjbLocal
	java:module/TesteEjb!br.com.coffeecode.ejb.TesteEjbLocal
	java:global/CriandoEAR/CriandoEAREJB/TesteEjb
	java:app/CriandoEAREJB/TesteEjb
	java:module/TesteEjb

Pronto, basta executarmos agora via browser uma requisição para a nossa servlet:

Exemplo requisição

Demonstramos neste post como criar uma Enterprise Application que muitas vezes pode complicar o desenvolvimento com J2EE mas que como vimos é bem simples e ainda nos força uma boa divisão em camadas.

Vídeo: