一、消息中间件介绍
消息中间件的产生，个人认为是解决端对端通信问题，基于tcp/ip协议的长连接的工具，例如websocket已经做到了端对端通信，那么消息中间件的出现要解决哪些端对端问题呢？
- 消息量积压问题，大数据量高并发下，数据量太大
- 解决多端对多端问题，同个业务中消息源和消费源现实中有很多个，除了端不同，其它没有差别，所以需要无差别通信，急需要一个中间组件让多个端共享
- 解决消息安全问题，实际生产中要保证消息有效消费，需要一个组件来管理消息，让消息的得与失稳定可控。
- 简化上下游应用开发成本，即插即用的模块化思想，做到了上下游应用的松耦合
- 区别于通信的消息处理能力，可以魔法式的完成消息处理，还想花点心思赚点外快。
具体可以读读JMS规范，大差不差基于此规范开发的消息中间件。
二、消息中间件现在常用的场景
- 异步处理
- 应用解耦
- 流量削峰
- 日志处理
- 分布式消息处理
- 流式计算
三、常用消息中间件对比
| 特性 | activeMQ | rabbitMQ | rocketMQ | kafka |
|---|---|---|---|---|
| 单机吞吐量 | 万级，比rocketMQ和kafka低一个数量级 | 同activeMQ | 10万级，支撑高吞吐 | 10万级，高吞吐量，常用于大数据生态 |
| topic数量对吞吐量的影响 | 可以达到几百/几千的级别，吞吐量会有较小幅度下降，在同等机器下，可以支撑大量的topic | topic从几十到几百时，吞吐量会大幅度下降，在同等机器下，kafka尽量保证topic数量不要过多，如果要支持大规模的topic，需要增加机器数 | ||
| 时效性 | ms级 | 微秒级，延迟最低 | ms级 | 延迟在ms级以内 |
| 可用性 | 高，主从架构实现高可用 | 同activeMQ | 非常高，基于分布式架构 | 非常高，分布式，一个partition多个副本，少数机器宕机不会丢失数据，高可用 |
| 消息可靠性 | 有较低的概率丢失数据 | 基本不丢 | 经过参数优化配置，做到0丢失 | 同rocketMQ |
| 功能支持 | MQ领域功能完备 | 基于erlang开发，并发能力强，性能极好，延迟很低 | MQ功能较为完善，分布式，扩展性好 | 功能较为简单，支持简单MQ功能，在大数据领域的实时计算和日志采集被大规模使用 |
| 社区活跃度 | 低 | 中 | 高 | 高 |
四、kafka介绍
kafka是一个分布式，支持分区（partition），多副本（replica），基于类似zk协调的分布式消息系统。常用于实时处理大数据量场景，比如日志收集、用户活动追踪、运营指标分析报告和报警。是大数据生态中的常客。
1. kafka架构图
kafka集群一般需要一个分布式协调框架，常用zookeeper。kafka分布式体现在partition上，可以配置多个分区副本，但只有leader分区参与读写。controller在kafka集群中参与分区管理，包括分区故障恢复以及集群元数据同步分发。
2. 消费流程
生产者指定分区或key来发送消息，发送完会受到ack，但不表示发送成功，具体需要参考ack配置策略。
kafka集群，会将消息提交到leader中的partition，partition维护segement文件，支持消息的顺序读写，并将消息同步到其它副本分区。在读写消息时，支持零拷贝，大大提高读写性能。kafka基于磁盘文件存储，顺序读写和零拷贝保证读写性能大大提高，可以比肩内存存储的读写。
消费者通过消费者组来订阅topic，topic对消费组是多播，对消费组中的各个消费者是单播。单播得益于rebalance机制，每个分区只能绑定消费组内的一个消费者，topic下分区和组内消费者只存在多对一的关系。消费者需要自己维护分区的offset，消费消息后需要提交offset到kafka，保存最后一个消费消息的偏移量。
3. HW和LEO
HW为高水位，取一个partition对应的ISR中最小的LEO(log-end-offset)作为HW，consumer最多只能消费到HW所在的位置。每个副本都有HW，leader和follower各自负责更新自己的HW状态。对于leader新写入的消息，consumer不能立即消费，leader会等消息被ISR中所有replicas同步更新后更新HW，此时消息才能被消费者消费。这样做保证leader所在broker宕机后，该消息仍然可以从新选出来的leader中获取到。
五、kafka集群搭建
1. 环境配置
1.搭建三台虚拟机，节点分别为192.168.47.128、192.168.47.129、192.168.47.130
2.安装好jdk环境
3.下载apache-zookeeper-3.8.3-bin.tar.gz并解压，搭建zk集群并启动
4.下载kafka_2.12-3.6.0版本到三台虚拟机，并添加到系统环境中
2. 修改配置
修改 config/server.properties文件，在三台虚拟机中都需要修改。
3. 启动kafka集群
在每台虚拟机上执行 kafka-server-start.sh -daemon ../config/server.properties，启动kafka集群
查看kafka集群是否启动成功，可以连接zk集群 zkCli.sh -server master1:2181,worker1:2182,worker2:2183 查看如下，表示成功：
六、kafka 客户端配置
1. java客户端配置
1.1 引入依赖
1.2 配置生产者和消费者
package com.spring.zkkafka.conf;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Properties;
@Configuration
public class ConfigKafka {
@Bean
Producer<String, String> kafkaProducer() {
Properties props = new Properties();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.47.128:9092,192.168.47.129:9093,192.168.47.130:9094");
props.put(ProducerConfig.ACKS_CONFIG, "1"); // ack 确认机制
props.put(ProducerConfig.RETRIES_CONFIG, 3); // 重试次数
props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 3000); // 每次重试之间间隔时间
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432); // 生产者本地缓冲区大小，可以提高发送性能，默认32MB
props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); // 批量发送消息量大小，默认16384，即16KB
props.put(ProducerConfig.LINGER_MS_CONFIG, 10); // 发送消息的延迟时间，默认为0，有消息就发送，设置10ms发送，但如果batch够了也发送
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); // 设置key序列化工具
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); // 设置value序列化工具
return new KafkaProducer<>(props);
}
@Bean
KafkaConsumer<String, String> kafkaConsumer() {
Properties props = new Properties();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.47.128:9092,192.168.47.129:9093,192.168.47.130:9094");
props.put(ConsumerConfig.GROUP_ID_CONFIG, "testGroup_2"); // 消费者组
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false); // 改为手动提交，默认自动提交（poll之后就提交offset了）
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // key值反序列化(二进制转成字符串)
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // value值反序列化(二进制转成字符串)
/*
当消费主题的是一个新的消费组，或者offset不存在，怎么消费
latest(默认)：只消费自己启动之后发送到主题的消息
earliest：第一次从头开始消费，之后按照offset记录继续消费，这个区别于consumer.seekToBeginning（每次都从头消费）
*/
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");
props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 1000); // consumer给broker发送的心跳间隔时间毫秒
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10 * 1000); // kafka如果10s没有收到消费者心跳，则会把消费者剔除消费组，进行rebalance.
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 10); // 一次poll能拉的最大消息条数，根据消费能力设定. 默认值500
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 30 * 1000); // 两次poll的时间超过30s，kafka认为消费能力低，剔除消费组，触发rebalance
return new KafkaConsumer<>(props);
}
}1.3 测试用例
package com.spring.zkkafka;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.common.TopicPartition;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.time.Duration;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
@SpringBootTest
public class KafkaTest {
@Autowired
private Producer<String, String> kafkaProducer;
@Autowired
private KafkaConsumer<String, String> kafkaConsumer;
private String topic = "testt";
@Test
public void sendMessage() throws ExecutionException, InterruptedException {
ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, "my",
"client-test11");
RecordMetadata metadata = kafkaProducer.send(producerRecord).get();
System.out.printf("发送消息成功：message-%s, topic-%s, partition-%s, offset-%d%n", "client-test11", metadata.topic(),
metadata.partition(), metadata.offset());
kafkaProducer.close();
}
@Test
public void sendAsyncMessage() throws IOException {
for (int i = 0; i < 10; i++) {
String mess = "kkkk" + i;
ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, 1, "myzff",
mess);
kafkaProducer.send(producerRecord, (recordMetadata, e) -> {
if (e != null) {
System.out.printf("消息 %s 发送失败，报异常 %s%n", mess, e.getMessage());
} else {
System.out.printf("发送消息成功：message-%s, topic-%s, partition-%s, offset-%d%n", mess,
recordMetadata.topic(), recordMetadata.partition(), recordMetadata.offset());
}
});
}
System.out.println("主线程 -------------------");
System.in.read();
}
@Test
public void testConsumer() throws InterruptedException {
kafkaConsumer.subscribe(Collections.singletonList(topic)); // 内部算法，自动分给分区给消费组中的消费者(range、轮询、sticky)
// 手动指定分区消费，手动指定分区后，消费者自动分区就会失效(如果不提交offset，不影响subscribe的消费者)
// kafkaConsumer.assign(Collections.singletonList(new TopicPartition(topic, 1)));
// kafkaConsumer.seekToBeginning(Collections.singletonList(new TopicPartition(topic, 1))); // 指定分区消费后，可以从头0开始消费，消费者启动后每次都从0开始消费
// 手动指定分区偏移量消费，消费者自动分区就会失效(如果不提交offset，不影响subscribe的消费offset)
// kafkaConsumer.assign(Collections.singletonList(new TopicPartition(topic, 1)));
// kafkaConsumer.seek(new TopicPartition(topic, 1),75); // 指定分区开始消费的offset
// 手动指定时间开始消费，这里消费topic中所偶分区，消费者自动分区就会失效(如果不提交offset，不影响subscribe的消费offset)
// List<PartitionInfo> partitions = kafkaConsumer.partitionsFor(topic); // 获取所有分区
// long millis = System.currentTimeMillis() - 1000 * 60 * 20;
// Map<TopicPartition, Long> tPTime = new HashMap<>(partitions.size());
// for (PartitionInfo p : partitions) {
// tPTime.put(new TopicPartition(p.topic(), p.partition()), millis);
// }
// Map<TopicPartition, OffsetAndTimestamp> tPOffsetMap = kafkaConsumer.offsetsForTimes(tPTime);
// // 这种方式有问题，assign方法使用一次，后面的会覆盖前面指派的分区，所以要指派分区后消费完，再指派
// for (Map.Entry<TopicPartition, OffsetAndTimestamp> entry : tPOffsetMap.entrySet()) {
// TopicPartition topicPartition = entry.getKey();
// OffsetAndTimestamp offsetAndTimestamp = entry.getValue();
// if (topicPartition == null || offsetAndTimestamp == null) continue;
// kafkaConsumer.assign(Collections.singletonList(topicPartition)); // 手动指定分区偏移量，只能指定一个分区后消费完，再指定另外的分区消费
// kafkaConsumer.seek(topicPartition, offsetAndTimestamp.offset());
// // 消费逻辑，一个分区一个分区消费
// }
// 长轮训消费
while (true) {
ConsumerRecords<String, String> records = kafkaConsumer.poll(Duration.ofMillis(1000)); // poll在1s内是长轮询poll
for (ConsumerRecord<String, String> record : records) {
System.out.printf("收到消息：topic-%s, partition-%s, offset-%d, key-%s, value-%s%n", record.topic(),
record.partition(), record.offset(), record.key(), record.value());
}
if (!records.isEmpty()) {
// TimeUnit.SECONDS.sleep(40); // 这里是模拟 两次poll间隔超过30s，kafka会把该消费者剔除消费者组
kafkaConsumer.commitSync(); // 阻塞 每批相同分区的offset只需要提交一次（顺序消费，每个分区提交最后消费的消息，即为最大的offset）
kafkaConsumer.commitAsync((map, e) -> { // 异步 每批相同分区的offset只需要提交一次
if (e != null) {
System.out.println(e.getMessage());
} else {
for (Map.Entry<TopicPartition, OffsetAndMetadata> entry : map.entrySet()) {
System.out.printf("已提交offset : partition-%s，offset-%s.%n", entry.getKey().partition(),
entry.getValue().offset());
}
}
});
}
if (records.isEmpty()) {
TimeUnit.SECONDS.sleep(2);
}
}
}
}2. springboot 配置
2.1 引入依赖
2.2 参数配置
server.port=8080
#### ZK ####
curator.retryCount=5
curator.elapsedTimeMs=5000
curator.server=192.168.47.128:2181,192.168.47.129:2182,192.168.47.130:2183
curator.sessionTimeoutMs=600000
curator.connectTimeoutMs=5000
#### kafka ####
### producer ####
spring.kafka.bootstrapServers=192.168.47.128:9092,192.168.47.129:9093,192.168.47.130:9094
spring.kafka.producer.acks=1
spring.kafka.producer.batchSize=16384
spring.kafka.producer.bufferMemory=33554432
spring.kafka.producer.retries=3
spring.kafka.producer.keySerializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.valueSerializer=org.apache.kafka.common.serialization.StringSerializer
### consumer ####
spring.kafka.consumer.groupId=testGroup_2
spring.kafka.consumer.enableAutoCommit=false
spring.kafka.consumer.autoOffsetReset=earliest
spring.kafka.consumer.heartbeatInterval=1000
spring.kafka.consumer.maxPollRecords=5
spring.kafka.consumer.keyDeserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.valueDeserializer=org.apache.kafka.common.serialization.StringDeserializer
### listener ####
## MANUAL_IMMEDIATE(调用ack..方法就提交了，MANUAL(批量提交，消费端本地暂存offset(每个分区最大Offset)，poll的数据消费完后，在下次poll时提交(惰性提交))) ##
spring.kafka.listener.ackMode=MANUAL_IMMEDIATE2.3 客户端消费者配置
package com.spring.zkkafka.conf;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
@Configuration
@ConditionalOnClass(ConfigKafka.MyConsumer.class)
public class ConfigKafka {
@Bean
@ConditionalOnMissingBean(MyConsumer.class)
MyConsumer myConsumer() {
return new MyConsumer();
}
static class MyConsumer {
@KafkaListener(topics = "testt", groupId = "testGroup_2")
void listenGroup(ConsumerRecord<String, String> record, Acknowledgment ack) {
String value = record.value();
System.out.printf("消费成功：%s.%n", value);
ack.acknowledge(); // 手动提交
}
}
}2.4 生产者调用
package com.spring.zkkafka;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
@SpringBootTest
public class KafkaTest {
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
private String topic = "testt";
@Test
public void sendMessageSpringBoot() throws ExecutionException, InterruptedException, IOException {
SendResult<String, String> res = kafkaTemplate.send(topic, 1, "key", "springboot发送消息了").get();
System.out.printf("发送成功：%s%n", res.getProducerRecord().value());
System.in.read();
}
}七、kafka监听kafka-eagle的搭建
1. 环境准备
下载efak-web-3.0.1-bin.tar.gz到本地任意一台虚拟机，解压缩，添加系统环境配置
2. 修改配置文件
vi conf/system-config.properties
3. 启动并访问监控页面
ke.sh start
扫一扫
1011
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
