点对点模式
一、同步
1.创建springboot的生产者
1>创建module的springboot项目(选择Spring Initializr)
2>添加依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-pool</artifactId>
</dependency>
3>配置:application.properties
#配置连接url
spring.activemq.broker-url=tcp://localhost:61616
#配置目的地
spring.jms.template.default-destination=springQueue
4>创建相关实现接口和类
4.1>创建controller
@RestController
public class MessageController {
@Autowired
private MessageService messageService;
@RequestMapping("/send/message")
public String sendMessage(){
String message = "springboot集成activeMQ发送消息";
messageService.sendMessage(message);
return "OK";
}
}
4.2>创建service
public interface MessageService {
public void sendMessage(String message);
}
@Service
public class MessageServiceImpl implements MessageService {
@Autowired
private MessageDao messageDao;
@Override
public void sendMessage(String message) {
messageDao.sendMessage(message);
}
}
4.3>创建dao
public interface MessageDao {
public void sendMessage(String message);
}
@Repository
public class MessageDaoImpl implements MessageDao {
@Autowired
private JmsTemplate jmsTemplate;
@Override
public void sendMessage(final String message) {
jmsTemplate.send(new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
System.out.println("create message");
return session.createTextMessage(message);
}
});
}
}
5>Application项目启动
页面访问http://localhost:8080/send/message 页面弹出OK,查看http://localhost:8161观察springQueue的消息情况
2.创建springboot的消费者
1>添加依赖
<!--添加springboot对应的activemq的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
2>配置application.properties
#配置连接url
spring.activemq.broker-url=tcp://localhost:61616
#配置目的地
spring.jms.template.default-destination=springQueue
3>创建相关实现接口和类
3.1>controller
@RestController
public class MessageController {
@Autowired
private MessageService messageService;
@RequestMapping("/receive/message")
public String receive(){
return messageService.receive();
}
}
3.2>service
public interface MessageService {
public String receive();
}
@Service
public class MessageServiceImpl implements MessageService {
@Autowired
private MessageDao messageDao;
@Override
public String receive() {
return messageDao.receive();
}
}
3.3>dao
public interface MessageDao {
public String receive();
}
@Repository
public class MessageDaoImpl implements MessageDao {
@Autowired
private JmsTemplate jmsTemplate;
@Override
public String receive() {
Message message = jmsTemplate.receive();
if (message instanceof TextMessage){
try {
return ((TextMessage) message).getText();
} catch (JMSException e) {
e.printStackTrace();
}
}
return "";
}
}
4>启动Application类,访问http://localhost:8080/receive/message,页面弹出收到的消息springboot集成activeMQ发送消息,访问http://localhost:8161/admin/queues.jsp,消息信息发生变化
二、异步
实现异步方式一:
1.创建生产者同同步模式一致<因为同步异步只是针对消费者>
2.创建消费者
1>创建maven项目springInitiziler
2>添加依赖
<!--添加springboot对应的activemq的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
3>配置application.properties
server.port=9090
#配置连接url
spring.activemq.broker-url=tcp://localhost:61616
#配置目的地
spring.jms.template.default-destination=springQueue
4>创建监听器类
@Component
public class MessageListener {
@JmsListener(destination="${spring.jms.template.default-destination}")
public void asynReceiveMessage(Message message){
if(message instanceof Message){
try {
String text = ((TextMessage)message).getText();
System.out.println(text);
} catch (JMSException e) {
e.printStackTrace();
}
}
}
}
运行生产者和消费者发现是异步进行的
实现异步方式二:
实现消费者
1.创建maven项目springboot
2.添加依赖
3.配置application.properties文件
4.创建实现类
@Configuration
public class ActiveMQConfig {
@Value("${spring.jms.template.default-destination}")
private String defaultDestinationName;
/**
* springboot自动初始化的,不用创建
*/
@Autowired
public ActiveMQConnectionFactory activeMQConnectionFactory;
@Autowired
private MyMessageListener myMessageListener;
/*
@Bean对应<bean>
id对应方法名称
class对应类型
property对应设置属性
<!--创建一个连接工厂-->
<bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<!--连接地址-->
<property name="brokerURL" value="tcp://localhost:61616"/>
<property name="userName" value="admin"/>
<property name="password" value="admin"/>
</bean>
<!--配置一个spring的jms消息监听器-->
<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory"/>
<property name="DestinationName" value="springTopic"/>
<property name="messageListener" ref="myMessageListener"/>
<!--pubSubDomain这个property对应模式true代表发布订阅,false代表点对点,默认是false,-->
<property name="pubSubDomain" value="true"/>
</bean>
<bean id="myMessageListener" class="com.test.jms.listener.MyMessageListener"/>
*/
@Bean
public DefaultMessageListenerContainer defaultMessageListenerContainer(){
DefaultMessageListenerContainer defaultMessageListenerContainer = new DefaultMessageListenerContainer();
defaultMessageListenerContainer.setConnectionFactory(activeMQConnectionFactory);
defaultMessageListenerContainer.setDestinationName(defaultDestinationName);
defaultMessageListenerContainer.setMessageListener(myMessageListener);
defaultMessageListenerContainer.setPubSubDomain(true);
return defaultMessageListenerContainer;
}
}
@Component
public class MyMessageListener implements MessageListener {
@Override
public void onMessage(Message message) {
if(message instanceof TextMessage){
String text = null;
try {
text = ((TextMessage)message).getText();
System.out.println("接收到的消息是:"+text);
} catch (JMSException e) {
e.printStackTrace();
}
}
}
}
发布订阅模式
一、同步
在点对点的同步模式的基础上添加:
application.properties中添加一个配置
#发送模式,true表示发布订阅,false表示点对点,默认是false
spring.jms.pub-sub-domain=true;
注意消费者先启动
二、异步
在点对点模式的基础上
方式一:
application.properties中添加一个配置
#发送模式,true表示发布订阅,false表示点对点,默认是false
spring.jms.pub-sub-domain=true;
方式二:
配置文件也添加
spring.jms.pub-sub-domain=true;创建一个属性类似
@Value("${spring.jms.template.default-destination}")
private String defaultDestinationName;
去读取,读取完成后设置
defaultMessageListenerContainer.setPubSubDomain(pubSubDomain);
或者
defaultMessageListenerContainer.setPubSubDomain(true);
总结:
一般项目中采用异步的方式-监听器,
如果是消息被消费一次,采用点对点模式;
如果项目中消息被多个消费者消费,就采用发布订阅模式;
同步方式一直接收的话采用while(true)接收;
异步方式的监听器就是一直接收;