测试使用:
队列模式:
生产者MessageProducer:
package Queues;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;
/**
* @ Description:用于消息的创建类
* @ Modified By:
* @Version: $version$
*/
public class MessageProducer {
//定义ActivMQ的连接地址
private static final String ACTIVEMQ_URL = "tcp://127.0.0.1:61616";
//定义发送消息的队列名称
private static final String QUEUE_NAME = "MyMessage";
public static void main(String[] args) throws JMSException {
//创建连接工厂
ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
//创建连接
Connection connection = activeMQConnectionFactory.createConnection();
//打开连接
connection.start();
//创建会话
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建队列目标
Destination destination = session.createQueue(QUEUE_NAME);
//创建一个生产者
javax.jms.MessageProducer producer = session.createProducer(destination);
//创建模拟100个消息
for (int i = 1 ; i <= 100 ; i++){
TextMessage message = session.createTextMessage("我发送message:" + i);
//发送消息
producer.send(message);
//在本地打印消息
System.out.println("我现在发的消息是:" + message.getText());
}
//关闭连接
connection.close();
}
}
消费者MessageConsumer1:(可以有多个)
package Queues;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;
/**
* @ Description:消息消费者
* @ Modified By:
* @Version: $version$
*/
public class MessageConsumer1 {
//定义ActivMQ的连接地址
private static final String ACTIVEMQ_URL = "tcp://127.0.0.1:61616";
//定义发送消息的队列名称
private static final String QUEUE_NAME = "MyMessage";
public static void main(String[] args) throws JMSException {
//创建连接工厂
ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
//创建连接
Connection connection = activeMQConnectionFactory.createConnection();
//打开连接
connection.start();
//创建会话
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建队列目标
Destination destination = session.createQueue(QUEUE_NAME);
//创建消费者
javax.jms.MessageConsumer consumer = session.createConsumer(destination);
//创建消费的监听
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage) message;
try {
System.out.println("获取消息:" + textMessage.getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
});
}
}
主体模式:
生产者MessageTopicProducer:
package Topics;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;
/**
* @ Description:${description}
* @ Modified By:
* @Version: $version$
*/
public class MessageTopicProducer {
//定义ActivMQ的连接地址
private static final String ACTIVEMQ_URL = "tcp://127.0.0.1:61616";
//定义发送消息的主题名称
private static final String TOPIC_NAME = "MyTopicMessage";
public static void main(String[] args) throws JMSException {
//创建连接工厂
ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
//创建连接
Connection connection = activeMQConnectionFactory.createConnection();
//打开连接
connection.start();
//创建会话
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建队列目标
Destination destination = session.createTopic(TOPIC_NAME);
//创建一个生产者
javax.jms.MessageProducer producer = session.createProducer(destination);
//创建模拟100个消息
for (int i = 1; i <= 100; i++) {
TextMessage message = session.createTextMessage("当前message是(主题模型):" + i);
//发送消息
producer.send(message);
//在本地打印消息
System.out.println("我现在发的消息是:" + message.getText());
}
//关闭连接
connection.close();
}
}
消费者MessageTopicConsumer1:(可以有多个)
package Topics;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;
/**
* @ Description:${description}
* @ Modified By:
* @Version: $version$
*/
public class MessageTopicConsumer1 {
//定义ActivMQ的连接地址
private static final String ACTIVEMQ_URL = "tcp://127.0.0.1:61616";
//定义发送消息的队列名称
private static final String TOPIC_NAME = "MyTopicMessage";
public static void main(String[] args) throws JMSException {
//创建连接工厂
ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
//创建连接
Connection connection = activeMQConnectionFactory.createConnection();
//打开连接
connection.start();
//创建会话
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建队列目标
Destination destination = session.createTopic(TOPIC_NAME);
//创建消费者
javax.jms.MessageConsumer consumer = session.createConsumer(destination);
//创建消费的监听
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage) message;
try {
System.out.println("获取消息:" + textMessage.getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
});
}
}
Maven测试使用:
pom.xml:
<!--添加activemq的依赖-->
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-all</artifactId>
<version>5.15.4</version>
</dependency>
生产者配置文件producer.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd ">
<context:annotation-config />
<!--Activemq的连接工厂-->
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://127.0.0.1:61616" />
</bean>
<!--spring jms为我们提供的连接池 获取一个连接工厂-->
<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory" ref="targetConnectionFactory" />
</bean>
<!-- 消息目的地 点对点的模式-->
<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg value="SpringActiveMQMsg"/>
</bean>
<!-- 消息目的地 (主题模式)-->
<!--<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQTopic">
//配置队列模型的消息名称
<constructor-arg value="SpringActiveMQMsgTopic"/>
</bean>-->
<!-- jms模板 用于进行消息发送-->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="connectionFactory"/>
</bean>
<!--注入我们的生产者-->
<bean class="com.test.controller.Producer.ProduceServiceImpl"/>
</beans>
生产者接口ProduceService:
package com.test.controller.Producer;
/**
* @ Description:生产者的接口
* @ Modified By:
* @Version: $version$
*/
public interface ProduceService {
void sendMessage(String msg);
}
接口实现ProduceServiceImpl:
package com.test.controller.Producer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import javax.annotation.Resource;
import javax.jms.*;
/**
* @ Description:生产者的实现类
* @ Modified By:
* @Version: $version$
*/
public class ProduceServiceImpl implements ProduceService {
@Autowired
private JmsTemplate jmsTemplate;
@Resource(name = "queueDestination")
private Destination destination;
/**
* 发送消息
* @param msg
*/
@Override
public void sendMessage(final String msg) {
jmsTemplate.send(destination , new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage(msg);
return textMessage;
}
});
System.out.println("现在发送的消息为: " + msg);
}
}
生产者测试类ProducerTest:
package com.test.controller.Producer;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @ Description:生产者的测试
* @ Modified By:
* @Version: $version$
*/
public class ProducerTest {
public static void main(String[] args){
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("producer.xml");
ProduceService bean = classPathXmlApplicationContext.getBean(ProduceService.class);
//进行发送消息
for (int i = 0; i < 100 ; i++) {
bean.sendMessage("test" + i);
}
//当消息发送完后,关闭容器
classPathXmlApplicationContext.close();
}
}
消费者配置文件consumer.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd ">
<context:annotation-config />
<!--Activemq的连接工厂-->
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://127.0.0.1:61616" />
</bean>
<!--spring jms为我们提供的连接池 获取一个连接工厂-->
<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory" ref="targetConnectionFactory" />
</bean>
<!-- 消息目的地 点对点的模式-->
<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg value="SpringActiveMQMsg"/>
</bean>
<!-- 配置消息监听器-->
<bean id="consumerMessageListener" class="com.test.controller.Consumer.ComsumerMessageListener"/>
<!--配置消息容器-->
<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>
消费者的监听ComsumerMessageListener:
package com.test.controller.Consumer;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
/**
* @ Description:消息的监听者,用于处理消息
* @ Modified By:
* @Version: $version$
*/
public class ComsumerMessageListener implements MessageListener {
@Override
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage) message;
try {
System.out.println("接受到消息:" + textMessage.getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
}
消费者测试类ConsumerTest:
package com.test.controller.Consumer;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @ Description:消费者的测试
* @ Modified By:
* @Version: $version$
*/
public class ConsumerTest {
public static void main(String[] args){
//启动消费者
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("consumer.xml");
}
}
springboot集成
创建消息队列对象MqConfig:
package com.test.config;
import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.jms.Queue;
@Configuration
@EnableCaching
public class MqConfig {
/**
* 创建消息队列对象
* @return
*/
@Bean
public Queue queue() {
return new ActiveMQQueue("active.queue");
}
}
队列消息控制器QueueController:
package com.test.controller;
import javax.jms.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 队列消息控制器
*/
@RestController
@RequestMapping("/MQ")
public class QueueController {
@Autowired
private JmsMessagingTemplate jmsMessagingTemplate;
@Autowired
private Queue queue;
/**
* 消息生产者
*/
@RequestMapping("/send")
public void send() {
// 指定消息发送的目的地及内容
this.jmsMessagingTemplate.convertAndSend(this.queue, "新发送的消息!");
}
}
客户控制器CustomerController:
package com.test.controller;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.web.bind.annotation.RestController;
/**
* 客户控制器
*/
@RestController
public class CustomerController {
/**
* 监听和读取消息
*/
@JmsListener(destination="active.queue")
public void readActiveQueue(String message) {
System.out.println("接受到:" + message);
}
}
附-使用外部的ActiveMQ:
application.properties:
#使用外部的ActiveMQ
spring.activemq.broker-url=tcp://127.0.0.1:61616