Spring整合JMS P2P方式

来源：互联网发布：注册码破解软件下载编辑：程序博客网时间：2024/04/30 12:32

javajms 使用jms消息发送 Producer，Consumer，Listener 直接使用queue传的消息为点对点模式

点对点当同时存在consumer跟listener时不存在先后顺序两者能同时接收到消息

这里consumer有两种获取消息的机制

1.使用消费者接收 consumer.receive()

2.使用绑定监听 consumer.setMessageListener(new Listener());

当系统已有Listener与Producer（发送者）绑定的时候（如下代码写法），再使用Consumer.receive 获取消息时会报如下错误：

           consumer.setMessageListener(new ConsumerMessageListener());
           while (true) {
                Message message = consumer.receive();

                TextMessage textMessage = (TextMessage) message;
                if(textMessage!=null){
                     String text = textMessage.getText();

                     System.out.println("从ActiveMQ取回一条消息: " + text);
                }else{
                     break;
                }
           }

Cannot synchronously receive a message when a MessageListener is set

此时只要确保系统只有一种方式绑定即可

当系统有多个Consumer在等候是一个发送者发出消息，每个Consumer都能收到消息

监测客户端 ActiveMQ 登录地址http://localhost:8161/admin 用户admin、密码admin

使用Spring管理jms

这里使用Maven构建框架

pom.xml如下：

<properties>
          <org.springframework-version>4.1.6.RELEASE</org.springframework-version>
          <spring.security.version>2.0.5.RELEASE</spring.security.version>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
     <dependencies>
           <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>

           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${org.springframework-version}</version>
                <exclusions>
                     <exclusion>
                           <groupId>commons-logging</groupId>
                          <artifactId>commons-logging</artifactId>
                     </exclusion>
                </exclusions>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>4.1.6.RELEASE</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-instrument</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-oxm</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc-portlet</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <!-- springframework end -->

           <!-- spring security start -->
           <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-acl</artifactId>
                <version>${spring.security.version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-core</artifactId>
                <version>${spring.security.version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-core-tiger</artifactId>
                <version>${spring.security.version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-taglibs</artifactId>
                <version>${spring.security.version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jms</artifactId>
                <version>4.1.5.RELEASE</version>
           </dependency>

           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-expression</artifactId>
                <version>${org.springframework-version}</version>
           </dependency>
           <dependency>
                <groupId>javax.annotation</groupId>
                <artifactId>jsr250-api</artifactId>
                <version>1.0</version>
           </dependency>
           <dependency>
                <groupId>org.apache.activemq</groupId>
                <artifactId>activemq-core</artifactId>
                <version>5.7.0</version>
           </dependency>
     </dependencies>

spring配置文件applicationContext.XML 如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">

    <context:component-scan base-package="Jms.JmsTest" />

    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
        <property name="connectionFactory" ref="connectionFactory"/>
    </bean>

    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->
    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://localhost:61616"/>
    </bean>

    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
        <property name="targetConnectionFactory" ref="targetConnectionFactory"/>
    </bean>

    <!--这个是队列目的地-->
    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg>
            <value>queue</value>
        </constructor-arg>
    </bean>
    <!-- 消息监听器 -->
    <bean id="consumerMessageListener" class="Jms.JmsTest.ConsumerMessageListener"/>
    <!-- 消息监听容器   将发送者监听捆绑在一起 P2P-->
    <bean id="jmsContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="destination" ref="queueDestination" />
         <property name="messageListener" ref="consumerMessageListener" />
    </bean>
</beans>

消息生产者

package Jms.JmsTest;

import javax.annotation.Resource;

import javax.jms.Destination;

import javax.jms.JMSException;

import javax.jms.Message;

import javax.jms.Session;

import org.springframework.jms.core.JmsTemplate;

import org.springframework.jms.core.MessageCreator;

import org.springframework.stereotype.Component;

@Component

public class ProducerServiceImpl implements ProducerService {

private JmsTemplate jmsTemplate;

public void sendMessage(Destination destination, final String message) {

System.out.println("---------------生产者发了一个消息：" + message);

jmsTemplate.send(destination, new MessageCreator() {

public Message createMessage(Session session) throws JMSException {

return session.createTextMessage(message);

}

});

}

public JmsTemplate getJmsTemplate() {

return jmsTemplate;

}

@Resource

public void setJmsTemplate(JmsTemplate jmsTemplate) {

this.jmsTemplate = jmsTemplate;

}

消息监听

package Jms.JmsTest;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
public class ConsumerMessageListener implements MessageListener {

    public void onMessage(Message message) {
        //这里我们知道生产者发送的就是一个纯文本消息，所以这里可以直接进行强制转换
        TextMessage textMsg = (TextMessage) message;
        try {
            System.out.println("监听接收消息内容是：1111——————>" + textMsg.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

消息消费者

package Jms.JmsTest;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
public class MessageConsumer {
     public static void main(String[] args) throws JMSException {
           String jmsProviderAddress = "tcp://localhost:61616";// 地址
           ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
                     jmsProviderAddress);// 连接器
           Connection connection = connectionFactory.createConnection();// 创建连接
           Session session = connection.createSession(false,
                     Session.AUTO_ACKNOWLEDGE);// 打开会话
           String destinationName = "queue";
           Destination dest = session.createQueue(destinationName);// 消息目的地
           javax.jms.MessageConsumer consumer = session.createConsumer(dest);
           connection.start();
//         consumer.setMessageListener(new ConsumerMessageListener());
//         consumer.setMessageListener(new ConsumerMessageListener2());
           while (true) {
                Message message = consumer.receive();
                TextMessage textMessage = (TextMessage) message;
                if(textMessage!=null){
                     String text = textMessage.getText();

                     System.out.println("从ActiveMQ取回一条消息: " + text);
                }else{
                     break;
                }
           }
     }
}

测试类

package Jms.JmsTest;

import javax.jms.Destination;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/applicationContext.xml")
public class ProducerConsumerTest {
     @Autowired
     private ProducerService producerService;
     @Autowired
     @Qualifier("queueDestination")
     private Destination destination;

     @Test
     public void testSend() {
           for (int i = 0; i <= 5; i++) {
                producerService.sendMessage(destination, "生产发送消息：————>" + (i + 1));
           }
     }
}

测试结果：

---------------生产者发了一个消息：生产发送消息：————>1
监听接收消息内容是：1111——————>生产发送消息：————>1
---------------生产者发了一个消息：生产发送消息：————>2
监听接收消息内容是：1111——————>生产发送消息：————>2
---------------生产者发了一个消息：生产发送消息：————>3
监听接收消息内容是：1111——————>生产发送消息：————>3
---------------生产者发了一个消息：生产发送消息：————>4
监听接收消息内容是：1111——————>生产发送消息：————>4

阅读全文

1 0