Upload
phamhanh
View
215
Download
0
Embed Size (px)
Citation preview
1
Departamento de Engenharia Informática
Invocação de Métodos em Objectos Remotos
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Sistemas Distribuídos 2009/10
public static void main(String args[]){
AccountList acList = ObtemObjecto(“//server.meubanco.pt/AccountList”);
Account a = acList.getAccount(2);
a.debit(1000);
Account b = new Account(1000);
acList.addAccount(b);
}
Invocação de Métodos em Objectos Remotos
Departamento de Engenharia Informática
Invocações de métodos remotas e locais
invocation invocation
remote
invocationremote
local
local
local
invocation
invocation
AB
C
D
E
F
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
m4
m5
m6
Interface
Remota
m1
m2
m3Código
dos
métodos
Dados
Objecto remoto
Invocação de Objectos Remotos
Sistemas Distribuídos 2009/10
2
Departamento de Engenharia Informática
Invocação de Métodos em Objectos Remotos
• Um sistema de objectos distribuídos é uma extensão ao
conceito de RPC
• Um objecto invoca um método noutro objecto localizado
remotamente.
• Num sistema de objectos o RPC designa-se normalmente
Remote Method Invocation ou RMI
• A IDL é uma linguagem orientada aos objectos
tipicamente baseada em C++, Java, ou C#.
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Diferenças Relevantes
• Reutilização de conceitos Object Oriented
– Melhor ligação às metodologias e linguagens OO
– Utilização de conceitos OO na programação das interfaces
• Separação da interface e da implementação
• Desenvolvimento incremental
– Herança – simplifica desenvolvimento
– Polimorfisno – permite redefinir interfaces
• Granularidade
– Mais fina do que em servidores que tipicamente disponibilizam
interfaces para programas com alguma complexidade
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Diferenças Relevantes
• Objectos passados por valor ou referência
– Os objectos podem migrar ou são invocados localmente
• Invocação dinâmica
– Sistemas de objectos � desenvolvimento incremental / loosely
coupled
• Permitem um objecto invocar dinamicamente outros de que obtém a
interface em tempo de execução
• Gestão do Ciclo de Vida dos objectos
2009 José Alves Marques
Departamento de Engenharia Informática
Modelo de Objectos Distribuído
• Referência para um objecto remoto– Referência par a entidade sobre a qual é feita a
invocação (evolução do binding handle)
– Identificador que os clientes remotos usam para representar um objecto num sistema distribuído
– Podem ser passados como argumentos ou valores de retorno dos métodos remotos
• Interface Remota– Conjunto de métodos de um objecto que podem ser
invocados remotamente.
– Um objecto pode definir métodos que podem ser acedidos quer remotamente quer localmente
Sistemas Distribuídos 2009/10
3
Departamento de Engenharia Informática
Modelo de Objectos Distribuído (2)
• Acções num sistema de objectos distribuído– Iniciadas por invocação de método
– Invocação pode resultar noutras invocações de métodos noutros objectos, quer locais quer remotos
– Podem levar à criação de novas instâncias de objectos• Normalmente a instância reside na mesma máquina do objecto
criador
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Modelo de Objectos Distribuído
• Garbage Collection
– Deve ser suportada remotamente pelo RMI
• Excepções
– As invocações remotas podem falhar devido a excepções.
– A maioria das linguagens Object-oriented disponibilizam excepções que podem ser estendidas
– Deve ser suportado na IDL
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Elementos principais da arquitectura do RMI
• Objectos remotos/Servants
• Módulo de comunicações
• Módulo de Referências Remotas
• Proxies – stubs do lado do Cliente
• Skeletons – stubs do lado do Servidor
• Dispatcher
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Elementos principais da arquitectura do RMI
object A object BskeletonRequestproxy for B
Reply
CommunicationRemote Remote referenceCommunication
modulemodulereference module module
for B’s class
& dispatcher
remoteclient server
servant
4
Departamento de Engenharia Informática
Objectos remotos/Servants
• Instância de classe no servidor
• Clientes que chamam métodos da classe podem
ser remotos ou locais
– Se objecto fosse local, não podia ser invocado por
clientes remotos
Departamento de Engenharia Informática
Módulo de comunicações
• Um no cliente, outro no servidor
• Idênticos à biblioteca de run-time do RPC
• Asseguram semântica de invocação pretendida
(talvez, pelo-menos-uma-vez, no-máx-uma-vez, exactamente-uma-
vez)
• Módulo de comunicações do servidor selecciona o
dispatcher da classe do objecto invocado
– Passa-lhe a referência para o objecto local sobre o qual é feito o
pedido do cliente
– Passa também o pedido
Departamento de Engenharia Informática
Módulo de referências remotas
• Pedidos de outros clientes trazem identificador de objecto remoto, não referência local– Como é que o módulo de comunicação do servidor sabe qual a
referência local? E vice-versa?
• Módulo de referências remotas traduz entre referências remotas e locais
• Mantém Tabela de Objectos Remotos com entradas para:– Objectos remotos que residem no processo
– Proxies para objectos remotos (em outros processos)
• Gere as referências remotas que saem e entram do processo:– Quando referência para o objecto remoto é enviada a outro processo
como argumento ou retorno pela primeira vez, cria uma referência remota (e adiciona-a à tabela)
– Quando chega uma referência remota que não existe ainda na tabela, cria um proxy e acrescenta a entrada correspondente na tabela
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Proxy (Stub)
• Torna o RMI transparente para o cliente actuando como um objecto local
• Esconde os detalhes de:
– Tradução das referências para objectos
– Conversão e serialização dos parâmetros (marshalling)
• A interface do proxy é idêntica à interface do objecto remoto
• Existe um proxy por cada objecto remoto (noutro processo) que o cliente referencia
Sistemas Distribuídos 2009/10
5
Departamento de Engenharia Informática
Dispatcher
• Função de despacho do servidor
• Responsável por converter o methodId da
mensagem de invocação no método do objecto
local que está a ser invocado remotamente
• Existe um por classe invocável remotamente
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Skeleton
• Stub do lado Servidor
• Implementa os métodos da interface remota
• Converte os parâmetros do pedido (unmarshalling)
• Invoca o método no objecto de destino
• Quando o método termina converte os parâmetros de retorno e codifica eventuais excepções
• Envia a resposta
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Características mais complexas
• Activação dos objectos
• Invocação dinâmica
• Recuperação de memória – garbage collection
Departamento de Engenharia Informática
Activação dos Objectos
• Os objectos no servidor podem ter um período de vida longo
• Recursos estão a ser gastos se os objectos não estiverem a ser invocados
• Leva a distinguir entre objectos:– Activos: prontos para ser invocados
– Passivos : não estão activos mas podem ser activados
• Tornar o objecto passivo implica salvar o estado do objecto para poder ser em seguida reactivado. – O estado tem de ser transformado num formato coerente
(marshalled) e guardado persistentemente
• Tem de existir uma componente no servidor que saiba activar o objecto quando for necessário
Sistemas Distribuídos 2009/10
6
Departamento de Engenharia Informática
Invocação Dinâmica: alternativa a proxies
Invocação estática
Invocação dinâmica
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Reflection - definition
• The reflective programming paradigm introduces the concept of meta-information, which keeps knowledge of program structure.
• Meta-information stores information such as the name of the contained methods, the name of the class, the name of parent classes, and/or what the compound statement is supposed to do.
• Using this stored information, as an object is consumed (processed), it can be reflected upon to find out the operations that it supports.
• The operation that issues in the required state via the desired state transition can be chosen at run-time without hard-coding it.
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Garbage Collection
• Recuperar a memória usada por objectos remotos quando mais nenhum cliente se lhes refere
• Uma aproximação é baseada em contagem das referências– Cada vez que um cliente recebe uma referência a um objecto remoto
faz uma chamada addRef() ao servidor e instancia o respectivo proxy– Quando o garbage collector local detecta que o proxy não pode ser
mais usado faz uma chamada a removeRef()– Quando a contagem de referência no servidor se torna zero o servidor
pode recuperar a memória.
• Outra aproximação é baseada em leases - licença para usar o objecto durante um certo período de tempos– O servidor permite o acesso ao objecto remoto durante um certo
período
– Se a lease não for renovada quando o tempo expira a referência é automaticamente removida
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
RMI: comparação com RPC
Positivo Negativo
� Tudo o que o RPC disponibilizava +
� A interface do serviço é descrita numa
linguagem centrada nos objectos
� Uso dos mecanismos OO como herança
� Criação automática de referências remotas
�Invocação dinâmica que permite uma
interface fracamente ligada
�Recuperação de memória (garbagge
collection) automático
�Optimização de invocação remota
passagem de objectos por valor ou referência
• As mesmas do RPC +
•Plataformas ficam dependentes do modelo
de objectos e consequentemente limitam
interoperacionalidade
Sistemas Distribuídos 2009/10
7
Departamento de Engenharia Informática
Principais Sistemas de Objectos Remotos
• Corba
• RMI (Java / J2EE)
• Remoting (C# / .NET)
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
CORBA
• Tem origem no Object Management Group (OMG) criado em 1989
• Modelo Conceptual é uma síntese entre o modelo cliente –servidor e as arquitecturas de objectos
• A proposta original do Corba - Object Management Architecture foi publicada em 1990 e continha:
– Serviços de suporte ao ciclo de vida dos objectos
– Object request broker
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Object Request Broker
• Novo paradigma proposto consistia num serviço que
auxilia a invocação de objectos remotos – (evolução do
run-time do RPC)
• O papel do ORB é localizar o objecto, activá-lo se
necessário, enviar o pedido do cliente ao objecto
ORB
AplicaçãoCliente
ServiçoRemoto(objecto)
Activar serviçoLocalizar objecto(serviço) Estabelecer
ligação
Comunic.
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
CORBA
• CORBA 2.0 publicado em 1996
• Os principais elementos da plataforma são:– IDL – linguagem object oriented com suporte para herança
– Arquitectura – define o ambiente de suporte aos objectos, à invocação, ao ciclo de vida
– GIOP – General Inter Orb Protocol – protocolo de invocação remota entre Orb de fabricantes diferentes
– IIOP - Internet Inter Orb Protocol – implementação do GIOP sobre protocolos TCP/IP
• Actualmente– Actividade de normalização reduzida
– Vários produtos disponíveis • Visigenic/Visibroker
• IONA
• Menos utilizado vs. plataformas J2EE / .net
Sistemas Distribuídos 2009/10
8
Departamento de Engenharia Informática
Modelo de Objectos
• Um objecto CORBA implementa uma interface descrita na IDL CORBA
• Um objecto CORBA pode ser invocado remotamente através de uma referência remota
• Os objectos CORBA residem no servidor
• Os clientes podem ser objectos ou programas que enviam as mensagens correctas para os objectos
• Os objectos CORBA não têm de ser implementados numa linguagem Object Oriented podem ser em Cobol, C, etc.
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Passagem de Parâmetros
• Todos os parâmetros cujo tipo é especificado pelo nome de
uma interface é uma referência a um objecto CORBA e são
passados como referências a objectos remotos.
• Os argumentos do tipo primitivo ou estruturas são
passados por valor. Na chegada um novo objecto é criado
no processo receptor (pode ser no cliente ou no servidor).
Este mecanismo é idêntico ao do RPC
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
CORBA IDL
• A interface é escrita em OMG IDL
– A interface é object-oriented com sintaxe muito
semelhante ao C++
• A herança é suportada
– Especifica um nome de uma interface e um conjunto de
métodos que os clientes podem invocar
– Descreve os parâmetros e o respectivo sentido in, out,
inout
– Os métodos podem ter excepções
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
module Accounts
{
interface Account
{
readonly attribute string number;
readonly attribute float balance;
exception InsufficientFunds (string detail);
float debit (in float amount) raises (insufficientFunds);
float credit (in float amount);
}
interface InterestAccount : Account
{
readonly attribute float rate;
}
}
Exemplo da IDL CORBA
Herança
Sistemas Distribuídos 2009/10
9
Departamento de Engenharia Informática
Arquitectura
Implementationrepository
interfacerepository
Clientprogram Proxy
for AORBcore
client
or dynamic skeleton
object
adapter
ORBcore
server
skeleton
ServantA
Request
Reply
Or dynamic invocation
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Elementos da Arquitectura
• ORB – núcleo – run-time da invocação remota, conjunto de funções residentes quer no cliente quer no servidor– Implementa a infra-estrutura de comunicação
– O ORB tem funções para ser inicializado e parado
• Servidor– Object adapters - rotina de despacho que recebe as mensagens e invoca os
stubs apropriado • O nome do object adapter faz parte da referência remota e permite a sua
invocação
• Despacha cada invocação via um skeleton para o método apropriado
– Skeletons• Funções de adaptação que fazem a conversão dos parâmetros de entrada e saída
e o tratamento das excepções
• Client proxies– Para as linguagens Object-oriented
– Efectua a conversão dos parâmetros de entrada e de saída
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Referências Remotas
• Para invocar uma operação remota é necessário que o objecto
invocador tenha uma referência remota para o objecto
• Uma referência remota pode ser obtida como
– Resultados de invocações remotas anteriores – a servidores ou ao
gestor de nomes
– Ter sido obtida como parâmetro de um invocação a um objecto local
• É diferente de binding handle estático dos RPC
IDL interface type name Protocol and address details Object key
interface repository
identifier
IIOP host domain
name
port number adapter name object nameIOR
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Invocação
• A invocação do método tem por omissão uma semântica at-most-once
• A heterogeneidade é resolvida com a conversão para CDR –Common Data Representation
– Inclui 15 tipos básicos
– Receiver makes it right
Sistemas Distribuídos 2009/10
10
Departamento de Engenharia Informática
index in
sequence of bytes
notes
on representation
0-3
4-7
8-11
12-15
16-19
20-23
24-27
5
“Smit”
“h____”
6
“Lond”
“on____”
1934
4 bytes
length of string
“Smith”
length of string
London
unsigned long
Struct Pessoa {
string Nome;
string Lugar;
unsigned long Ano;
};
Representa a struct Person com os valores: {‘Smith’, ‘London’, 1934}
CORBA CDR
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Elementos da Arquitectura: Servidor de
Interfaces
• Interface repository
– Dá informação sobre as interfaces registadas
– Para uma interface pode dar a informação dos métodos e dos respectivos parâmetros
– O compilador de IDL atribui um número único a cada tipo IDL que compila. Esta facilidade permite a invocação dinâmica em CORBA.
– Se um cliente recebe uma referência remota para um novo objecto CORBA de que não tem um proxy, pode ir buscar esta informação ao Interface repository
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Elementos da Arquitectura: servidor do
código das implementações
• Implementation repository– Contém localização das implementações dos objectos
– Permite ao object adapter carregar o código das classes para instanciar os respectivos objectos
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
CORBA – Invocação Dinâmica
• Para dinamicamente invocar um objecto em tempo de execução existe a invocação dinâmica
• O cliente não precisa de ter os proxies – As invocações remotas são construídas dinamicamente
– Novos servidores podem ser usados por clientes já existentes
• Funcionamento– O Cliente usa o Interface Repository para obter a informação sobre os
métodos e argumentos.
– Cria a mensagem de acordo com a especificação da interface, e envia o pedido para o respectivo objecto.
Account_ptr acc = ...; // Obter ref para objecto Account
acc.credit( 100 ); // Invoc. estática
CORBA::Object_ptr obj = ...;
CORBA::Request_ptr req = obj.request( “credit" );
req.add_in_arg( "amount" ) <<= (CORBA::ULong) 100;
req->invoke();
Invocação DinâmicaSistemas Distribuídos 2009/10
11
Departamento de Engenharia Informática
Invocação
dinâmica
• Obter a referência para o método
• Obter a lista de parâmetros
• Criar a mensagem de invocação
• Invocar – várias alternativas
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Java RMI
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
RMI
• Remote Method Invocation: mecanismo de chamada
remota a métodos Java utilizado para RPCs entre objectos
Java distribuídos
– Mantém a semântica de uma chamada local, para objectos distantes
– Efectua automaticamente o empacotamento e desempacotamento
dos parâmetros
– Envia as mensagens de pedido e resposta
– Faz o agulhamento para encontrar o objecto e o método pretendido
Sistemas Distribuídos 2009/10
12
Departamento de Engenharia Informática
Java RMI
• O RMI Java pressupõe que se utiliza um ambiente Java de linguagem única, pelo que não se colocam alguns dos problemas que o CORBA pretende resolver.
• Apesar do ambiente uniforme um objecto tem conhecimento que invoca um método remoto porque tem de tratar RemoteExceptions
• A interface do objecto remoto por sua vez tem de ser uma extensão da interface Remote
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
import java.rmi*;
public interface Account extends Remote {
float debit(float amount) throws RemoteException, InsufficientFundsException;
float credit(float amount) throws RemoteException;
}
public interface AccountList extends Remote {
Account getAccount(int id) throws RemoteException;
}
RMI – Exemplo de interfaces
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Java RMI
• No Java RMI os parâmetros de um método assumem-se como entradas (input) e o resultado do método como parâmetro de saída (output)
• Quando o parâmetro é um objecto remoto (herda de java.rmi.Remote)– é sempre passado como uma referência para um objecto remoto
• Quando o parâmetro é um objecto local (caso contrário)– é serializado e passado por valor. Quando um objecto é passado
por valor uma nova instância é criada remotamente– Tem de implementar java.io.Serializable– Todos os tipos primitivos e objectos remotos são serializáveis.
(java.rmi.Remote descende de java.io.Serializable)
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Java RMI
• Quando um objecto é enviado como parâmetro por valor pode ocorrer que o receptor não tenha a classe respectiva.
• Problema: Como “des-serializar” o objecto?
• Solução: quando um objecto é serializado, é enviado (juntamente com a informação sobre a sua classe) a localização da classe (URL) de onde é feito o seu carregamento dinâmico.
Sistemas Distribuídos 2009/10
13
Departamento de Engenharia Informática
Protocolos de invocação remota
• RMI pode ser suportado usando o Java RemoteMethod Protocol (JRMP) ou o Internet Inter-ORBProtocol (IIOP).
– O JRMP é um protocolo específico criado para o RMI
– O IIOP é um protocolo normalizado para comunicação entre objectos CORBA.
• O RMI usando o IIOP permite aos objectos remotos em Java comunicarem com objectos em CORBA que podem estar programados com linguagens diferentes do Java
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
JNDI
Java Naming and Directory Interface
• Mecanismo de nomes do J2EE
• Utilizado para associar nomes a recursos e objectos de forma portável
– Identificação, localização, partilha
• Mapeia nomes em referências para objectos
• Uma instância do registry deve executar-se em todos servidores que têm objectos remotos.
• Os clientes têm de dirigir as suas pesquisas para o servidor pretendido
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
import java.rmi.*;
public class BankServer{
public static void main(String args[]){
System.setSecurityManager(new RMISecurityManager());
try{
AccountList accountList = new AccountListServant();
Naming.rebind(“AccountList”, accountList );
System.out.println(“accountList server ready” );
}catch(Exception e) {System.out.println(“accountList
server main” + e.getMessage());}
}
}
classe BankServer com o método main
Criar um gestor de segurançapara evitar problemas com classes que são carregadas a partir de
outros sites.
Associa um nome a uma instância a partir da qual se pode aceder a
outros objectos do servidor
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
Import java.util.Vector;
public class AccountListServant extends UnicastRemoteObject implements AccountList {
private Vector<Account> theList; //contains the list of accounts private
public AccountListServant()throws RemoteException{...}
public Account getAccount(int id) throws RemoteException {
return theList[id];
}
}
Classe AccountListServant implementa a
interface AccountList
Necessário também implementar interface Account
Sistemas Distribuídos 2009/10
14
Departamento de Engenharia Informática
Sistemas Distribuídos 2009/10
import java.rmi.*;
import java.rmi.server.*;
public class AccountListClient{
public static void main(String args[]){
System.setSecurityManager(new RMISecurityManager());
AccountList acList = null;
try{
acList = (AccountList)Naming.lookup(“//host/AccountList”);
Account a = acList.getAccount(2);
a.debit(1000);
}catch(RemoteException e) {System.out.println(e.getMessage());
}catch(Exception e){System.out.println(“Client:”+e.getMessage());}
}
}
Cliente da interface AccountList
Obteve referência remota pelo nome da instância remota
Obteve referência remota por retorno de método
Departamento de Engenharia Informática
Java RMI – mecanismo de Reflexão
• A reflexão é usada para passar informação nas mensagens
de invocação sobre o método que se pretende executar
• API de reflexão permite, em run-time:
– Determinar a classe de um objecto.
– Obter informação sobre os métodos / campos de uma classe /
interface
– Criar uma instância de uma classe cujo nome é desconhecido antes
da execução
– Invocar métodos que são desconhecidos antes da execução
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Reflexão no RMI – como usar
• Visão geral:
– Obter instâncias das classes genéricas “Class” e “Method”
– Cada instância de Method representa as características de um
método (classe, tipo dos argumentos, valor de retorno, e
excepções)
– Invocar métodos remotos com o método “invoke” da classe
“Method”. Requer dois parâmetros:
• O primeiro é o objecto a invocar
• O segundo é um vector de Object contendo os argumentos
• Mais detalhes em
http://java.sun.com/docs/books/tutorial/reflect/
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Contexto: J2EE
• Até agora vimos arquitecturas cliente-servidor
– Simples, mas…
– difícil de fazer evoluções
– difícil de reutilizar a lógica de negócio ou de
apresentação
• J2EE é uma plataforma para desenvolver e
executar aplicações distribuídas multi-nível
Sistemas Distribuídos 2009/10
15
Departamento de Engenharia Informática
Páginas HTML dinâmicas
Páginas JSP
Enterprise Beans
Base de Dados
Aplicação J2EE Multi-nível
Cliente
ServidorJ2EE
Servidor deBase de Dados
Camada cliente
Camada Web
Camada de negócio
Camada EIS
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Tecnologias Principais do J2EE
• Servlets
• Java Server Pages (JSP)
• Enterprise Java Beans (EJB)
• Java Database Connectivity (JDBC)
• Remote Method Invocations (RMI)
• XML
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
2009 José Alves Marques
Arquitectura J2EE
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
.NET REMOTING
Equivalente ao RMI para C# na plataforma .NET. Vamo-nos concentrar
nas novas opções fornecidas
Sistemas Distribuídos 2009/10
16
Departamento de Engenharia Informática
Objectos Remotos
• Qualquer objecto pode ser usado remotamente derivando-o de
MarshalByRefObject ou de MarshalByValObject
• MarshallByValue
– Objectos serializáveis, são copiados para o cliente
– Pode ser muito ineficiente
• MarshallByRef
– Quando o cliente recebe uma referência de um objecto remoto está
efectivamente a receber uma referência a um objecto proxy local criado
automaticamente pelo .NET Remoting.
– Esse proxy é encarregue de efectuar as chamadas aos métodos para o
servidor.
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Utilização de Objectos Remotos
• Requer a respectiva activação. Dois modos:
• Singleton
– Apenas uma instância em cada instante
– Criada aquando da primeira invocação
– Requer sincronização no acesso a estado partilhado
• SingleCall
– Uma nova instância é criada para cada pedido.
– Após a execução de uma chamada, a próxima chamada será
servida por outra instância.
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Tempo de Vida dos Objectos
• Tempo de vida dos objectos Singleton
determinado por sistema de leases.
– Ao expirar um lease, este deve ser renovado, caso
contrário a memória ocupada pelo objecto é recuperada
pelo garbage collector.
Java RMI escolheu solução mais complexa: contagem de referência distribuída.
Problema: falhas na rede e nos servidores?
Java RMI usa adicionalmente leases para tolerar falhas
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Canais
• A comunicação entre dois processos distintos é realizada através de canais, cuja função é:
– Empacotar a informação de acordo com um tipo de protocolo
– Enviar esse pacote a outro computador.
• Dois tipos pré-definidos:
– TcpChannel (que envia os dados por TCP em formato binário).
– HttpChannel (que utiliza o protocolo HTTP em formato XML).
• Maior flexibilidade do que no RMI na escolha dos mecanismos de serialização e protocolos de transmissão
Sistemas Distribuídos 2009/10
17
Departamento de Engenharia Informática
Resumo das Opções
• MarshallByRef vs. MarshallByValue
• Canais – TcpChannel vs. HttpChannel vs. Custom
• Activação – Singleton vs. Single Call
• Tempo de vida – Single Call vs. Leases
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Exemplo: Interface
public interface Account {
float debit(float amount);
float credit(float amount);
}
public interface AccountList {
Account getAccount(int id);
}
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Exemplo: Servidor
class bankServer : MarshalByRefObject, accountList {
ArrayList acList;
public bankServer () {...}
public Account getAccount(int id) {
return acList[id];
}
static void Main() {
TcpChannel chan1 = new TcpChannel(8086);
ChannelServices.RegisterChannel(chan1);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(bankServer),
“accountList", WellKnownObjectMode.Singleton);
System.Console.WriteLine("<enter> para sair...");
System.Console.ReadLine();
}
}
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
Exemplo: Cliente
class cl {
static void Main() {
TcpChannel chan = new TcpChannel();
ChannelServices.RegisterChannel(chan);
accountList acList =
(accountList) Activator.GetObject(typeof(accountList),
"tcp://localhost:8086/accountList");
if (acList == null)
System.Console.WriteLine("Could not locate server");
else {
Account a = acList.getAccount(2);
Console.WriteLine(a.debit(1000));
}
}
Sistemas Distribuídos 2009/10
18
Departamento de Engenharia Informática
Comparação – IDL
C#/Remoting – IDL CORBA - IDL Java/RMI - Interface definition
using System;
namespace SimpleStocks
{
public interface StockMarket {
float get_price(string symbol);
}
module SimpleStocks
{
interface StockMarket
{
float get_price(in string symbol);
};
};
package SimpleStocks;
import java.rmi.*;
import java.util.*;
public interface StockMarket extends
java.rmi.Remote
{
float get_price( String symbol)
throws RemoteException;
}
Sistemas Distribuídos 2009/10
Departamento de Engenharia Informática
2009 José Alves Marques
C# / Remoting - Server implementation CORBA - Server implementation Java/RMI - Server implementation
//
//
// StockMarketServer
//
//
using System.Runtime.Remoting;
public class StockMarketImpl :
MarshalByRefObject,
SimpleStocks.StockMarket
{
public float get_price( string symbol
)
{
float price = 0;
for( int i = 0; i < symbol.length();
i++ )
{
price += (int) symbol.charAt(i);
}
price /= 5;
return price;
}
}
//
//
// StockMarketServer
//
//
import org.omg.CORBA.*;
import SimpleStocks.*;
public class StockMarketImpl extends
_StockMarketImplBase
{
public float get_price( String symbol
)
{
float price = 0;
for(int i = 0; i < symbol.length();
i++)
{
price += (int) symbol.charAt( i );
}
price /= 5;
return price;
}
public StockMarketImpl( String name )
{
super( name );
}
}
//
//
// StockMarketServer
//
//
package SimpleStocks;
import java.rmi.*;
import
java.rmi.server.UnicastRemoteObject;
public class StockMarketImpl extends
UnicastRemoteObject implements
StockMarket
{
public float get_price( String symbol
)
{
float price = 0;
for( int i = 0; i < symbol.length();
i++ )
{
price += (int) symbol.charAt( i );
}
price /= 5;
return price;
}
public StockMarketImpl( String name )
throws RemoteException
{
try
{
Naming.rebind( name, this );
}
catch( Exception e )
{
System.out.println( e );
}
}
}
Departamento de Engenharia Informática
2009 José Alves Marques
C# / Remoting - Server Main CORBA - Server Main Java/RMI - Server Main
//
//
// StockMarketServer Main
//
//
using System.Runtime.Remoting;
class StockMarketServer
{
static void Main(string[] args)
{
TcpChannel chan1 = new
TcpChannel(8086);
ChannelServices.RegisterChannel
(chan1);
RemotingConfiguration.RegisterWel
lKnownServiceType(typeof(StockMar
ket),“NASDAQ",WellKnownObjectMode
.Singleton);
System.Console.WriteLine("<enter>
para sair...");
System.Console.ReadLine();
}
}
//
//
// StockMarketServer Main
//
//
import org.omg.CORBA.*;
import org.omg.CosNaming.*;
import SimpleStocks.*;
public class StockMarketServer
{
public static void main(String[] args)
{
try
{
ORB orb = ORB.init();
BOA boa = orb.BOA_init();
StockMarketImpl stockMarketImpl = new
StockMarketImpl("NASDAQ");
boa.obj_is_ready( stockMarketImpl );
org.omg.CORBA.Object object =
orb.resolve_initial_references("NameSer
vice");
NamingContext root =
NamingContextHelper.narrow( object ) ;
NameComponent[] name = new
NameComponent[1];
name[0] = new NameComponent("NASDAQ",
"");
root.rebind(name, stockMarketImpl);
boa.impl_is_ready();
}
catch( Exception e )
{
e.printStackTrace();
}
}
}
//
//
// StockMarketServer Main
//
//
import java.rmi.*;
import
java.rmi.server.UnicastRemoteObject;
import SimpleStocks.*;
public class StockMarketServer
{
public static void main(String[] args)
throws Exception
{
if(System.getSecurityManager() == null)
{
System.setSecurityManager(new
RMISecurityManager());
}
StockMarketImpl stockMarketImpl = new
StockMarketImpl("NASDAQ");
}
}
Departamento de Engenharia InformáticaC# / Remoting - Client implementation CORBA - Client implementation Java/RMI - Client implementation
//
//
// StockMarketClient
//
//
namespace SimpleStocks
{
public class StockMarketClient
{
static void Main()
{
try {
StockMarket market =
(StockMarket)Activator.GetObject(
typeof(StockMarket),
“tcp://localhost:8086/NASDAQ”);
System.Console.WriteLine("The price
of MY COMPANY is " +
market.get_price("MY_COMPANY") );
}
}
//
//
// StockMarketClient
//
//
import org.omg.CORBA.*;
import org.omg.CosNaming.*;
import SimpleStocks.*;
public class StockMarketClient
{
public static void main(String[]
args)
{
try
{
ORB orb = ORB.init();
NamingContext root =
NamingContextHelper.narrow(
orb.resolve_initial_references("NameS
ervice") );
NameComponent[] name = new
NameComponent[1] ;
name[0] = new
NameComponent("NASDAQ","");
StockMarket market =
StockMarketHelper.narrow(root.resolve
(name));
System.out.println("Price of MY
COMPANY is " +
market.get_price("MY_COMPANY"));
}
catch( SystemException e )
{
System.err.println( e );
}
}
}
//
//
// StockMarketClient
//
//
import java.rmi.*;
import java.rmi.registry.*;
import SimpleStocks.*;
public class StockMarketClient
{
public static void main(String[]
args)throws Exception
{
if(System.getSecurityManager() == null)
{
System.setSecurityManager(new
RMISecurityManager());
}
StockMarket market =
(StockMarket)Naming.lookup("rmi://local
host/NASDAQ");
System.out.println( "The price of MY
COMPANY is "
+ market.get_price("MY_COMPANY") );
}
}
19
Departamento de Engenharia Informática
EXEMPLOS ANTIGOS
2009 José Alves Marques
Departamento de Engenharia Informática
2009 José Alves Marques
Implementação do Servidor em Java
• A implementação dos métodos da interface remota é uma
classe que se designa habitualmente por “servant”
• No exemplo seguinte o método newShape pode ser
designado uma factory porque permite ao cliente criar
objectos remotos.
Departamento de Engenharia Informática
2009 José Alves Marques