2009
José Alves Marques
Invocação de Métodos em Objectos Remotos
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#.
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
•
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
2009
José Alves Marques
m4
m5
m6
Interface
Remota
m1
m2
m3
Código
dos
métodos
Dados
Objecto remoto
Invocação de Objectos Remotos
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
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
Invocação Dinâmica
2009
José Alves Marques
Invocação estática
Invocação dinâmica
Departamento de Engenharia Informática
2009
José Alves Marques
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
Elementos principais da arquitectura do
RMI
• Módulo de comunicações – idêntico à biblioteca
de run-time do RPC
• Módulo de Referências Remotas
• Proxies – stubs do lado do Cliente
• Skeletons – stubs do lado do Servidor
Departamento de Engenharia Informática
Módulo para gestão das referências
remotas
• Traduz entre as referências locais e remotas
• Tem uma Tabela de Objectos Remotos que
contém:
– Objectos remotos que estão mapeados no processo
– Proxies para objectos remotos
• Gere as referências remotas que entram e saem do
processo
• Determina que objecto local deve ser invocado
quando chega um RMI
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 dos parâmetros (marshalling)
• A interface do proxy é idêntica à interface do objecto
remoto
• Existe um proxy por cada objecto remoto referenciado pelo
cliente
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
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
Departamento de Engenharia Informática
Características mais complexas
• Activação dos objectos
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
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 faz uma referência a uma objecto remoto
uma chamada addRef() é efectuada no servidor
– Quando o garbage collector local detecta que o objecto 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
2009
José Alves Marques
Principais Sistemas de Objectos Remotos
• Corba
• RMI (Java / J2EE)
• Remoting (C# / .NET)
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
2009
José Alves Marques
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ção
Cliente
Serviço
Remoto
(objecto)
Activar serviço
Localizar objecto
(serviço)
Estabelecer
ligação
Comunic.
Departamento de Engenharia Informática
2009
José Alves Marques
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
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 não têm de ser implementados numa
linguagem Object Oriented podem ser em Cobol, C, etc.
2009
José Alves Marques
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)
2009
José Alves Marques
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
Departamento de Engenharia Informática
2009
José Alves Marques
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
2009
José Alves Marques
Arquitectura
Implementation
repository
interface
repository
Client
program
Proxy
for A
ORB
core
client
or dynamic skeleton
o
b
je
c
t
a
d
a
p
te
r
ORB
core
server
s
k
e
le
to
n
Servant
A
Request
Reply
Or dynamic invocation
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
2009
José Alves Marques
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 name
IOR
Departamento de Engenharia Informática
2009
José Alves Marques
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
2009
José Alves Marques
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
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
2009
José Alves Marques
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
Departamento de Engenharia Informática
2009
José Alves Marques
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->deposit( 100 ); // Invoc. estática
CORBA::Object_ptr obj = ...;
CORBA::Request_ptr req = obj->_request( "deposit" );
req->add_in_arg( "amount" ) <<= (CORBA::ULong) 100;
req->invoke();
2009
José Alves Marques
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
2009
José Alves Marques
Java RMI
Departamento de Engenharia Informática
2009
José Alves Marques
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
2009
José Alves Marques
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
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;
}
2009
José Alves Marques
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)
Departamento de Engenharia Informática
2009
José Alves Marques
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.
Protocolos de invocação remota
• RMI pode ser suportado usando o Java Remote
Method Protocol (JRMP) ou o Internet Inter-ORB
Protocol (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
2009
José Alves Marques
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
2009
José Alves Marques
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ça
para evitar problemas com classes
que são carregadas a partir de
outros sites.
Associa um nome remoto à
instância
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 “servant”
• No exemplo seguinte o método newShape pode ser
designado uma factory porque permite ao cliente criar
objectos remotos.
2009
José Alves Marques
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 ShapeListServant()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
Departamento de Engenharia Informática
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
2009
José Alves Marques
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
Departamento de Engenharia Informática
2009
José Alves Marques
Reflexão no RMI – como usar
• Visão de 10,000 pés:
– 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
2009
José Alves Marques
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
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
Servidor
J2EE
Servidor de
Base de Dados
Camada cliente
Camada Web
Camada de negócio
Camada EIS
2009
José Alves Marques
Tecnologias Principais do J2EE
• Servlets
• Java Server Pages (JSP)
• Enterprise Java Beans (EJB)
• Java Database Connectivity (JDBC)
• Remote Method Invocations (RMI)
• XML
Departamento de Engenharia Informática
2009
José Alves Marques
2009
José Alves Marques
.NET Remoting
• Equivalente ao RMI para C# / Plataforma .NET
• Semelhante ao RMI, vamo-nos concentrar nas novas
opções fornecidas
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 ele 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.
2009
José Alves Marques
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.
Departamento de Engenharia Informática
2009
José Alves Marques
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?
2009
José Alves Marques
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
Departamento de Engenharia Informática
Resumo das Opções
• MarshallByRef vs. MarshallByValue
• Canais – TcpChannel vs. HttpChannel vs. Custom
• Activação – Singleton vs. Single Call
2009
José Alves Marques
Exemplo: Interface
public interface Account {
float debit(float amount);
float credit(float amount);
}
public interface AccountList {
Account getAccount(int id);
}
Departamento de Engenharia Informática
2009
José Alves Marques
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();
}
2009
José Alves Marques
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));
}
}
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; }
2009
José Alves Marques
// // 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") ); }
}
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 StockMarketImplextends 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 ); } }
2009
José Alves Marques
// // 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");
}
