comment implémenter un consommateur d'événement-disque dans camel

Question

Je suis très nouveau à Camel, et ai lutté pour comprendre comment utiliser camel dans un scénario spécifique. Dans ce scénario, un agent (basé sur Java) génère des actions de temps en temps. J'ai besoin d'un consommateur axé sur les événements pour être averti de ces événements. Ces événements seront acheminés vers un producteur de fichiers (pour le moment).

Dans le livre camel, l'exemple est pour un consommateur interrogé. Je n'ai pas trouvé de solution générique pour un consommateur axé sur les événements. je suis tombé sur une mise en œuvre similaire pour JMX:

public class JMXConsumer extends DefaultConsumer implements NotificationListener { 

JMXEndpoint jmxEndpoint;  
public JMXConsumer(JMXEndpoint endpoint, Processor processor) { 
    super(endpoint, processor); 
    this.jmxEndpoint = endpoint; 
} 

public void handleNotification(Notification notification, Object handback) { 
    try { 
     getProcessor().process(jmxEndpoint.createExchange(notification)); 
    } catch (Throwable e) { 
     handleException(e); 
    } 
} 

}

Ici, le handleNotification appelé chaque fois une notification JMX arrive.

Je crois que je dois faire quelque chose de similaire pour que mon client soit notifié chaque fois que l'agent génère une action. Cependant, la méthode handleNotification ci-dessus est spécifique à JMX. La page Web indique: «Lors de l'implémentation de votre propre consommateur piloté par les événements, vous devez identifier une méthode d'écouteur d'événement similaire à implémenter dans votre client personnalisé.

Je veux savoir: Comment puis-je identifier un écouteur d'événement analogue, afin que mon client soit averti lorsque mon agent a une action.

Tout conseil/lien vers une page Web est très apprécié.

Answer 1

Événement conduit est ce que camel est.

Toute route est en fait un écouteur d'événements.

donné la route:

from("activemq:SomeQueue"). 
    bean(MyClass.class); 

public class MyBean{ 
    public void handleEvent(MyEventObject eventPayload){ // Given MyEventObject was sent to this "SomeQueue". 
    // whatever processing. 
    } 
} 

Cela mettrait en place un événement axé sur le consommateur. Comment envoyer des événements alors? Si vous avez camel intégré dans votre application et accédez au CamelContext à partir de votre générateur d'actions, vous pouvez en saisir un Producer Template et déclencher votre événement vers le point de terminaison que vous avez défini dans Camel, tel que "seda: SomeQueue". Sinon, si votre instance Camel s'exécute sur un autre serveur ou instance que votre application, vous devez utiliser un autre mode de transport plutôt que SEDA. De préférence JMS, mais d'autres feront aussi bien, choisir et choisir. ActiveMQ est mon préféré. Vous pouvez démarrer une instance ActiveMQ intégré (JVM intra) facilement et le connecter à dos de chameau par:

camelContext.addComponent("activemq", activeMQComponent("vm://localhost")); 

Answer 2

Je sais que c'est une vieille question, mais je l'ai eu du mal avec elle et juste pensé que je documenter mes conclusions pour quelqu'un d'autre à la recherche d'une réponse.

Lorsque vous créez une classe Endpoint (extension DefaultEndpoint) vous substituez la méthode suivante pour créer un consommateur:

public Consumer createConsumer(Processor processor) 

Dans votre consommation alors, vous avez accès à un processeur - appeler le « processus » sur ce processeur va créer un événement et déclencher l'itinéraire. Par exemple, supposons que vous ayez une API Java à l'écoute des messages et que vous ayez une sorte d'écouteur.Dans mon cas, le récepteur met les messages entrants sur un LinkedBlockingQueue, et ma consommation méthode « doStart » ressemble à ceci (ajoutez votre propre gestion des erreurs):

@Override 
protected void doStart() throws Exception { 
    super.doStart(); 

    // Spawn a new thread that submits exchanges to the Processor 
    Runnable runnable = new Runnable() { 
     @Override 
     public void run() { 
      while(true) { 
       IMessage incomingMessage = myLinkedBlockingQueue.take(); 
       Exchange exchange = getEndpoint().createExchange(); 
       exchange.getIn().setBody(incomingMessage); 
       myProcessor.process(exchange); 
      } 
     } 
    }; 
    new Thread(runnable).start(); 
} 

Maintenant, je peux mettre le composant qui crée le point final qui crée cette consommation dans mon CamelContext, et l'utiliser comme ceci:

from("mycomponent:incoming").to("log:messages"); 

et le message du journal se déclenche à chaque fois qu'un nouveau message arrive de l'API Java.

Espérons que cela aide quelqu'un!