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
 RPC ( Remote Procedure Call)
 CORBA ( Common Object Request Broker
Architeture)
 JAVA RMI ( Remote Method Invocation )
5
RPC (I)
Estes
procedimentos,
normalmente,
envolvem serviços disponibilizados em
redes.
RPC é muito utilizado em sistemas
operacionais distribuídos para chamada
remota de procedimentos.
6
RPC (II)
RPC não precisa, necessariamente, envolver
estruturação em termos de objetos.
Tanto o cliente quanto o servidor necessitam
de um Runtime para processamento da
RPC.
Existe a necessidade de se trabalhar com
interfaces remotas denominadas STUBS.
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++ 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.
9
CORBA (III)
 CORBA exige uma espécie de “servidor”
especializado chamado ORB (Object
Request Broker). Existem alguns ORB´s
comerciais, tal como VisiBroker.
10
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.
11
Java RMI
Em termos de ambiente, exige somente
suporte TCP/IP e um serviço de nomes de
objetos (rmiregistry), disponilizado
gratuitamente com o JDK/SDK.
12
Arquitetura Java RMI
Na realidade, o RMI é uma interface que permite a
intercomunicação entre objetos Java localizados
em diferentes hosts.
13
Arquitetura Java RMI
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.
14
Modelo de Camadas do RMI
15
Interfaces para métodos remotos(I)
A definição do serviço remoto é feita
através de uma interface Java.
16
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.
17
Interfaces para métodos remotos(III)
 A construção desta interface pode ser feita
com base na extensão da interface Remote
do pacote java.rmi.
18
Interfaces para métodos remotos(IV)
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.
19
Interfaces para métodos remotos(V)
Um cliente faz chamadas de métodos ao objeto
proxy, RMI envia a requisição à JVM remota, que
executa o método.
20
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.
21
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;
}
22
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).
23
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”);
}
24
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.
25
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
26
Stubs e Skeletons
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.
27
Stubs e Skeletons
O stub, por sua vez, passa a invocação para
a camada de referência remota.
Esta invocação é passada para um skeleton
(esqueleto), que se comunica com o
programa servidor.
28
Compilação do exemplo anterior
servidor.java
javac
servidor.class
rmic
servidor_Stub.class
servidor_Skel.class
29
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.
30
Execução do servidor
Isto é feito chamando-se o programa
rmiregistry. Este programa pode estar
ouvindo portas específicas, como por
exemplo:
% rmiregistry 2048 &
31
Execução do servidor
Uma vez que este programa está
executando, pode-se chamar o interpretador
java para o arquivo servidor.class .
32
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.
33
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);
}
}
34
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
35
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;
}
36
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;
}
37
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;
}
}
38
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();
}
}
39
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);
}
}
}
40
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 .