头条系统-06-kafka及异步通知文章上下架-kafka（主题！，分区！，高可用集群，生产消费，消费者组！）、springboot集成kafka（文章上下架业务通过kafka实现）

奇迹是执着的人创造的

已于 2024-06-27 00:28:32 修改

阅读量846

点赞数 18

分类专栏：分布式 # 分布式实战文章标签： kafka linq 分布式

于 2024-06-27 00:27:04 首次发布

本文链接：https://blog.csdn.net/hza419763578/article/details/139907167

版权

分布式同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

分布式实战

8 篇文章 0 订阅

订阅专栏

主题，生产者消费者根据主题确定同一条消息队列
分区：一个主题存放在几个队列里（一般1个分区，多个分区就是把主题存放在多个队列，可能会破坏消息生产和消费的次序）
消费者组：每个组只有一台机器能收到同一个消息，一个组内，消息只会被消费一次。（同一条消息，每个组都会消费一次）

kafka及异步通知文章上下架

1)自媒体文章上下架

需求分析

在这里插入图片描述

2)kafka概述

消息中间件对比

特性	ActiveMQ	RabbitMQ	RocketMQ	Kafka
开发语言	java	erlang	java	scala
单机吞吐量	万级	万级	10万级	100万级
时效性	ms	us	ms	ms级以内
可用性	高（主从）	高（主从）	非常高（分布式）	非常高（分布式）
功能特性	成熟的产品、较全的文档、各种协议支持好	并发能力强、性能好、延迟低	MQ功能比较完善，扩展性佳	只支持主要的MQ功能，主要应用于大数据领域

消息中间件对比-选择建议 (主流3种)

消息中间件	建议
Kafka	追求高吞吐量，适合产生大量数据的互联网服务的数据收集业务
RocketMQ	可靠性要求很高的金融互联网领域,稳定性高，经历了多次阿里双11考验
RabbitMQ	性能较好，社区活跃度高，数据量没有那么大，优先选择功能比较完备的RabbitMQ

kafka介绍

Kafka 是一个分布式流媒体平台,类似于消息队列或企业消息传递系统。kafka官网：http://kafka.apache.org/
在这里插入图片描述

cluster: 集群
broker: 代理；中间人
Connectors用不到（从db接收消息，把消息写到db）

kafka介绍-名词解释
在这里插入图片描述

producer：发布消息的对象称之为主题生产者（Kafka topic producer）
topic：Kafka将消息分门别类，每一类的消息称之为一个主题（Topic）
consumer：订阅消息并处理发布的消息的对象称之为主题消费者（consumers）
broker：已发布的消息保存在一组服务器中，称之为Kafka集群。集群中的每一个服务器都是一个代理（Broker）。消费者可以订阅一个或多个主题（topic），并从Broker拉数据，从而消费这些已发布的消息。

3)kafka安装配置

Kafka对于zookeeper是强依赖，保存kafka相关的节点数据，所以安装Kafka之前必须先安装zookeeper

Docker安装zookeeper

下载镜像：

docker pull zookeeper:3.4.14

创建容器

docker run -d --name zookeeper -p 2181:2181 zookeeper:3.4.14

版本号不要轻易改动
若虚拟机已经安装过了，最好删除重新安装，不然后面会有问题的

# 删除已经安装的容器
docker ps | grep zookeeper
docker stop ac4dc0ef456e
docker rm ac4dc0ef456e

Docker安装kafka

下载镜像：

docker pull wurstmeister/kafka:2.12-2.3.1

创建容器

docker run -d --name kafka \
--env KAFKA_ADVERTISED_HOST_NAME=192.168.141.102 \
--env KAFKA_ZOOKEEPER_CONNECT=192.168.141.102:2181 \
--env KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.141.102:9092 \
--env KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
--env KAFKA_HEAP_OPTS="-Xmx256M -Xms256M" \
--net=host wurstmeister/kafka:2.12-2.3.1

docker ps | grep kafka 能查到正在运行的容器，但是ip配置可能不一致，删除容器重新创建即可
这里的ip应该是本机ip(虚拟机ip)

KAFKA_ADVERTISED_HOST_NAME: kafka主机地址：本虚拟机ip
KAFKA_ZOOKEEPER_CONNECT: ZOOKEEPER连接地址：本机地址：2181 (上面创建ZOOKEEPER容器时配置的端口)
KAFKA_ADVERTISED_LISTENERS： kafka容器对外监听地址：本机的9092端口（也是kafka默认端口号）

在这里插入图片描述

# 删除已经安装了的容器
docker ps | grep kafka
docker stop 3b4e615e0fd2
docker rm 3b4e615e0fd2
docker ps | grep kafka
docker ps -a | grep kafka

然后再执行创建容器的命令

查看kafka日志

docker ps | grep kafka # 拿到kafka容器id
docker logs -f d4414f1afb4e

在这里插入图片描述

4)kafka入门

在这里插入图片描述

生产者发送消息，多个消费者只能有一个消费者接收到消息
生产者发送消息，多个消费者都可以接收到消息

（1）创建kafka-demo项目，导入依赖

heima-leadnews-test下新建项目kafka-demo
在这里插入图片描述
pom.xml修改成如下形式：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.heima</groupId>
        <artifactId>heima-leadnews-test</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>kafka-demo</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
    	<!-- kafka客户端依赖 -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
        </dependency>
    </dependencies>
</project>

其中导入了kafka客户端依赖

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
</dependency>

目录结构修改成如下形式：
在这里插入图片描述

（2）生产者发送消息：ProducerQuickStart类

package cn.whu.kafka.sample;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

/**
 * 生产者
 */
public class ProducerQuickStart {

    public static void main(String[] args) {
        // 1. kafka连接配置信息
        Properties properties = new Properties();
        //kafka的连接地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.141.102:9092");
        //发送失败，失败的重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,5);
        //消息key的序列化器 死代码 两个序列化器(第二个参数)是一样的
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        //消息value的序列化器  死代码
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");

        //2. 创建kafka生产者对象
        KafkaProducer<String,String> producer = new KafkaProducer<String,String>(properties);

        //3. 发送消息
        /**
         * 第一个参数: topic (消息分类)  :string
         * 第二个参数：消息的key         :string
         * 第三个参数：消息的value       :string
         */
        ProducerRecord<String, String> kvProducerRecord = new ProducerRecord<String, String>(
                "topic-first","key-001","hello kafka");
        producer.send(kvProducerRecord);

        //4. 关闭消息通道 -- 必须要关闭，否则消息发送不成功
        producer.close();

    }
}

（3）消费者接收消息： ConsumerQuickStart类

package cn.whu.kafka.sample;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

/**
 * 消费者
 */
public class ConsumerQuickStart {

    public static void main(String[] args) {

        // 1. kafka的配置信息
        Properties properties = new Properties();
        //kafka的连接地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.141.102:9092");
        //消息的反序列化器
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //消费者组 ★
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "group1");

        // 2. 创建消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(properties);

        // 3. 订阅主题
        consumer.subscribe(Collections.singletonList("topic-first"));

        // 4. 拉取消息
        while (true){
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(1000));//每s拉取一次
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                System.out.println(consumerRecord.key());
                System.out.println(consumerRecord.value());
            }
        }
    }
}

测试

注意代码中两个ip都换成自己的
没反应可能到删除zookeeper和kafka容器，重新安装

1）先启动消费者，一直在那里poll任务，然后再启动生产者，发送一个消息
在这里插入图片描述
2）启动两个消费者，生产一个消息，应该只有一个消费者能收到消息（一对一，因为两个消费者都在同一个组group1下）

在这里插入图片描述

3）代码中消费者组修改成group2，然后重启ConsumerQuickStart-2，再启动ProducerQuickStart生产一个消息，应该2个消费者都能收到，因为在不同的组
在这里插入图片描述

总结

生产者发送消息，多个消费者订阅同一个主题，只能有一个消费者收到消息（一对一）
- （一对一，因为两个消费者都在同一个组group1下）
生产者发送消息，多个消费者订阅同一个主题，所有消费者都能收到消息（一对多）

在这里插入图片描述

kafka分区

在这里插入图片描述

每个分区理解为一个文件夹，主题T1的不同消息可存储在不同分区下，如图，两台机器的P1分区下都存储了T1主题的一些不同的消息
同一个主题下会有多个消息

在这里插入图片描述

如图把同一个topic的不同消息存储在3个分区下
每个分区上的消息都有编号，编号就是连续自增的数值，也叫偏移量，偏移量在当前分区下绝对唯一的

在这里插入图片描述

不同分区的消息不重复

可以用代码打印分区号，目前就一台机器(kafka服务器)，分区肯定都是唯一的

System.out.println(consumerRecord.partition());// 当前消息存储在哪个分区 打印分区号(目前就一个kafka服务器)

在这里插入图片描述

a、不指定分区，轮询策略选择消息的分区

不指定key所以是null
只有一台机器所以分区号是0
b、指定分区号 (此时key对分区不起作用)

只有一台kafka服务器，也只能指定0
c、按键的hash值选择保存的分区

5)kafka高可用设计

5.1)集群

在这里插入图片描述

Kafka 的服务器端由被称为 Broker 的服务进程构成，即一个 Kafka 集群由多个 Broker 组成
这样如果集群中某一台机器宕机，其他机器上的 Broker 也依然能够对外提供服务。这其实就是 Kafka 提供高可用的手段之一

5.2)备份机制(Replication）

在这里插入图片描述

Kafka 中消息的备份又叫做副本（Replica）

Kafka 定义了两类副本：

领导者副本（Leader Replica） 1个
追随者副本（Follower Replica）多个

同步方式
在这里插入图片描述
追随者副本又分为2类，ISR (同步备份) 和普通(异步备份)

ISR（in-sync replica）需要同步复制保存的follower

如果leader失效(挂掉了)后，需要选出新的leader，选举的原则如下：

第一：选举时优先从ISR中选定，因为这个列表中follower的数据是与leader同步的

第二：如果ISR列表中的follower都不行了，就只能从其他(普通)follower中选取

极端情况，就是所有副本都失效了，这时有两种方案

第一：等待ISR中的第一个活过来，选为Leader，数据可靠，但活过来的时间不确定

第二：选择第一个活过来的Replication，不一定是ISR中的，选为leader，以最快速度恢复可用性，但数据不一定完整

6)kafka生产者详解

6.1)发送类型

同步发送

使用send()方法发送，它会返回一个Future对象，调用get()方法进行等待，就可以知道消息是否发送成功
```
RecordMetadata recordMetadata = producer.send(kvProducerRecord).get();
System.out.println(recordMetadata.offset());
```

异步发送

调用send()方法，并指定一个回调函数，服务器在返回响应时调用函数

//异步消息发送
producer.send(kvProducerRecord, new Callback() {
    @Override
    public void onCompletion(RecordMetadata recordMetadata, Exception e) {
        if(e != null){
            System.out.println("记录异常信息到日志表中");
        }
        System.out.println(recordMetadata.offset());
    }
});

可以在测试demo里面试一下
同步测试

// 同步发送消息
RecordMetadata recordMetadata = producer.send(kvProducerRecord).get();
System.out.println(recordMetadata.offset());

在这里插入图片描述

再发offset会是9，说明偏移量确实是一个连续自增的数值

在这里插入图片描述

可以在测试demo里面试一下
异步测试

        // 异步发送消息
        producer.send(kvProducerRecord, new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                if (e != null) {
                    System.out.println("记录异常信息到日志表中:" + e.getMessage());
                }
                System.out.println(recordMetadata.offset());
            }
        });

在这里插入图片描述

6.2)参数详解

详细完整配置参数：https://blog.csdn.net/hza419763578/article/details/139969728?spm=1001.2014.3001.5501

代码的配置方式：

//ack配置  消息确认机制
properties.put(ProducerConfig.ACKS_CONFIG,"all");

在这里插入图片描述

参数的选择说明

确认机制	说明
acks=0	生产者在成功写入消息之前不会等待任何来自服务器的响应(就认为发送成功了),消息有丢失的风险，但是速度最快
acks=1（默认值）	只要集群首领节点收到消息(就认为发送成功了)，生产者就会收到一个来自服务器的成功响应
acks=all	只有当所有参与赋值的节点(leader和所有follower副本)全部收到消息时(才认为发送成功了)，生产者才会收到一个来自服务器的成功响应

实际开发中一般使用默认值1，不会去手动设置

retries

生产者从服务器收到的错误有可能是临时性错误，在这种情况下，retries参数的值决定了生产者可以重发消息的次数，如果达到这个次数，生产者会放弃重试返回错误，默认情况下，生产者会在每次重试之间等待100ms

默认配置1，需要首领确认，首领一直没有确认回馈，生产者就重试发送，最多重试次数的配置，如下为10次

代码中配置方式：

//重试次数
properties.put(ProducerConfig.RETRIES_CONFIG,10);

在这里插入图片描述

消息压缩

默认情况下，消息发送时不会被压缩。

代码中配置方式：

//数据压缩
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");//gzip/lz4 都行

压缩算法	说明
snappy	占用较少的 CPU，却能提供较好的性能和相当可观的压缩比，如果看重性能和网络带宽，建议采用
lz4	占用较少的 CPU，压缩和解压缩速度较快，压缩比也很客观
gzip	占用较多的 CPU，但会提供更高的压缩比，网络带宽有限，可以使用这种算法

使用压缩可以降低网络传输开销和存储开销，而这往往是向 Kafka 发送消息的瓶颈所在。

在这里插入图片描述

7)kafka消费者详解

7.1)消费者组

在这里插入图片描述

消费者组（Consumer Group）：指的就是由一个或多个消费者组成的群体
一个发布在Topic上消息被分发给此消费者组中的一个消费者
- 所有的消费者都在一个组中，那么这就变成了queue模型（消息队列，组内消费者只有一个能接收到消息）
- 所有的消费者都在不同的组中，那么就完全变成了发布-订阅模型（所有消费者都能接收到消息）

7.2)消息有序性

应用场景：

即时消息中的单对单聊天和群聊，保证发送方消息发送顺序与接收方的顺序一致
充值转账两个渠道在同一个时间进行余额变更，短信通知必须要有顺序

左图有两台kafka服务器，每个服务器有两个分区。下面是两个消费者组
要保证消息的有序性，那么创建topic时只能提供一个分区

topic分区中消息只能由消费者组中的唯一一个消费者处理，所以消息肯定是按照先后顺序进行处理的。但是它也仅仅是保证Topic的一个分区顺序处理，不能保证跨分区的消息先后处理顺序。所以，如果你想要顺序的处理Topic的所有消息，那就只提供一个分区。

7.3)提交和偏移量

kafka不会像其他JMS队列那样需要得到消费者的确认（rabbitMQ有确认），消费者可以使用kafka来追踪消息在分区的位置（偏移量）（通过偏移量来确认消息能否消费）

消费者会往一个叫做_consumer_offset的特殊主题发送消息，消息里包含了每个分区的偏移量。如果消费者发生崩溃或有新的消费者加入群组，就会触发再均衡
在这里插入图片描述

正常的情况
在这里插入图片描述

如果消费者2挂掉以后，会发生再均衡，消费者2负责的分区会被其他消费者进行消费

再均衡后不可避免会出现一些问题

问题一：
在这里插入图片描述

消费者X消费到了10，但是提交偏移量到2后就挂掉了

如果提交偏移量小于客户端处理的最后一个消息的偏移量，那么处于两个偏移量之间的消息就会被重复处理。

问题二：
在这里插入图片描述

准备消费到11，偏移量提交到了11，但是消费到5消费者X就挂掉了

如果提交的偏移量大于客户端的最后一个消息的偏移量，那么处于两个偏移量之间的消息将会丢失。

如果想要解决这些问题，还要知道目前kafka提交偏移量的方式：

提交偏移量的方式有两种，分别是自动提交偏移量和手动提交

自动提交偏移量

当enable.auto.commit被设置为true，提交方式就是让消费者自动提交偏移量，每隔5秒消费者会自动把从poll()方法接收的最大偏移量提交上去

手动提交，当enable.auto.commit被设置为false可以有以下三种提交方式
- 提交当前偏移量（同步提交）
- 异步提交
- 同步和异步组合提交

1.提交当前偏移量（同步提交）

把enable.auto.commit设置为false,让应用程序决定何时提交偏移量。使用commitSync()提交偏移量，commitSync()将会提交poll返回的最新的偏移量，所以在处理完所有记录后要确保调用了commitSync()方法。否则还是会有消息丢失的风险。

只要没有发生不可恢复的错误，commitSync()方法会一直尝试直至提交成功，如果提交失败也可以记录到错误日志里。

while (true){
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
    for (ConsumerRecord<String, String> record : records) {
        System.out.println(record.value());
        System.out.println(record.key());
        try {
            consumer.commitSync();//同步提交当前最新的偏移量
        }catch (CommitFailedException e){
            System.out.println("记录提交失败的异常："+e);
        }

    }
}

缺点: 一直重复尝试提交，会产生方法阻塞

2.异步提交

手动提交有一个缺点，那就是当发起提交调用时应用会阻塞。当然我们可以减少手动提交的频率，但这个会增加消息重复的概率（和自动提交一样）。另外一个解决办法是，使用异步提交的API。

while (true){
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
    for (ConsumerRecord<String, String> record : records) {
        System.out.println(record.value());
        System.out.println(record.key());
    }
    consumer.commitAsync(new OffsetCommitCallback() {
        @Override
        public void onComplete(Map<TopicPartition, OffsetAndMetadata> map, Exception e) {
            if(e!=null){
                System.out.println("记录错误的提交偏移量："+ map+",异常信息"+e);
            }
        }
    });
}

缺点：服务器返回提交失败，也不会去重试
（异步不能重试提交，可能导致偏移量的覆盖）

3.同步和异步组合提交

异步提交也有个缺点，那就是如果服务器返回提交失败，异步提交不会进行重试。相比较起来，同步提交会进行重试直到成功或者最后抛出异常给应用。异步提交没有实现重试是因为，如果同时存在多个异步提交，进行重试可能会导致位移覆盖。

举个例子，假如我们发起了一个异步提交commitA，此时的提交位移为2000，随后又发起了一个异步提交commitB且位移为3000；commitA提交失败但commitB提交成功，此时commitA进行重试并成功的话，会将实际上将已经提交的位移从3000回滚到2000，导致消息重复消费。

try {
    while (true){
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
        for (ConsumerRecord<String, String> record : records) {
            System.out.println(record.value());
            System.out.println(record.key());
        }
        consumer.commitAsync(); // 1. 先异步提交
    }
}catch (Exception e){+
    e.printStackTrace();
    System.out.println("记录错误信息："+e);
}finally {
    try {
        consumer.commitSync(); // 2. 异步失败抛异常了，再用同步提交方式去重试提交
    }finally {
        consumer.close();
    }
}

测试
ConsumerQuickStart.java

// 手动提交偏移量
properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);

在这里插入图片描述

1）手动同步提交

// 手动写代码提交，也有3种手动方式
// 1) 同步提交偏移量
try {
    consumer.commitSync();
} catch (CommitFailedException e) {
    System.out.println("记录提交失败的异常: " + e);
}

重启consumer，再生产2条消息
在这里插入图片描述

2）手动异步方式提交偏移量

// 2) 异步方式提交偏移量
consumer.commitAsync(new OffsetCommitCallback() {
    @Override
    public void onComplete(Map<TopicPartition, OffsetAndMetadata> map, Exception e) {
        if (e != null) {
            System.out.println("记录错误的提交偏移量: " + map + ",异常信息为:" + e);
        }
    }
});

在这里插入图片描述
测试方式同上1）

3）手动同步和异步结合的方式提交偏移量

// 3) 手动，同步和异步方式提交偏移量
try {
    while (true) {
        ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(1000));//每s拉取一次
        //System.out.println("isEmpty: " + consumerRecords.isEmpty());
        for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
            System.out.println(consumerRecord.key());
            System.out.println(consumerRecord.value());
            System.out.println(consumerRecord.partition());// 当前消息存储在哪个分区 打印分区号(目前就一个kafka服务器)
            System.out.println(consumerRecord.offset());
            // a、先异步提交偏移量
            consumer.commitAsync();
        }
    }
} catch (Exception e) {
    System.out.println("记录错误的信息: " + e);
} finally {
    // b、异步失败，再用同步提交方式去重试提交
    consumer.commitSync();
}

测试方式同上
在这里插入图片描述

最终代码总结

ConsumerQuickStart.java

package cn.whu.kafka.sample;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

/**
 * 消费者
 */
public class ConsumerQuickStart {

    public static void main(String[] args) {

        // 1. kafka的配置信息
        Properties properties = new Properties();
        //kafka的连接地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.141.102:9092");
        //消息的反序列化器
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //消费者组 ★
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "group2");

        // 手动提交偏移量
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);

        // 2. 创建消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(properties);

        // 3. 订阅主题
        consumer.subscribe(Collections.singletonList("topic-first"));

        // 4. 拉取消息
        /*while (true) {
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(1000));//每s拉取一次
            //System.out.println("isEmpty: " + consumerRecords.isEmpty());
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                System.out.println(consumerRecord.key());
                System.out.println(consumerRecord.value());
                System.out.println(consumerRecord.partition());// 当前消息存储在哪个分区 打印分区号(目前就一个kafka服务器)
                System.out.println(consumerRecord.offset());

                // 手动写代码提交，也有3种手动方式
                // 1) 同步提交偏移量
                *//*try {
                    consumer.commitSync();
                } catch (CommitFailedException e) {
                    System.out.println("记录提交失败的异常: " + e);
                }*//*
            }

            // 2) 异步方式提交偏移量
            consumer.commitAsync(new OffsetCommitCallback() {
                @Override
                public void onComplete(Map<TopicPartition, OffsetAndMetadata> map, Exception e) {
                    if (e != null) {
                        System.out.println("记录错误的提交偏移量: " + map + ",异常信息为:" + e);
                    }
                }
            });
        }*/

        // 3) 手动，同步和异步方式提交偏移量
        try {
            while (true) {
                ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(1000));//每s拉取一次
                //System.out.println("isEmpty: " + consumerRecords.isEmpty());
                for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                    System.out.println(consumerRecord.key());
                    System.out.println(consumerRecord.value());
                    System.out.println(consumerRecord.partition());// 当前消息存储在哪个分区 打印分区号(目前就一个kafka服务器)
                    System.out.println(consumerRecord.offset());
                    // a、先异步提交偏移量
                    consumer.commitAsync();
                }
            }
        } catch (Exception e) {
            System.out.println("记录错误的信息: " + e);
        } finally {
            // b、异步失败，再用同步提交方式去重试提交
            consumer.commitSync();
        }

    }

}

ProducerQuickStart.java

package cn.whu.kafka.sample;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;
import java.util.concurrent.ExecutionException;

/**
 * 生产者
 */
public class ProducerQuickStart {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1. kafka连接配置信息
        Properties properties = new Properties();
        //kafka的连接地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.141.102:9092");
        //发送失败，失败的重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG, 5);
        //消息key的序列化器 死代码 两个序列化器(第二个参数)是一样的
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        //消息value的序列化器  死代码
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        // ack配置
        properties.put(ProducerConfig.ACKS_CONFIG, "all");

        // 重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG, 10);

        // 数据压缩
        properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");//gzip/lz4 都行

        //2. 创建kafka生产者对象
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);

        //3. 发送消息
        /**
         * 第一个参数: topic (消息分类)  :string
         * 第二个参数：消息的key         :string
         * 第三个参数：消息的value       :string
         */
        ProducerRecord<String, String> kvProducerRecord = new ProducerRecord<String, String>(
                "topic-first", "key-001", "hello kafka");
        // 同步发送消息
        /*RecordMetadata recordMetadata = producer.send(kvProducerRecord).get();
        System.out.println(recordMetadata.offset());*/

        // 异步发送消息
        producer.send(kvProducerRecord, new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                if (e != null) {
                    System.out.println("记录异常信息到日志表中:" + e.getMessage());
                }
                System.out.println(recordMetadata.offset());
            }
        });


        //4. 关闭消息通道 -- 必须要关闭，否则消息发送不成功
        producer.close();

    }
}

8)springboot集成kafka

8.1)入门

1.导入spring-kafka依赖信息

kafka-demo的pom.xml的<dependencies>替换成下面的形式

<dependencies>
    <!-- 需要用到controller -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- kafkfa -->
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.apache.kafka</groupId>
                <artifactId>kafka-clients</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
    </dependency>
</dependencies>

2.新建引导类
KafkaDemoApplication
在这里插入图片描述

package cn.whu.kafka;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class KafkaDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(KafkaDemoApplication.class, args);
    }
}

3.在resources下创建文件application.yml

server:
  port: 9991
spring:
  application:
    name: kafka-demo
  kafka:
    bootstrap-servers: 192.168.141.102:9092
    producer:
      retries: 10
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer # 序列化器
    consumer:
      group-id: ${spring.application.name}-test
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer # 反序列化器

3.消息生产者
kafka-demo下新建cn.whu.kafka.controller包

package cn.whu.kafka.controller;

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class HelloController {

    @Resource
    private KafkaTemplate<String, String> kafkaTemplate;

    @GetMapping("hello")
    public String hello() {
        kafkaTemplate.send("whu-topic","毕业啦");
        return "ok";
    }

}

4.消息消费者
kafka-demo下新建cn.whu.kafka.listener包

package cn.whu.kafka.listener;

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class HelloListener {

    @KafkaListener(topics = "whu-topic") // 发送方定义的topic
    public void onMessage(String message) {
        if (!StringUtils.isEmpty(message)) {
            System.out.println(message);
        }
    }
}

启动boot工程（启动引导类）
注意服务端kafka得保持启动状态
http://localhost:9991/hello

在这里插入图片描述
控制台打印消息：

8.2)传递消息为对象

目前springboot整合后的kafka，因为序列化器是StringSerializer，这个时候如果需要传递对象可以有两种方式

方式一：可以自定义序列化器，对象类型众多，这种方式通用性不强，本章节不介绍

方式二：可以把要传递的对象进行转json字符串，接收消息后再转为对象即可，本项目采用这种方式

kafka-demo下新建cn.whu.kafka.pojo包

package cn.whu.kafka.pojo;
import lombok.Data;
@Data
public class User {
    private String name;
    private Integer age;
}

发送消息

package cn.whu.kafka.controller;

import cn.whu.kafka.pojo.User;
import com.alibaba.fastjson.JSON;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class HelloController {

    @Resource
    private KafkaTemplate<String, String> kafkaTemplate;

    @GetMapping("/hello")
    public String hello() {
        //kafkaTemplate.send("whu-topic","毕业啦");

        User user = new User();
        user.setName("whu");
        user.setAge(121);

        kafkaTemplate.send("whu-topic", JSON.toJSONString(user));

        return "ok";
    }

}

接收消息

package cn.whu.kafka.listener;

import cn.whu.kafka.pojo.User;
import com.alibaba.fastjson.JSON;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class HelloListener {

    @KafkaListener(topics = "whu-topic") // 发送方定义的topic
    public void onMessage(String message) { // 有了@KafkaListener注解加持，message就是发送消息的data
        if (!StringUtils.isEmpty(message)) {
            //System.out.println(message);
            User user = JSON.parseObject(message, User.class);
            System.out.println(user);
        }
    }

}

测试

http://localhost:9991/hello

在这里插入图片描述

9)自媒体文章上下架功能完成

9.1)需求分析

在这里插入图片描述

已发表且已上架的文章可以下架 才会显示相应的下架图标
已发表且已下架的文章可以上架 才会显示相应的上架图标

9.2)流程说明

在这里插入图片描述

pojo.WmNews.java
在这里插入图片描述

在这里插入图片描述
通过article_id知道是哪个文章要上下架，从而修改其ap_article_config表的enable状态

9.3)接口定义

	说明
接口路径	/api/v1/news/down_or_up
请求方式	POST
参数	DTO
响应结果	ResponseResult

DTO
只看dto中这两个属性，并不是dto只有这两个属性

@Data
public class WmNewsDto {
    
    private Integer id;
    /**
    * 是否上架  0 下架  1 上架
    */
    private Short enable;
                       
}

ResponseResult
在这里插入图片描述
文章上下架状态：

文章是否已发布：

9.4)自媒体文章上下架-功能实现

heima-leadnews-model

9.4.1)接口定义

在heima-leadnews-wemedia工程下的WmNewsController新增方法

@PostMapping("/down_or_up")
public ResponseResult downOrUp(@RequestBody WmNewsDto dto){
    return null;
}

在WmNewsDto中新增enable属性，完整的代码如下： heima-leadnews-model模块下

package com.heima.model.wemedia.dtos;

import lombok.Data;

import java.util.Date;
import java.util.List;

@Data
public class WmNewsDto {
    
    private Integer id;
     /**
     * 标题
     */
    private String title;
     /**
     * 频道id
     */
    private Integer channelId;
     /**
     * 标签
     */
    private String labels;
     /**
     * 发布时间
     */
    private Date publishTime;
     /**
     * 文章内容
     */
    private String content;
     /**
     * 文章封面类型  0 无图 1 单图 3 多图 -1 自动
     */
    private Short type;
     /**
     * 提交时间
     */
    private Date submitedTime; 
     /**
     * 状态 提交为1  草稿为0
     */
    private Short status;
     
     /**
     * 封面图片列表 多张图以逗号隔开
     */
    private List<String> images;

    /**
     * 上下架 0 下架  1 上架
     */
    private Short enable;
}

9.4.2)业务层编写

在WmNewsService新增方法

/**
 * 文章的上下架
 * @param dto
 * @return
 */
public ResponseResult downOrUp(WmNewsDto dto);

实现方法

/**
 * 文章的上下架
 *
 * @param dto
 * @return
 */
@Override
public ResponseResult downOrUp(WmNewsDto dto) {
    // 1. 检查参数
    if (dto == null || dto.getId() == null || dto.getEnable() == null) {
        return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
    }

    // 2. 查询文章
    WmNews wmNews = getById(dto.getId());
    if (wmNews == null) {
        return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST, "文章不存在");
    }

    // 3. 判断文章是否已发布
    if (!wmNews.getStatus().equals(WmNews.Status.PUBLISHED.getCode())) {
        return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "当前文章不是已发布状态，不能上下架");
    }

    // 4. 修改文章enable
    // 也要判断，健壮性哥们儿
    if (dto.getEnable() != null && dto.getEnable() > -1 && dto.getEnable() < 2) {
        update(Wrappers.<WmNews>lambdaUpdate()
                .eq(WmNews::getId, dto.getId())
                .set(WmNews::getEnable, dto.getEnable())
        );
    }

    // 先不考虑kafka消息发送

    return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
}

9.4.3)控制器

@PostMapping("/down_or_up")
public ResponseResult downOrUp(@RequestBody WmNewsDto dto){
    return wmNewsService.downOrUp(dto);
}

9.4.4)测试

启动3个微服务WemediaGatewayApplication、WemediaApplication、ScheduleApplication
在这里插入图片描述
http://localhost:8802/

在这里插入图片描述

说明db的enable标记确实变了

再测试下上架：

自媒体端给自媒体用户的上下架逻辑没有问题了

9.5)消息通知article端文章上下架

9.5.1)在heima-leadnews-common模块下导入kafka依赖

<!-- kafkfa -->
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
</dependency>

其实之前已经导入过了：
在这里插入图片描述

9.5.2)在自媒体端的nacos配置中心配置kafka的生产者

spring:
  kafka:
    bootstrap-servers: 192.168.141.102:9092
    producer:
      retries: 10
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

在这里插入图片描述

9.5.3)在自媒体端文章上下架后发送消息

heima-leadnews-wemedia的cn.whu.wemedia.service.impl.WmNewsServiceImpl#downOrUp方法里，更新完db后就发消息通知文章端修改app文章状态

// 发送消息，通知article修改文章的配置
if (wmNews.getArticleId() != null) {// 安全性无处不在
    HashMap<String, Object> map = new HashMap<>();//好像这种都是String--Object 可以传很多类型，到时候自己去强转就行了
    map.put("articleId", wmNews.getArticleId());
    map.put("enable", dto.getEnable()); // 这里拿dto的，wmNews的不会回显
    kafkaTemplate.send(WmNewsMessageConstants.WM_NEWS_UP_OR_DOWN_TOPIC, JSON.toJSONString(map));
}

在这里插入图片描述

常量类：
heima-leadnews-common模块的cn.whu.common.constants包下

public class WmNewsMessageConstants {

    public static final String WM_NEWS_UP_OR_DOWN_TOPIC="wm.news.up.or.down.topic";
}

9.5.4)在article端的nacos配置中心配置kafka的消费者

spring:
  kafka:
    bootstrap-servers: 192.168.141.102:9092
    consumer:
      group-id: ${spring.application.name}
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

在这里插入图片描述

当前微服务名作为一个组，同一个组内只有一个实例能收到消息进行消费，也就保证了分布式下只有一个实例会去消费消息。

9.5.5)在article端编写监听，接收数据

heima-leadnews-article模块下新建包：cn.whu.article.listener

package cn.whu.article.listener;

import cn.whu.article.service.ApArticleConfigService;
import cn.whu.common.constants.WmNewsMessageConstants;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Map;

@Component
@Slf4j
public class ArticleIsDownListener {

    @Resource
    private ApArticleConfigService apArticleConfigService;

    @KafkaListener(topics = WmNewsMessageConstants.WM_NEWS_UP_OR_DOWN_TOPIC)
    public void OnMessage(String message) {
        if(StringUtils.isNotBlank(message)){
            Map<String,Object> map = JSON.parseObject(message, Map.class);
            apArticleConfigService.updateByMap(map);

        }
    }
}

9.5.6)修改ap_article_config表的数据

之前没有创建ap_article_config表对应的service,这里补一下

新建ApArticleConfigService

package cn.whu.article.service;

import cn.whu.model.article.pojos.ApArticleConfig;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.Map;

public interface ApArticleConfigService extends IService<ApArticleConfig> {
    /**
     * 修改文章
     * @param map
     */
    void updateByMap(Map<String, Object> map);
}

实现类：

package cn.whu.article.service.impl;

import cn.whu.article.mapper.ApArticleConfigMapper;
import cn.whu.article.service.ApArticleConfigService;
import cn.whu.model.article.pojos.ApArticleConfig;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Map;

@Service
@Slf4j
@Transactional
public class ApArticleConfigServiceImpl extends ServiceImpl<ApArticleConfigMapper, ApArticleConfig> implements ApArticleConfigService {

    /**
     * 修改文章
     * @param map
     */
    @Override
    public void updateByMap(Map<String, Object> map) {
        Integer articleId = (Integer) map.get("articleId");
        Short enable = (Short) map.get("enable");// 1上架  0下架
        // 直接修改文章上下架了
        update(Wrappers.<ApArticleConfig>lambdaUpdate()
                .eq(ApArticleConfig::getArticleId, articleId)
                .set(ApArticleConfig::getIsDown, enable == 0)
        );
    }
}

app端加载文章时，app端的xml-sql就已经写好了：
在这里插入图片描述

测试
启动：WemediaGatewayApplication、WemediaApplication、ScheduleApplication、ArticleApplication

WemediaApplication代码改了，注意重启一下

在这里插入图片描述

http://localhost:8802/

use leadnews_wemedia;

SELECT id,user_id,title,article_id,enable from wm_news
where title='测试文章13';

在这里插入图片描述

测试完毕，真测试出问题了，传数据时一定要细心

奇迹是执着的人创造的

关注

18
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
头条系统-06-kafka及异步通知文章上下架-kafka（主题！，分区！，高可用集群，生产消费，消费者组！）、springboot集成kafka（文章上下架业务通过kafka实现）

消息中间件对比特性ActiveMQRabbitMQRocketMQKafka开发语言javaerlangjavascala单机吞吐量万级万级10万级100万级时效性msusmsms级以内可用性高（主从）高（主从）非常高（分布式）非常高（分布式）功能特性成熟的产品、较全的文档、各种协议支持好并发能力强、性能好、延迟低MQ功能比较完善，扩展性佳只支持主要的MQ功能，主要应用于大数据领域消息中间件对比-选择建议消息中间件建议Kafka。
复制链接

扫一扫