Kafka 多数据源 多生产者 多消费者

已于 2023-07-28 13:47:26 修改
阅读量3.7k 收藏 15
点赞数 1
分类专栏： kafka 多数据源 多消费者 文章标签： kafka
于 2021-03-03 16:43:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rongshisuo/article/details/114320432
版权

1.背景

随着业务的发展，服务进行拆分，由原先的一个kafka根据业务线拆分成了多个kafka，现在底层又不支持多kafka数据源，只能自己对kafka进行二次封装

2.kafka配置说明 

下面配置了两套kafka，

主kafka为 primary: kafka_db_data1和第二个数据源kafka_db_data2，以后有第三个kafka可以按照同样的方式进行配置。

kafkas:
  kafka:
    enabled: true
    primary: kafka_db_data1
    producer:
      enabled: true
    consumer:
      enabled: true
    source:
      kafka_db_data1:
        bootstrap-servers: 172.16.**.**:9092,172.16.**.**:9092,172.16.**.**:9092
        producer:
          enabled: true
          retries: 0
          acks: 1
          batch-size: 16384
          properties:
            linger: 50
          buffer-memory: 33554432
          key-serializer: org.apache.kafka.common.serialization.StringSerializer
          value-serializer: org.apache.kafka.common.serialization.StringSerializer
        consumer:
          enabled: true
          group-id: test_group
          max-poll-records: 100
          fetch-max-wait: 100
          fetch-min-size: 100
          enable-auto-commit: true
          heartbeat-interval: 1000
          client-id: ""
          auto-offset-reset: latest
          auto-commit-interval: 1000
          workNum: 1
          pollTime: 100
      kafka_db_data2:
        bootstrap-servers: 172.16.**.**:9092,172.16.**.**:9092,172.16.**.**:9092
        producer:
          enabled: true
          retries: 0
          acks: 1
          batch-size: 16384
          properties:
            linger: 50
          buffer-memory: 33554432
          key-serializer: org.apache.kafka.common.serialization.StringSerializer
          value-serializer: org.apache.kafka.common.serialization.StringSerializer
        consumer:
          enabled: true
          group-id: test_group
          max-poll-records: 100
          fetch-max-wait: 100
          fetch-min-size: 100
          enable-auto-commit: true
          heartbeat-interval: 1000
          client-id: ""
          auto-offset-reset: latest
          auto-commit-interval: 1000
          workNum: 1
          pollTime: 100

3.加载kafka源

kafka配置加载

3.1KafkaProperties

@ConditionalOnProperty(prefix = "kafkas.kafka",name = "enabled")
@ConfigurationProperties(prefix = "kafkas.kafka")
public class KafkaProperties {

    private String primary;
    private Map<String, KafkaDetail> source;

}

 KafkaDetail

public class KafkaDetail {

    private String bootstrapServers;
    private Producer producer;
    private Consumer consumer;
    private Listener listener;

}

Producer

public class Producer {

    private int retries;
    private int batchSize;
    private int bufferMemory;
    private String acks;
    private Properties properties;
    private Boolean enabled;

}

Consumer

public class Consumer {

    private String groupId;
    private Integer maxPollRecords = 100;
    private String fetchMaxWait;
    private String fetchMinSize;
    private boolean enableAutoCommit = true;
    private Integer heartbeatInterval = 3000;
    private String clientId;
    private String autoOffsetRest = "latest";
    private Integer autoCommitInterval = 5000;
    private Integer workerNum = 1;
    private Boolean enabled;
    private Integer pollTime = 100;
    private Integer retries = 0;

}

3.2KafkaAutoConfiguration

加载配置类，此类初始化了多个producer，将多个producer初始化好后，放入Map，交由spring进行管理

package com.rongss.boot.middleware.kafka;

import com.google.common.collect.Maps;
import com.rongss.boot.middleware.kafka.producer.KafkaTemplate;
import com.rongss.boot.middleware.kafka.producer.impl.KafkaTemplateImpl;
import com.rongss.boot.middleware.kafka.properties.KafkaDetail;
import com.rongss.boot.middleware.kafka.properties.KafkaProperties;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;


@Configuration
@ConditionalOnProperty(prefix = "kafkas.kafka",name = "enabled")
@EnableConfigurationProperties(KafkaProperties.class)
public class KafkaAutoConfiguration {

    private KafkaProducer<String, String> kafkaProducer;

    @Autowired
    private KafkaProperties kafkaProperties;

    public Properties producerConfigs(KafkaDetail kafkaDetail) {
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaDetail.getBootstrapServers());
        props.put(ProducerConfig.RETRIES_CONFIG, kafkaDetail.getProducer().getRetries());
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, kafkaDetail.getProducer().getBatchSize());
        props.put(ProducerConfig.LINGER_MS_CONFIG, kafkaDetail.getProducer().getProperties().getLinger());
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, kafkaDetail.getProducer().getBufferMemory());
        props.put(ProducerConfig.ACKS_CONFIG, kafkaDetail.getProducer().getAcks());
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

    public KafkaProducer<String, String> kafkaProducer(KafkaDetail kafkaDetail) {
        kafkaProducer = new KafkaProducer<>(producerConfigs(kafkaDetail));
        return kafkaProducer;
    }

    @Bean
    @ConditionalOnProperty(prefix = "kafkas.kafka.producer",name = "enabled")
    public Map<String,KafkaTemplate> kafkaTemplate(){
        Map<String,KafkaDetail> sources = kafkaProperties.getSource();
        Map<String,KafkaTemplate> templateMap = new HashMap<>();

        for (String key : sources.keySet()){
            KafkaDetail kafkaDetail = sources.get(key);
            if(kafkaDetail.getProducer() != null && kafkaDetail.getProducer().getEnabled()){
                KafkaTemplate template = new KafkaTemplateImpl(kafkaProducer(kafkaDetail));
                templateMap.put(key,template);
            }
        }
        return templateMap;
    }

    public Map<String, Object> consumerConfigs(KafkaDetail kafkaDetail) {
        Map<String, Object> props = Maps.newHashMap();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaDetail.getBootstrapServers());
        props.put(ConsumerConfig.GROUP_ID_CONFIG, kafkaDetail.getConsumer().getGroupId());
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, kafkaDetail.getConsumer().getMaxPollRecords());
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, kafkaDetail.getConsumer().isEnableAutoCommit());
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 120000);
        props.put(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, 180000);
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG, kafkaDetail.getConsumer().getFetchMaxWait());
        props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, kafkaDetail.getConsumer().getHeartbeatInterval());
        props.put(ConsumerConfig.CLIENT_ID_CONFIG, kafkaDetail.getConsumer().getClientId());
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, kafkaDetail.getConsumer().getAutoCommitInterval());
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, kafkaDetail.getConsumer().getAutoOffsetRest());
        return props;
    }

}

producer发消息

消息实体

public class MessageEvent implements Serializable {

    private static final long serialVersionUID = -2624253925403159396L;
    /**
     * 事件序列ID
     */
    private String txId;
    /**
     * 话题的名字
     */
    private String topic;
    /**
     * 话题的名字
     */
    private String tag;
    /**
     * 需要传递的领域对象
     */
    private Object body;
    /**
     * 传递的领域对象的唯一标识,用来构建消息的唯一标识,不检测重复,可以为空,不影响消息收发
     */
    private String bodyKey;
    /**
     * 事件创建时间
     */
    private long createdDate = System.currentTimeMillis();
    /**
     * 消息类型
     */
    private MessageType messageType;


    /**
     * 方便的生成TxId的方法
     *
     * @return
     */
    public String generateTxId() {
        if (null == txId) {
            txId = getTopic() + ":" + getTag() + ":";
            if (StringUtil.isNullOrEmpty(bodyKey)) {
                txId = txId + getCreatedDate() + ":" + UUID.randomUUID().toString();
            } else {
                txId = txId + bodyKey;
            }
        }
        return txId;
    }

}

producer接口类

public interface KafkaTemplate {

    Future<RecordMetadata> send(MessageEvent event);

    Future<RecordMetadata> send(MessageEvent event, Callback callback);
}

实现

public class KafkaTemplateImpl implements KafkaTemplate {

    private Logger log = LoggerFactory.getLogger(KafkaTemplateImpl.class);

    private KafkaProducer kafkaProducer;

    public KafkaTemplateImpl(KafkaProducer kafkaProducer){
        this.kafkaProducer = kafkaProducer;
    }

    private ProducerRecord<String, Object> getRecord(MessageEvent event){
        if(event == null) {
            throw new RuntimeException("event is null.");
        }
        if (StringUtils.isEmpty(event.getTopic())  || null == event.getBody()) {
            throw new RuntimeException("topic, or body is null.");
        }
        return new ProducerRecord<>(event.getTopic(), event.getBody());
    }

    @Override
    public Future<RecordMetadata> send(MessageEvent event) {
        return kafkaProducer.send(getRecord(event));
    }

    @Override
    public Future<RecordMetadata> send(MessageEvent event, Callback callback) {
        return kafkaProducer.send(getRecord(event),callback);
    }


}

多实例多消费者

首先在这里准备了几个自定义注解

@ListenerHandler //写在类上，让spring扫描到，表示该类使用了kafka的消费者
@ListenerExecute //写在具体方法上，监听器会将相应的topic数据推送至该方法

ListenerExecute注解

@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ListenerExecute {

    String message() default "";

    String topic() default "";

    String tags() default "";

    int retry() default 0;

    MessageType action();

}

KafkaListenerProcessor

主要是将ListenerExecute注解 和 KafkaListener进行关联

@Configuration
public class ListenerProcessor implements BeanPostProcessor {


    @Autowired
    private ApplicationContext applicationContext;


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class<?> clazz = AopUtils.getTargetClass(bean);
        ListenerExecute annotation = clazz.getAnnotation(ListenerExecute.class);
        if (null != annotation) {
            final Method[] methods = bean.getClass().getMethods();
            for (Method method : methods) {
                final ListenerExecute methodAnnotation = method.getAnnotation(ListenerExecute.class);
                if (methodAnnotation != null) {
                    final MessageType action = methodAnnotation.action();
                    addListener(methodAnnotation.source(), bean, method, action, methodAnnotation.topic(), methodAnnotation.tags(),methodAnnotation.reMsg());
                }
            }
        }
        return bean;
    }

    private void addListener(String source, Object bean, Method method, MessageType action, String topic, String tags,String reMsg){
        KafkaListener kafkaListener = applicationContext.getBean(KafkaListener.class);
        if(null == kafkaListener){
            throw new NullPointerException("KafkaListener is null ! please check kafka.consumer.enabled = true");
        }
        kafkaListener.addListener(source, bean, method, topic, tags, reMsg);
    }
}

具体监听类

此类初始化时启动，扫描项目中注解@ListenerHandler 和 @ListenerExecute，监听相应的方法，并把数据推送给消费的具体方法

@Component
@ConditionalOnProperty(prefix = "kafkas.kafka.consumer",value = "enabled")
public class KafkaListener implements Listener {

    @Autowired
    private Environment env;

    @Autowired
    private KafkaAutoConfiguration kafkaAutoConfiguration;

    @Autowired
    private KafkaProperties kafkaProperties;

    @Override
    public void addListener(String source, Object bean,Method method, String topicKey, String tags, String reMsg) {
        Map<String, KafkaDetail> kafkaConfings = kafkaProperties.getSource();
        KafkaDetail kafkaDetail = kafkaConfings.get(source);

        if(kafkaDetail.getConsumer() != null && kafkaDetail.getConsumer().getEnabled()){
            Integer workNum = kafkaDetail.getConsumer().getWorkerNum();
            for (int i=0;i<workNum;i++){
                log.info("init kafka consumer start source:{}", source);
                openListener(kafkaDetail, bean, method, topicKey);
            }
        }
    }

    private void openListener(KafkaDetail kafkaDetail, Object bean,Method method, String topicKey){
        topicKey = topicKey.replace(" ","");
        if(StringUtils.isEmpty(topicKey)){
            throw new RuntimeException("topic is null");
        }
       final String topicValue = topicKey.substring(2,topicKey.length()-1);
        new Thread(){
            @Override
            public void run() {

                KafkaConsumer<String, String> consumer = new KafkaConsumer<>(kafkaAutoConfiguration.consumerConfigs(kafkaDetail));
                String topic = env.getProperty(topicValue);
                consumer.subscribe(Arrays.asList(topic));
                Parameter[] parameters = method.getParameters();
                while (true){
                    try {
                        ConsumerRecords<String, String> records = consumer.poll(kafkaDetail.getConsumer().getPollTime());
                        if(!records.isEmpty()){
                            List<String> list = new ArrayList<>(records.count());
                            for (ConsumerRecord record : records) {
                                list.add(record.value().toString());
                            }
                            Object[] params = new Object[parameters.length];
                            params[0] = list;

                            log.info("kafka commit info fail topic={}, message={}",topic,JSON.toJSON(list));
                            Boolean ret = invoke(bean, method,params);

                            if(!kafkaDetail.getConsumer().isEnableAutoCommit()){
                                if(ret){
                                    log.info("kafka commit info fail ret={}, topic={}, message={}",ret,topic,JSON.toJSON(list));
                                    consumer.commitAsync();
                                } else if(!ret && kafkaDetail.getConsumer().getRetries().intValue() > 0){
                                    for (int i = 1;i<kafkaDetail.getConsumer().getRetries().intValue();i++) {
                                        ret = invoke(bean, method, params);
                                        if (ret) {
                                            consumer.commitAsync();
                                            break;
                                        }
                                        if(i == kafkaDetail.getConsumer().getRetries().intValue() - 1){
                                            log.info("kafka commit info retries fail topic={}, message={}",topic,JSON.toJSON(list));
                                            consumer.commitAsync();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IllegalAccessException e) {
                        log.error("消费器不合法访问！",e);
                    } catch (InvocationTargetException e) {
                        log.error("消费器调用handler失败！",e);
                    } catch (Throwable e){
                        log.error("Throwable！Consumer error",e);
                    }
                }
            }
        }.start();
    }


    public Boolean invoke(Object bean, Method method, Object[] params) throws Exception{
        Object obj = method.invoke(bean,params);
        return obj == null ? false : (Boolean)obj;
    }

    public String[] getMethodParamName(Class<?> clazz, String methodName, Class<?>[] parameterTypes) {
        try {
            Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
            LocalVariableTableParameterNameDiscoverer parameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
            return parameterNameDiscoverer.getParameterNames(method);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

使用方式

参数详解：

@Value 表示从spring管理的Map中区key值为kafka_db_data1的KafkaTemplate对象

@ListenerExecute 定义了source来源，可以匹配到kafka的数据源，topic可配置

@Slf4j
@Component
@ListenerHandler
public class KafkaDemo {


    @Value("#{kafkaTemplate.kafka_db_data1}")
    private KafkaTemplate kafkaDbData1;

    public void kafkaProducerDemo(){
        MessageEvent event = new MessageEvent();
        event.setBody("我是具体数据");
        event.setTopic("demo_topic");
        kafkaDbData1.send(event);
    }

    @ListenerExecute(source = "kafka_db_data1", topic = "${kafkas.kafka.source.kafka_db_data.topic.comments}", action = MessageType.KAFKA, reMsg = "data")
    public void kafkaDemo(List<String> data) {
        log.info(JSON.toJSONString(data));
    }
}

英俊xiansen
关注
专栏目录
Kafka生产者消费者API原理与代码实例讲解
AI大模型应用之禅
06-05 326
Kafka生产者消费者API原理与代码实例讲解 1.背景介绍 Apache Kafka是一个分布式流处理平台,它提供了一种统一、高吞吐、低延迟的方式来处理实时数据流。Kafka被广泛应用于日志收集、消息系统、数据管道、流式处理、事件源等场景。其核心概念是将数据流组织为不同的主题
Kafka实例：如何配置多个消费者集群
DeoSql的博客
09-18 1090
请注意，消费者组内的每个消费者实例将共享分配给该组的分区，以确保每个消息只被一个消费者实例处理。总结起来，要配置多个消费者集群，您需要创建多个消费者组，为每个组配置不同的消费者属性，并编写相应的消费者代码。通过独立运行每个消费者实例，每个集群可以独立地消费Kafka主题中的消息。为了创建多个消费者集群，您需要为每个集群创建不同的消费者组。使用Kafka提供的客户端库，您可以编写消费者代码来消费Kafka主题中的消息。使用命令行或您喜欢的方式运行多个消费者实例，并确保为每个实例使用不同的消费者组配置。
同一服务Kafka多数据源配置
sinat_41913348的博客
02-16 2147
同一服务Kafka多数据源配置 一个微服务项目，业务需要，引入两套kafka集群的配置 1.xml文件加入新老Kafka集群配置信息 2.添加KafkaTemplateConfig bean文件 3.注解@Qualifier(“kafkaTemplateNew”)使用 @EnableKafka @Configuration public class KafkaTemplateConfig { @Value("${spring.kafka.bootstrap-servers}") pr
kafka 多消费者实现
热门推荐
u012447842的博客
12-05 1万+
kafka官网：http://kafka.apache.org/quickstart 目录 kafka简单介绍： 实现方式 1：kafka分区 2: 实现结果 3：kafka的consumer代码 4:kafka生产者 kafka简单介绍（网上找的）： 实现方式 必要条件： kafka配置： > b...
springboot kafka多数据源，通过配置动态加载发送者和消费者
最新发布
fenglllle的博客
10-07 1089
如果消费者或者发送者逻辑需要写在当前kafka网关应用，那么只能通过自定义扫描方式支持配置不同，所有配置的生成者和消费者必须代码实现逻辑，通过配置加载方式，自定义扫描注入bean即可。以消费者为例，生产者不涉及注解发送方式相对简单。});写了一个初始化的bean，用于通过配置加载bean。消费者是注解方式扫描，bean需要根据配置加载，不能写在代码里面这里仅仅是注册bean，并不会被beanpostprocessor处理关于第1点。
Kafka 自定义多数据源
wkfyynh的博客
06-12 1448
Kafka 自定义多数据源
springboot 实现kafka多源配置
batman
06-02 1016
实际开发中，不同的topic可能来自不同的集群，所以就需要配置不同的kafka数据源，基于springboot自动配置的思想，最终通过配置文件的配置，自动生成生产者及消费者的配置。
Spring Boot集成Kafka（含多数据源）
付聪
08-22 958
在项目的pom.xml文件中添加 Spring Kafka 的依赖。</</</
多个消费者订阅一个Kafka的Topic(使用KafkaConsumer和KafkaProducer)
zhangbeizhen18的博客
06-26 1万+
记录：466 场景：一个KafkaProducer在一个Topic发布消息，多个消费者KafkaConsumer订阅Kafka的Topic。每个KafkaConsumer指定一个特定的ConsumerGroup，达到一条消息被多个不同的ConsumerGroup消费。
kafka多分区只有一个在消费_Kafka分区与消费者的关系
weixin_39731682的博客
12-19 3067
1. 前言我们知道，生产者发送消息到主题，消费者订阅主题(以消费者组的名义订阅)，而主题下是分区，消息是存储在分区中的，所以事实上生产者发送消息到分区，消费者则从分区读取消息，那么，这里问题来了，生产者将消息投递到哪个分区？消费者组中的消费者实例之间是怎么分配分区的呢？接下来，就围绕着这两个问题一探究竟。2. 主题的分区数设置在server.properties配置文件中可以指定一个全局的分区...
kafka生产者消费者插件 steps.zip
11-16
标题中的"Kafka生产者消费者插件 steps.zip"指的是在Kettle 8.2版本中使用的，与Kafka交互的特定插件。这个插件允许Kettle作业或转换发送和接收消息到Kafka集群，从而实现数据的实时流动。 描述中提到，该插件适用...
node-red-contrib-kafka-nodes:节点将Apache Kafka集成到NodeRed中。 生产者和消费者有单独的节点
05-14
这是NodeRed内部的Apache Kafka消费者和生产者客户端的实现。 这些使您能够收集和使用将通过Kafka服务器传递的事件。 它易于使用：将适当的节点拖到上颚，填写Zookeeper服务器信息，将其连接到其他节点，然后进行...
多个生产者消费者的解决
04-13
一个消费者生产者问题linux的实现,是我们操作系统的小作业
笔记：配置多个kafka生产者和消费者
oki
06-11 4418
当然也可以只定义生产者或者只定义消费者，按需进行，以下示例是同时定义生产者和消费者。/*** 自定义kafka配置*//** 生产者 *//** 消费者 *//** 配置文件*/// @Primary 要指定一下，不然启动会因为存在多个KafkaProperties,而导致kafka的自动装配不懂要选哪个而报错@Primary@Bean@Primary@BeanTips：1）消费者。
搭建大型分布式服务（三十六）SpringBoot 零代码方式整合多个kafka数据源
hanyi_的专栏
11-17 581
让我们来看一下网上是怎样使用SpringBoot整合kafka数据源的，都存在哪些痛点？手撸kafka配置代码，各种硬编码，无法利用SpringBoot的约定大于配置的优势。当项目需要消费的topic，而且他们在不同集群时，需要不断地复制粘贴config和factory，如果项目需要5个不同集群的topic以上，那么这些代码将面临巨大维护压力，并且极其容易出错。假如来了个新业务，也是消费kafka，然后做一些业务逻辑处理，你会发现你不得不又搭建一个新工程，然后重复上述步骤，把代码和配置都复制粘贴一遍。
Kafka多生产者消费者自动配置
不定时分享最优质的网络技术与教程，满满的干货。
12-30 1530
使用接收配置，但是需要修改下前缀，但是源码改不了，新写一个类继承@Component@Primary}复制代码如果没有Kafka默认配置，Kafka会自动实例化默认的，如果有多个实例，需要指定一个首选的bean，否则类中构造函数会报错。所以在其中一个加上@Primary注解。
springboot整合kafka多数据源
weixin_56227932的博客
08-14 1411
在很多与第三方公司对接的时候，或者处在不同的网络环境下，比如在互联网和政务外网的分布部署服务的时候，我们需要对接多台kafka来达到我们的业务需求，那么当kafka存在多数据源的情况，就与单机的情况有所不同。 配置 单机的情况 如果是单机的kafka我们直接通过springboot自动配置的就可以使用，例如在yml里面直接引用 在使用的时候直接注入,然后就可以使用里面的方法了 多数据源情况下本篇文章主要讲的是在多数据源下的使用，和单机的有所不同，我也看了网上的一些博客，但是当我去按照网上的配置的时候，总是会
多个生产者和多个消费者
weixin_33696106的博客
09-25 1352
2019独角兽企业重金招聘Python工程师标准>>> ...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值