第三章 Kafka-基础操作

最新推荐文章于 2024-05-07 10:28:08 发布
最新推荐文章于 2024-05-07 10:28:08 发布
阅读量171 收藏
点赞数 1
分类专栏： Kafka专题学习 文章标签： kafka big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37225926/article/details/120434696
版权

目录

一、Kafka基础API

1.1、创建KafkaAdminClient

1.2、异步创建Topic信息

1.3、同步创建Topic信息

1.4、查看Topic列表

1.5、异步删除Topic

1.6、同步删除Topic

1.7、查看topic详情信息

1.8、关闭client

二、生产者和消费者

2.1、生产者：

2.2、消费者：

2.3、消费者(手动指定起始消费位置)：

三、自定义分区

3.1、自定义分区策略：

3.2、采用自定义分区策略生成消息：

四、序列化

4.1、user实体类：

4.2、user自定义序列化类：

4.3、user反序列化类：

4.4、消费者：

五、拦截器

5.1、自定义拦截器：

5.2、生产者：

5.3、消费者：

一、Kafka基础API

1.1、创建KafkaAdminClient

Properties prop = new Properties();
prop.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
KafkaAdminClient client = (KafkaAdminClient) KafkaAdminClient.create(prop);

1.2、异步创建Topic信息

CreateTopicsResult topic01 = client.createTopics(Arrays.asList(new NewTopic("topic01", 3, (short) 3)));

1.3、同步创建Topic信息

CreateTopicsResult topic02 = client.createTopics(Arrays.asList(new NewTopic("topic02", 3, (short) 3)));
topic02.all().get();

1.4、查看Topic列表

ListTopicsResult topics = client.listTopics();
Set<String> names = topics.names().get();
for (String name :
    names) {
    System.out.println(name);
}

1.5、异步删除Topic

DeleteTopicsResult deleteTopics = client.deleteTopics(Arrays.asList("topic01", "topic02"));

1.6、同步删除Topic

deleteTopics.all().get();

1.7、查看topic详情信息

DescribeTopicsResult dtr = client.describeTopics(Arrays.asList("topic01"));
Map<String, TopicDescription> topicDescriptionMap = dtr.all().get();
for (Map.Entry<String, TopicDescription> entry :
        topicDescriptionMap.entrySet()) {
    System.out.println(entry.getKey()+"\t"+entry.getValue());
}

1.8、关闭client

client.close();

二、生产者和消费者

2.1、生产者：

package com.baron.quickStart;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author baron
 * @description
 * @date 2021/9/6 15:24
 */
public class KafkaProducerQuickStart {
    public static void main(String[] args) {
        // 1、创建KafkaProducer
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
        // 2、生产消息
        for(int i=0; i<30; i++) {
            ProducerRecord<String, String> record =
                    new ProducerRecord<>("topic01", "key" + i, "value" + i);
//                    new ProducerRecord<>("topic01", "value" + i);
            // 发送消息给服务器
            producer.send(record);
        }
        // 3、关闭producer
        producer.close();

    }
}

2.2、消费者：

package com.baron.quickStart;

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 org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;

import java.time.Duration;
import java.util.Iterator;
import java.util.Properties;
import java.util.regex.Pattern;

/**
 * @author baron
 * @description
 * @date 2021/9/6 15:24
 */
public class KafkaConsumerQuickStart_1 {
    public static void main(String[] args) {
        // 1、创建KafkaConsumer
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        // 以组管理消费者
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "g2");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        // 2、订阅相关的topics
        consumer.subscribe(Pattern.compile("^topic.*"));
        // 3、遍历消息队列
        while (true) {
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1));
            if (!consumerRecords.isEmpty()) { // 从队列中取到了数据
                Iterator<ConsumerRecord<String, String>> it = consumerRecords.iterator();
                while (it.hasNext()) {
                    // 获取一个消息
                    ConsumerRecord<String, String> record = it.next();
                    String topic = record.topic();
                    int partition = record.partition();
                    long offset = record.offset();

                    String key = record.key();
                    String value = record.value();
                    long timestamp = record.timestamp();
                    System.out.println(topic+"\t"+partition+","+offset+"\t"+key+""+value+timestamp);
                }
            }
        }

    }
}

2.3、消费者(手动指定起始消费位置)：

package com.baron.quickStart;

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 org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.regex.Pattern;

/**
 * @author baron
 * @description
 * @date 2021/9/6 15:24
 */
public class KafkaConsumerQuickStart_2 {
    public static void main(String[] args) {
        // 1、创建KafkaConsumer
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        // 以组管理消费者
//        props.put(ConsumerConfig.GROUP_ID_CONFIG, "g2");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        // 2、订阅相关的topics,手动指定消费分区，失去组管理特性
        List<TopicPartition> partitions = Arrays.asList(new TopicPartition("topic01", 0));
        consumer.assign(partitions);
        // 指定消费分区的位置(从topic01中0分区的开头-0位置进行消费)
//        consumer.seekToBeginning(partitions);
        // 指定消费分区的位置(从topic01中0分区的指定位置进行消费)
        consumer.seek(new TopicPartition("topic01", 0), 1);

        // 3、遍历消息队列
        while (true) {
            // 一秒取一次
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1));
            if (!consumerRecords.isEmpty()) { // 从队列中取到了数据
                Iterator<ConsumerRecord<String, String>> it = consumerRecords.iterator();
                while (it.hasNext()) {
                    // 获取一个消息
                    ConsumerRecord<String, String> record = it.next();
                    String topic = record.topic();
                    int partition = record.partition();
                    long offset = record.offset();

                    String key = record.key();
                    String value = record.value();
                    long timestamp = record.timestamp();
                    System.out.println(topic+"\t"+partition+","+offset+"\t"+key+""+value+timestamp);
                }
            }
        }

    }
}

三、自定义分区

消费策略：如果消息有key，根据key进行消费，如果没有key，则轮询进行消费。

3.1、自定义分区策略：

package com.baron.partitioner;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import org.apache.kafka.common.PartitionInfo;
import org.apache.kafka.common.utils.Utils;

import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义分区策略
 * @author baron
 * @description
 * @date 2021/9/7 9:57
 */
public class UserDefinePartitioner implements Partitioner {
    private AtomicInteger counter = new AtomicInteger(0);
    /**
     * 返回分区号
     * @param topic
     * @param key
     * @param keyBytes
     * @param value
     * @param valueBytes
     * @param cluster
     * @return
     */
    @Override
    public int partition(String topic,
                         Object key,
                         byte[] keyBytes,
                         Object value,
                         byte[] valueBytes,
                         Cluster cluster) {
        // 获取所有分区
        List<PartitionInfo> partitions = cluster.partitionsForTopic(topic);
        int numPartitions = partitions.size();
        if (keyBytes == null){
            // 轮询
            int andIncrement = counter.getAndIncrement();
            return Utils.toPositive(andIncrement)%numPartitions;
        }else {
            // 对key进行hash运算
            return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
        }
    }

    @Override
    public void close() {
        System.out.println("close");
    }

    @Override
    public void configure(Map<String, ?> configs) {
        System.out.println("configure");
    }
}

3.2、采用自定义分区策略生成消息：

package com.baron.partitioner;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author baron
 * @description
 * @date 2021/9/6 15:24
 */
public class KafkaProducerPartitioner {
    public static void main(String[] args) {
        // 1、创建KafkaProducer
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //
        /*
        * 配置分区策略
        * 1、如果指定分区则固定将消息发到指定的分区
        * 2、如果没有指定分区，但是有key的话则对key进行hash来选择分区
        * 3、如果没有指定分区也没有key，则按照轮询的策略来选择分区
        * */
        props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, UserDefinePartitioner.class.getName());

        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
        // 2、生产消息
        for(int i=0; i<6; i++) {
            ProducerRecord<String, String> record =
                    new ProducerRecord<>("topic01", "key" + i, "value" + i);
//                    new ProducerRecord<>("topic01", "value" + i);
            // 发送消息给服务器
            producer.send(record);
        }
        // 3、关闭producer
        producer.close();

    }
}

四、序列化

4.1、user实体类：

package com.baron.serializer;

import java.io.Serializable;
import java.util.Date;

/**
 * @author baron
 * @description
 * @date 2021/9/7 14:50
 */

public class User implements Serializable {
    private Integer id;
    private String name;
    private Date birthday;

    public User() {
    }

    public User(Integer id, String name, Date birthday) {
        this.id = id;
        this.name = name;
        this.birthday = birthday;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}

4.2、user自定义序列化类：

package com.baron.serializer;

import org.apache.commons.lang3.SerializationUtils;
import org.apache.kafka.common.serialization.Deserializer;

import java.util.Map;

/**
 * @author baron
 * @description
 * @date 2021/9/7 14:47
 */
public class UserDefineDeserializer implements Deserializer<Object> {
    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        System.out.println("configure");
    }

    @Override
    public Object deserialize(String topic, byte[] data) {
        return SerializationUtils.deserialize(data);
    }

    @Override
    public void close() {
        System.out.println("close");
    }
}

4.3、user反序列化类：

package com.baron.serializer;

import org.apache.commons.lang3.SerializationUtils;
import org.apache.kafka.common.serialization.Deserializer;

import java.util.Map;

/**
 * @author baron
 * @description
 * @date 2021/9/7 14:47
 */
public class UserDefineDeserializer implements Deserializer<Object> {
    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        System.out.println("configure");
    }

    @Override
    public Object deserialize(String topic, byte[] data) {
        return SerializationUtils.deserialize(data);
    }

    @Override
    public void close() {
        System.out.println("close");
    }
}

4.4、消费者：

package com.baron.serializer;

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 org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Properties;
import java.util.regex.Pattern;

/**
 * @author baron
 * @description
 * @date 2021/9/6 15:24
 */
public class KafkaConsumerUser {
    public static void main(String[] args) {
        // 1、创建KafkaConsumer
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, UserDefineDeserializer.class.getName());
        // 以组管理消费者
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "g1");
        KafkaConsumer<String, User> consumer = new KafkaConsumer<>(props);
        // 2、订阅相关的topics
//        consumer.subscribe(Pattern.compile("^topic.*"));
        consumer.subscribe(Arrays.asList("topic02"));
        // 3、遍历消息队列
        while (true) {
            ConsumerRecords<String, User> consumerRecords = consumer.poll(Duration.ofSeconds(1));
            if (!consumerRecords.isEmpty()) { // 从队列中取到了数据
                Iterator<ConsumerRecord<String, User>> it = consumerRecords.iterator();
                while (it.hasNext()) {
                    // 获取一个消息
                    ConsumerRecord<String, User> record = it.next();
                    String topic = record.topic();
                    int partition = record.partition();
                    long offset = record.offset();

                    String key = record.key();
                    User value = record.value();
                    long timestamp = record.timestamp();
                    System.out.println(topic+"\t"+partition+","+offset+"\t"+key+""+value+timestamp);
                }
            }
        }

    }
}

五、拦截器

5.1、自定义拦截器：

package com.baron.interceptors;

import com.baron.serializer.User;
import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Map;

/**
 * @author baron
 * @description
 * @date 2021/9/7 15:15
 */
public class UserDefineProducerInterceptors implements ProducerInterceptor<String, User> {
    @Override
    public ProducerRecord<String, User> onSend(ProducerRecord<String, User> record) {
        return new ProducerRecord(record.topic(), record.key(), record.value()+" --- baron");
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        System.out.println("metadata:" + metadata + ",exception:" + exception);
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map<String, ?> configs) {

    }
}

5.2、生产者：

package com.baron.interceptors;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author baron
 * @description
 * @date 2021/9/6 15:24
 */
public class KafkaProducerInterceptors {
    public static void main(String[] args) {
        // 1、创建KafkaProducer
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, UserDefineProducerInterceptors.class.getName());

        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
        // 2、生产消息
        for(int i=0; i<8; i++) {
            ProducerRecord<String, String> record =
                    new ProducerRecord<>("topic01", "key" + i, "value" + i);
//                    new ProducerRecord<>("topic01", "value" + i);
            // 发送消息给服务器
            producer.send(record);
        }
        // 3、关闭producer
        producer.close();

    }
}

5.3、消费者：

package com.baron.interceptors;

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 org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Properties;
import java.util.regex.Pattern;

/**
 * @author baron
 * @description
 * @date 2021/9/6 15:24
 */
public class KafkaConsumerInterceptors {
    public static void main(String[] args) {
        // 1、创建KafkaConsumer
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        // 以组管理消费者
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "g1");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        // 2、订阅相关的topics
//        consumer.subscribe(Pattern.compile("^topic.*"));
        consumer.subscribe(Arrays.asList("topic01"));
        // 3、遍历消息队列
        while (true) {
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1));
            if (!consumerRecords.isEmpty()) { // 从队列中取到了数据
                Iterator<ConsumerRecord<String, String>> it = consumerRecords.iterator();
                while (it.hasNext()) {
                    // 获取一个消息
                    ConsumerRecord<String, String> record = it.next();
                    String topic = record.topic();
                    int partition = record.partition();
                    long offset = record.offset();

                    String key = record.key();
                    String value = record.value();
                    long timestamp = record.timestamp();
                    System.out.println(topic+"\t"+partition+","+offset+"\t"+key+""+value+timestamp);
                }
            }
        }

    }
}

风过水无痕·
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
kafka topic 管理api
诸葛子房的博客
09-27 198
1.使用AdminClient进行处理 2.topic 创建、删除等操作代码 pom文件 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dep..
Kafka系列——生产者的分区，序列化，自定义拦截器以及头部信息
zekser的博客
03-18 1056
kafka的分区，序列化，自定义序列化源码示例；自定义拦截器，头部信息的作用
32 | KafkaAdminClient：Kafka的运维利器
最新发布
qq_37756660的博客
05-07 764
今天要和你分享的主题是：Kafka 的运维利器 KafkaAdminClient。
【Kafka笔记】4.Kafka API详细解析 Java版本（Producer API，Consumer API，拦截器等）
菜鸟sdut的博客
11-24 1171
简介 Kafka的API有Producer API，Consumer API还有自定义Interceptor (自定义拦截器)，以及处理的流使用的Streams API和构建连接器的Kafka Connect API。 Producer API Kafka的Producer发送消息采用的是异步发送的方式。在消息发送过程中，涉及两个线程：main线程和Sender线程，以及一个线程共享变量Recor...
Kafka Producer 自定义 拦截器 & 序列化
u013433591的博客
12-21 734
kafka 自定义拦截器、自定义序列化
Kafka：KafkaAdminClient应用
程序员无羡的博客
03-31 1091
Kafka：KafkaAdminClient应用
第3章 Kafka架构深入
牛牛
06-06 139
Kafka中消息是以topic进行分类的，生产者生产消息，消费者消费消息，都是面向topic的。topic是逻辑上的概念，而partition是物理上的概念，每个partition对应于一个log文件，该log文件中存储的就是producer生产的数据。Producer生产的数据会被不断追加到该log文件末端，且每条数据都有自己的offset。消费者组中的每个消费者，都会实时记录自己消费到了哪个offset，以便出错恢复时，从上次的位置继续消费。由于生产者生产的消息会不断追加到log文件末尾，为防止log文
Kafka API AdminClient基本使用
余金兑人的技术角落
11-16 4273
目前 Kafka 提供了一个新的 API 工具 AdminClient。通过SpringBoot集成AdminClient可以进行kafka的管理。实现了查询、新建、删除topic、调整partition、获取lag、配置信息等常用功能。通过这些功能可以为业务人员构建一个简单的kafka管理界面。 pom <dependency> <groupId>org.springframework.kafka</groupId> <artifactId&
java kafka的AdminClient创建、查看、删除topic、修改Config信息、增加partition
qq_37432174的博客
01-01 1507
记录个人学习
Kafka删除topic
蜗牛^_^的博客
09-26 2297
思路 topic中的元数据存储在ZooKeeper中的/brokers/topics和/config/topics路径下，topic中的消息数据存储在log.dir或log.dirs配置的路径下，所以删除topic就需要删除这些路径下的内容。 准备工作 创建topic: bin/kafka-topics.sh --create --zookeeper bigdata-pro01.wn.co...
20 KafkaAdminClient
，
02-24 630
初识KafkaAdminClient 一般情况下，我们习惯使用 kafka-topics.sh 脚本来管理主题。但有些时候我们希望将主题管理类的功能集成到公司内部系统中，集管理、监控、运维、警告等一体，那么就需要以程序调用API的方式去实现。这节主要记录 KafkaAdminClient 的基本使用方式，以及采用这种方式创建主题时的合法性验证。 基本使用 在代码清单16-1中使用了 TopCom...
KafkaAdminClient
杜海的博客
10-30 1082
一般情况下，我们都习惯使用kafka-topics .sh 脚本来管理主题，但有些时候我们希望将主题管理类的功能集成到公司内部的系统中， 打造集管理、监控、运维、告警为一体的生态平台，那么就需要以程序调用API 的方式去实现。本节主要介绍KafkaAdminC!ient 的基本使用方式，以及采用这种调用API 方式下的创建主题时的合法性验证。 在Kafka 0.11.0.0 版本之前，我们可以通过kafka-core 包（ Kafka 服务端代码）下的kafka.admin.AdrninCLient 和k
kafka API操作topic
不管大小写的博客
01-05 3231
kafka 版本：2.1.0 具体更多的明细API用法见官网：kafka官网API pom信息： <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka_2.11</artifactId> <vers...
KafkaAdminClient类详解
香槟的博客
09-24 4832
Kafka的管理客户端，支持管理和检查主题，代理，配置和ACL。所需的最低代理版本为0.10.0.0。要求更严格的方法将指定所需的最低代理版本。我们将尝试以兼容的方式改进API，但如有必要，我们保留在次要版本中进行重大更改的权利。一旦认为API稳定，我们将更新InterfaceStability批注和此通知。 主要方法 public static AdminClient create(java....
Kafka2.5.0源码关于 KafkaAdminClient 中 listTopic( ) 的源码详解
biaoguaqie7838的博客
07-13 2764
Kafka2.5.0源码关于 KafkaAdminClient 中 listTopic( ) 的源码详解 参考链接： @Override public ListTopicsResult listTopics(final ListTopicsOptions options) { final KafkaFutureImpl<Map<String, TopicListing>> topicListingFuture = new KafkaFutureImpl<>();
kafka接口操作topic
莫语？倾城
06-14 3655
翻译主要的创建参数备忘，忒TM烦人的多 import com.google.common.collect.ImmutableList; import org.apache.kafka.clients.admin.*; import org.apache.kafka.common.KafkaFuture; import org.apache.kafka.common.config.TopicConf...
Java操作Kafka创建Topic、Producer、Consumer
qq_28834355的博客
09-02 4729
环境 JDK 1.8 Zookeeper 3.6.1 Kafka 2.6.0 引入依赖 <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>2.6.0</version> </dependency> <dependency> <group
java批量创建删除Kafka的topic
fct2001140269的博客
08-11 589
java批量创建删除Kafka的topic 一、前言 参考资料：Kafka 0.11客户端集群管理工具AdminClient https://blog.csdn.net/u012501054/article/details/80594374 2.批量创建删除Kafka的topic 2.集群管理工具AdminClient （新版本kafka） 较为新的版本：Kafka 0.11以上版本上测试的,新的API 集群管理工具AdminClient package zktest.navinfo; import or
20_初识KafkaAdminClient
一个搬砖工人
11-24 2601
1基本使用 一般情况下，我们都习惯使用 kafka-topics.bat 脚本来管理主题，但有些时候我们希望将主题管理类的功能集成到公司内部的系统中，打造集管理、监控、运维、告警为一体的生态平台，那么就需要以程序调用 API 的方式去实现。本节主要介绍 KafkaAdminClient 的基本使用方式，以及采用这种调用 API 方式下的创建主题时的合法性验证。 使用 TopicCommand 创建了一个主题: public static void createTopic(){ String[] op
第一关kafka-初体验
12-01
以下是kafka的初体验步骤： 1. 下载并解压kafka ```shell wget https://mirrors.tuna.tsinghua.edu.cn/apache/kafka/2.8.0/kafka_2.13-2.8.0.tgz tar -xzf kafka_2.13-2.8.0.tgz cd kafka_2.13-2.8.0 ``` 2. 启动kafka服务 ```shell # 启动zookeeper服务 bin/zookeeper-server-start.sh config/zookeeper.properties & # 启动kafka服务 bin/kafka-server-start.sh config/server.properties & ``` 3. 创建一个主题 ```shell bin/kafka-topics.sh --create --topic test --bootstrap-server localhost:9092 ``` 4. 发送一些消息 ```shell bin/kafka-console-producer.sh --topic test --bootstrap-server localhost:9092 >Hello, Kafka! >This is my first message. ``` 5. 从主题中消费消息 ```shell bin/kafka-console-consumer.sh --topic test --from-beginning --bootstrap-server localhost:9092 Hello, Kafka! This is my first message. ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

风过水无痕·

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值