Spring boot 如何使用MessageListener声明队列_Spring Boot_Jms_Spring Jms

Spring boot 如何使用MessageListener声明队列

spring-boot jms

Spring boot 如何使用MessageListener声明队列,spring-boot,jms,spring-jms,Spring Boot,Jms,Spring Jms,我使用SpringBoot2.2，需要通过JMS接收消息我看到了，然后我们可以使用注释 @组成部分公共类JMS接收器{ @JmsListenerdestination=队列 public void receiveMessageString消息{ 接收到System.out.PrintLn； } } 实现MessageListener： @组成部分公共类JMSReceiver实现MessageListener{ @凌驾消息上的公共无效消息{ ... } } 对于MessageLis

我使用SpringBoot2.2，需要通过JMS接收消息

我看到了，然后我们可以使用注释

@组成部分公共类JMS接收器{ @JmsListenerdestination=队列 public void receiveMessageString消息{ 接收到System.out.PrintLn； } } 实现MessageListener：

@组成部分公共类JMSReceiver实现MessageListener{ @凌驾消息上的公共无效消息{ ... } }

对于MessageListener，我们如何声明使用的队列？

您不在MessageListener实现上声明队列，而是在MessageListenerContainer上声明队列

例如：

  @Bean
  public MessageListenerContainer messageListenerContainer() {
      DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
      container.setConnectionFactory(connectionFactory());
      container.setDestinationName("queue"); // Set the queue name here.
      container.setMessageListener(jmsReceiver()); // Your JMS receiver message listener.
      return container;
  }

您不在MessageListener实现上声明队列，而是在MessageListenerContainer上声明队列

例如：

  @Bean
  public MessageListenerContainer messageListenerContainer() {
      DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
      container.setConnectionFactory(connectionFactory());
      container.setDestinationName("queue"); // Set the queue name here.
      container.setMessageListener(jmsReceiver()); // Your JMS receiver message listener.
      return container;
  }

消息侦听器接口在消息上只有一个方法

public interface MessageListener {
    void onMessage(Message message);
}

消息一到达目的地，消息使用者就通过调用消息侦听器的onMessage方法来传递消息。注册消息侦听器允许客户端异步接收消息，而无需阻止/轮询消息使用者。因此，我们必须在消息使用者中注册消息侦听器，因为消息是由消息使用者接收的，因此在消息使用者中设置队列。下面的示例演示了以下消息使用者界面：

public interface MessageConsumer {
    String getMessageSelector() throws JMSException;
    MessageListener getMessageListener() throws JMSException;
    void setMessageListener(MessageListener listener) throws JMSException;
    Message receive() throws JMSException;
    Message receive(long timeout) throws JMSException;
    Message receiveNoWait() throws JMSException;
    void close() throws JMSException;
}

下面是可以帮助您的代码

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class ConsumerMessageListener implements MessageListener {
    private String consumerName;

    public ConsumerMessageListener(String consumerName) {
        this.consumerName = consumerName;
    }

    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage) message;
        try {
            System.out.println(consumerName + " received "
                    + textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

}

队列创建在此处完成，消息从此处发送

import java.net.URI;
import java.net.URISyntaxException;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;


import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;

public class JmsMessageListenerExample {
    public static void main(String[] args) throws URISyntaxException, Exception {
        BrokerService broker = BrokerFactory.createBroker(new URI(
                "broker:(tcp://localhost:61616)"));
        broker.start();
        Connection connection = null;
        try {
            // Producer
            ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
                    "tcp://localhost:61616");
            connection = connectionFactory.createConnection();
            Session session = connection.createSession(false,
                    Session.AUTO_ACKNOWLEDGE);
            Queue queue = session.createQueue("customerQueue");
            String payload = "Important Task";
            Message msg = session.createTextMessage(payload);
            MessageProducer producer = session.createProducer(queue);
            System.out.println("Sending text '" + payload + "'");
            producer.send(msg);

            // Consumer
            MessageConsumer consumer = session.createConsumer(queue);
            consumer.setMessageListener(new ConsumerMessageListener("Consumer"));
            connection.start();
            Thread.sleep(1000);
            session.close();
        } finally {
            if (connection != null) {
                connection.close();
            }
            broker.stop();
        }
    }

}

从控制器发送消息并使用Spring Boot接收：

@RestController
@RequestMapping("/transaction")
public class BackOfficeController {
  @Autowired private JmsTemplate jmsTemplate;
  @PostMapping("/send")
  public void send(@RequestBody BackOfficeVO transaction) {
    System.out.println("Sending a transaction.");
    // Post message to the message queue named "BackOfficeTransactionQueue"
    jmsTemplate.convertAndSend("BackOfficeTransactionQueue", transaction);
  }
}

@Component
public class BackOfficeReceiver {
  @Autowired
  private BackOfficeTransactionRepository transactionRepository;
  @JmsListener(destination = "BackOfficeTransactionQueue", containerFactory = "myFactory")
  public void receiveMessage(BackOfficeVO transaction) {
    System.out.println("Received <" + transaction + ">");
    transactionRepository.save(transaction);
  }
}

如果您使用的是现有的消息侦听器，您可以在bean中定义它：

<bean id="messageListener" class="ConsumerMessageListener"/>


<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="connectionFactory"/>
    <property name="destination" ref="destination"/>
    <property name="messageListener" ref="messageListener"/>
</bean>

资料来源：