Objetivos do Tutorial:
Ajudar no desenvolvimento das primeiras aplicações, utilizando
EJB 3.0.
Indicar uma sequência de passos a serem seguidos a fim de compreender os
principais mecanismos oferecidos por esse framework.
Passo 1: Configurar o Ambiente
Jboss AS 4.0.4 instalado com perfil
EJB 3.0 (
http://labs.jboss.com/jemsinstaller/, baixar o arquivo:
1.2.0.GA)
Eclipse SDK, versão 3.2
http://www.eclipse.org/downloads/
PostgreSQL, versão 8.2
http://www.postgresql.org/download/
Driver do PostgresSQL
http://jdbc.postgresql.org/download.html, baixar arquivo
JDBC3)
Passo 2: Contruir Projeto
Crie um
Java Project. Modifique o Build Path do projeto para referenciar as APIS do JBOSS que estão no diretório
jboss-4.0.5.GA \ client.
Passo 3: Construir Entidade
import javax.persistence.Entity;
import
javax.persistence.Id;
@ Entity
public class Curso implements Serializable {
@ Id
@ GeneratedValue
private Integer cod;
private
String nome;
/ /.. getters e setters omitidos
}
Essa entidade utiliza anotações presentes na bibliteca do JPA,
Java Persistence
API. A anotação @ Entity define a classe como persistente.
Os cursos serão persistidos na tabela? curso? na base de dados, pois por default o JPA considera o nome da classe igual ao da tabela. a anotação @ Id define o atributo cod como o identificador da tabela no banco de dados a anotação @ GeneratedValue define que o valor do atributo cod será gerado automaticamente no momento em que os objetos forem persistidos.
Passo 4: Construir Interface
import javax.ejb.Local;
import javax.ejb.Remote;
@ Remote
public interface Cadastrar {
void cadCurso (Curso curso);
Collection getCursos ();
}
Características de
EJB 3
Antes de criar o Session Bean, é preciso definir suas interfaces de acesso. Um Stateless Session Bean, definido no próximo passo, pode ter uma interface local e remota.
Nesse exemplo, a interface é remota. A anotação @ Remote define essa interface como Remota, oferecendo acesso a clientes remotos. Para declarar uma interface como Local? que não oferece acesso a clientes remotos, deve ser utilizada a anotação @ Local. Esse tipo de interface deve ser usado para clientes localizados na mesma JVM onde está rodando o container de EJBs.
Passo 5: Construir Session Bean
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
@ Stateless
public class CadastrarBean implements Cadastrar {
private List cursos;
@ Persistence
Context EntityManager entitymanager;
public CadastrarBean () {
cursos = new ArrayList ();
}
public void cadCurso (Curso curso) {
entitymanager.persist (curso);
}
public List getCursos () {
cursos = entitymanager.createQuery (" select * from CURSO "). getResultList (); return cursos;
}
}
Características de EJB 3
O Session Bean representa um cliente no servidor J2EE. Para acessar a aplicação, o cliente invoca os métodos do Session Bean. É similar a uma sessão interativa, sendo único para cada cliente. Assim como a sessão, os dados do bean não são armazenados em uma base de dados. Quando o cliente encerra a sessão, o session finaliza e não ficará mais associado a ele.
Existem dois tipo de Session Bean: Stateless e StateFul. A anotação @ Stateless define a classe CadastrarBean como sendo do tipo Stateless. É mais leve e indicado para processos que não necessitam manter estado (valores de atributos) durante as chamadas de métodos. Para definir o tipo Stateful, é necessário atribuir a anotação @ Stateful. Esse bean é mais pesado, mas garante a preservação do estado entre as chamadas de métodos de um mesmo cliente.
A anotação @ PersistenceContext, da
API de JPA, possibilita o processo de injeção de dependência. O container
EJB reconhece a anotação e, automaticamente, injeta um objeto EntityManager na propriedade.
Passo 6: Contruir os arquivos de configuração
Vejamos o arquivo persistence.xml
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_1_0.xsd">
java: / CursoDS
Esse arquivo deve ser inserido na aplicação, no diretório META-INF / persistence.xml. O elemento deve estar associado ao elemento do arquivo curso-dx.xml, explicado abaixo.
Vejamos o arquivo curso-ds.xml
CursoDS
jdbc: postgresql: / / localhost: 5432 / curso org.postgresql.Driver
postgres
postgres
PostgreSQL 7.2
Esse arquivo deve ser inserido dentro do diretório server \ default \ deploy do JBOSS.
Nesse arquivo, são configuradas as propriedades referentes à conexão com o banco de dados PostgreSQL. O nome CursoDS configurado através do elemento está associado ao elemento, mencionado no arquivo de configuração citado anteriormente.
Passo 7: Deploy do projeto
Após ter criado o projeto, exporte para arquivo.
jar dentro do diretório
jboss-4.0.5.GA / server \ default \ deploy do JBOSS. Repare que é o mesmo local onde fica armazenado o curso-ds.xml.
Inicie a conexão com o PostgreSQL e crie um banco de dados com o nome curso.
Coloque o driver do PostreSQL no diretório jboss-4.0.5.GA2 \ server \ default \ lib do JBOSS. Inicie o JBOSS e confira se o projeto foi deployado. Confira se a tabela curso foi criada no seu banco.
Passo 8: Construir o Cliente
Crie no mesmo projeto a classe abaixo:
import javax.naming.Context;
import javax.naming.InitialContext;
import java.util.Hashtable;
public class Cliente {
public static void main (
String [] args) throws Exception {
Hashtable prop = new Hashtable ();
prop.put (InitialContext.INITIAL_CONTEXT_FACTORY, " org.jnp.interfaces.NamingContextFactory ");
prop.put (InitialContext.PROVIDER_URL, " jnp: / / localhost: 1099 ");
Context ctx = new InitialContext (prop); Cadastrar cad = (Cadastrar) ctx.lookup (" CadastrarBean / remote ");
Curso curso = new Curso ();
curso.setNome ("
AJAX ");
cad.cadCurso (curso);
curso.setNome ("
XML ");
cad.cadCurso (curso);
curso.setNome (" PROGRAMAÇÃO ");
cad.cadCurso (curso);
for (Curso c: cad.getCursos ()) {
System.out.println (c.getCod () +? -? + c.getNome ());
}
}
}
Características de
EJB 3
É necessário realizar a conexão com o serviço de nomes, através de um objeto InitialContext da
API JNDI (
Java Naming and Directory Interface). Através desse objeto, é possível obter um referência para o objeto remoto.
Nesse exemplo, o contexto deve ser inicializado por meio de um objeto HashTable. Caso a aplicação fosse construída utilizando um mesmo container, o contexto seria único e conhecido.
Então, não seria necessário especificá-lo, possibilitando a inicialização do objeto InitialContext sem parâmetros. Através do método ctx.lookup (" nome-da-clase / remote "), um Session Bean remoto é solicitado ao container.
Passo 9: inicializar o Cliente
