Durante a fase de registro, o intermediário descobre quais recursos, neste caso nós, estão disponíveis e quais lils podem fornecê-los. A fase inicia quando um grupo de exceções inicia. As lils são carregadas na inicialização de um grupo de execução e o intermediário as consulta para descobrir que recursos elas podem fornecer.
Uma estrutura CciFactory é criada durante a fase de registro, quando o nó definido pelo usuário chama cniCreateNodeFactory.
Uma instância de um nó Input definido pelo usuário é criada quando a comando mqsistart inicia ou inicia novamente o processo do grupo de execução ou quando um fluxo de mensagens associado ao nó é implementado.
Durante essa fase uma estrutura CciTerminal é criada. Essa estrutura é criada quando cniCreateTerminal é chamado.
A fase de processamento começa quando a funçãocniRun é chamada pelo intermediário. O intermediário utiliza a função cniRun para determinar como processar uma mensagem, incluindo a determinação do domínio no qual uma mensagem está definida e a chamada do analisador relevante para esse domínio.
Um encadeamento é pedido do conjunto de encadeamentos do fluxo de mensagens e é iniciado no método run do nó de entrada. O encadeamento se conecta ao gerenciador de filas do intermediário e retém essa conexão por seu ciclo de vida. Quando um encadeamento tiver sido alocado, o nó entrará em um loop de processamento de mensagem enquanto aguarda receber uma mensagem, repetindo até que uma mensagem seja recebida. Se o fluxo de mensagens for configurado para utilizar vários encadeamentos, o dispatch de encadeamentos será ativado.
Os dados da mensagem podem agora ser propagados downstream.
Um nó de entrada definido pelo usuário é destruído quando o fluxo de mensagens é reimplementado, ou quando mqsistop é utilizado para parar o processo do grupo de execução. É possível destruir o nó implementando a função cniDeleteNodeContext.
Quando um nó de entrada definido pelo usuário é destruído de uma dessas maneiras, deve-se liberar qualquer memória utilizada pelo nó e liberar quaisquer recursos retidos, tais como soquetes.
Durante a fase de registro um nó Input definido pelo usuário escrito em Java torna-se conhecido ao intermediário. O nó é registrado com o intermediário através do método estático getNodeName. Sempre que um intermediário inicia, ele carrega todas as classes java relevantes. O método estático getNodeName é chamado nesse ponto e o intermediário registra o nó de entrada com o nome de nó especificado no método getNodeName. Se não for especificado um nome de nó, o intermediário criará automaticamente um nome para o nó com base no pacote onde ele está contido.
Utilizar um método estático aqui significa que o método pode ser chamado pelo intermediário antes que o próprio nó seja instanciado.
Um nó de entrada Java definido pelo usuário é instanciado quando um intermediário implementa um fluxo de mensagens contendo o nó de entrada definido pelo usuário. Quando o nó é instanciado, o construtor da classe de nó de entrada é chamado.
Quando um nó é instanciado, quaisquer terminais que tenham sido especificados utilizando os métodos relevantes são criados. Um nó Input não tem nenhum terminal de entrada associado a ele mas pode ter qualquer número de nós de saída. Os terminais de saída incluem terminais out, failure e catch. Utilize o método createOutputTerminal dentro do construtor da classe do nó para criar o número de terminais de saída necessário.
Se deseja lidar com exceções passadas de volta para seu nó de entrada, utilize createOutputTerminal para criar um terminal de captura para seu nó de entrada. Quando o nó de entrada capturar um erro, o terminal catch o processará da mesma maneira que um nó MQInput regular o faria. Porém, você pode permitir que a maioria das exceções, como exceções causadas por problemas de implementação, sejam transmitidas de volta ao intermediário, o qual avisará o usuário sobre quaisquer possíveis erros de configuração.
Como um mínimo, a classe do construtor somente necessita criar esses terminais de saída no nó de entrada. Contudo, se precisar inicializar valores de atributos, tais como definir o analisador que fará a análise inicial de uma mensagem transmitida do nó de entrada, você deve incluir também esse código neste ponto no nó de entrada.
O processamento de mensagens para um nó de entrada começa quando o intermediário chama o método run. O método run cria a mensagem de entrada, e deve conter a função de processamento para o nó de entrada.
O método run é definido em MbInputNodeInterface, que é a interface utilizada em um nó de entrada definido pelo usuário que o define como nó de entrada. É preciso incluir um método run no nó. Se um método run não for incluído no nó de entrada definido pelo usuário, o código fonte do nó não será compilado.
Quando um fluxo de mensagens contendo um nó de entrada definido pelo usuário é implementado com êxito, o intermediário chama o método de implementação run do nó, e continua a chamar esse método enquanto aguarda o processo das mensagens.
Quando um fluxo de mensagens é iniciado, um único encadeamento é despachado pelo intermediário e é chamado para o método run do nó de entrada. Se o método dispatchThread for chamado, mais encadeamentos podem também ser criados no mesmo método run. Esses novos encadeamentos chamam imediatamente para o método run do nó de entrada, e podem ser tratados da mesma forma que o encadeamento original. O número de novos encadeamentos que podem ser criados é definido pelo atributo additionalInstances. Certifique-se de que os encadeamentos são despachados após a criação de uma mensagem e antes que ela seja propagada. Isso assegura que somente um encadeamento por vez esteja aguardando por uma nova mensagem.
Um usuário que esteja implementando um fluxo de mensagens utilizando um nó de entrada definido pelo usuário pode especificar que vários encadeamentos possam ser utilizados para servir o fluxo de mensagens. O nó de entrada é responsável por implementar o modelo de encadeamento escolhido, mas não é possível impor restrições a essa capacidade no código. Em vez disso, você deve garantir que seu código seja completamente reentrante e que quaisquer funções que o código chame também o sejam.
Para obter informações adicionais sobre o modelo de encadeamento para nós Input definidos pelo usuário, consulte Encadeamentos.
Um nó de entrada Java definido pelo usuário é destruído quando o nó é excluído ou o intermediário é encerrado. Você não necessita incluir algo em seu código que especifique que o nó deve ser excluído fisicamente, porque isso pode ser tratado pelo coletor de lixo.
Contudo, se quiser ser notificado de que um nó está prestes a ser excluído, você pode utilizar o método onDelete. Você pode querer fazer isso se existirem recursos além dos que serão coletados como lixo que você deseje excluir. Por exemplo, se você tiver aberto um soquete, este não será, novamente, fechado corretamente quando o nó for excluído automaticamente. Você pode incluir essa instrução no método onDelete para assegurar que o soquete seja fechado corretamente.
Conceitos relacionados
Analisadores Definidos pelo Usuário
Extensões Definidas pelo Usuário
Tarefas relacionadas
Criando um Nó de Entrada em Java
Criando um Nó de Entrada em C
Referências relacionadas
cniCreateInputTerminal
cniCreateNodeContext
cniCreateNodeFactory
cniRun
cniSetInputBuffer
Avisos |
Marcas |
Downloads |
Biblioteca |
Suporte |
Feedback
![]() ![]() |
as01391_ |