PROGRAMA

1
PROGRAMAÇÃO DISTRIBUÍDA EM JAVA

• Unidade 5
• Objetos Distribuídos RMIRemote 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
class ... String hello() ...
PROCESSO
Chamada remota
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 ORBs 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 servnew servidor()
• Naming.rebind(ServidorHello,serv) //
  Registra nome do servidor
• System.out.println(Servidor remoto
  pronto.)
• catch(RemoteException e)
• System.out.println(Exceção remotae)
• 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,
  pode-se 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.br2048 /ServidorHello)
• String retornoserv.sayHello()
• catch(Exception e)

27
Esquema da chamada
ime.usp.br
lookup(.../Servidor)
cliente
Registry
Servidor está aqui
Solicitação de stub
Servidor_Stub.class
Stub
Stub
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.UnicastRemoteObje
  ct
• 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.br1
  099/ 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.br1099/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.UnicastRemote
  Object.