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

• 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 sistemasoperacionais
  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 ORBs 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 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.

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.br2048 /ServidorHello)
• String retornoserv.sayHello()
• catch(Exception e)

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

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.br1
  099/ 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.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)

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 .