Comment écouter un message de la file d'attente à partir d'une application web? (Tomcat, ActiveMQ)

Je suis heureux de l'amélioration de mon application web qui s'exécute sur un Apache Tomcat. Un ActiveMQ serveur JMS est ajouté à envoyer et recevoir des messages.

J'ai déjà pouvez envoyer et recevoir des messages, mais besoin d'aide sur le côté du récepteur.

Comment mon application web en permanence d'écouter une seule file d'attente pour recevoir des messages?

De nouveaux messages arrivent et le serveur doit agir sur eux. Ex: ajouter des données dans la DB ou ou envoyer un message en retour.

Je peux déjà envoyer des messages. C'est le code.

ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
Connection connection = factory.createConnection();
Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
Queue queue = session.createQueue("clientQueue");
MessageProducer publisher = session.createProducer(queue);
connection.start();

Message message = null;
message = session.createTextMessage("Text Message");
publisher.send(message);

Je peux déjà vous recevez un message après une demande (un clic ;-))

connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
connection = connectionFactory.createConnection();
connection.start();
session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
destination = session.createQueue("serverQueue");
consumer = session.createConsumer(destination);

while (true) {
    Message message = consumer.receive(300000);
    //Do message stuff
}

Comment dois-je laisser l'application web, écouter de la file d'attente en permanence?
Qu'est-ce que le conseillé?

Toute aide est vivement appréciée. Merci.

EDIT - SOLUTION

Actuelle solution de travail avec les propositions de DaveH

J'ai ajouté un ServletContextListener pour écouter mon message en permanence.

web.xml

<listener>
    <listener-class>com.test.JMSContextListener</listener-class>
</listener>

La Listeren:

public class JMSContextListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent arg0) {
        Thread thread = new Thread(new JMSConnector());
        thread.start();
    }

    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
        //Nothing
    }
}

La Connexion:

public class JMSConnector implements Runnable {
    public void run() {
        try {
            Context context = new InitialContext();
            QueueConnectionFactory factory = (QueueConnectionFactory) context.lookup("java:comp/env/jms/ConnectionFactory");            
            Connection connection = factory.createConnection();
            Queue queue = (javax.jms.Queue) context.lookup("java:comp/env/jms/serverQueue");
            Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);

            MessageConsumer consumer = session.createConsumer(queue);

            //This MessageListener will do stuff with the message
            MessageListenerImpl messageListener = new MessageListenerImpl();
            consumer.setMessageListener(messageListener);
            connection.start();

            //Start connection or nothing will happen!!!
            connection.start();
        } catch (JMSException ex) {
            //TODO
        } catch (NamingException ex) {
            //TODO
        }
    }
}

Est-ce un conseillé façon ou devrait-il être amélioré?

Toute aide est vivement appréciée. Merci.

Pour info: je ne suis pas en utilisant le Printemps...
Pour le conteneur de Servlet 3.x, vous pouvez annoter l'auditeur avec @WebListener, pas besoin de le déclare dans web.xml. (Mkyong)

OriginalL'auteur Dimitri Dewaele | 2015-07-28

4

Si vous avez le code qui déjà peut consommer les messages de la file d'attente ( dont il semble que vous faites ), alors je pense que votre problème est comment obtenez-vous ce morceau de code à exécuter.

Il semble que vous ne l'utilisez pas tout de cadres, donc je pense que l'approche que j'allais faire, serait de prendre ce code qui peut récupérer les messages de la file d'attente et l'exécuter dans un thread séparé dans le serveur d'application. Obtenir ce thread pour démarrer au démarrage du serveur d'applications temps, et de faire le ménage lui-même que le serveur d'application se ferme.

Façon la plus simple pour démarrer le thread sur l'application de démarrage du serveur est d'introduire une ServletContextListener ( un exemple ici.) Dans le Contexte de l'Écouteur de commencer votre file d'attente à l'écoute de code dans un thread séparé.

EDIT: j'ai utilisé cette solution proposée et ajouté le code ci-dessus à la question.

Ça a l'air prometteur. Je peux recevoir des messages quand je "clic" sur un bouton. Laissez-moi essayer cette approche et de revenir sur le forum avec une solution.
Votre code n'est pas tout à fait ce que je voulais dire. Vous avez besoin pour commencer votre auditeur dans un thread séparé - je pense que ce que vous avez là va entraîner le serveur d'application pour les accrocher. Je suggère de faire vos JMSConnector implémenter l'interface Runnable et de départ que dans un thread séparé de votre ServletContextListener
un thread est ajouté et cela semble fonctionner. Si vous avez plus de les conseiller, alors ce n'est plus que bienvenue!
Qui a l'air mieux. Vous voudrez probablement mettre en œuvre le Cadre détruit la méthode de l'auditeur en tant que bien de sorte que vous pouvez fermer la file d'attente tidyly.

OriginalL'auteur DaveH

Je suis à l'aide de printemps pour écouter une file d'attente.
la définition de l'auditeur est comme ceci :

<jms:listener-container connection-factory="jmsConnectionFactoryLocal">
            <jms:listener destination="QUEUE_NAME" ref="channelManagerSimulatorDefault"/>
</jms:listener-container>

la jmsConnectionFactoryLocal doivent être créés en fonction de vos MQ. dans mon cas, c'était IBM WebsphereMQ, de sorte que le jmsConnectionFactoryLocal définition est comme ceci :

<bean id="mqConnectionFactoryLocal" class="com.ibm.mq.jms.MQQueueConnectionFactory">
       <property name="hostName">
         <value>THE_MQ_SERVER_IP</value>
       </property>
       <property name="port">
          <value>MQ_PORT</value>
       </property>
       <property name="queueManager">
          <value>QUEUE_MANAGER_NAME</value>
       </property>
       <property name="transportType">
          <value>1</value>
       </property>
    </bean>
    <bean id="jmsConnectionFactoryLocal" class="org.springframework.jms.connection.UserCredentialsConnectionFactoryAdapter">
       <property name="targetConnectionFactory" ref="mqConnectionFactoryLocal"/>
       <property name="username" value="USER_NAME"/>
       <property name="password" value="PASSWORD"/>
    </bean>

vous devez trouver la bonne ConnectionFactory mise en œuvre pour ActiveMQ et de l'utiliser. l'auditeur et jmsConnectionFactory sont identiques et indépendantes à la MQ fournisseur.

OriginalL'auteur Hossein

Je suis en utilisant activeMQ dans mon webApplication spring-mvc et JMS Modèle avec l'approche suivante.

<bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
    <property name="brokerURL">
        <value>tcp://localhost:61616</value>
    </property>
</bean>

<bean id="messageSender" class="xyz.MessageSender"/>
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory" ref="connectionFactory" />
    <property name="defaultDestination" ref="destination" />
</bean>
<bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
    <constructor-arg value="REQUEST_QUEUE" />
</bean> 
<bean id="messageListener" class="xtz.MessageListener">
    <property name="listenerId" value="1" />
</bean> 

<jms:listener-container connection-factory="connectionFactory">     
    <jms:listener destination="RESPONSE_QUEUE" ref="messageListener" method="messageReceived" />
</jms:listener-container>

De l'expéditeur et l'Auditeur implémentation de la classe donnée ci-dessous.

public class MessageSender 
{

    @Autowired
    private JmsTemplate jmsTemplate;

    public void sendMessage()
    {

        jmsTemplate.send(new MessageCreator()
        {
            public Message createMessage(Session session) throws JMSException
            {
                MapMessage message = session.createMapMessage();
                message.setString("messageType", XXX);
                message.setString("jsonMessage", XXXX);
                return message;
            }
        });
    }
}


public class MessageListener
{
    private int listenerId;

    @Override
    public void messageReceived(Map<String, Object> message) throws Exception
    {        
        //put your logic here 
    }

    public int getListenerId()
    {
        return listenerId;
    }

    public void setListenerId(int listenerId)
    {
        this.listenerId = listenerId;
    }
}

OriginalL'auteur ManojP

Configurer la file d'attente JMS dans Tomcat:
https://martinsdeveloperworld.wordpress.com/2013/03/03/apache-activemq-and-tomcat/
Mettre activemq-all-5.xx.jar $TOMCAT_HOME/lib
Écouter dans le cycle de Filetage, a commencé en @WebListener:

Arrêter quand contextDestroyed

@WebListener
@Slf4j
public class JmsMailListener implements ServletContextListener {
private Thread listenerThread = null;
private QueueConnection connection;
@Override
public void contextInitialized(ServletContextEvent sce) {
try {
InitialContext initCtx = new InitialContext();
ActiveMQConnectionFactory connectionFactory =
(ActiveMQConnectionFactory) initCtx.lookup("java:comp/env/jms/ConnectionFactory");
connectionFactory.setTrustAllPackages(true);
connection = connectionFactory.createQueueConnection();
QueueSession queueSession = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
Queue queue = (Queue) initCtx.lookup("java:comp/env/jms/queue/MailQueue");
QueueReceiver receiver = queueSession.createReceiver(queue);
connection.start();
log.info("Listen JMS messages ...");
listenerThread = new Thread(() -> {
try {
while (!Thread.interrupted()) {
Message m = receiver.receive();
if (m instanceof ObjectMessage) {
ObjectMessage om = (ObjectMessage) m;
MyObject myObject = (MyObject) om.getObject();
log.info("Received MyObject {}", myObject);
...
}
}
} catch (Exception e) {
log.error("Receiving messages failed: " + e.getMessage(), e);
}
});
listenerThread.start();
} catch (Exception e) {
log.error("JMS failed: " + e.getMessage(), e);
}
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
if (connection != null) {
try {
connection.close();
} catch (JMSException ex) {
log.warn("Couldn't close JMSConnection: ", ex);
}
}
if (listenerThread != null) {
listenerThread.interrupt();
}
}
}

OriginalL'auteur GKislin

Vous devez vous connecter pour publier un commentaire.