Java消息中间件(activeMQ)

最新推荐文章于 2024-10-02 17:34:46 发布
置顶 最新推荐文章于 2024-10-02 17:34:46 发布
阅读量3.1k 收藏 20
点赞数 5
分类专栏： JavaEE 文章标签： JMS AMQP Java消息中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcl_love_wx/article/details/78406416
版权

文章目录

第一章 消息中间件概述

1. 消息中间件的好处

解耦、异步、横向扩展、安全可靠、顺序保证

2. 什么是消息中间件

发送和接收数据，利用高效可靠的异步消息传递机制集成分布式系统

3. 什么是JMS（规范）

Java消息服务（Java Message Service），是一个Java平台中面向消息中间件的API

4. 什么是AMQP（协议）

AMQP(advanced message queuing protocol)，是一个提供统一消息服务的应用层标准协议。
此协议不受客户端和中间件的不同产品和不同开发语言的限制。

5. 几个常用消息中间对比

.ActiveMQRabbitMQKafka
优点遵循JMS规范，安装方便继承Erlang天生的并发性，最初用于金融行业，稳定性和安全性有保障依赖zk，可动态扩展节点，高性能、高吞吐量、无限扩容、消息可指定追溯
缺点有可能会丢失消息。现在的重心在下一代产品apolle上，所以5.x的产品不怎么维护了Erlang语言难度较大，不支持动态扩展严格的顺序机制，不支持消息优先级，不支持标准的消息协议，不利于平台迁移
支持协议AMQP,OpenWire,Stomp,XMPPAMQP
应用适合中小企业，不适合好千个队列的应用适合对稳定性要求高的企业级应用应用在大数据日志处理或对实时性、可靠性（少量数据丢失）要求较低的场景应用

第二章 初始JMS

2.1 JSM相关概念

  1. 提供者： 实现JMS规范的消息中间件服务器
  2. 客户端：发送或接收消息的应用程序
  3. 生产者/发布者： 创建并发送消息的客户端
  4. 消费者/订阅者：接收并处理消息的客户端
  5. 消息：应用程序之间传递的数据内容
  6. 消息模式：在客户端之间传递消息的方式，JMS中定义了主题和队列两种模式

2.2 队列模式

1. 特性：
客户端包括生产者和消费者
队列中的消息只能被一个消息费者消息
消费者可以随时消费队列中的消息

2. 队列模型示意图

这里写图片描述

2.3 主题模式

1. 特性：
客户端包括发布者和订阅者
主题中的消息被所有订阅者消息
消费者不能消费订阅之前就发送到主题中的消息

2. 主题模型示意图
这里写图片描述

2.4 JSM编码接口

ConnectionFactory 用于创建连接到消息中间件的连接工厂
Connection 代表了应用程序和消息服务器之间的通信链路
Destination 指消息发布和接收的地点，包括队列或主题
Session 表示一个单线程的上下文，用于发送和接收消息
MessageProducer 由会话创建，用于发送消息到目标
MessageConsumer 由会话创建，用于接收发送到目标的消息
Message 是在消费者和生产者之间传送的对象， 消息头，一组消息属性，一个消息体
这里写图片描述

第三章 ActiveMQ的使用

3.1 activeMQ在Windows平台上的安装

1.下载ActiveMQ
去官方网站下载：http://activemq.apache.org/activemq-5152-release.html

2.运行ActiveMQ
解压缩apache-activemq-5.5.1-bin.zip到C盘，然后双击C:\apache-activemq-5.15.2\bin\win64\activemq.bat运行ActiveMQ程序。

启动ActiveMQ以后，登陆：http://localhost:8161/admin/，进入管理界面。
用户名与密码均为：admin

3.2 ActiveMQ的队列模式

生产者代码片：

package com.queue;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
/**
 * 生产者
 * @author Peter
 *
 */
public class Proceducer {

	/**
	 * 
	 */
	private final static String URL = "tcp://localhost:61616";
	/**
	 * 
	 */
	private final static String QUEUE_NAME = "queue-name";
	
	public static void main(String[] args) throws JMSException {
		// 1. 创建ConnectionFactory
		ConnectionFactory factory = new ActiveMQConnectionFactory(URL);
		// 2. 创建Connection
		Connection con = factory.createConnection();
		// 3. 启动连接
		con.start();
		// 4. 创建会话
		Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE);
		// 5. 创建一个目标
		Destination dest = session.createQueue(QUEUE_NAME);
		// 6. 创建一个生产者
		MessageProducer pro = (MessageProducer) session.createProducer(dest);
		for(int i = 0; i<10;i++) {
			// 7. 创建消息
			TextMessage msg = session.createTextMessage("消息"+i); 
			// 8. 发布消息
			pro.send(msg);
			System.out.println(msg);
		}
		// 9. 关闭连接
		con.close();
	}
}

执行上面代码后，在管理界面看到的结果是：
这里写图片描述

消费者代码片：

/**
 * 消费者
 * @author Peter
 */
public class Consumer {
	/**
	 * 中间件地址
	 */
	private final static String URL = "tcp://localhost:61616";
	/**
	 * 中间件队列名，与生产者的一致
	 */
	private final static String QUEUE_NAME = "queue-name";
	
	public static void main(String[] args) throws JMSException {
		// 1. 创建ConnectionFactory
		ConnectionFactory factory = new ActiveMQConnectionFactory(URL);
		// 2. 创建Connection
		Connection con = factory.createConnection();
		// 3. 启动连接
		con.start();
		// 4. 创建会话
		Session session = con.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
		// 5. 创建一个目标
		Destination dest = session.createQueue(QUEUE_NAME);				
		// 6. 创建一个消费者
		MessageConsumer consumer = session.createConsumer(dest);
		// 7. 创建一个监听器
		consumer.setMessageListener(new MessageListener() {			
			@Override
			public void onMessage(Message message) {
				TextMessage msg = (TextMessage) message;
				try {
					System.out.println("接收消息为："+msg.getText());
				} catch (JMSException e) {
					e.printStackTrace();
				}
			}
		});
		// 先不关闭，不然还没接收到消息就关闭了
		 //con.close();
	}
}

执行上面代码后，在管理界面的结果如下：
这里写图片描述

如果我再新建一个消费者，我们会发现，两个消费者在抢收消息，即一个消费者收到了消息，则另一个消费者就收不到该消息了。

3.3 ActiveMQ的主题模式（发布/订阅）

由于订阅者是收不到还未订阅主题之前的内容的，所以必须要先启动订阅者。

订阅者代码片:

/**
 * 订阅者
 * @author Peter
 *
 */
public class Consumer {
	private final static String URL = "tcp://localhost:61616";
	private final static String TOPIC_NAME = "topic-name";
	
	public static void main(String[] args) throws JMSException {
		// 1. 创建ConnectionFactory
		ConnectionFactory factory = new ActiveMQConnectionFactory(URL);
		// 2. 创建Connection
		Connection con = factory.createConnection();
		// 3. 启动连接
		con.start();
		// 4. 创建会话
		Session session = con.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
		// 5. 创建一个目标【与队列模式的区别就在这里，相当于订阅了该主题】
		Destination dest = session.createTopic(TOPIC_NAME);			
		// 6. 创建一个消费者
		MessageConsumer consumer = session.createConsumer(dest);
		// 7. 创建一个监听器
		consumer.setMessageListener(new MessageListener() {			
			@Override
			public void onMessage(Message message) {
				TextMessage msg = (TextMessage) message;
				try {
					System.out.println("接收消息为："+msg.getText());
				} catch (JMSException e) {
					e.printStackTrace();
				}
			}
		});
		// 先不关闭，不然还没接收到消息就关闭了
		 //con.close();
	}
}

发布者代码片：

/**
 * 发布者
 * @author Peter
 *
 */
public class Proceducer {

	private final static String URL = "tcp://localhost:61616";
	private final static String TOPIC_NAME = "topic-name";
	
	public static void main(String[] args) throws JMSException {
		// 1. 创建ConnectionFactory
		ConnectionFactory factory = new ActiveMQConnectionFactory(URL);
		// 2. 创建Connection
		Connection con = factory.createConnection();
		// 3. 启动连接
		con.start();
		// 4. 创建会话
		Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE);
		// 5. 创建一个目标【与队列模式的区别就在这里，相当于发布一个主题】
		Destination dest = session.createTopic(TOPIC_NAME);
		// 6. 创建一个生产者
		MessageProducer pro = (MessageProducer) session.createProducer(dest);
		for(int i = 0; i<10;i++) {
			// 7. 创建消息
			TextMessage msg = session.createTextMessage("消息"+i); 
			// 8. 发布消息
			pro.send(msg);
			System.out.println(msg);
		}
		// 9. 关闭连接
		con.close();
	}
}

如果我们再新建一个订阅者，我们会发现两个订阅者收到的消息完全一样。

3.4 spring集成JMS连接ActiveMQ

我们下载的activeMQ压缩文件里解压后，能找到相关的jar包，但spring-jms这个可去maven仓库下载

3.4.1 几个相关类

1. ConnectionFactory 用于管理连接的连接工厂【也是连接池：管理JmsTemplate每次发送消息都会重新创建的连接、会话、productor】
实现类：
SingleConnectionFactory：每次都返回同一个连接
CachingConnectionFactory：继承了SingleConnectionFactory，并实现了缓存

2.JmsTemplate 用于发送和接收消息的模板类
由spring提供，它是线程安全类，可以在整个应用范围内应用

3.MessageListener 消息监听器
只需实现一个只接收Message参数的onMesssage方法

3.4.2 消息队列模式与spring集成

1. 发送消息的接口

public interface ProducerInter {
	public void sendMessage(String message);
}

2. 发送消息实现类

import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class ProducerImpl implements ProducerInter {
	
	@Autowired
	JmsTemplate jms;
	// 由于可能会有多个目标，所以一定要以注入bean的id区分
	@Resource(name="destination")
	Destination destination;

	@Override
	public void sendMessage(String message) {
		jms.send(destination, new MessageCreator() {			
			@Override
			public Message createMessage(Session sessioin) throws JMSException {
				TextMessage msg = sessioin.createTextMessage(message);
				System.out.println("发送消息："+msg.getText());
				return msg;
			}
		});
		
	}

}

3. 配置文件（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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-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/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd  
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
            http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd"
	default-autowire="byName" default-lazy-init="false">
	
	<!-- 开启注解 -->
	<context:component-scan base-package="com.jms.spring"></context:component-scan>
	
	<!-- ActiveMQ提供的 -->
	<bean id="targetConnectionFactoryId" class="org.apache.activemq.ActiveMQConnectionFactory">
		<property name="brokerURL" value="tcp://localhost:61616"/>
	</bean>
	
	<!-- spring提供的连接池 -->
	<bean id="connectionFactoryId" class="org.springframework.jms.connection.SingleConnectionFactory">
		<property name="targetConnectionFactory" ref="targetConnectionFactoryId"/>
	</bean>
	
	<!-- 创建一个点对点的队列目标对象 -->
	<bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg value="queuename"/>
	</bean>
	
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory" ref="connectionFactoryId"/>
	</bean>
	
	<!--  -->
	<bean id="producerImpl" class="com.jms.spring.ProducerImpl"></bean>
</beans>

4. 测试发送
执行之后，进入管理界面可查看结果

public class TestProducer {
 public static void main(String[] args) {
	// 从classpath下加载配置文件
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("producer.xml");
	ProducerImpl pro = (ProducerImpl) applicationContext.getBean("producerImpl");
	pro.sendMessage("hello world");

 }
}

5. 监听消息类

public class ConsumerMessageListener implements MessageListener{
	// 监听消息
	@Override
	public void onMessage(Message message) {
		TextMessage msg = (TextMessage) message;
		try {
			System.out.println("收到消息："+msg.getText());
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}

}

6. 接收消息的配置

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-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/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd  
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
            http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd"
	default-autowire="byName" default-lazy-init="false">
	
	<!-- 开启注解 -->
	<context:component-scan base-package="com.jms.spring"></context:component-scan>
	
	<!-- ActiveMQ提供的 -->
	<bean id="targetConnectionFactoryId" class="org.apache.activemq.ActiveMQConnectionFactory">
		<property name="brokerURL" value="tcp://localhost:61616"/>
	</bean>
	
	<!-- spring提供的连接池 -->
	<bean id="connectionFactoryId" class="org.springframework.jms.connection.SingleConnectionFactory">
		<property name="targetConnectionFactory" ref="targetConnectionFactoryId"/>
	</bean>
	
	<!-- 创建一个点对点的队列目标对象 -->
	<bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg value="queuename"/>
	</bean>
	
	<!-- 上面的配置与producer.xml里是一样的 -->
	
	<!-- 注入消息监听器 -->
	<bean id="consumerMessageListener" class="com.jms.spring.ConsumerMessageListener"></bean>
	
	<!-- 配置消息监听容器 -->
	<bean id="jmsContainerListener" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactoryId"/>
		<property name="destination" ref="destination"/>
		<property name="messageListener" ref="consumerMessageListener"/>
	</bean>
	
</beans>

7. 测试消费者

public class TestConsumer {
	public static void main(String[] args) {
		new ClassPathXmlApplicationContext("consumer.xml");		
	}
}
3.4.3 主题模式与spring的集成

只需要将配置文件中的目标对象org.apache.activemq.command.ActiveMQQueue改成org.apache.activemq.command.ActiveMQTopic即可。需要注意的是，在主题模式下，一定要先启动消费者。

第四章 ActiveMQ集群

4.1 集群方式

客户端集群：让多个消费者消费同一个队列
Broker clusters：多个Broker之间同步消息
Master Slave（主从）：实现高可用

4.2 客户端配置

4.2.1. ActiveMQ失效转移（failover）：

定义：允许当其中一台消息服务器宕机时，客户端在传输层上重新连接到其它消息服务器
语法：failover:(uri1,uri2,…,uriN)?transportOptions
transportOptions参数说明
randomize 默认为true，表示在uri列表中选择uri连接时，是否采用随机策略
initialReconnectDelay 默认为10，单位毫秒，表示第一尝试重连之间等待的时间
maxReconnectionDelay 默认30000，单位毫秒，最长重连的时间间隔

4.3 Broker Cluster集群配置

1. 原理：
这里写图片描述
2. NetworkConnector(网络连接器)
网络连接器主要用于配置ActiveMQ服务器与服务器之间的网络通讯方式，用于服务器透传消息
分为静态连接器和动态连接器

3. 静态连接器：适用连接地址不多的情况

<networkConnectors>
	<networkConnector uri="static:(tcp://127.0.0.1:61617,tcp://127.0.0.1:61618)">
</networkConnectors>

4. 动态连接器

<networkConnectors>
	<networkConnector uri="multicast://default">
</networkConnectors>
<transportConnectors>
	<transportConnector uri="tcp://localhost:0" discoveryUri="multicast://default">
</transportConnectors>

4.4 Master/Slave集群配置

1. Master/Slave集群方案
Share nothing storage master/slave (5.8 以后的版本删除了)
Share storage master/slave 共享存储
Replicated LevelDB Store 基于可复制的LevelDB Store

2. 共享存储集群的原理
先启动A，A就因为排他锁独占资源成为Master，此时A有外部服务能力，而B没有
这里写图片描述
如果A挂了，则B获取资源成为Master，这时所有请求都会交给B
这里写图片描述

3. 基于复制的LevelDB Store的原理
因为是基于ZooKeeper的，所以至少需要3劝服务器。zk选举A作为Master后，A就具有了外部服务能力，而B、C没有。当A获取到外部资源存储后，会通过zk将资源同步到B和C。
这里写图片描述
如果A故障，则zk会重新选举一个节点作为Master

4.5 Broker clusters和Master Slave对比

.高可用负载均衡
Master/Slave是否
Broker Cluster否是

4.6 高可用且负载均衡的集群方案

这里写图片描述

第五章 消息中间件如何传对象

利用Json

Java-分布式系统---消息中间件
HuangWeiGen的博客
12-16 587
简介 消息中间件也可以称消息队列，是指用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息队列模型，可以在分布式环境下扩展进程的通信。当下主流的消息中间件有RabbitMQ、Kafka、ActiveMQ、RocketMQ等。其能在不同平台之间进行通信，常用来屏蔽各种平台协议之间的特性，实现应用程序之间的协同。其优点在于能够在客户端和服务器之...
Java消息中间件
c136547731的博客
01-31 1314
消息中间件带来的好处：解耦、异步、横向扩展、安全可靠、顺序保证等。1.消息中间件的概述什么是中间件？非底层操作系统软件，非业务应用软件，不是直接给用户使用的，不能直接给客户带来价值的软件统称为中间件。什么是消息中间件？关注于数据的发送和接收，利用高效可靠的异步传输机制集成分布式系统。什么是JMS?Java消息服务(Java Message Service)即JMS，是一个Java平台中关于面向消息中
MQ 系列之 ActiveMQ 可靠性
Demo_Null
12-09 304
由持久化、事务、签收三者保证 ActiveMQ 的可靠性
消息中间件---初识（Kafka、RocketMQ、RabbitMQ、ActiveMQ、Redis）
weixin_44929475的博客
10-02 1888
消息中间件是一种支撑性软件系统，它在网络环境中为应用系统提供同步或异步、可靠的消息传输。消息中间件利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。它支持多种通信协议和数据格式，可以在不同的应用系统之间进行透明的消息传递。消息中间件的主要特点包括异步通信、持久化、削峰填谷、系统解耦、集群扩展、负载均衡等。
Java消息中间件---基础篇
lydia88的专栏
03-21 271
1.概述中间件 非底层操作系统软件，非业务应用软件，不是直接给最终用户使用的，不能直接给客户带来价值的软件统称为中间件。 消息中间件 管制关注于数据的发送和接收，利用高效可靠的异步消息传递机制集成分布式系统。 优点 ① 解耦 ② 异步 ③ 横向扩展 ④ 安全可靠 ⑤ 顺序保证（比如kafka） jms java消息服务(Java Message Service)即JMS，是一个Java平台中关于面...
java 消息中间件_学习笔记--Java消息中间件
weixin_42414212的博客
02-16 437
消息中间件消息中间件：关注于数据的发送和接受，利用高效可靠的异步消息传递机制集成分布式系统JMS：Java消息服务，Java平台中关于面向消息中间件的APIAMQP：提供统一消息服务的应用层标准协议常见消息中间件ActiveMQRabbitMQKafkaJMS规范提供者：实现JMS规范的消息中间件服务器客户端：发送或接受消息的应用程序生产者/发布者：创建并发送消息的客户端消费者/订阅者：接收并处理...
Java消息中间件ActiveMQ学习资料
06-18
Java消息中间件ActiveMQ是Apache软件基金会开发的一款开源消息队列系统，广泛应用于分布式系统中的异步处理和解耦。ActiveMQ提供了多种协议支持，包括开放标准的JMS（Java Message Service）和AMQP（Advanced ...
java消息中间件之ActiveMq安装
06-16
安装 下载完成后，我们直接解压即可，解压后的目录如下： 进入相对应的目录双击a c t i v e M q.bat启动我们的服务端即可。 E:\tools\M q\Activit eM q\apache-a c t i v e M q-5.16.0-bin\apache-a c t i v e M q-...
工作学习-消息中间件activeMQ学习总结
11-23
工作学习-消息中间件ActiveMQ学习总结 本文总结了消息中间件ActiveMQ的学习要点，涵盖了为什么使用消息中间件、消息中间件的组成、JMS规范、ActiveMQ简介、消息中间件的应用场景等方面。 一、为什么使用消息中间件...
基于Java的Apache ActiveMQ高性能消息中间件设计源码
最新发布
10-04
该项目为Apache ActiveMQ高性能消息中间件设计源码，采用Java语言编写，总计包含5357个文件，其中Java源文件4383个，XML配置文件340个，属性文件82个，HTML文件77个，JavaScript文件35个，Markdown文件31个，PNG图片...
java消息中间件
08-16
java消息中间件入门资料，中间件 非底层操作系统软件，非业务应用软件，不是直接给最终用户使用的，不能直接给客户带来价值的软件统称为中间件。 消息中间件 管制关注于数据的发送和接收，利用高效可靠的异步消息传递机制集成分布式系统。 优点 ① 解耦 ② 异步 ③ 横向扩展 ④ 安全可靠 ⑤ 顺序保证（比如kafka） jms java消息服务(Java Message Service)即JMS，是一个Java平台中关于面向消息中间件的api，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信 什么是AMQP AMQP(advanced message queuing protocol)是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言等条件的限制 常见消息中间件 activeMQ（支持多语言，实现jms1.1，j2ee1.4规范），RabbitMQ（支持更多语言，基于AMQP规范），kafka(高吞吐量，分布式，分区,O(1)磁盘顺序提供消息持久化)
java消息中间件教程-activemq
12-20
### Java消息中间件教程——ActiveMQ #### 一、课程安排与消息中间件的重要性 - **1-1 课程安排**：本课程旨在系统性地介绍ActiveMQ的各个方面，包括安装、使用、集群搭建等内容。 - **1-2 为什么使用消息中间件**...
JAVA消息中间件/消息队列
qq_52093708的博客
06-08 1497
1、消息中间件也可以称消息队列，是指用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。2、通过提供消息传递和消息队列模型，可以在分布式环境下扩展进程的通信。当下主流的消息中间件有RabbitMQ、Kafka、ActiveMQ、RocketMQ等。其能在不同平台之间进行通信，常用来屏蔽各种平台协议之间的特性，实现应用程序之间的协同。3、其优点在于能够在客户端和服务器之间进行同步和异步的连接，并且在任何时刻都可以将消息进行传送和转发，是分布式系统中非常重要的组件。
java 中间件介绍（一）
热门推荐
苏叶的专栏
05-11 4万+
1.定义　中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源，中间件位于客户机服务器的操作系统之上，管理计算资源和网络通信，也可以定义为网络环境下处于操作系统、数据库等系统软件和应用软件之间的一种起连接作用的分布式软件，主要解决异构网络环境下分布式应用软件的互连与互操作问题，提供标准接口、协议，屏蔽实现细节，提高应用系统易移植性。2.作用　中间件通过提供简单、一
java消息中间件的测试
iteye_6063的博客
09-09 564
前段时间刚测试的一个项目，其中两个系统之间需要实现增量数量的读取更新，即A系统获取到增量数据后通知B系统获取新增数据并进行后续的处理，为达到这一目标，最终设计为A数据存在增量数据至activeMQ，B系统从activeMQ中获取数据，为此，开发童鞋需实现一个通用的客户端工具包，方便两个系统发送和读取消息。 测试思路： 根据项目情况分析，该消息中间件的测试主要关注点是“生产者”、“消费者”两者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值