Sistemas Distribuídos - Comunicação Distribuída - EJB

Comunicação Distribuída - EJB
Prof. Adriano Teixeira de Souza

 Estratégias diferentes que permitem a
comunicação entre aplicações distribuídas.

 Tipos distintos de comunicação em um sistema
distribuído:

◦ Sockets
◦ RMI - Remote Method Invocation
◦ CORBA – Commom Object Request Broker Architecture
◦ EJB – Enterprise Java Bean
◦ Web Services


 Se utilizar a versão 6.0 do JBoss , não é
requerida uma instalação, basta apenas
descompactar o arquivo na sua máquina e
adicionar a variável de ambiente
JBOSS_HOME;


 Vá em Iniciar -> Painel de controle -> Sistema ->
Avançado ->Variáveis de ambiente;
 Adicione as variáveis JAVA_HOME e JBOSS_HOME,
com os seguintes valores:
◦ JAVA_HOME = “meu caminho do JDK”
◦ JBOSS_HOME = “meu caminho do Jboss”

 Caso não tenha permissão, “sete” as variáveis em
tempo de console (abra uma “console” e digite):
◦ SET JAVA_HOME=diretorioJVM
◦ SET JBOSS_HOME=diretorio do JBOSS
◦ Em seguida, entre na pasta bin e digite RUN.BAT


 JEE: Acrônimo de Java Enterprise Edition Kit

 Plataforma Java voltada para aplicações corporativas,
no modelo de sistema distribuído.

 Voltada para aplicações multi-camadas, baseadas em
componentes que são executados em um servidor de
aplicações (JBoss, exemplo).

 A plataforma Java EE é considerada um padrão de
desenvolvimento, pois o fornecedor de software nesta
plataforma deve seguir determinadas regras
compatíveis com Java EE.

 A plataforma J2EE contém uma série de especificações, cada uma com
funcionalidades distintas. Entre elas, tem-se:

◦ EJBs (Enterprise Java Beans), utilizados no desenvolvimento de
componentes de software. Eles permitem que o programador se
concentre nas necessidades do negócio do cliente, enquanto questões
de infra-estrutura, segurança, disponibilidade e escalabilidade são
responsabilidade do servidor de aplicações.

◦ JPA (Java Persistence API), é uma API que padroniza o acesso a banco
de dados através de mapeamento Objeto/Relacional dos Enterprise
Java Beans
◦ JTA (Java Transaction API), é uma API que padroniza o tratamento de
transações dentro de uma aplicação Java.
◦ JDBC (Java Database Connectivity), utilizado no acesso a bancos de dados;
◦ JCA (Java Connector Architecture), é uma API que padroniza a ligação a
aplicações legadas.
◦ Servlets e JSP (Java Server Pages), utilizados para o desenvolvimento de
aplicações Web com conteúdo dinâmico.
◦ E outros.


• Transações gerenciadas
• Segurança
• Clustering
• Escalabilidade
• Alta Disponibilidade
• Comunicação Assíncrona
• Integração com Legado
• Persistência
• etc…


 Representa um objeto de entidade de negócios
que existe no armazenamento persistente
(banco de dados, por exemplo)
 Classes simplificadas, chamadas “POJOS”,
mapeadas com JPA ;
 Flexíveis para qualquer banco de dados
relacional;
 Tão portáveis, que podem ser usados também
fora de um servidor de aplicação (aplicação
“desktop”);
 São agrupados em uma unidade de
persistência;


 Espelham objetos do mundo real;

 Possuem uma chave primária “id”(pode ser
uma classe ou um tipo primitivo);

 Identificado pela anotação @Entity;

 Não necessitam de nenhuma interface;

 Gerenciados pelo EntityManager;


 Sistema de Cadastro de Cliente


@Entity
.
@Table(name=“cliente”)
public class Cliente implements Serializable {

private static final long serialVersionUID = 1L;

@Id
@GeneratedValue(strategy=AUTO)
private int id;

private String nome;

private String cpf;

public Cliente() { }

// get’s e set’s

//equals e hashCode

} // fim da entidade


 @Entity
◦ Indica ao provedor de persistência que a Classe bean será mapeada para uma
tabela de banco de dados e gerenciada por um Entity Maganer;

 @Table
◦ Informa ao container EJB para qual tabela do banco será mapeada a
classe bean;

 @Column
◦ Informa ao container EJB para qual coluna da tabela a propriedade do
bean será mapeada;

 @Id
◦ Informa que atributo será tratado como chave primária na tabela de
banco de dados.

 @GeneratedValue - define que o valor do atributo “id” será gerado
automaticamente no momento em que os objetos forem persistidos
(inseridos na tabela).


 Implementar a interface java.io.Serializable não
é obrigatório.
◦ Com “Serializable” é possível usar a mesma classe
tanto para persistência, quanto para transferência de
dados (entre sistemas ou camadas).

 Assim como todo POJO, as propriedades de um
Entity Bean são acessadas através dos métodos
get’s e set’s.


 Conjunto de todos os entity beans;
 Quem gerencia é um serviço de EntityManager;
 Cada unidade de persistência deve estar
associada a um banco de dados;
 Todas essas informações estão descritas em
um arquivo chamado persistence.xml
 Localizado no diretório META-INF da aplicação
 A unidade de persistência é identificada pela
marcação:
◦ <persistence-unit name=“xxxx”>
 Onde “xxxx” é o nome a ser referenciado como a unidade
de persisência.


O arquivo persistence.xml (definido com
“data-source” - DS)

<?xml version="1.0" encoding="UTF-8"?>
<persistence>
<persistence-unit name= “nomeUP” >
<jta-data-source>java:/nome_DS </jta-data-source>
</persistence-unit>
</persistence>


 <persistence-unit
name=“nomeUP”>
◦ Conjunto das classes gerenciadas
por um Entity Manager

 <jta-data-source>
◦ Define o banco de dados que será
usado para esta implantação.
◦ No JBoss deve ser definido em um
arquivo “.xml”, implantado (deploy)
na pasta “deploy”


 São componentes EJB do lado do servidor que podem ser
acessados utilizando vários protocolos de objetos
distribuídos;

 Para acessar uma aplicação que foi instalada no servidor
(JBoss), a aplicação cliente invoca os métodos do Session
Bean.

 O Session Bean executa o trabalho para seu cliente,
protegendo o cliente da complexidade através da execução
de tarefas de negócio dentro do servidor.

 Suas atividades são geralmente transitórias (não tem um
estado persistente);


 Stateless:
◦ Não mantém estado;
◦ Cada método é completamente independente ;
 Stateful:
◦ Mantém estado;
◦ Não é compartilhado entre clientes;
 Todo Session Bean deve implementar uma interface
local ou remota.
◦ Local – o cliente compartilha a mesma máquina
(processador e memória) que o servidor
◦ Remoto – o cliente acessa de forma remota (de outra
máquina), mesmo estando na mesma máquina que o
servidor


 Será criado um “session beans” (componente)
chamado ClienteFacade, que fornecerá todos os
serviços/tarefas de um cadastro de clientes:
◦ Cadastrar um Cliente
◦ Listar os Clientes cadastrados
◦ Localizar um Cliente
 E outros que se tornarem necessários.

•Por convenção, todos os componentes “session beans” terão no nome o
sufixo “Facade”.
•A classe interface terá o mesmo nome da classe “session beans”,
adicionado com o sufixo “Remote” ou “Local”, dependendo do uso.


@Stateless (mappedName =" ejb/ClienteBean")
@LocalBean
public class ClienteFacade implements ClienteFacadeRemote
{
@PersistenceContext
private EntityManager manager;

public void cadastraCliente(Cliente cliente)
{
manager.persist(cliente);
}

public Cliente localizaCliente(int id) {
return manager.find(Cliente.class, id);
}
}


 @Stateless:
◦ Mostra que o componente ClienteFacade não
mantém o estado (objetos/dados em memória);

 @PersistenceContext
◦ Obtém o acesso a um serviço EntityManager;


 Especifica quais métodos de negócio um cliente
tem permissão para invocar no EJB;

 @Remote
◦ Instrui o container de que esta é uma interface remota
para o ClienteFacade


@Remote
public interface ClienteFacadeRemote
{
public void cadastraCliente(Cliente cliente);
public Cliente localizaCliente(int id);
public List<Cliente> listaClientes();
}


 Considere um novo projeto para representar a aplicação
“servidora” do Sistema de Cadastro de Clientes.
 Crie um projeto do tipo EJB: File – New – Project ... EJB

Em seguida, informe:
a) O nome do projeto
b) O servidor para execução
c) A configuração do JPA

Veja a seguir...


a) Nome do projeto

b) Servidor para execução

c) Configuração do JPA

d) Pressione Next duas vezes


a) Defina a plataforma
b) Adicione a conexao

c) Selecione o driver

e) Pressione Finish


a) Selecione a conexão

b) Marque a opção para listar
classes no arquivo persistence.xml

c) Marque a opção para criar o
arquivo orm.xml


 Visão do projeto JPA(“AULAJEE6-JPA”), na
perspectiva “Java EE”:

Área (pasta) de código fonte
(source)


 As entidades utilizam anotações presentes na bibliteca do JPA, Java
Persistence API.
 Considere a entidade Cliente apresentada anteriormente.
 Crie a classe Cliente.java no pacote modelo conforme figura abaixo.


 Após importar as classes, adicione as referências
das entidade no arquivo “persistence.xml”.
◦ Use o recurso “Syncronize Class List”

34

 Adicione o nome da “data-source” (MySqlDS) no arquivo
persistence.xml.
◦ Use a tag:
 <jta-data-source>java:/jdbc/MySqlDS</jta-data-source>
◦ Ou use o editor (assistente) na aba “Connection”. Informe em JTA_Data
Source: java:/ jdbc/MySqlDS


 Diferente da configuração em aplicação desktop (console ou
stand-alone), uma aplicação no JBOSS fica responsável pelo
acesso aos recursos de banco, que são gerenciados pela JTA –
Java Transaction API.

36

 Crie um arquivo “xml” no diretório “deploy” do JBOSS contendo o
acesso ao banco de dados.
 O exemplo a seguir, mostra o DS (data-source) MySqlDS, que
registra esse nome no serviço de diretório JNDI (Java Naming and
Directory Interface).

Arquivo “mysql-ds.xml”

Diretório:
jboss-6.0.0.Finalserverdefaultdeploy


<?xml version="1.0" encoding="UTF-8"?>
<datasources>
<local-tx-datasource>
<jndi-name>jdbc/MySqlDS</jndi-name>
<connection-url>
jdbc:mysql://localhost:3306/test
</connection-url>
<driver-class>com.mysql.jdbc.Driver</driver-class>
<user-name>root</user-name>
<password>root</password>
<metadata>
<type-mapping>mySQL</type-mapping>
</metadata>
</local-tx-datasource>
</datasources>
Obs:
1. Implantar o driver do MySQL no diretório jboss-6.0.0.Finallib
2. Cuidado ao definir dois data-source com o mesmo nome (jdbc/MySqlDS)


 Considere um novo projeto para representar a aplicação
“servidora” do Sistema de Eventos.
 Crie um projeto do tipo EJB: File – New – Project ... EJB

Em seguida, informe:
a) O nome do projeto
b) A versão do EJB (use a 3.1)

Veja a seguir...


a) Nome do projeto

b) Versão do EJB (usar a 3.1)

c) Clique em Next duas vezes
d) Marque a opção “Generate ejb-
jar.xml deployment descriptor”


 Visão do projeto EJB (“AULAJEE6-EJB”), na
perspectiva “Java EE”:

Área (pasta) de código fonte
(source)


 Crie o arquivo “jndi.properties” dentro do diretório de
código fonte do projeto (ejbModule), com o conteúdo a
seguir:
jndi.properties
java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.provider.url=jnp://localhost:1099
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces


 Nesse passo serão criados o componente
ClienteFacade e sua interface remota ClienteFacade
Remote.
 No Eclipse, seleciona a pasta de código e escolha a
opção New – Session Bean (na perspectiva JEE).
◦ Pode ser também: File - New – EJB – Session Bean

43

 Criar o “session bean”: ClienteFacade na pacote “facade” (dentro da
pasta de código ejbModule).
 Desmarque a opção “Local” e marque “Remote”
◦ Altere o nome da interface remota para façade.ClienteFacade Remote


 Deployment (implantação) é o conjunto de
atividades que tornam um software, ou componentes
de software, pronto para uso.

 Durante o deployment, o container EJB lê as
configurações contidas em arquivos descritores
(deployment descriptor) ou nas annotations
(anotações) no código-fonte e prepara um ambiente
padronizado para a execução dos beans.

◦ O deployment descriptor especifica quais serviços de infra-
estrutura o container EJB proverá aos enterprise beans, desde
que o deployment seja feito num container EJB certificado.
◦ No Eclipse, cria-se o descritor através do atalho (sobre o
projeto):
 Java EE Tools – Generate Deployment Descriptor Stub
 Será criado o arquivo ejb-jar.xml na pasta META-INF (do projeto)


 Um arquivo “JAR” (Java Archive) é uma forma
conveniente de “empacotar” componentes para uso
em deployment
 O processo compacta (“zipa”) todas as classes,
interfaces e arquivos descritores para um único
arquivo JAR
 Em seguida esse arquivo deve ser copiado para a
pasta “deploy” do JBOSS (ou do servidor de aplicação
em uso).
 No Eclipse, você utiliza a opção:
◦ File – Export – EJB Jar File

◦ Ou usa o menu de atalho (veja na próxima figura)


Escolha o diretório destino
no do Jboss
(..serverdefaultdeploy)


 No JBoss, pools de conexões de bancos de dados são
acessíveis no servidor através de objetos DataSource,
publicadas no JNDI abaixo no namespace java:/
◦ java:/ jdbc/MySqlDS
◦ java:/ DefaultDS
 Os nomes são configurados nos arquivos *-ds.xml do
JBoss (localizados em deploy)
 Para acessar um banco existente no servidor use JNDI e
nome definido no *-service.xml correspondente (em
jdbc):
Context ctx = new InitialContext();
javax.sql.DataSource ds = (javax.sql.DataSource)
ctx.lookup("java:/DefaultDS");
java.sql.Connection = ds.getConnection();


 Para implantar é necessário iniciar o servidor JBoss
◦ Entre no diretório “bin”, onde está o Jboss instalado
◦ Execute o arquivo “run.bat” (na console Windows)
◦ Aguarde a carga ....

52

 O JBoss exige que você coloque seu projeto EJB
“JAR” em um dirétorio deploy.
◦ O default é a pasta
“ jboss-6.0.0.Finalserverdefaultdeploy”

 O servidor examina o arquivo JAR em tempo de
execução quando o servidor é inicializado para
determinar quais contêiners EJB devem ser
criados e acoplados em tempo de execução.
◦ Qualquer atualização do “JAR” pode ser feita com o
JBoss “rodando”


Acessando os componentes EJB remotamente
em uma aplicação console.

 Com o componente EJB ClienteFacade
implantado, vamos testar o acesso de um
cliente remoto (aplicação console)

 Para isso devemos criar o cliente que se
conecta ao servidor, localiza a interface
remota do componente ClienteFacade e
interage com ele para criar e selecionar
entidades “Cliente” no banco de dados.


 No Eclipse, crie um nov projeto Java EE, do tipo “Java Project”.
◦ Use a opção File – New Project – JavaEE

 Adicione o JAR criado anteriormente, para manter as
dependências das classes entidades (JPA) e a EJB remoto.


 Adicione a bibliotecas jbossall-client.jar do diretório
%JBOSS_HOME%client.

public class Principal {
public static void main(String[] args) {
try {
Context ctx = new InitialContext();
ClienteFacadeRemote facade = (ClienteFacadeRemote)ctx.lookup(“ejb/ClienteBean");
Scanner in = new Scanner(System.in);
while(true) {
System.out.println("Entre com o nome: ");
String nome = in.nextLine();
if (nome.equals("sair")) {break;}
System.out.println("Entre com o cpf: ");
String cpf = in.nextLine();
Cliente c = new Cliente();
c.setNome(nome);
c.setCpf(cpf);
facade.cadastraCliente(c);
}
System.out.println("nnListann");
for(Cliente cli : facade.listaClientes()){
System.out.println("Cliente: "+cli.getNome());
}
System.out.println("Terminou");
} catch (Exception e) { e.printStackTrace(); }
}
}


 Colocar uma cópia do arquivo jndi.properties
no diretório src, o qual é o diretório base
para os arquivos fonte.

 Executar a aplicação cliente


 Desenvolver uma aplicação JavaEE para
fornecer o seguinte componente:
◦ CadastrarAluno (Aluno a);
 Um aluno tem matricula, nome, curso.

◦ Desenvolver uma aplicação console para utilizar o
componente CadastraAluno, usando a interface
CadastrarAlunoRemote


Sistemas Distribuídos - Comunicação Distribuída - EJB

Mais conteúdo relacionado

Mais procurados

Semelhante a Sistemas Distribuídos - Comunicação Distribuída - EJB

Mais de Adriano Teixeira de Souza

Sistemas Distribuídos - Comunicação Distribuída - EJB