Sistemas Distribuídos - Comunicação Distribuída - EJB (JBoss 7)

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 7.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=IDENTITY)
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 o
datasource do banco de dados)

<?xml version="1.0" encoding="UTF-8"?>
<persistence>
<persistence-unit name= “nomeUP” >
<jta-data-source>
java:jboss/datasources/TesteSQLiteDS
</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” chamado
standalone.xml.


 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 biblioteca 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 “Generate Entities from Tables”

34

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


 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

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

Arquivo “standalone.xml”

Diretório:
jboss-as-7.1.0.Finalstandaloneconfiguration


Obs:
1. Implantar o driver do MySQL no diretório jboss-as-7.1.0.Finalmodulesorgsqlitemain


 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)


 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

42

 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)


 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 ....

50

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

 O servidor examina o arquivo JAR em tempo de
execução quando o servidor é inicializado para
determinar quais containers 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 para o cliente do diretório conforme abaixo.

public class Principal {
private static InterfaceRepositorioClientes lookupRemote() throws NamingException {

final Hashtable jndiProperties = new Hashtable();
jndiProperties.put(
Context.URL_PKG_PREFIXES,
"org.jboss.ejb.client.naming");
final Context context = new InitialContext(jndiProperties);
final String appName = "";
final String moduleName = "TesteJPA-EJB";
final String distinctName = "";
final String beanName = ServidorClientes.class.getSimpleName();
final String viewClassName = InterfaceRepositorioClientes.class.getName();
return (InterfaceRepositorioClientes) context.lookup(
"ejb:" + appName + "/" + moduleName + "/"
+ distinctName + "/" + beanName + "!" + viewClassName);
}


public static void main(String[] args) throws NamingException {
try{
// cria um cliente
InterfaceRepositorioClientes repositorioRemotoClientes = lookupRemote();
System.out.println("Efetuado conexao com servidor.");
Cliente cliente = new Cliente();
cliente.setNome("Paulo");
cliente.setCpf("0434567-89");

System.out.println("Gravando novo cliente.");
repositorioRemotoClientes.criarCliente(cliente);

System.out.println("Listando todos clientes.");
List<Cliente> clientes = repositorioRemotoClientes.listarClientes();
for(Cliente c : clientes){
System.out.println("Cliente: "+c.getNome()+" ("+c.getCpf()+")");
}
}catch (Exception e) {
e.printStackTrace();
}
}
}


 Colocar um arquivo jboss-ejb-client.properties no
diretório src, o qual é o diretório base para os
arquivos fonte com o conteúdo abaixo.
endpoint.name=client-endpoint
remote.connectionprovider.create.options.org.xnio.Options.SSL_ENABLED=false
remote.connections=default
remote.connection.default.host=127.0.0.1
remote.connection.default.port = 4447
remote.connection.default.connect.options.org.xnio.Options.SASL_POLICY_NOANONYMOUS=false

 Executar o programa


 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 (JBoss 7)

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Sistemas Distribuídos - Comunicação Distribuída - EJB (JBoss 7)

Semelhante a Sistemas Distribuídos - Comunicação Distribuída - EJB (JBoss 7) (20)

Mais de Adriano Teixeira de Souza

Mais de Adriano Teixeira de Souza (20)

Sistemas Distribuídos - Comunicação Distribuída - EJB (JBoss 7)