Invocação de Métodos em Objectos Remotos. Invocação de Métodos em Objectos Remotos. Invocação de Objectos Remotos

(1)

Invocação de Métodos em Objectos Remotos

Sistemas Distribuídos 2009/10 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 A B C D E F Sistemas Distribuídos 2009/10

m4 m5 m6 Interface Remota m1 m2 m3 Código dos métodos Dados Objecto remoto

Invocação de Objectos Remotos

(2)

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

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

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

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

(3)

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

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

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

Elementos principais da arquitectura do RMI

object A proxy for B _Request skeleton object B

Reply

Communication

Remote Communication Remote reference

module module

reference module module

for B’s class & dispatcher

remote

client server

(4)

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

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

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

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

(5)

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

Características mais complexas

• Activação dos objectos

• Invocação dinâmica

• Recuperação de memória – garbage collection

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

(6)

Invocação Dinâmica: alternativa a proxies

Invocação estática

Invocação dinâmica

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.

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

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

(7)

Principais Sistemas de Objectos Remotos

• Corba

• RMI (Java / J2EE)

• Remoting (C# / .NET)

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

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. Sistemas Distribuídos 2009/10

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

(8)

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.

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

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

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

(9)

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 Sistemas Distribuídos 2009/10

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

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

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

(10)

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

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

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

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âmica

(11)

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 Sistemas Distribuídos 2009/10

Java RMI

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

(12)

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

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

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)

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.

(13)

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

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

import java.rmi.*; public class BankServer{

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 a uma instância a partir da qual se pode aceder a

outros objectos do servidor Sistemas Distribuídos 2009/10

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

(14)

Sistemas Distribuídos 2009/10 import java.rmi.*;

import java.rmi.server.*; public class AccountListClient{

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

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

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

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

(15)

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 Sistemas Distribuídos 2009/10

Tecnologias Principais do J2EE

• Servlets

• Java Server Pages (JSP)

• Enterprise Java Beans (EJB)

• Java Database Connectivity (JDBC)

• Remote Method Invocations (RMI)

• XML

Arquitectura J2EE

.NET REMOTING

Equivalente ao RMI para C# na plataforma .NET. Vamo-nos concentrar nas novas opções fornecidas

(16)

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.

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.

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

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

(17)

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

Exemplo: Interface

public interface Account { float debit(float amount); float credit(float amount); }

public interface AccountList { Account getAccount(int id); }

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(); }

}

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)

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 StockMarketextends java.rmi.Remote

{

float get_price( String symbol) throws RemoteException; }

Sistemas Distribuídos 2009/10 2009 José Alves Marques

// 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 ); } } }

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");

} }

C# / 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)

EXEMPLOS ANTIGOS

2009 José Alves Marques 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.