#### 消息中间件
消息中间件：关注于数据的发送和接受，利用高效可靠的异步消息传递机制集成分布式系统
JMS：Java消息服务，Java平台中关于面向消息中间件的API
AMQP：提供统一消息服务的应用层标准协议
常见消息中间件
ActiveMQ
RabbitMQ
Kafka
JMS规范
提供者：实现JMS规范的消息中间件服务器
客户端：发送或接受消息的应用程序
生产者/发布者：创建并发送消息的客户端
消费者/订阅者：接收并处理消息的客户端
消息：应用程序之间传递的数据内容
消息模式：在客户端之间传递消息的方式，JMS中定义了主题和队列两种模式
JMS消息模式
队列模型：
- 客户端包括生产者和消费者
- 消息只能被一个消费者消费
- 随时消费
主题模型：
- 客户端包括发布者和订阅者
- 消息能被所有订阅者消费
- 消费者不能消费订阅之前就发送到主题中的消息
JMS编码接口：
- ConnectionFactory：用于创建连接到消息中间件的连接工厂
- Connection：代表了应用程序和消息服务器之间的通信链路
- Destination：消息发布和接收的地点，包括队列和主题
- Session：表示一个单线程的上下文，用于发送和接收消息
- MessageConsumer：由会话创建，用于接收发送到目标的消息
- MessageProducer：由会话创建，用于发送消息到目标
- Message：在消费者和生产者之间传送的对象，包括消息头，一组消息属性，一个消息体
使用ActiveMQ
队列模型
producer
//1. 创建ConnectionFactory
ConnectionFactory factory = new ActiveMQConnectionFactory(url);
//2. 创建Connection
Connection connection = factory.createConnection();
//3. 启动Connection
connection.start();
//4. 创建Session
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5. 创建Destination
Destination destination = session.createQueue(queueName);
//6. 创建MessageProducer
MessageProducer producer = session.createProducer(destination);
for (int i = 0; i < 100; i++) {
//7. 创建消息
TextMessage message = session.createTextMessage("test" + i);
//8. 发布消息
producer.send(message);
System.out.println("发送消息: " + message.getText());
}
//9. 关闭连接
connection.close();consumer
//1. 创建ConnectionFactory
ConnectionFactory factory = new ActiveMQConnectionFactory(url);
//2. 创建Connection
Connection connection = factory.createConnection();
//3. 启动Connection
connection.start();
//4. 创建Session
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5. 创建Destination
Destination destination = session.createQueue(queueName);
//6. 创建MessageConsumer
MessageConsumer consumer = session.createConsumer(destination);
//7. 创建消息监听器
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();
}
}
});
//9. 关闭连接（消息监听异步执行，需程序全部运行结束才能关闭连接）
// connection.close();主题模型
producer
//1. 创建ConnectionFactory
ConnectionFactory factory = new ActiveMQConnectionFactory(url);
//2. 创建Connection
Connection connection = factory.createConnection();
//3. 启动Connection
connection.start();
//4. 创建Session
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5. 创建Destination
Destination destination = session.createTopic(topicName);
//6. 创建MessageProducer
MessageProducer producer = session.createProducer(destination);
for (int i = 0; i < 100; i++) {
//7. 创建消息
TextMessage message = session.createTextMessage("test" + i);
//8. 发布消息
producer.send(message);
System.out.println("发送消息: " + message.getText());
}
//9. 关闭连接
connection.close();consumer
//1. 创建ConnectionFactory
ConnectionFactory factory = new ActiveMQConnectionFactory(url);
//2. 创建Connection
Connection connection = factory.createConnection();
//3. 启动Connection
connection.start();
//4. 创建Session
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5. 创建Destination
Destination destination = session.createTopic(topicName);
//6. 创建MessageConsumer
MessageConsumer consumer = session.createConsumer(destination);
//7. 创建消息监听器
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();
}
}
});
//9. 关闭连接（消息监听异步执行，需程序全部运行结束才能关闭连接）
// connection.close();spring jms
- ConnectionFactory 用于管理连接的连接工厂
- 由spring提供
- SingleConnectionFactory和CachingConnectionFactory
- JmsTemplate 用于发送和接收消息的模板类
- 由spring提供，在容器中注册就可以使用
- 线程安全
- MessageListener 消息监听器
- 实现一个onMessage方法，只接收一个Message参数
spring使用jms示例
common.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为我们提供的ConnectionFactory -->
<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="queue" />
</bean>
<!-- 一个主题目的地，发布订阅消息 -->
<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
<constructor-arg value="topic"/>
</bean>
</beans>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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="common.xml" />
<!-- 配置JmsTemplate，用于发送消息-->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="connectionFactory" />
</bean>
<bean class="com.qyluo.jms.spring.producer.ProducerServiceImpl" />
</beans>cosumer.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 导入公共配置 -->
<import resource="common.xml" />
<!-- 配置消息监听器 -->
<bean id="consumerMessageListener" class="com.qyluo.jms.spring.consumer.ConsumerMessageListener" />
<!-- 配置消息监听容器 -->
<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="topicDestination"/>
<property name="messageListener" ref="consumerMessageListener"/>
</bean>
</beans>ProducerServiceImpl
public class ProducerServiceImpl implements ProducerService {
@Autowired
JmsTemplate jmsTemplate;
@Resource(name = "topicDestination")
Destination destination;
@Override
public void sendMessage(final String message) {
//使用JmsTemplate发送消息
jmsTemplate.send(destination, new MessageCreator() {
//创建一个消息
@Override
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage(message);
return textMessage;
}
});
System.out.println("发送消息: " + message);
}
}AppProducer
public class AppProducer {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("producer.xml");
ProducerService service = context.getBean(ProducerService.class);
for (int i = 0; i < 100; i++) {
service.sendMessage("text" + i);
}
context.close();
}
}ConsumerMessageListener
public class ConsumerMessageListener implements MessageListener { @Override public void onMessage(Message message) { TextMessage textMessage = (TextMessage) message; try { System.out.println("接收消息: " + textMessage.getText()); } catch (JMSException e) { e.printStackTrace(); } } }
AppConsumer
public class AppConsumer {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("consumer.xml");
}
}ActiveMQ集群
集群方式
- 客户端集群：多个消费者消费同一个队列
- Broker clusters：多个Broker之间同步消息
- Master Slave：实现高可用
ActiveMQ失效转移(failover)
允许当其中一台消息服务器宕机时，客户端在传输层上重新连接到其它消息服务器
语法：failover:(uri1,...,uriN)?transportOptions
transportOptions参数说明
- randomize 默认为true，表示在URI列表中选择URI连接时是否采用随机策略
- initialReconnectDelay 默认为10，单位毫秒，表示第一次尝试重新连接之间等待的时间
- maxReconnectDelay 默认为30000，单位毫秒，最长重连的时间间隔
Broker Cluster集群配置
NetworkConnector（网络连接器）：ActiveMQ服务器之间的网络通讯方式
分为静态连接器和动态连接器
静态连接器：
<networkConnectors>
<networkConnector uri="static:(tcp://127.0.0.1:61617,tcp://127.0.0.1:61618)"/>
</networkConnectors>动态连接器：
<networkConnectors>
<networkConnector uri="multicast://default"/>
</networkConnectors>
<transportConnectors>
<transportConnector uri="tcp://localhost:0" discoverUri="multicast://default"/>
</transportConnectors>Master/Slave集群配置
ActiveMQ Master Slave集群方案
- Share nothing storage master/slave （已过时，5.8+后移除）
- Shared storage master/slave 共享存储
- Replicated LevelDB Store 基于复制的LevelDB Store
两种集群方式对比
方式 | 高可用 | 负载均衡 |
--|----------|--------------|
Master/Slave | 是 | 否 |
Broker Cluster | 否 | 是 |
三台服务器的完美集群方案
Node A和Node B做消息同步，Node A和Node C做消息同步，Node B和Node C做Master / Slave对资源进行持久化
| 服务器 | 服务端口 | 管理端口 | 存储 | 网络连接器 | 用途 |
|---|---|---|---|---|---|
| Node-A | 61616 | 8161 | - | Node-B、Node-C | 消费者 |
| Node-B | 61617 | 8162 | /share_file/kahadb | Node-A | 生产者，消费者 |
| Node-C | 61618 | 8163 | /share_file/kahadb | Node-A | 生产者，消费者 |
企业系统中的最佳实践
实际业务场景特点
- 子业务系统都有集群的可能性
- 同一个消息会广播给关注该类消息的所有子业务系统
- 同一类消息在集群中被负载消费
- 业务的发生和消息的发布最终一致性
使用ActiveMQ的虚拟主题解决方案
- 发布者：将消息发布到一个主题中，主题名以VirtualTopic开头，如VirtualTopic.TEST
- 消费者：从队列中获取消息，在队列名中表明自己身份，如Consumer.A.VirtualTopic.TEST
使用JMS中XA系列接口保证强一致性
- 引入分布式事务
- 要求业务操作必须支持XA协议
使用消息表的本地事务解决方案
使用内存日志的解决方案
基于消息机制的事件总线
事件驱动架构
RabbitMQ
RabbitMQ：使用交换器绑定到队列
- 创建ConnectionFactory
- 创建Connection
- 创建Channel
- 定义Exchange，类型I必须为fanout
- 定义Queue并且绑定队列
Kafka
Kafka使用group.id分组消费者
- 配置消息者参数group.id相同时对消息进行负载处理
- 配置服务器partitions参数，控制同一个group.id下的consumer数量小于partitions
- kafka只保证同一个group.id下的消息是有序的
原文地址：https://www.cnblogs.com/kioluo/p/8824804.html
时间： 2024-10-12 01:02:16