JavaEE - EJB e CDI

Prévia do material em texto

CENTRO UNIVERSITÁRIO DE PATOS DE MINAS 
DISCIPLINA: DESENVOLVIMENTO WEB II 
EDUARDO HENRIQUE SILVA 
 
 
 
 
 
 
 
 
 
EJB E CDI 
SUMÁRIO 
1 EJB.............................................................................................................. 1 
1.1 O QUE É UM EJB .......................................................................................................... 1 
1.2 TIPOS DE EJBS ............................................................................................................. 2 
1.2.1 Session Beans .................................................................................................................. 2 
1.2.2 Message-Driven Beans ................................................................................................... 4 
1.3 CONTÊINER EJB .......................................................................................................... 4 
1.4 TIPOS DE ACESSO AO SESSION BEAN ................................................................... 5 
1.4.1 @LocalBean ................................................................................................................... 5 
1.4.2 @Local ............................................................................................................................ 5 
1.4.3 @Remote ........................................................................................................................ 6 
2 JNDI E RMI ............................................................................................... 6 
REFERÊNCIAS .................................................................................................. 7 
 
 
1 
1 EJB 
Anteriormente vimos como implementar a camada de persistência com o JPA e 
como realizar consultas com JPQL. A camada de persistência foi desenvolvida usando objetos 
que encapsulam e mapeiam seus atributos para um banco de dados relacional, utilizando 
anotações. A ideia é manter as entidades o mais transparente possível e não mistura-las com a 
lógica de negócios. 
A camada de persistência não é apropriada para processar regras de negócios, 
como, a camada de visão também não é a ideal para implementar regras de negócios. Para 
separar a camada de persistência da camada de visão, para implementar a lógica de negócios, 
para adicionar o gerenciamento de transações e segurança, as aplicações precisam da camada 
de negócio. No Java EE, essa camada é implementada usando o Enterprise Java Beans (EJB). 
1.1 O QUE É UM EJB 
EJBs são componentes do lado do servidor que encapsula as regras de negócios e 
gerenciam as transações e segurança. Eles também podem ser integrados web services (REST 
ou SOAP), injeção de dependência, JPA, Java Transaction API (JTA), Java Authentication 
and Authorization Service (JAAS) dentre outros. EJBs usam um modelo de programação 
muito forte que combina com a facilidade de uso e robustez. Hoje, os EJBs são um modelo de 
desenvolvimento Java do lado do servidor muito simples, reduzindo a complexidade ao trazer 
a reutilização e escabilidade para aplicações empresariais de alta disponibilidade. 
Um contêiner EJB é um ambiente que fornece serviços em tempo de execução, 
assim como, gerenciamento de transações, controle de concorrência e segurança. Os 
desenvolvedores EJB pode então se concentrar na implementação das regras de negócios, 
enquanto o contêiner cuida de todos os aspectos técnicos. Uma vez escritos os EJBs eles 
podem ser implantados em qualquer contêiner que suporta a especificação JEE, como por 
exemplo, o GlassFish. 
 
 
 
 
2 
1.2 TIPOS DE EJBS 
Aplicações empresarias podem ser complexas, o Java EE define vários tipos de 
EJBs. 
1.2.1 Session Beans 
Os Session Beans são usados para encapsular a lógica de negócios, o que lhe torna 
uma das mais importantes partes da tecnologia EJB. Um session bean pode ter as seguintes 
características: 
 
 @Stateless: o session bean não mantém o estado da conversação com o 
cliente; 
 @Stateful: o session bean mantém o estado da conversação; 
 @Singleton: um único session bean é compartilhado entre os clientes e 
suporta o acesso concorrente. 
 
Para criar um EJB precisamos apenas de uma anotação. Seguindo o projeto, 
iremos criar um EJB para implementar as regras de negócios de “Marca”. Inicialmente, 
teremos apenas os métodos salvar (insere e altera), remover, e consultas. Então vamos criar 
uma interface “IMarcaService”. 
 
public interface IMarcaService { 
 
 List<Marca> listar(); 
 
 String remover(Short idMarca); 
 
 String salvar(Marca marca); 
 
 Marca obter(Short id); 
 
} 
 
Agora, criaremos o EJB que implementará a interface “IMarcaService”. 
 
 
3 
@Stateful 
public class MarcaService implements IMarcaService { 
 
 @PersistenceContext 
 private EntityManager em; 
 
 
 @Override 
 public String salvar(Marca marca){ 
 try{ 
 if(marca.getIdMarca() != null){ 
 em.merge(marca); 
 }else{ 
 em.persist(marca); 
 } 
 }catch(Exception ex){ 
 return ex.getMessage(); 
 } 
 return null; 
 } 
 
 @Override 
 public String remover(Short idMarca){ 
 try{ 
 Marca marca = obter(idMarca); 
 em.remove(marca); 
 }catch(Exception ex){ 
 return ex.getMessage(); 
 } 
 
 return null; 
 } 
 
 @Override 
 public List<Marca> listar(){ 
 TypedQuery<Marca> marcaQuery = 
 em.createQuery("select m from Marca m", Marca.class); 
 return marcaQuery.getResultList(); 
 } 
 
 @Override 
 public Marca obter(Short id){ 
 Marca marca = em.find(Marca.class, id); 
 return marca; 
 } 
 
} 
Conforme dito um EJB contém as regras de negócios, para definir um EJB do tipo 
session bean utilizamos a anotação “@Stateless”, para não manter o estado de conversação. 
Para usar o EJB, utilizamos a anotação “@EJB”. 
@EJB 
private IMarcaService marcaService; 
 
A anotação “@EJB” permite o contêiner injetar uma instância de um session bean 
que implementa a interface IMarcaService. 
4 
Se a anotação “@EJB” e a anotação “@Inject” do CDI permite a injeção de 
dependência, qual seria a diferença entre elas? A diferencia é que a anotação “@EJB” injeta 
apenas instâncias dos EJBs (session beans) que implementam regras de negócios, tais como, 
“@Stateless”, “@Stateful” e “@Singleton”, e podem ser acessados remotamente ou 
localmente. 
A anotação “@Inject” permite a injeção de dependência de qualquer outro 
componente do software. Ao utilizar o CDI como o “@Inject” é necessário ter em seu projeto 
um arquivo denominado “beans.xml”. Iremos falar mais sobre o CDI no desenvolvimento da 
camada de visão. 
Bom, prosseguindo o software, agora você pode criar todos os session beans do 
software, referentes as regras de negócios das entidades mapeadas. 
1.2.2 Message-Driven Beans 
Message-Driven Bean é um EJB que permite aplicações a processar mensagens 
assíncronas. Esse tipo de bean geralmente atua como ouvinte de mensagem Java Message 
Service (JMS). JMS é uma API Java para uma interface orientada a mensagens. 
1.3 CONTÊINER EJB 
Como dito, um EJB é um componente do lado do servidor, e precisa ser executado 
em um contêiner. Em tempo de execução, o ambiente fornece algumas funcionalidades para 
as aplicações: 
 
 Comunicação remota com o cliente: sem escrever qualquer código, um cliente 
EJB pode invocar métodos remotamente através de protocolos padronizados; 
 Injeção de dependência: o contêiner pode injetar váriosrecursos dentro de um 
EJB; 
 Gerenciamento do estado: para session beans stateful, o contêiner gerencia o 
seu estado. Você pode manter o estado para um cliente em particular, como se 
estivesse desenvolvendo uma aplicação desktop; 
 Pooling: para session beans stateless e Message-driven beans (MDB), o 
contêiner cria um pool de instâncias que são compartilhadas a vários clientes. 
5 
Uma vez invocado, o EJB retorna para o pool para ser reusado, invés de ser 
destruído; 
 Ciclo de vida: o contêiner é responsável por gerenciar o ciclo de vida de cada 
componente; 
 Mensagens: o contêiner permite o MDB a ouvir os destinos e consumir 
mensagens; 
 Gerenciamento de transações: o contêiner é responsável por cuidar das 
transações, realizar o commit e o rollback; 
 Segurança: permite realizar controle de acesso em nível de método e classe 
através de autenticação de usuários e controle de papeis; 
 Concorrência: você pode desenvolver aplicações de alto desempenho, sem se 
preocupar com questões de thread; 
 Interceptadores: são ações que podem ser executados antes e depois de uma 
lógica de negócio, invocado automaticamente pelo contêiner. 
 
1.4 TIPOS DE ACESSO AO SESSION BEAN 
1.4.1 @LocalBean 
Diz que o session bean não possui uma interface local. Exemplo: 
 
@Stateless 
@LocalBean 
public class MarcaService{ 
 
} 
 
1.4.2 @Local 
Essa anotação é aplicada a classe ou interface session bean, indicando que o 
session bean possuirá uma interface local. Exemplo: 
 
6 
@Local 
public interface IMarcaService { 
 
} 
 
@Stateless 
public class MarcaService implements IMarcaService { 
 
} 
1.4.3 @Remote 
Essa anotação é aplicada a classe ou interface session bean, indicando que o 
session bean possuirá uma interface remota. Exemplo: 
 
@Remote 
public interface IMarcaService { 
 
} 
 
@Stateless 
public class MarcaService implements IMarcaService { 
 
} 
 
Essa anotação permite acessar a interface remotamente, através do Remote 
Method Invocation (RMI). 
 
2 JNDI E RMI 
Java Naming and Directory Interface (JNDI) permite que aplicativos Java acessar 
serviços de diretórios, tais como, execução de chamadas de métodos remotos (RMI). Através 
do RMI podemos acessar objetos ativos em outras máquinas virtuais em diferentes 
localizações. 
 
 
 
7 
REFERÊNCIAS 
 GONCALVES, Antonio. Beginning Java™ EE 6 Platform with GlassFish™ 3. 2. ed. New 
York: Apress, 2010. 
ORACLE. The Java EE 6 Tutorial. Disponível em: 
<http://docs.oracle.com/javaee/6/tutorial/doc/>. Acesso em: 20 jan. 2014.