JAVA: Tecnologia e Tendências

PROGRAMAÇÃO
DISTRIBUÍDA EM JAVA
Unidade 5
Objetos Distribuídos
RMI
Remote Method Invocation
1
2
Tópicos de Aula





Problema da chamada remota de métodos
Tecnologia RMI
Interfaces para métodos remotos
Stubs e Skeletons
Registros de objetos remotos
3
Chamada remota de métodos
Servidor remoto
Cliente
PROCESSO
Chamada remota
class ...{
String hello(){
...
}
}
4
Arquiteturas para chamada remota
Existem algumas arquiteturas destinadas para
chamada remota de métodos:
 RPC ( Remote Procedure Call)
 CORBA ( Common Object Request Broker
Architeture)
 JAVA RMI ( Remote Method Invocation )
5
RPC (I)
Serviço muito utilizado em sistemas
operacionais distribuídos para chamada
remota de procedimentos.
Estes procedimentos, normalmente, envolvem
serviços disponibilizados em redes, tais
como acesso a DNS, gerencimento remoto,
etc.
6
RPC (II)
RPC não precisa, necessariamente, envolver
estruturação em termos de objetos.
Como em CORBA e RMI, existe a
necessidade de se trabalhar com interfaces
remotas denominadas STUBS. Tanto o
cliente quanto o servidor necessitam de um
Runtime para processamento da RPC.
7
CORBA (I)
CORBA é uma arquitetura para acesso a
objetos distribuídos que prima pela
independência da plataforma.
A especificação CORBA define, por exemplo,
tipos de dados que podem ser mapeados
para várias linguagem de programação,
como C++, Pascal e Java.
8
CORBA (II)
Um ponto-chave em CORBA é a utilização de uma
IDL (Linguagem de Definição de Interface).
Várias
linguagens
(inclusive
Java)
já
disponibilizam mecanismos para mapeamento de
IDL.
CORBA exige uma espécie de “servidor”
especializado chamado ORB (Object Request
Broker). Existem alguns ORB´s comerciais, tais
como VisiBroker e Orbix.
9
Java RMI
Arquitetura de acesso a objetos distribuídos
suportada pela linguagem Java.
Em termos de complexidade de programação e
ambiente, é muito simples construir aplicações
RMI, comparando-se com RPC e CORBA.
Em termos de ambiente, exige somente suporte
TCP/IP e um serviço de nomes de objetos
(rmiregistry), disponilizado gratuitamente com o
JDK/SDK.
10
Arquitetura Java RMI
Na realidade, o RMI é uma interface que permite a
intercomunicação entre objetos Java localizados
em diferentes hosts. Cada objeto remoto
implementa uma interface remota que especifica
quais de seus métodos podem ser invocados
remotamente pelos clientes.
Os clientes invocam tais métodos exatamente como
invocam métodos locais.
11
Modelo de camadas do RMI
12
Interfaces para métodos remotos(I)
A definição do serviço remoto é feita através
de uma interface Java.
13
Interfaces para métodos remotos(II)
O primeiro passo para disponibilizar métodos
que possam ser invocados remotamente
consiste na preparação de uma interface
remota com tais métodos.
A construção desta interface pode ser feita
com base na extensão da interface Remote
do pacote java.rmi.
14
Interfaces para métodos remotos(III)
A arquitetura RMI suporta duas classes
implementando a mesma interface:
 Uma, que implementa o serviço e é
interpretada no servidor
 Outra, que age como um mecanismo de
proxy e é interpretada no cliente
15
Interfaces para métodos remotos(IV)
Um cliente faz chamadas de métodos ao objeto
proxy, RMI envia a requisição à JVM remota, que
executa o método.
16
Interfaces para métodos remotos(V)
Valores retornados pelo serviço remoto são
enviados, inicialmente, ao objeto proxy, que
os repassa para a aplicação cliente.
Vários servidores podem implementar de
maneira diferente a mesma interface de
acesso ao serviço.
17
Exemplo
Suponha que se queira deixar um método chamado
sayHello(), que devolve uma String, disponibilizado
para chamada remota.
import java.rmi.*;
public interface Hello
extends Remote{
public String sayHello()
throws RemoteException;
}
18
Implementação do método remoto
Cada classe que queira disponibilizar tal
método remoto precisa implementar a
interface especificada anteriormente. Além
disto, a classe precisa extender a classe
UnicastRemoteObject,
que
é
uma
especialização de um servidor remoto (
classe RemoteServer).
19
Exemplo
import java.rmi.*;
import java.rmi.server.*;
import java.net.*;
public class servidor
extends UnicastRemoteObject
implements Hello{
public servidor() throws RemoteException{ // Construtor
super();
}
public String sayHello() throws RemoteException{ // Método remoto
return(“Oi cliente”);
}
20
Exemplo ( Continuação )
public static void main(String args[]){
try{
servidor serv=new servidor();
Naming.rebind(“ServidorHello”,serv); // Registra nome do servidor
System.out.println(“Servidor remoto pronto.”);
}
catch(RemoteException e){
System.out.println(“Exceção remota:”+e);
}
catch(MalformedURLException e){};
}
}
A partir deste ponto, o objeto chamado ServidorHello
está apto a aceitar chamadas remotas.
21
Compilação e execução do servidor
Não basta apenas compilar e executar o
programa anterior. Toda a compilação e
execução necessita de um ambiente dado
pela seguinte seqüência:
1. Compilar o arquivo .java
2. Chamar o aplicativo rmic para gerar o Stub e Skel
3. Ativar o controlador de registros (rmiregistry)
4. Chamar o interpretador com o servidor compilado
22
Stubs e Skels
O cliente, quando invoca remotamente um
método, não conversa diretamente com o
objeto remoto, mas com uma implementação
da interface remota chamada stub, que é
enviada ao cliente. O stub, por sua vez, passa a
invocação para a camada de referência remota.
Esta invocação é passada para um skel
(esqueleto) , que se comunica com o programa
servidor.
23
Compilação do exemplo anterior
servidor.java
javac
servidor.class
rmic
servidor_Stub.class
servidor_Skel.class
24
Execução do servidor
O primeiro passo antes de executar o servidor é
ativar uma espécie de servidor de nomes de
servidores que atendem solicitações de métodos
remotos. Isto é feito chamando-se o programa
rmiregistry. Este programa pode estar ouvindo
portas específicas, como por exemplo:
% rmiregistry 2048 &
Uma vez que este programa está executando, podese chamar o interpretador java para o arquivo
servidor.class .
25
Programação do cliente
O primeiro passo de implementação de um
cliente que quer invocar remotamente método
é obter o stub do servidor remoto. A
localização deste stub é feita com o método
lookup(endereço).
Este método devolve uma referência remota do
objeto, através do envio do stub.
26
Exemplo
import java.rmi.*;
class cliente{
public static void main(String args[]){
try{
Servidor serv= (Servidor) Naming.lookup(“rmi://ime.usp.br:2048
/ServidorHello”);
String retorno=serv.sayHello();
}
catch(Exception e);
}
}
27
Esquema da chamada
ime.usp.br
cliente
lookup(.../Servidor)
Servidor está aqui
Registry
Solicitação de stub
Stub
Stub
Servidor_Stub.class
sayHello()
Servidor_Skel.class
“Oi cliente”
Servidor..class
28
Exemplo II ( Calculadora)
Interface
public interface Calculator
extends java.rmi.Remote {
public long add(long a, long b)
throws java.rmi.RemoteException;
public long sub(long a, long b)
throws java.rmi.RemoteException;
public long mul(long a, long b)
throws java.rmi.RemoteException;
public long div(long a, long b)
throws java.rmi.RemoteException;
}
29
Exemplo II ( Calculadora)
Implementação dos métodos
public class CalculatorImpl
extends java.rmi.server.UnicastRemoteObject
implements Calculator {
public CalculatorImpl()
throws java.rmi.RemoteException {
super();
}
public long add(long a, long b)
throws java.rmi.RemoteException {
return a + b;
}
30
Exemplo II ( Calculadora)
Implementação dos métodos(II)
public long sub(long a, long b)
throws java.rmi.RemoteException {
return a - b;
}
public long mul(long a, long b)
throws java.rmi.RemoteException {
return a * b;
}
public long div(long a, long b)
throws java.rmi.RemoteException {
return a / b;
}
}
31
Exemplo II ( Calculadora)
Servidor
import java.rmi.Naming;
public class CalculatorServer {
public CalculatorServer() {
try {
Calculator c = new CalculatorImpl();
Naming.rebind(" rmi://jaca.ime.usp.br:1099/ CalculatorService", c);
} catch (Exception e) {
System.out.println("Trouble: " + e);
}
}
public static void main(String args[]) {
new CalculatorServer();
}
}
32
Exemplo II ( Calculadora)
Cliente
import java.rmi.Naming;
public class CalculatorClient {
public static void main(String[] args) {
try {
Calculator c =
(Calculator) Naming.lookup( "rmi://jaca.ime.usp.br:1099/CalculatorService");
System.out.println( c.sub(4, 3) );
System.out.println( c.add(4, 5) );
System.out.println( c.mul(3, 6) );
System.out.println( c.div(9, 3) );
}
catch (Exception e) {
System.out.println(e);
}
}
}
33
Passagem de parâmetros
Quando se passa um parâmetro para um método
remoto, pode ocorrer duas situações:
 Tipos primitivos: RMI faz uma cópia do
parâmetro e a envia para o servidor
 Objetos: RMI utiliza o mecanismo de
serialização para enviar uma cópia do objeto
para o servidor
34
Funcionalidades adicionais do RMI
 É possível substituição dinâmica da
interface remota enviada ao cliente
 É possível o servidor invocar, remotamente,
algum serviço do cliente sem que o cliente
estenda
diretamente
a
classe
java.rmi.server.UnicastRemoteObject.