API Java do SCS Tecgraf PUC-Rio maio de 2011. A API do SCS A API fica encapsulada em uma classe chamada ComponentBuilder, utilizada para “montar” um componente.

Apresentação em tema: "API Java do SCS Tecgraf PUC-Rio maio de 2011. A API do SCS A API fica encapsulada em uma classe chamada ComponentBuilder, utilizada para “montar” um componente."— Transcrição da apresentação:

1 API Java do SCS Tecgraf PUC-Rio maio de 2011

2 A API do SCS A API fica encapsulada em uma classe chamada ComponentBuilder, utilizada para “montar” um componente Definindo suas facetas, receptáculos e ComponentId Um componente SCS-Java é representado por uma interface Java ComponentContext Existem classes auxiliares

3 Criação de um Componente São necessários alguns passos: 1.Implementar suas facetas 2.Descrever as facetas 3.Descrever os receptáculos 4.Utilizar a API para instanciar e montar o componente

4 Implementação de uma Faceta

5 Criação de Facetas Uma faceta SCS nada mais é do que uma implementação de uma interface CORBA O SCS adiciona algumas convenções, mas a implementação da interface se dá da mesma forma Por herança ou delegação public class MyFacetServant extends MyFacetPOA { }

6 Criação de Facetas A API do SCS se responsabiliza por instanciar as facetas Devido a isso, é necessária a definição de um construtor obrigatório, que recebe uma referência ao componente ao qual a faceta pertence É possível não utilizar essa facilidade, o que elimina a necessidade desse construtor public class MyFacetServant extends MyFacetPOA { private ComponentContext context; public MyFacetServant(ComponentContext context) { this.context = context; }

7 Criação de Facetas Método _get_component() –Inicialmente criado para o CCM e CORBA 3.0 –Presente na especificação de CORBA 2.3.x Suportado em Java pelo JacORB mas não pelo ORB da Sun –Fornece a interface mais básica de um componente, a partir de qualquer outra de suas interfaces. Isso geralmente permite obter uma interface que acesse outras interfaces No SCS, a interface mais básica é a IComponent, da qual pode-se obter as outras facetas do componente

8 Criação de Facetas Definição do método _get_component() –Basta retornar o resultado do método auxiliar getIComponent existente na interface ComponentContext –Opcional, mas uma mensagem de aviso será impressa caso o método não seja implementado –Possibilidade do método ser adicionado automaticamente no futuro Desistimos da idéia por enquanto pois estamos investigando outras soluções para versões futuras do SCS //@Override public org.omg.CORBA.Object _get_component() { return context.getIComponent(); }

9 Criação de Facetas Exemplo de faceta completa public class MyFacetServant extends MyFacetPOA { private ComponentContext context; public MyFacetServant(ComponentContext context) { this.context = context; } //@Override public org.omg.CORBA.Object _get_component() { return context.getIComponent(); }... }

10 Descrição das Facetas de um Componente

11 Descrição de Facetas Facetas são normalmente descritas por FacetDescriptions, mas na API Java as descrevemos através da classe ExtendedFacetDescription Dessa forma fornecemos apenas metadados, o que traz algumas vantagens: A API torna-se capaz de instanciar as facetas para o usuário É possível externalizar a definição da faceta, permitindo mudanças tanto na faceta como no componente sem a recompilação de código

12 Descrição de Facetas Classe ExtendedFacetDescription –Similar à FacetDescription –Utilizada quando se deseja instanciar um componente utilizando somente metadados –Adiciona o campo class, que indica qual classe deve ser instanciada como a faceta –Não pede o campo obj_ref –Mantém os campos name e interface_name –Não estende FacetDescription porque essa é uma classe Java gerada pelo compilador IDL como final

13 Descrição de Facetas Definição dos metadados de facetas ExtendedFacetDescription[] extDescs = new ExtendedFacetDescription[1]; ExtendedFacetDescription extDesc = new ExtendedFacetDescription( MyFacetServant.class.getSimpleName(), MyFacetHelper.id(), MyFacetServant.class.getCanonicalName()); extDescs[0] = extDesc;

14 Descrição dos Receptáculos de um Componente

15 Descrição de Receptáculos Receptáculos são descritos por ReceptacleDescriptions Essa classe já é naturalmente composta apenas por metadados É possível externalizar a definição do receptáculo, permitindo mudanças tanto no receptáculo como no componente sem a recompilação de código Atualmente não é possível fornecer uma classe própria para representar um receptáculo A classe Receptacle é sempre instanciada automaticamente, pela API

16 Descrição de Receptáculos Classe Receptacle –Implementação base de um receptáculo Nessa versão não há suporte para uma implementação do usuário –Objeto apenas local

17 Descrição de Facetas Definição dos metadados de receptáculos O terceiro parâmetro é o campo is_multiplex O quarto parâmetro, o conjunto de conexões connections, será ignorado. Portanto, pode-se passar null ReceptacleDescription[] recDescriptions = new ReceptacleDescription[1]; recDescriptions[0] = new ReceptacleDescription (“MyReceptacle", ExpectedFacetHelper.id(), true, null);

18 Uso da API para Instanciar e Montar um Componente

19 Criação do ComponentId Definição do ComponentId Idêntico ao demonstrado na IDL ComponentId cpId = new ComponentId( “MyComponentName”, (byte) 1, (byte) 0, (byte) 0, “solaris10 linux26 windows” );

20 Uso da API Classe ComponentBuilder –API básica, responsável pela construção de um componente –Tem estado, composto pelo ORB e POA recebidos em seu único construtor ComponentBuilder(POA poa, ORB orb) ORB orb =...; POA poa =...; ComponentBuilder builder = new ComponentBuilder(poa, orb);

21 ComponentBuilder –Instancia um componente e suas facetas Método newComponent recebe: ‒ Descrições estendidas das facetas ‒ Descrições dos receptáculos ‒ Identificador do componente (ComponentId) Overload com versões simplificadas ComponentContext newComponent( ExtendedFacetDescription[] facetExtDescs, ReceptacleDescription[] receptacleDescs, ComponentId id, ComponentContext context)

22 ComponentBuilder –O método newComponent pode opcionalmente receber uma instância de uma classe que estenda ComponentContextImpl, fornecida pelo usuário. Essa instância será utilizada no lugar de uma instância padrão de ComponentContextImpl –Retorna um ComponentContext Facetas e receptáculos instanciados Mapas de metadados preenchidos Se não foram especificadas, as facetas básicas são adicionadas

23 Utilização da API –Exemplo deixando a criação do ComponentContext a cargo do ComponentBuilder –As descrições de receptáculos, nesse caso, são opcionais devido a um overload do método ComponentBuilder ComponentContext context = builder.newComponent( extDescs, receptDescs, cpId );

24 ComponentBuilder Utilização da API –Exemplo fornecendo o próprio ComponentContext –A implementação será uma do usuário, não a implementação padrão ComponentContextImpl ComponentContext context = new ComponentContextImpl(builder, cpId); builder.newComponent( extDescs, receptDescs, cpId, context );

25 ComponentBuilder –Outros métodos Map deactivateComponent (ComponentContext context) –Destrói os objetos CORBA e nulifica os facet_ref. Retorna um mapa com as facetas que não puderam ser desativadas e o erro associado static String componentIdToString(ComponentId compid) –Retorna uma versão em string de um identificador de componente POA getPOA() –Retorna o POA ao qual os objetos CORBA criados por este ComponentBuilder estão associados ORB getORB() –Retorna o ORB ao qual os objetos CORBA criados por este ComponentBuilder estão associados

26 O Componente

27 O Componente Java Interface ComponentContext –Atua como um envólucro que facilita o uso do componente como uma entidade única e não apenas um aglomerado de facetas e receptáculos Representação local do componente Acesso a todas as facetas (incluindo as básicas) e receptáculos Guarda os metadados, como descrições e identificador do componente (ComponentId)

28 Interface Java ComponentContext public abstract ComponentId getComponentId() –Retorna o identificador do componente public abstract Map getFacetDescs() –Retorna um mapa com todas as descrições de facetas public abstract Map getExtendedFacetDescs() –Retorna um mapa com todas as descrições estendidas de facetas public abstract Map getReceptacleDescs() –Retorna um mapa com todas as descrições de receptáculos

29 Interface Java ComponentContext public abstract Map getFacets() –Retorna um mapa com todos os objetos CORBA que implementam as facetas public abstract Map getReceptacles() –Retorna um mapa com todos os receptáculos (objetos JAVA, não CORBA!) public abstract ComponentBuilder getBuilder() –Retorna o construtor utilizado para criar o componente e seus objetos CORBA public abstract org.omg.CORBA.Object getIComponent() –Retorna o objeto CORBA da faceta IComponent

30 O Componente Java ComponentContextImpl –Implementação padrão para a interface Java ComponentContext –Pode ser estendida para adicionar outros dados de uso global no componente Dados acessados por mais de uma faceta Dados referentes ao componente em si, não a uma faceta específica Métodos

31 Como obter uma faceta a partir de outra? Como acessar uma faceta conectada a um receptáculo? Exemplos context.getReceptacles().get(“ReceptacleName”).ge tConnections() context.getFacets().get(“FacetName”) context.getReceptacleDescs().get(“ReceptacleName” ).connections context.getFacetDescs().get(“FacetName”).facet_ref

32 Outras Funcionalidades

33 ComponentBuilder É possível fornecer facetas já instanciadas ‒ Descrições das facetas (incluem o servant) ‒ Descrições dos receptáculos ‒ Identificador do componente (ComponentId) ‒ Vantagens Total controle sobre a criação das facetas, como seus construtores Possibilidade de utilizar o mesmo objeto Java para implementar várias facetas (objeto monolítico) ‒ Desvantagens Maior amarração na definição do componente Programador fica responsável por acesso das facetas ao seu contexto ComponentContext newComponent( FacetDescription[] facetDescs, ReceptacleDescription[] receptacleDescs, ComponentId id, ComponentContext context)

34 Criação de FacetDescriptions –Caso utilize FacetDescription (fornecendo as implementações de facetas) ComponentContext context = new ComponentContextImpl(builder, cpId); FacetDescription[] facetDescs = new FacetDescription[1]; FacetDescription facetDesc = new FacetDescription( MyFacetServant.class.getSimpleName(), MyFacetHelper.id(), new MyFacetServant(...)); facetDescs[0] = facetDesc;

35 Aplicação Exemplo

36 Exemplo passo-a-passo Veremos um exemplo, passo-a-passo, de desenvolvimento de uma aplicação SCS usando Java Para desenvolver a aplicação, usaremos o JacORB como ORB tanto para o cliente quanto para o servidor, e as bibliotecas do SCS

37 Exemplo de Aplicação StockSeller StockServer Stock Exchange StockLogger ExchangePrinter O componente StockSeller implementa duas facetas: StockServer e StockExchange O componente StockSeller tem um receptáculo para componentes que implementem a faceta ExchangePrinter O componente StockLogger implementa a faceta ExchangePrinter

38 Passo 1: Alterando a IDL // StockMarket.idl // O módulo StockMarket consiste das definições // úteis para desenvolvimento de aplicações // que lidam com mercado de ações. module StockMarket {... // A interface ExchangePrinter é a interface que // representa uma impressora de negociações de ações. interface ExchangePrinter { // Imprime que houve uma negociação da ação indicada. // A saída utilizada para impressão não é especificada. // Exemplos de saídas: tela, arquivo, clients remotos. void print(in StockSymbol symbol); }; // A interface StockExchange é a interface que permite // a compra de ações. interface StockExchange { // Usa os componentes ExchangePrinter que estejam // conectados para imprimir a negociaçao efetuada. boolean buyStock(in StockSymbol symbol); };};

39 Passo 2: Implementando as facetas Precisaremos alterar a classe StockServerImpl para que ela se torne uma Faceta SCS Além disso, precisaremos implementar as facetas StockExchange e ExchangePrinter

40 Implementando uma faceta Facetas são interfaces CORBA e, portanto, sua implementação segue as mesmas regras que vimos nos exemplos de CORBA A implementação SCS-Java exige também que facetas implementem um construtor que receba um ComponentContext (Contexto de Componentes).

41 StockServerImpl /** * StockServerImpl implementa a interface IDL StockServer */ public class StockServerImpl extends StockServerPOA { /** * Construtor * @param context o contexto do componente dono da faceta. */ public StockServerImpl(ComponentContext context) { } /** * Retorna o valor corrente a determinada ação do mercado, dado o * símbolo que a representa. */ @Override public float getStockValue(String symbol) { } /** * Retorna a sequência com todos os símbolos que definem as ações * de mercado mantidas por esse StockServer. */ @Override public String[] getStockSymbols() { } /** * Obtém a faceta IComponent do componente. * @return a faceta IComponent */ public org.omg.CORBA.Object _get_component() { } }

42 StockExchangeImpl /** * StockExchangeImpl implementa a interface IDL StockExchange */ public class StockExchangeImpl extends StockExchangePOA { /** * Construtor * * @param context o contexto do componente dono da faceta. */ public StockExchangeImpl(ComponentContext context) { } /** * Quando uma ação é negociada, seu valor aumenta em uma taxa de 10%. * Usa os componentes StockLogger que estejam conectados para imprimir * a negociaçao efetuada. */ @Override public boolean buyStock(String symbol) { } /** * Obtém a faceta IComponent do componente. * * @return a faceta Icomponent */ public org.omg.CORBA.Object _get_component() { } }

43 DisplayExchangePrinter /** * DisplayExchangePrinterImpl implementa a interface IDL ExchangePrinter. * Essa implementação usa o display (console) para mostrar a negociação de * cada ação do mercado. */ public class DisplayExchangePrinterImpl extends ExchangePrinterPOA { /** * Construtor * * @param context o contexto do componente dono da faceta. */ public DisplayExchangePrinterImpl(ComponentContext context) { } /** * Imprime que houve uma negociação da ação indicada. A saída utilizada * para impressão não é especificada. Exemplos de saídas: tela, arquivo, * clients remotos. */ @Override public void print(String text) { } /** * Obtém a faceta IComponent do componente. * * @return a faceta Icomponent */ public org.omg.CORBA.Object _get_component() { } }

44 Passo 3: Criando o componente StockSeller O componente StockSeller oferece as facetas StockServer e StockExchange O componente StockSeller possui um receptáculo para conectar um ou mais compontes que implementem a faceta ExchangePrinter

45 Inicia o ORB e ativa o POA A inicialização do ORB e ativação do POA, ao iniciar o servidor, são iguais ao que já usamos nos exemplos anteriores. O servidor deve, após criar o componente, deixar o ORB aguardando as requisições /* * As propriedades que informam o uso do JacORB como ORB. */ Properties orbProps = new Properties(); orbProps.setProperty("org.omg.CORBA.ORBClass", "org.jacorb.orb.ORB"); orbProps.setProperty("org.omg.CORBA.ORBSingletonClass", "org.jacorb.orb.ORBSingleton"); /* Inicializa o ORB */ ORB orb = ORB.init(args, orbProps); /* Obtém a referência para o POA e inicializa o POA */ POA poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); poa.the_POAManager().activate();... orb.run();

46 Cria a descrição das facetas A classe ExtendedFacetDescription é usada para criar as descrições das facetas ExtendedFacetDescription[] facetDescriptions = new ExtendedFacetDescription[2]; facetDescriptions[0] = new ExtendedFacetDescription( "StockServer", StockServerHelper.id(), "StockMarket.StockServerImpl"); facetDescriptions[1] = new ExtendedFacetDescription("StockExchange", StockExchangeHelper.id(), "StockMarket.StockExchangeImpl");

47 Cria a descrição dos receptáculos A classe ReceptacleDescription é usada para criar as descrições dos receptáculos ReceptacleDescription[] recDescriptions = new ReceptacleDescription[1]; recDescriptions[0] = new ReceptacleDescription ("ExchangePrinter", ExchangePrinterHelper.id(), true, null);

48 Cria o identificador do componente Todo componente precisa ter um identificador, que é descrito usando a classe ComponentId ComponentId componentId = new ComponentId("StockSeller", (byte) 1, (byte) 0, (byte) 0, "Java");

49 Cria o componente com um ComponentBuilder A classe ComponentBuilder é usada para construir um componente a partir da descrição de suas facetas e receptáculos O método newComponent retorna o contexto ComponentContext do componente recém criado ComponentBuilder builder = new ComponentBuilder(poa, orb); ComponentContext context = builder.newComponent(facetDescriptions, recDescriptions, componentId);

50 Salva o IOR em um arquivo Nessa solução, ainda usaremos um arquivo para gravar a referência para o objeto CORBA Note que estamos usando a referência para um IComponent org.omg.CORBA.Object obj = context.getIComponent(); IComponent component = IComponentHelper.narrow(obj); PrintWriter ps = new PrintWriter(new FileOutputStream(new File(“seller.ior”))); ps.println(orb.object_to_string(component)); ps.close();

51 Passo 4: Criando o componente StockLogger O componente StockLogger oferece a faceta ExchangePrinter O código StockLoggerMain.java é responsável por criar o componente SCS StockLogger Em nosso exemplo, o código que o conecta ao componente StockSeller é uma aplicação separada A criação do componente StockLogger é similar ao que fizemos para criar o StockSeller, exceto que não há receptáculos

52 Passo 5: Recupera as referências dos componentes para conectá-los A referência para o componente StockSeller é lida do arquivo seller.ior A referência para o componente StockSeller é lida do arquivo logger.ior /* * Lê o IOR do componente StockSeller do arquivo seller.ior */ BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(“seller.ior”))); String ior_seller = reader.readLine(); /* * Lê o IOR do componente StockLogger do arquivo logger.ior * parâmetro 2. */ reader = new BufferedReader(new InputStreamReader(new FileInputStream(“logger.ior”))); String ior_logger = reader.readLine();

53 Obtém as facetas IReceptacles do StockSeller e ExchangePrinter do StockLogger Precisaremos da faceta ExchangePrinter do componente StockLogger, pois é essa faceta que será conectada ao receptáculo do StockSeller O componente tem métodos para recuperar suas facetas /* Obtém a referência para component StockSeller. */ org.omg.CORBA.Object obj = orb.string_to_object(ior_seller); IComponent stockSeller = IComponentHelper.narrow(obj); /* Obtém a referência para component StockLogger. */ obj = orb.string_to_object(ior_logger); IComponent stockLogger = IComponentHelper.narrow(obj); /* Obtém a referência para IReceptacles do StockSeller */ IReceptacles irStockSeller = IReceptaclesHelper.narrow(stockSeller.getFacet(IReceptaclesHelper.id())); /* Obtém a referência para ExchangePrinter do StockLogger */ ExchangePrinter printer = ExchangePrinterHelper.narrow(stockLogger.getFacet(ExchangePrinterHelper.id()));

54 Faz a conexão da faceta ExchangePrinter do StockLogger no receptáculo do StockSeller Usamos a faceta IReceptacles de StockSeller para fazer a conexão de componentes O método connect faz a conexão do componente StockLogger usando sua faceta ExchangePrinter /* * Faz a conexão do componente StockLogger nos receptáculos de * StockSeller. Note que a faceta ExchangePrinter do componente é usada * para a conexão. */ irStockSeller.connect("ExchangePrinter", printer);

55 Passo 6: Usando os componentes conectados ao receptáculo do StockSeller A implementação do método buyStock pela faceta StockExchange do componente StockSeller deve chamar o método print da faceta ExchangePrinter conectada a esse mesmo componte.

56 Obtém o receptáculo correspondente a ExchangePrinter O contexto do componente possui o método getReceptacles que retorna os receptáculos do componente A classe Receptacle permite então recuperar as conexões As descrições das conexões são recuperadas com o método getConnections de Receptacle O campo objref de ConnectionDescription possui a referência para a faceta do componente conectado public boolean buyStock(String symbol) { … Receptacle receptacle = context.getReceptacles().get("ExchangePrinter"); if (receptacle == null) { … } List connections = receptacle.getConnections(); for (ConnectionDescription connection : connections) { ExchangePrinter printer = ExchangePrinterHelper.narrow(connection.objref); printer.print("Ação " + symbol + " foi negociada"); }... }

57 Passo 7: Usando o componente StockSeller O cliente usa o componente StockSeller através de suas facetas O StockMarketClient.java possui a etapa de inicialização do ORB que já vimos nos exemplos anteriores O que muda é o uso das facetas do componente para invocar as funções

58 Obtendo a referência para o componente StockSeller O cliente recupera a referência para o componente StockSeller lendo do arquivo seller.ior /* * Lê o IOR do componente StockSeller do arquivo seller.ior * parâmetro. */ BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(“seller.ior”))); String ior_seller = reader.readLine(); /* Obtém a referência para component StockSeller. */ org.omg.CORBA.Object ior = orb.string_to_object(ior_seller); IComponent stockSeller = IComponentHelper.narrow(ior);

59 Obtendos as facetas StockServer e StockExchange do componente StockSeller Tendo o componente, as facetas StockServer e StockExchange são recuperadas, pelo nome ou pela interface /* Obtém a faceta StockServer */ org.omg.CORBA.Object obj = stockSeller.getFacetByName("StockServer"); StockServer stockServerFacet = StockServerHelper.narrow(obj); /* Obtém a faceta StockExchange */ obj = stockSeller.getFacetByName("StockExchange"); StockExchange stockExchangeFacet = StockExchangeHelper.narrow(obj);

60 Invocando as funções disponibilizadas em cada faceta O cliente faz as chamadas aos métodos usando as respectivas facetas /* Obtém os símbolos de todos as ações. */ String[] stockSymbols = stockServerFacet.getStockSymbols(); /* Mostra as ações de mercado com seus respectivos valores */ for (int i = 0; i < stockSymbols.length; i++) { System.out.println(stockSymbols[i] + " " + stockServerFacet.getStockValue(stockSymbols[i])); } if (stockSymbols.length > 0) { String first = stockSymbols[0]; System.out.println("--Compra a ação :" + first); boolean success = stockExchangeFacet.buyStock(first); if (success) { System.out.println("--Ação " + first + " depois da negociação: " + stockServerFacet.getStockValue(first)); } else { System.out.println("--Não foi possivel negociar a ação " + first); }