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();

}


Passo-a-passo

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.


34

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


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


36

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.


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

Diretório:

\jboss-6.0.0.Final\server\default\deploy

Arquivo “mysql-ds.xml”


<?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.Final\lib

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:

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

jndi.properties


43

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


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


45 Prof. Adriano Teixeira de Souza

46 Prof. Adriano Teixeira de Souza

“Deploy no Eclipse”

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

(..\server\default\deploy)

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();


52

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


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

“\ jboss-6.0.0.Final\server\default\deploy”

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("\n\nLista\n\n");

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

Technology

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