Tecnologia IBM na linha de frente dos Mercados Financeiros, Parte 2: Invoque regras de negócios condicionais com base na análise de fluxos de dados

Integrando IBM InfoSphere Streams e IBM WebSphere ILOG JRules

Este artigo, que é o segundo da série, trata da integração do InfoSphere™ Streams ao WebSphere® ILOG® JRules. InfoSphere Streams é um mecanismo de processamento de fluxos de alto desempenho que faz cálculos e análises de fluxos de dados em tempo real. ILOG JRules é um sistema de gerenciamento de regras de negócios que possibilita a criação de aplicativos baseados em regras. Este artigo apresenta um cenário simples de trading algorítmico no qual o InfoSphere Streams opera em um fluxo de dados do mercado e, sob determinadas circunstâncias, uma regra de negócios é invocada usando o ILOG JRules. Para executar essa tarefa, você aprenderá a integrar os dois produtos de forma eficiente.

Nick Schofield, Software Developer, IBM

Photo of Nick SchofieldNick Schofield é desenvolvedor de software e trabalha na IBM Software Services para a organização WebSphere, no IBM Software Development Lab de Toronto, Ontário. Trabalhou em diversos projetos, tais como teste/ajuste de desempenho, desenvolvimento de aplicativos e integração de produtos.



Mary Taylor, Senior IT Architect, IBM

Author Photo: Mary TaylorMary está na IBM há mais de 25 anos. Ela ocupou várias posições, incluindo programadora, engenheira de sistemas, líder de projetos, DBA e especialista em qualidade de dados. Ela está na Estratégia Técnica SWG nos últimos quatro anos. Grande parte desse tempo esteve dedicada ao Software como um Serviço. Agora, ela administra o Programa de Incubação SWG. Nos últimos 18 anos, ela liderou um projeto chamado Botticelli, que está focado no posicionamento do middleware IBM na linha de frente dos mercados financeiros.



27/Ago/2010

Introdução

Este artigo é o segundo de uma série que mostra como os recursos do middleware IBM podem ser integrados para preencher os requisitos técnicos da linha de frente dos mercados financeiros. Os requisitos da linha de frente exigem um software especializado com capacidade de tratar grandes volumes de dados em velocidades extremamente altas. Esta série de artigos descreve um cenário de trading algorítmico que foi implementado como parte de um projeto de incubação do IBM Software Group.

InfoSphere Streams

O InfoSphere Streams (Streams) é um ambiente de desenvolvimento de aplicativos e tempo de execução que permite criar aplicativos que operam em fluxos de dados de produção em tempo real. Os aplicativos de Streams são definidos em uma linguagem de processamento de fluxo de alto nível. Cada aplicativo de Streams é uma série de operadores que executam uma função ou cálculo nos dados que fluem por ele. Em seguida, esses operadores são encadeados para executar funções complexas. Estão incluídos vários operadores que executam funções, como agregação, junção e divisão de dados e funções complexas. O Streams também permite criar operadores personalizados para executar instruções específicas. Esses operadores personalizados podem ser codificados em Java ou C++ e são denominados user-defined operators (UDOPs). Este artigo mostra como criar um UDOP de Java para integrar ao ILOG JRules.

WebSphere ILOG JRules

ILOG JRules (JRules) é um business rules management system (BRMS) que permite projetar, desenvolver e implementar regras de negócios que são acessíveis a partir de sistemas ou aplicativos externos. As regras de negócios são desenvolvidas por meio do ambiente de desenvolvimento Rule Studio ou do aplicativo da Web Rule Team Server (RTS). Em seguida, as regras são implementadas no Rule Execution Server (RES). Os aplicativos podem se conectar ao RES e fazer com que as regras executem no servidor ou adquirir as regras e executá-las localmente. O cenário deste artigo faz com que o UDOP de Java do Streams adquira as regras e os execute localmente por questões de desempenho.

Pré-requisitos

Para concluir este exemplo de cenário, é necessário ter os seguintes componentes de software instalados:

  • ILOG Rule Studio Development Environment
  • ILOG Rule Team Server
  • ILOG Rule Execution Server
  • InfoSphere Streams

Sobre o cenário

Este artigo descreve um exemplo de cenário no qual JRules e Streams devem funcionar em conjunto. É possível seguir o cenário para fazê-lo funcionar no seu ambiente.

O cenário começa com um aplicativo de Streams que recebe negociações e cotações de ações. Em seguida, você fará alguns cálculos simples com esses dados do mercado para gerar um valor chamado índice de bom negócio. Se esse valor é superior a um determinado limiar, você faz o pedido dessa ação automaticamente. Para se certificar de que você não irá fazer pedidos altos sem aprovação, você modificará o aplicativo Streams para que roteie os pedidos altos primeiramente para o JRules. Em seguida, o JRules decide se o pedido passa automaticamente ou não.


Criando regras de negócios com o ILOG Rule Studio Development Environment

Siga estas etapas para criar regras de negócios com o ILOG Rule Studio Development Environment.

Crie o XOM

A primeira coisa a fazer ao criar um aplicativo do JRules é definir o execution object model (XOM). O XOM define a entrada e saída das chamadas que você faz ao JRules. Para o cenário, você usa objetos simples de Java® (POJOs) como interface. Também é possível usar um esquema XML para definir o XOM.

Siga estas etapas para criar o XOM e abrir o Rule Studio por meio de POJOs:

  1. Crie um novo projeto Java ao inserir OrderDecision-XOM como nome do projeto, como mostra a Figura 1, e clique em Next.
    Figura 1. Criação do projeto OrderDecision-XOM
    Criação do projeto OrderDecision-XOM
  2. Crie uma nova classe Java no pacote com.ibm.orderdecision ao inserir OrderDecision no campo Name, como mostra a Figura 2.
    Figura 2. Classe Java OrderDecision
    Classe Java OrderDecision
  3. Adicione os seguintes campos no campo Interfaces da classe OrderDecision e clique em Finish.
    • private Boolean canContinue;
    • private String symbol;
    • private Double price;
    • private Double qty;
  4. Crie os métodos getter e setter para os quatro campos seguindo o método mostrado na Listagem 1 referente ao campo de símbolo.
Listagem 1. Crie os métodos getter e setter
	    public String getSymbol() {
	        return symbol;
	    }
	    public void setSymbol(String symbol) {
	        this.symbol = symbol;
	    }

O campo canContinue contém o resultado da execução da regra e identifica se o pedido é uma exceção ou não. O valor de canContinue é 0 quando o pedido é uma exceção. Símbolo, preço e quantidade são passados ao ILOG a partir dos dados do mercado que são processados pelo programa Streams.

Crie as regras

Siga estas etapas para criar as regras de negócios efetivas que serão executadas:

  1. Crie um novo projeto de regra padrão inserindo OrderDecisionRules como nome do projeto na janela New Rule Project, como mostra a Figura 3.
    Figura 3. Criação do projeto OrderDecisionRules
    Criação do projeto OrderDecisionRules
  2. Abra a visualização Rule Project Map e clique em Import XOM na entidade Design, como mostra a Figura 4.
    Figura 4. Importar o XOM
    Importar o XOM
  3. Selecione Java Execution Object Model.
  4. Selecione OrderDecision-XOMe clique em OK.
  5. Clique em Create BOM (Business Object Model) na entidade Design da visualização Rule Project Map. O BOM contém a conversão do código Java ou XML da entrada para o termo de negócios usado no mecanismo de regras, como mostra a Figura 5.
    Figura 5. Entidade Design - etapa 1
    Entidade Design - etapa 1
  6. Aceite os valores padrão na primeira página e certifique-se de que o pacote com.ibm.orderdecision esteja selecionado em Select classes na janela New BOM Entry, como mostra a Figura 6.
    Figura 6. Entrada de BOM
    Entrada de BOM
  7. Aceite os valores padrão da terceira página e clique em OK.
  8. Clique em Define Parameters na entidade Design, na visualização Rule Project Map, como mostra a Figura 7.
    Figura 7. Entidade Design - etapa 2
    Entidade Design - etapa 2
  9. Adicione os parâmetros de conjunto de regras mostrados na tabela 1.
Tabela 1. Parâmetros de conjunto de regras
Nome Tipo Direção Valor-padrão Verbalização
symboljava.lang.StringINsymbol
pricedoubleINprice
qtydoubleINquantity
canContinueBooleanOUTfalsecan continue
  1. Clique em Add Rule Package na entidade Orchestrate.
  2. Clique emAdd rule package para adicionar os parâmetros do conjunto de regras, como mostra a Figura 8.
    Figura 8. Entidade Orchestrate para adicionar o pacote de regras
    Entidade Orchestrate para adicionar o pacote de regras
  3. Dê ao pacote o nome com.ibm.orderdecision.
  4. Clique em Add Ruleflow na entidade Orchestrate, como mostra a Figura 9. O fluxo de regra é uma representação da lógica de negócios do aplicativo. Os fluxos de regras são usados para orquestrar a execução de regras agrupando as regras em uma série de tarefas.
    Figura 9. Entidade Orchestrate para adicionar um fluxo de regra
    Entidade Orchestrate para adicionar um fluxo de regra
  5. Defina as opções do fluxo de regra da seguinte forma:
    1. Insira /OrderDecisionRules/rules na pasta Source.
    2. Insira com.ibm.orderdecision em Package.
    3. Insira OrderDecisionRuleFlow em Name.
    4. Insira RuleFlow em Type.
    5. Clique em Finish.
  6. Clique em Add Business Rule na entidade Author, na visualização Rule Project Map, como mostra a Figura 10.
    Figura 10. Entidade Author para adicionar regras de negócios
    Entidade Author para adicionar regras de negócios
  7. Defina as propriedades de regras de negócios da seguinte forma:
    1. Insira /OrderDecisionRules/rules em Source folder.
    2. Insira com.ibm.orderdecision em Package.
    3. Insira Order Decision Rule em Name.
    4. Insira ActionRule em Type.
    5. Clique em Finish.
  8. Defina o código da regra como mostra a Listagem 2.
Listagem 2. Regra de decisão sobre o pedido
if
     price * quantity is less than 500 or symbol is "IBM"
then
     set 'can continue' to true;

Isso define o sinalizador canContinue como true para todos os pedidos da IBM e para os outros pedidos nos quais "preço x quantidade" é inferior a 500. Esses pedidos no Streams são pedidos de não-exceção (ou pedidos de processamento direto).

  1. Edite o OrderDecisionRuleFlow que você criou anteriormente.
  2. Insira um elemento inicial, um elemento final e um elemento de tarefa de regra na paleta e junte-os como mostra a Figura 11.
    Figura 11. Crie o diagrama do fluxo de regra
    Crie o diagrama do fluxo de regra
  3. Altere o ID em Rule Task para Order Decision.
  4. Adicione a regra com.ibm.orderdecision.Order Decision Rule à seção Rule Selection na guia Properties, como mostra a Figura 12.
    Figura 12. Atualize a seção de regras
    Atualize a seção de regras

Implementando as regras no Rule Team Server

Quando tiver um projeto de regras completo, publique-o no Rule Team Server (RTS). Com as regras no RTS, os usuários de negócios podem alterar os valores que você definiu. Por exemplo: se uma quantidade excessiva de pedidos for considerada como exceção, um usuário de negócios pode alterar o valor do limite de 500 para 1000.

Para implementar no RTS, siga estas etapas:

  1. Clique com o botão direito no projeto OrderDecisionRules no painel Rule Explorer à esquerda e clique em Rule Team Server > Connect.
  2. Insira as informações de conexão.
  3. Certifique-se de que Create a new project on Rule Team Server esteja selecionado e clique em Finish.

Pronto! Agora os usuários de negócios podem efetuar login no RTS e editar a regra que você acabou de publicar.

Publicando regras no Rule Execution Server

Para executar as regras, é preciso publicá-las do RTS para o Rule Execution Server (RES). O RES fornecer dois recursos:

  • Pode executar as regras remotamente e enviar a resposta de volta para o responsável pela chamada.
  • Pode usar o RES como repositório de regras.

Para o exemplo de cenário, você se conectará ao RES e adquirirá a versão mais recente das regras, mas as executará localmente — dentro do seu ambiente do InfoSphere Streams — para obter um desempenho máximo.

Crie um ruleapp

Um ruleapp é um formato de empacotamento usado para implementar regras no RES. Depois que você cria um conjunto de regras, ele é empacotado em um ruleapp e implementado em um ambiente de execução do RES. Siga estas etapas para criar um ruleapp:

  1. Efetue login no RTS e clique em Configure > Manage RuleApps.
  2. Clique em Newe insira o nome OrderDecisionRuleApp.
  3. Clique em New em Rulesets e dê o nome OrderDecisionRuleSet.
  4. Selecione o projeto OrderDecisionRules e clique em Save > Save para salvar o aplicativo de regra.

Publique o ruleapp

Siga estas etapas para publicar o ruleapp:

  1. Clique em Configure > Manage RuleApps.
  2. Selecione a caixa ao lado de OrderDecisionRuleAppe clique em Deploy.
  3. Desmarque a caixa ao lado de Create a baseline for this deploymente clique em Next.
  4. Selecione Deploy on a Rule Execution Servere clique em Next.
  5. Selecione Increment ruleset(s) major versione clique em Next.
  6. Selecione o servidor de execução a partir da lista e clique em Deploy.

Desenvolvendo e integrando aplicativos do Streams

Esta seção mostra como trabalhar com os aplicativos do Streams.

Visão geral do aplicativo

O exemplo de aplicativo do Streams fornecido em Downloads calcula o índice de bom negócio. A Figura 13 mostra uma visualização gráfica do aplicativo obtido a partir da ferramenta StreamSight, incluída no InfoSphere Streams.

Figura 13. Aplicativo do Streams
Aplicativo do Streams

Na Figura 13, os dados entram, provenientes do operador de origem à esquerda, e em seguida são divididos em dois fluxos. Um fluxo é para comercializações e o outro é para as cotações. Em seguida, o fluxo de comercialização é agregado e são feitas operações nele para calcular o volume weighted average price (VWAP). Em seguida, o VWAP é juntado ao fluxo de cotações e o índice de bom negócio é calculado. Finalmente, se o valor do índice de bom negócio é superior a um determinado limiar, gera-se um pedido.

Para o exemplo de cenário, você estenderá este aplicativo colocando um operador entre os dois últimos operadores à direita do gráfico. Esse operador chamará a regra do JRules que você já criou para determinar se a execução do pedido pode continuar.

Estendendo o aplicativo

Siga estas etapas para ampliar o aplicativo adicionando um operador JavaUdop.

  1. Extraia o aplicativo do Streams anexado (orderDecision_orig.tar.gz) para um diretório no seu computador, tal como um diretório chamado orderDecision_orig, inserindotar -xvzf orderDecision_orig.tar.gz.
  2. Crie um diretório no diretório recém-criado orderDecision_orig, chamado classpathe copie o jars como se mostra.
    • No diretório studio lib do ILOG:
      • asm-3.1.jar
      • asm-analysis-3.1.jar
      • asm-commons-3.1.jar
      • asm-tree-3.1.jar
      • asm-util-3.1.jar
      • bcel-5.1.jar
      • jdom-1.0.jar
      • jrules-engine.jar
      • sam.jar
    • No diretório java do db2:
      • db2jcc4.jar
    • No diretório executionserver lib do ILOG:
      • jrules-res-execution.jar
      • j2ee_connector-1_5-fr.jar
  3. Configure a conexão do JRules ao obter o arquivo ra.xml em Downloads.
  4. Coloque o arquivo no diretório de caminhos de classe.
  5. Edite o arquivo e insira o nome de usuário, senha e URL do banco de dados do RES do JRules referente à propriedade persistenceProperties.
  6. Adicione os dois operadores mostrados na Listagem 3 logo antes do operador sink ao final do arquivo vwap.dps para adicionar o UDOP de Java ao aplicativo do Streams. O arquivo vwap.dps contém o aplicativo do Streams mostrado na Figura13.
Listagem 3. UDOPs de Java para dividir o fluxo de pedido
	    stream OrdersNotToVerify(schemaFor(Orders))
		:= Functor(Orders)
		     [price * qty <= 200d]
		     {}	

	    stream OrdersToVerify(schemaFor(Orders))
		:= Functor(Orders)
		     [price * qty > 200d]
		     {}

Esses operadores dividem o fluxo de pedidos em dois fluxos separados. Um fluxo contém os pedidos que são suficientemente baixos para dispensar a verificação. O JRules precisa verificar o outro fluxo.

  1. Adicione os operadores na Listagem 4 depois do operador OrdersToVerify para adicionar a chamada ao mecanismo do JRules.
Listagem 4. Atualizações para o operador OrdersToVerify
	    stream CheckedOrders(schemaFor(Orders), canContinue: Boolean)
	     := JavaUdop(OrdersToVerify)
	     [generated;
	     className:"com.ibm.orderchecker.OrderDecision";
	     classLibrary:
	     "../orderDecision_orig/classpath/asm-3.1.jar",
	     "../orderDecision_orig/classpath/asm-analysis-3.1.jar",
	     "../orderDecision_orig/classpath/asm-commons-3.1.jar",
	     "../orderDecision_orig/classpath/asm-tree-3.1.jar",
	     "../orderDecision_orig/classpath/asm-util-3.1.jar",
	     "../orderDecision_orig/classpath/bcel-5.1.jar",
	     "../orderDecision_orig/classpath/j2ee_connector-1_5-fr.jar",
	     "../orderDecision_orig/classpath/jdom-1.0.jar",
	     "../orderDecision_orig/classpath/jrules-engine.jar",
	     "../orderDecision_orig/classpath/jrules-res-execution.jar",
	     "../orderDecision_orig/classpath/sam.jar",
	     "../orderDecision_orig/classpath/db2jcc4.jar",
	     "../orderDecision_orig/classpath",
	     "../orderDecision_orig/bin";
 	     vmArg:"-Xmx512m"] {}
  1. Modifique os caminhos referentes ao diretório do caminho de classe no parâmetro classLibrary para o caminho que você criou acima.
  2. Depois da chamada a JRules, é necessário filtrar todos os pedidos que não são aprovados na verificação e modificar o operador Sink para imprimir os pedidos verificados e também os que não foram verificados. Faça isso substituindo o operador Sink ao final do arquivo com o código na Listagem 5.
Listagem 5. Modificar VerifiedOrders
	    stream VerifiedOrders(schemaFor(Orders))
	     := Functor(CheckedOrders)
	     [canContinue]
	     {}
	    
	    Null := 
	    Sink (OrdersNotToVerify, VerifiedOrders) ["file:///Orders.dat", nodelays]{}
  1. Salve o arquivo vwap.dps.
  2. Insira o comando make a partir do diretório orderDecision_orig para compilar o aplicativo.
  3. Quando a compilação do exemplo de cenário concluir com êxito, você verá o seguinte:
    • Um resumo que mostra que 1 tarefa e 12 processing elements (PEs) foram criados.
    • Os três operadores que você criou anteriormente (OrdersToVerify.dpe, OrdersNotToVerify.dpe e CheckedOrders.dpe).
    • Vários shell scripts.
    Quando você compila o aplicativo do Streams pela primeira vez com o operador JavaUdop nele, o aplicativo cria automaticamente os arquivos .java e .class necessários sob o diretório src.
  4. Modifique o arquivo OrderDecision.java para chamar a API do ILOG JRules adicionando as linhas em negrito da Listagem 6 ao arquivo OrderDecision.java já existente. Os comentários da Listagem 6 documentam a funcionalidade que está sendo adicionada. Um arquivo OrderDecision.java modificado está incluído em Downloads caso você precise dele.
Listagem 6. Filtrar pedidos
	    package com.ibm.orderchecker;
	   
	  import ilog.rules.res.model.IlrPath;
	    import ilog.rules.res.session.IlrJ2SESessionFactory;
	    import ilog.rules.res.session.IlrSessionRequest;
	    import ilog.rules.res.session.IlrSessionResponse;
	    import ilog.rules.res.session.IlrStatelessSession;
	   
	    import com.ibm.streams.spade.OperatorContext;
	   
	    public  class OrderDecision extends AbstractOrderDecision {
	   
	   
	    	private IlrPath path;
	   	
	   	
	       /**
	       ** Initialize the operator
	       */
	       @Override
	       public void initialize(OperatorContext context) throws Exception {
	           super.initialize(context);
	   		
	   	//Set the path to the Rule. It is in the form /RuleApp/RuleSet
	   		this.path = 
	   		  IlrPath.parsePath("/OrderDecisionRuleApp/OrderDecisionRuleSet");
	       }
	   
	       /**
	       ** process method for port 0 (Stream IPort0Stream).
	       */
	       @Override
	       protected void process0(IPort0 tuple) throws Exception {
	   	//Initialize a new JRules Session. If you are concerned about 
	   		//performance, this session can be re-used. However if a 
	   		//new version of the rules are published to the RES, they 
	   		//will not be picked up until the session is re-initialized
	   		IlrJ2SESessionFactory sessionFactory = 
	   		  new IlrJ2SESessionFactory();
	           sessionFactory.setClassLoader(getClass().getClassLoader());
	   		
	   		
	   		//Create the JRules Request Object
	   		IlrSessionRequest sRequest = sessionFactory.createRequest();
	   		sRequest.setRulesetPath(path);	
	   		sRequest.setInputParameter("symbol", tuple.get_symbol());
	   		sRequest.setInputParameter("price", tuple.get_price());
	   		sRequest.setInputParameter("qty", tuple.get_qty());
	   
	   		IlrSessionResponse sResponse = null;
	   		try {
	   			//Execute the JRules Rule
	   			IlrStatelessSession ss = 
	   			  sessionFactory.createStatelessSession();
	   			sResponse = ss.execute(sRequest);
	   			
	   			//Parse the response
	   			boolean canContinue = 
	   ((Boolean)sResponse.getOutputParameters().get("canContinue")).booleanValue();
	   			
	   			
	   			//Create the Output Tuple. You have to set all of 
	   			//the input params as well as the JRules result
	   			OPort0 otuple = getOutput0().newTuple();
	   			
	   			otuple.set_symbol(tuple.get_symbol());
	   			otuple.set_price(tuple.get_price());
	   			otuple.set_qty(tuple.get_qty());
	   			
	   			otuple.set_canContinue(canContinue);
	   			
	   			//Submit the result tuple
	   			submit0(otuple);
	   			
	   		} catch (Exception e) {
	   			e.printStackTrace();
	   		}
	   		
	        }
	    }
  1. Insira o comando ./start_streams_vwap.sh para iniciar o servidor do Streams.
  2. Insira o comando ./submitjob_vwap.sh para enviar a tarefa.
  3. Use a ferramenta StreamSight incluída no InfoSphere Streams para ver o aplicativo ao abrir o eclipse e selecionar a perspectiva InfoSphere Streams Live Graph.
  4. Clique no ícone Load na barra de ferramentas e selecione Spade. A Figura 14 mostra o gráfico do aplicativo resultante.
Figura 14. Aplicativo do Streams modificado
Aplicativo do Streams modificado

Na Figura 14, os dados fluem da esquerda para a direita — como na Figura 13 — mas, quando chegam à função Orders, o fluxo se divide em dois caminhos antes de convergir novamente na função Sink.

  1. Execute o aplicativo. Você modificou o arquivo orderDecision.java para chamar a regra do ILOG que define o sinalizador canContinue como true se "preço * quantidade" é inferior a US$ 500 ou se o símbolo é IBM. Depois de executar o aplicativo, você verá o arquivo de saída, Orders.dat, no diretório orderDecision_orig/data. Dentro desse arquivo, você só deve ver os pedidos que estão de acordo com a regra do ILOG, como mostra a Listagem 7.
Listagem 7. Arquivo Generated Orders
	    symbol:TWX,price:17.7,qty:1
	    symbol:UNH,price:64.6,qty:4
	    symbol:MRK,price:32.07,qty:3
	    symbol:VRX,price:18.67,qty:1
	    symbol:CD,price:16.75,qty:17
	    symbol:CVS,price:27.26,qty:10
	    symbol:CVS,price:27.26,qty:8
	    symbol:HAR,price:97.23,qty:1CH
	    symbol:IBM,price:83.59,qty:6
	    symbol:THC,price:7.93,qty:14
	    symbol:THC,price:7.93,qty:7
	    symbol:FSLb,price:26.04,qty:4
	    symbol:BHI,price:61.95,qty:3
	    symbol:LRY,price:43.67,qty:4
	    symbol:DG,price:19.18,qty:24
	    symbol:CEG,price:56.79,qty:1

Conclusão

Este artigo mostrou o processo de desenvolver e implementar uma regra de negócios em um servidor de aplicativos do JRules e usar essa regra a partir de um aplicativo InfoSphere Streams. A combinação dessas duas tecnologias fornece uma forma eficiente para que um usuário de negócios modifique as regras usadas por um mecanismo de processamento de dados de alto desempenho em tempo real sem necessidade de desenvolvimento ou implementação.


Download

DescriçãoNomeTamanho
Downloads for this articleStreamsJRulesCodeDownloads.zip831KB

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Information Management, WebSphere, Tecnologia Java
ArticleID=513751
ArticleTitle=Tecnologia IBM na linha de frente dos Mercados Financeiros, Parte 2: Invoque regras de negócios condicionais com base na análise de fluxos de dados
publish-date=08272010