Parte 2
Agora é hora de começar a desenvolver!
Abra o Eclipse e crie um projeto Java, simples, vazio. Você pode fazer isso no menu:
“File” -> “New Project…” e selecionando a opção “Java Project”.
Escolha um nome para o seu projeto e clique em “finish”, não precisa setar mais nada, por enquanto.
Um projeto novo apereceu agora, na aba “Package Explorer”, do lado esquerdo do seu Eclipse. Agora precisamos configurar os diretórios de fonte e de output do seu projeto. Clique com o botão direito em cima dele e selecione “Properties”.
Uma janela se abrirá, no menu do lado esquerdo selecione a opção “Java build path”, algumas opções aparecerão do lado direito, certo? Selecione a aba “source”. Nela você escolhe os diretórios de fonte e de output do seu projeto.
Para este tutorial, criaremos um diretório chamado “src”, clique em “add folder…” do lado direito, e na caixa de diálogo que se abre entre com o nome dele, “src”. Provavelmente após fazer isso, a “Default output folder”, ali embaixo, foi automaticamente configurada para “SeuProjeto/bin”. Se sim, feche a janela, clicando em “ok”.
Caso não seja esta a pasta, clique em “Browse” e crie uma pasta chamada “bin”, imediatamente abaixo da pasta do projeto.
Criando nosso primeiro Session…
Chega de enrolação agora, vamos escrever código! Crie um pacote para seus Sessions, clicando com o botão direito em cime do diretorio “src”, que é o nosso diretório de fontes, e selecione “new” -> “package”.
Crie um pacote com o nome “com.model.ejb.session”
Crie uma classe nesse pacote, chamada “UsuarioServiceBean”:
package com.model.ejb.session;
@Stateless
public class UsuarioServiceBean {
}
Aquela “annotation” em cima do nome da classe indica que trata-se de um SessionBean do tipo Stateless. Inicialmente o Eclipse não vai reconhece-la, e vai indicar um erro ali, resolveremos isso adicionando ao path do seu projeto o “jar” com essa classe.
Crie um diretório chamado “lib” imediatamente abaixo do diretório do seu projeto. Copie para dentro deles o jar “ejb3x.jar” que fica dentro diretório de instalação do JBoss:
jboss/server/default/deploy/ejb3.deployer
Note que a rigor não é necessário copiar esse jar para cá, como alternativa você poderia simplesmente adicionar um jar externo ao seu java build path. Mas eu pessolamente prefiro assim, porque facilitará muito quando formos empacotar nossa aplicação com ajuda do ant, e evita problemas com path se por acaso você levar seu projeto para outra máquina, onde o diretório do JBoss pode ser diferente.
Agora faça o seguinte, clique com botão direito em cima do seu projeto, e depois em “properties”, no menu ” Java build path”, selecione a aba “Libraries”, nela você vai adicionar o jar utilizando “add jars” e selecionando o nosso “ejb3x.jar”.
Volte ? nossa classe “UsuarioServiceBean”, que estava com erro, e use o recurso “organize imports” do Eclipse, pode ser pelas teclas de atalho “Ctrl+Shift+O”. Nossa classe agora ficará assim:
package com.model.ejb.session;
import javax.ejb.Stateless;
@Stateless
public class UsuarioServiceBean {
}
E não devem haver mais erros.
Ok, agora deixe-me dar uma breve explicação de um tópico muito importante, que são as interfaces locais e remotas do seu EJB. Todo EJB pode ter interfaces do tipo “Local” ou “Remote”, e é por estas interfaces que o cliente acessa os métodos do seu componente.
É considerado “local” tudo o que estiver na mesma VM (Virtual Machine). Então suponha, por exemplo que você tenha um Tomcat, com alguns Servlets rodando em uma aplicação na sua máquina e um JBoss, na mesma máquina, com seus componentes EJB.
A pergunta é: o meu Servlet que está lá dentro do Tomcat vai acessar os meus componentes EJB de maneira local ou remota?
Provavelmente remota.
O que ocorre é que muito provavelmente estes dois containers, por estarem separados, foram startados por VMs diferentes. O que não ocorre por exemplo se os seus Servlets estiverem dentro do JBoss (O JBoss possui um módulo do Tomcat dentro dele), quando então ambos estarão na mesma VM.
E porque você precisa de uma interface para os seus componentes?
Bem, uma das vantagens de usar componentes remotos é que você pode disponibiliza-los para seus clientes sem que eles tenham acesso a implementação dos métodos e ? s suas regras de negócio. Então certamente você não vai enviar para o seu cliente um pacote com seus Session Beans, certo? Na prática o que você fará é disponibilizar um pacote para o cliente com suas interfaces remotas, para que ele acesse seus métodos de negócio, apenas.
Detalhes da implementação são problema seu, não dele.
Então vamos agora escrever uma interface remota, com os métodos de negócio para que nossos clientes possam acessar nosso SessionBean. Crie um pacote chamado “com.service”, e crie uma interface chamada “UsuarioService”:
package com.service;
import javax.ejb.Remote;
@Remote
public interface UsuarioService {
}
A anotation “@Remote” indica que trata-se de uma interface do tipo “Remote” para a classe que a implementa. Vamos também adicionar um método a ela:
package com.service;
import java.rmi.RemoteException;
import javax.ejb.Remote;
@Remote
public interface UsuarioService {
public String getMessage() throws RemoteException;
}
Agora, o nosso UsuarioServiceBean deve implementar a interface, vamos fazer mais algums modificações nele:
package com.model.ejb.session;
import java.rmi.RemoteException;
import javax.ejb.Stateless;
import com.service.UsuarioService;
@Stateless
public class UsuarioServiceBean implements UsuarioService{
public String getMessage() throws RemoteException {
return “don’t worry buddy it is just a test…”;
}
}
Repare que agora ele implementa a interface, e adicionamos um código bem simples ao método de negócio.
O próximo passo é configurar o ant para automatizarmos o processo de compilação, teste e deploy da nossa aplicação. Crie um arquivo chamado “build.xml” no diretório principal do nosso projeto, esse será o aqruivo de build do ant.
Vamos editar o arquivo da seguinte forma:
Iniciando build do EJB tutorial
É muito importante que não haja nenhum espaço ou tabulação antes da primeira linha “” porque isso gera um erro no processamento do arquivo pelo ant. A partir disso, espaços ou tabulações serão ignoradas, apenas nessa primeira linha temos esta restrição.
O atributo “basedir”:
basedir=”.”
indica que estamos no diret?oio raiz do projeto, algumas pessoas (inclusive eu) preferem colocar o arquivo build do ant em um diretório separado, chamado normalmente de “META-INF”. Mas tenho como objetivo neste tutorial simplificar o máximo possível, então vamos deixar ele aqui mesmo.
Temos agora um arquivo de build do Ant bastante básico, que na verdade não faz muita coisa, apenas imprime na tela a mensagem “Iniciando build do EJB tutorial”. entretanto o Ant é uma bastante poderosa, e vamos utilizar um pouco mais de recursos dele, vamos setar algumas propriedades dele começando pelos diretórios de fonte, output e lib da nossa aplicação e também algumas “targets”:
Agora nosso arquivo ganhou alguma utilidade, de fato.? Adicionamos “targets” a ele que fazem algum trabalho para nós, como limpar o diretório de output e compilar nossas classes.
Vamos fazer uma análise rápida delas:
Aqui o que fizemos foi setar algumas propriedades do Ant, que facilitarão nossa vida porque substituem os nomes de diretórios por variáveis, que podem ser referenciadas.? Nesse caso, não percebemos muita vantagem porque os diretórios são simples, e estão dentro do nosso projeto, só que mais adiante vamos adicionar mais variáveis e você perceberá de forma mais clara a verdadeira vantagem de usarmos estas propriedades.
Aqui setamos o classpath para a compilação, com o nosso diretório “lib” e todos os jars que estiverem dentro dele.? Perceba que aqui já fazemos uso da variável que setamos anteriormente.
Esta target existe apenas para garantir que antes de iniciar o processo de compilação estaremos limpando tudo o que existe no diretório de output.
Aqui a mais importante delas, a compilação das nossas classes.? Note que fazemos referência ao classpath que setamos antes, para que o compilador utilize as classes do nosso diretório “lib”.
Agora, no Eclipse, clique com o botão direito no arquivo “build.xml”, e depois no menu “Run As…” -> “Ant Build”
Na janela de opções que se abre, selecione apenas a target “compile”, desmarque todas as outras, e clique em “run”.
Você verá o Ant sendo executado, e algumas informações sobre o processamento deverão aparecer, ao final a mais importante é:
“BUILD SUCCESSFUL”
Excelente tutorial