You are on page 1of 12

Tutorial Corba 1

Tutorial Corba
Introdução

Este trabalho, tem como finalidade o desenvolvimento de um estudo mais detalhado de como a
linguagem de programação Java utiliza a arquitetura CORBA (Commom Object Request Broker
Arquiteture) e a interface IDL (Interaface Definiton Language) para desenvolvimento de aplicações
Cliente / Servidor.

O que é CORBA?

O CORBA é um padrão que foi definido em 1991 pela OMG (Object Management Group),
uma organização que reúne cerca de 800 empresas do mundo todo, inclusive gigantes como IBM,
Digital, Oracle, Sun e Sybase. O padrão CORBA é um sistema que permite que aplicações distribuídas
em uma rede (local ou mesmo na internet) comuniquem-se entre si e troquem informações. Estas
aplicações podem estar sendo executadas em diferentes plataformas (Intel, Sun, etc) e sistemas
operacionais (Windows, Linux, Unix, etc) e podem ter sido construídas em diferentes linguagens de
programação. Utilizando o padrão CORBA é possível ter aplicações completamente distribuídas,
potencialmente com cada pedaço de software sendo executado em qualquer parte da rede e em
qualquer plataforma, sem que o usuário perceba que isto está acontecendo e sem que o desenvolvedor
precise se preocupar em criar soluções que resolvam os problemas de interoperabilidade entre os
diferentes pedaços da aplicação. Atualmente, diversas ferramentas já suportam o padrão CORBA,
como Delphi 4, JBuilder 2, Oracle 8i, Cold Fusion e C++ Builder. Uma grande vantagem de CORBA
é ser um padrão diretamente suportado por empresas em todo o mundo e com dezenas de
implementações disponíveis, incluindo algumas gratuitas.
Na prática, essa padronização significa que você não precisa ficar preso a determinados
fornecedores, plataformas ou produtos, como acontece quando são escolhidas soluções proprietárias.

O que é o padrão ORB?

O ORB é o middleware que estabelece os relacionamentos cliente-servidor entre os objetos.
Utilizando um ORB, um cliente pode invocar transparentemente um método de um objeto no servidor,
que pode estar na mesma máquina ou em qualquer ponto da rede. O ORB intercepta a chamada por
parte do cliente e tem a responsabilidade: localizar o objeto que implementa a chamada,passar os
parâmetros necessários a este objeto, fazer a chamada dos métodos e retornar dos resultados. O cliente,
por sua vez, não precisa preocupar-se com a localização do objeto que está sendo invocado, na que
linguagem que o mesmo foi programado ou, mesmo, no sistema operacional que está sendo utilizado.
Para o cliente a única coisa que importa é a interface. Ao realizar esta tarefa, o ORB oferece uma
solução para a interoperabilidade entre aplicações em máquinas diferentes em ambientes distribuídos e
heterogêneos, ao mesmo tempo que interconecta múltiplos sistemas baseados em objetos.
O segredo desta arquitetura reside na definição das interfaces, ou seja, na forma como os
objetos vão interagir entre si e que serviços (métodos) estarão disponíveis. A correta definição das
interfaces é, sem dúvida, o maior desafio desta arquitetura. Geralmente, nas aplicações cliente-
servidor clássicas, os desenvolvedores utilizam um protocolo próprio ou reconhecem um protocolo
padrão para estabelecer a comunicação entre módulos. A definição do protocolo depende da

Fabio Lopes Licht Fev/2002

4 versão beta) “Hello World” Transiente.java  Hello.omg. Mais do que isto. string sayHello().ObjectImpl e implementa a interface Hello. oneway void shutdown(). extende HelloPOA  _HelloStub. é similar à utilizada em C++. a interface HelloOperations e org. { 3.CORBA.java – Esta classe abstrata é baseada no esqueleto do servidor.portable.java – Esta classe final assegura um método de solicitação público (Public) do tipo Hello.portable. A sintaxe utilizada para a IDL. Alguns Exemplos (O desenvolvimento dos exemplos que se seguem.omg.Servant. Desenvolvedores tem a liberdade de escolher o sistema operacional.omg.Tutorial Corba 2 linguagem de implementação. { 5.omg. o ambiente de desenvolvimento e execução de cada um dos componentes que está sendo desenvolvido.IDLEntity  HelloHelper. }. além de fornecer operações para org. fazem parte do pacote do jdk 1. 6. do protocolo da rede e uma dezena de outros fatores.CORBA. 8.omg. através da utilização de ORBs é possível a integração de componentes já existentes.portable.CORBA. serão criados os arquivos-fonte:  HelloPOA. No caso do ORB.idl” 1. HelloServant. Extende org. }.OutputStream e org.java – Esta classe é o stub do cliente. e implementa a interface InvokeHandler e a interface HelloOperations.PortableServer. A classe de servidor. interface Hello 4. Extende org. o protocolo é definido através da aplicação de interfaces através da IDL . O ORB na realidade oferece flexibilidade.CORBA. Extende org.Object.Interface Definition Language uma implementação linguagem independente.java – Esta classe contém a versão da interface IDL Java.omg. “Hello.  HelloHolder.idl” .portable.java – A classe HelloHelper é responsável pela leitura e escrita dos dados do CORBA. 7.CORBA. A linha 1 “module HelloApp” especifica um diretório.InputStream Fabio Lopes Licht Fev/2002 . ORBs simplificam este processo. module HelloApp 2. e onde após a compilação com o comando “idlj -fall Hello. Definição de uma interface. bem como os compiladores utilizados. que será criado.

import java.omg. import org. 40. 7. 43. import org. orb = orb_val. public void setORB(ORB orb_val) { 15. O idlj coloca as operações definidas na interface IDL dentro este arquivo. 30. 13. } 28. // implementação do método sayHello() 19. 8. que CORBA permite.PortableServer. import org.util.CosNaming. 3. // obtém a referência do rootpoa e ativa o POAManager 38. rootpoa.POA.java” 1. 9. helloImpl.resolve_initial_references("RootPOA")). import HelloApp. public static void main(String args[]) { 33. 39.  HelloOperations.Tutorial Corba 3 argumentos. 37. 6. 36. // obtém referência do objeto servant Fabio Lopes Licht Fev/2002 . // implementação do método shutdown() 24.omg. que é compartilhado por ambos o stubs e esqueletos.CORBA.CosNaming. // cria o servant e registra com o ORB 42. // HelloServer. return "\nHello world !!\n". 44.portable. 32. Esta classe.*. 41.narrow(orb. 4.the_POAManager().*.*.PortableServer. POA rootpoa = POAHelper. ORB orb = ORB. Definição da Classe “HelloServer. 10. 14.CORBA. implementa org. 29. import org. 5. public class HelloServer { 31.java . class HelloImpl extends HelloPOA { 12. } 27. try{ 34. orb.Esta interface contém o método sayHello() e shutdown().Properties. } 17. 11.omg. 16. null).java 2.omg.setORB(orb). public void shutdown() { 25.init(args.Streamable.NamingContextPackage. 26. public String sayHello() { 20. 18.activate().shutdown(false).omg. HelloImpl helloImpl = new HelloImpl(). // Criação e inicialização do ORB 35.omg.*. import org.*. private ORB orb. 23. 45. } 22. 21.

narrow(objRef).Object objRef = 17. 71. 65. NamingContextExt ncRef = NamingContextExtHelper.Object ref = rootpoa. 61.omg.").init(args. 53. 19. 54.CORBA.Object objRef = 50.println("Obtained a handle on server object: " + helloImpl). import org. System. try{ 13. catch (Exception e) { 66. orb. 6. 56.println("HelloServer ready and waiting . // Aguarda a invocação de clientes 62. org. 49. 57.CORBA. 10. orb. } 74. ncRef.narrow(ncRef. NamingContextExt ncRef = NamingContextExtHelper. } 64. // Especifica uma referência de objeto 55. 60. 15.. 3. helloImpl = HelloHelper.NamingContextPackage.out.out. import org. e. 51. public static void main(String args[]) 11. import HelloApp. 4.resolve_str(name)). 20. // Especifica o servidor de nomes(INS) 52. 9.err.println("ERROR: " + e). 21. NameComponent path[] = ncRef.servant_to_reference(helloImpl).*. } 69. 72.CosNaming. System. 23. public class HelloClient 7. Hello href = HelloHelper.out). org. Fabio Lopes Licht Fev/2002 . org.omg.resolve_initial_references("NameService").printStackTrace(System.omg.. null). 59. 2. 48.rebind(path.resolve_initial_references("NameService").*. import org.narrow(ref). 16. System.. { 8.omg.*. 63. String name = "Hello".omg. String name = "Hello". // Cria e inicializa o ORB 14. 47. static Hello helloImpl. { 12.out.to_name( name ).println("HelloServer Exiting .omg. System. 58."). orb.CosNaming. ORB orb = ORB.*. 5.CORBA. href). 70.run()..Tutorial Corba 4 46.java” 1.CORBA. 67. Definição da Classe “HelloClient.narrow(objRef). 68. } 73. 22. 18.

} 32.java tnameserv -ORBInitialPort 1050& Fabio Lopes Licht Fev/2002 . 26. helloImpl. System.idl javac *.idl javac *. 27.out).Tutorial Corba 5 24.java HelloApp/*.println("ERROR : " + e) .out. 30.shutdown().println(helloImpl.java tnameserv -ORBInitialPort 1050 start java HelloServer -ORBInitialPort 1050 A partir da máquina cliente java HelloClient -ORBInitialPort 1050 -ORBInitialHost <IP_do_servidor> Linux (Na janela do editor) Na máquina Servidor idlj -fall Hello. e o cliente em máquinas diferentes: Windows (no prompt do DOS) Na máquina Servidor idlj -fall Hello.java HelloApp/*. 29.java tnameserv -ORBInitialPort 1050 start java HelloServer -ORBInitialPort 1050 java HelloClient -ORBInitialPort 1050 Linux (Na janela do editor) idlj -fall Hello. e. } Compilando e executando o Exemplo: Para se executar o exemplo acima. } 31.sayHello()).idl javac *. algumas tarefas deverão ser cumpridas “exatamente” da maneira como for especificado adiante: Windows (no prompt do DOS) idlj -fall Hello. 25. System.printStackTrace(System.idl javac *.out.java HelloApp/*.java HelloApp/*. 33.java tnameserv -ORBInitialPort 1050& java HelloServer -ORBInitialPort 1050& java HelloClient -ORBInitialPort 1050& Para executar o servidor. } catch (Exception e) { 28.

omg. public class PersistentServer { 15. 12. "localhost" ). // PersistentServer. import org. import org. A sintaxe utilizada para a IDL. import org.omg.omg. 22. é que no anterior o servidor fica rodando na máquina mesmo quando não está sendo invocado.CosNaming. está ocupando memória desnecessariamente.omg. ORB orb = ORB. import org.*. 19.Policy. 4. import org. 13.idl” 1. properties.CosNaming. 6. 4.Properties.ORBInitialHost". // Copyright and License 3. é registrado em um servidor de nomes (servertool) que é uma ferramenta de registro de servidores.omg.CORBA. 10. 23. 11. import org.CosNaming.CORBA.ORBInitialPort".omg.java” 1. A diferença entre o exemplo mostrado anteriormente (Transiente) e o que vou mostrar agora (Persistente). enquanto que o “Hello Wolrd Persistente”. }. 6.getProperties(). 18. 5. é similar à utilizada em C++.PortableServer. interface Hello { 3.PortableServer. 8.init(args. // Step 1: Instantiate the ORB 25. import org.ORB. public static void main( String args[] ) { 17. string sayHello( ).PortableServer. 16. Fabio Lopes Licht Fev/2002 .java 2.NamingContextExt. que possibilita aos clientes localizar o objeto servidor e invocá-lo somente na hora em que for necessário. Definição da Classe “PersistentServer. import org. import java.CORBA. “PersistentHello. import org.put( "org. 7.Servant. try { 24.util. properties. 20. oneway void shutdown().omg. module Persistent { 2.CORBA.NameComponent.CORBA.Tutorial Corba 6 start java HelloServer -ORBInitialPort 1050& A partir da máquina cliente java HelloClient -ORBInitialPort 1050 -ORBInitialHost <IP_do_servidor>& “Hello World” Persistente. 9.Object. 21.omg.omg. Properties properties = System. "1050" ). }.put( "org. 14. 26. 5. a memória fica livre para ser usada por outros aplicativos. com isso.omg. e desta maneira. Definição de uma interface.NamingContextExtHelper.POA.omg. properties).

org. // 'NameService' as the key for resolve_initial_references() when 56. 59.narrow( obj ). 45.create_lifespan_policy( 37. 38. 70. persistentPolicy ).CORBA. // Step 2: Instantiate the servant 28. LifespanPolicyValue. 63. POA rootPOA = POAHelper. System. // Step 6: We are ready to receive client requests 67. Even if ORBD is restarted the Name 54. orb. POA persistentPOA = rootPOA. // Step 5: Resolve RootNaming context and bind a name for the 51.the_POAManager().omg. // servant. // will be in the 'HOLD' state. // Step 3 : Create a POA with Persistent Policy 31.PERSISTENT).resolve_initial_references("RootPOA")). // Step 3-3: Create a POA by passing the Persistent Policy 39. PersistentHelloServant servant = new PersistentHelloServant(orb). 47. } catch ( Exception e ) { 69. 60. // Step 3-1: Get the rootPOA 33. // Bindings will be intact.resolve_initial_references( 58. 65. "NameService" ).run(). } Definição da Classe “PersistentHelloServant. rootContext. 44. persistentPOA. 36. 49.servant_to_reference( 64.rebind( nc. // ******************* 32. servant ) ). // *********************** 46. 66. 50. 57.to_name( 62. 30. NamingContextExt rootContext = NamingContextExtHelper. } 71.create_POA("childPOA".activate_object( servant ).narrow(orb. 68. } 72. Policy[] persistentPolicy = new Policy[1].println( "Exception in Persistent Server Startup " + e ).java” Fabio Lopes Licht Fev/2002 . "PersistentServerTutorial" ). // NOTE: If the Server is persistent in nature then using Persistent 53. // Name Service is a good choice. persistentPOA. persistentPOA. Without this 42. // All calls to Persistent Server will hang because POAManager 43.Object obj = orb. // Step 3-2: Create the Persistent Policy 35. 41. 52. NameComponent[] nc = rootContext.err. persistentPolicy[0] = rootPOA. // ORBD is running. null. To use Persistent Name Service use 55. 34.activate( ). // Step 3-4: Activate PersistentPOA's POAManager. 40. 61.Tutorial Corba 7 27. // Step 4: Associate the servant with PersistentPOA 48. 29.

PortableServer. // 'PersistentServerTutorial' from that NameService 24.ORB. Fabio Lopes Licht Fev/2002 . 11. import org. import java. import org. */ 23. // localhost and listening on 1050 and resolve 23. 8. } 18.NameComponent. 10. 19. /** 13. 26.NamingContext. public class PersistentClient { 13.OBJ_ADAPTER. 27. 14.narrow( obj ). 22.shutdown( false ). org.util.Tutorial Corba 8 1. * See NOTE below. 25. public void shutdown( ) { 24. 5. 19.CORBA. private ORB orb. */ 15.CORBA. // Step 2: Resolve the PersistentHelloServant by using INS's 21. orb. null).string_to_object( 25.. import Persistent. // corbaname url. 8. try { 17. // PersistentHelloServant.java 2.Hello. 20. public String sayHello( ) { 16. } 11.omg. import Persistent.omg.omg.POA. // Step 1: Instantiate the ORB 18. } Definição da Classe “PersistentClient. 16.CosNaming. 6. * sayHello() method implementation returns a simple message.java” 1. return "Hello From Persistent Server. 5. 7. 3. public class PersistentHelloServant extends Persistent.orb = orb.omg. 17. Hello hello = HelloHelper. 14. import org.. /** 20. this.CosNaming.omg.init(args. // Copyright and License 3. public PersistentHelloServant( ORB orb ) { 9. 7.HelloHelper.CORBA.".Properties. import org. import org. * shutdown() method shuts down the Persistent Server. The URL locates the NameService running on 22.HelloPOA { 6. 9.CORBA. public static void main(String args[]) { 15. 12. import org. } 26.CosNaming. 21. "corbaname::localhost:1050#PersistentServerTutorial"). ORB orb = ORB.omg.Object obj = orb. 4.omg.ORB. 10. 2. 12. 4.NamingContextHelper.omg. import org.

} catch ( Exception e ) { 42. 35. 31.java HelloApp/*. } 46.idl javac *. // the server. Thread.out..Tutorial Corba 9 28. 37. System. 38. System..java HelloApp/*.out. } 45. 43. PersistentClient -ORBInitialPort 1050 -ORBInitialHost <host_servidor> Servertool Fabio Lopes Licht Fev/2002 . helloFromServer ). String helloFromServer = hello." + e ).. 32. e.out.println( "Calling Persistent Server. System.println( "Exception in PersistentClient. // Step 3: Call the sayHello() method every 60 seconds and shutdown 30.sleep( 60000 ). algumas tarefas deverão ser cumpridas “exatamente” da maneira como for especificado adiante: Windows (no prompt do DOS) idlj -fall -td . para se executar o exemplo acima. hello..java start orbd -ORBInitialPort 1050 -ORBInitialHost localhost java -classpath . -verbose PersistentHello. 40. -verbose PersistentHello.err.shutdown( ). // because it is persistent in nature. e o cliente em máquinas diferentes: Windows (no prompt do DOS) idlj -fall -td . System. 29.idl javac *. 39. Next call from the client will restart the server." )." ).printStackTrace( ).println( "Shutting down Persistent Server. } 41.java.println("Message From Persistent Server: " + 36. } Compilando e executando o Exemplo: Assim como no exemplo “Hello World Transiente”. 44.sayHello(). 34.java start orbd -ORBInitialPort 1050 -serverPollingTime 200 start servertool -ORBInitialPort 1050 Na janela do servertool que se inicializará: register -server PersistentServer -applicationName S1 -classpath <localização_da_classe_Servidor> No prompt do DOS java -classpath . PersistentClient Para executar o servidor. while( true ) { 33.

48 mb. desregistrar. -J-Xms48m atribui à memória do startup. COMANDOS register -server <Nome_da_Classe_Servidor> -classpath <localização_do_servidor(path)> -applicationName <Nome_da_Aplicação> -args <Argumentos_do_Servidor> -vmargs <Argumentos_Máquina_Virtual_Java> ] Registra um novo servidor persistente com o ORBD. locate -serverid <id_do_servidor > | -applicationName <nome_da_aplicação> [- endpointType <endpointType> ] Localiza os endpoints (portas) de um tipo específico. -Joption Passe opção à Máquina Virtual Java. startar. onde option é uma das opções descritas na página de referência do java application launcher na página da sun http://java. e desligar um servidor persistente. Fabio Lopes Licht Fev/2002 . Por Exemplo. getserverid -applicationName <nome_da_aplicação> Retorna a id de servidor correspondente.Tutorial Corba 10 É uma ferramenta de Java para registro de servidores IDL servertool fornece uma linha de comando aos programadores de aplicação para registrar. listappnames Lista a aplicação especifica de todos servidores que estão executando e registrados com o ORBD. listactive Lista informações sobre todos os servidores persistentes que têm sido lançados pelo ORBD e estão sendo executados. Se orbd e servertool estão rodando em máquinas diferentes. Se um servidor não estiver sendo executado.sun. para todos os ORBs criados por um servidor registrado. O default do host_servidor é localhost se esta opção não for especificada. isto o ativa. Isto é uma convenção comum para -J.com . você deve especificar o nome ou IP do servidor em que orbd está sendo executado. Sinopse servertool -ORBInitialPort <Nº_da_porta>(maior que 1024) <OPÇÕES> <COMANDOS> OPÇÕES -ORBInitialHost <host_servidor> Especifica a máquina onde a “classe servidor” está sendo executada. list Lista informações sobre todos os servidores persistentes registrados com o ORBD. unregister -serverid <id_do_servidor > | -applicationName <nome_da_aplicação> Desregistra um servidor do ORBD podendo ser utilizado de duas formas com o identificador do servidor ou pelo nome da aplicação.

então isto o ativa. OUTRAS OPÇÕES . help Lista todos os comandos disponíveis ao servidor através da ferramenta servertool. Sinopse Orbd<OPÇÕES> OPÇÃO REQUERIDA -ORBInitialPort <Nº_da_porta>(maior que 1024) Especifica a porta em que o servidor de nomes será executado. este comando lança o servidor. shutdown -serverid <id_do_servidor> | -applicationName <nome_da_aplicação> Desativa um servidor ativo que é registrado com o ORBD. Se o servidor está sendo executado. Se o servidor não está sendo executado. Uma vez iniciado. quit Sai da ferramenta servertool. orbd escutará as solicitações que entrarem nesta porta. é um comando que é utilizado para habilitar clientes afim de localizar e invocar objetos persistentes em servidores no ambiente CORBA.port <porta> Fabio Lopes Licht Fev/2002 . ORBD Orbd. startup -serverid <id_do_servidor> | -applicationName <nome_da_aplicação> Ativa um servidor que é registrado com o ORBD.Tutorial Corba 11 locateperorb -serverid <id_do_servidor> | -applicationName <nome_da_aplicação> [- orbid <Nome_ORB> ] Localiza todos os endpoints (portas) registradas por um ORB específico registrado. uma mensagem de erro é retornada ao usuário. Se um servidor não estiver sendo executado. orblist -serverid <id_do_servidor> | -applicationName <nome_da_aplicação> Lista o ORB_id dos ORBs definidos em um servidor.

org . Bibliografia http://www./orb.db é criado. O valor de default é 1. Fabio Lopes Licht Fev/2002 . onde option é uma das opções descritas na página de referência do java application launcher na página da sun http://java. Isto é uma convenção comum para -J. -defaultdb <diretório> Especifica onde o diretório ORBD de armazenamento persistente orb. O valor de default para esta porta é 1049. -serverPollingTime milisegundos Especifica quantas vezes o ORBD checa a “saúde” dos servidores persistentes registrados via servertool. deve ser um inteiro positivo válido. o valor default é ".com . -serverStartupDelay milisegundos Especifica quanto tempo ORBD espera antes de enviar uma localização.db". Se esta opção não for especificada.Tutorial Corba 12 Especifica a porta de ativação onde ORBD deverá iniciar. deve ser um inteiro positivo válido. -J- Xms48m atribui à memória do startup.omg. depois que um servidor persistente registrado via servertool é reiniciado. O valor default é 1.sun. 48 mb.000 e o valor especificado em milisegundos. Excelente fonte de consulta sobre Corba para iniciantes.Site da OMG (Object Management Group). Por Exemplo. -Joption Passe esta opção à Máquina Virtual Java.000 e o valor especificado em milisegundos. e onde o ORBD aceita solicitações para objetos persistentes.