三、Kafka的基础API操作

最新推荐文章于 2024-06-05 09:42:04 发布
最新推荐文章于 2024-06-05 09:42:04 发布
阅读量128 收藏 1
点赞数
分类专栏： Kafka 文章标签： 队列 kafka 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d749800796/article/details/108786801
版权
Kafka基础API

1、Topic基本操作 DML管理
2、生产者
3、消费者 sub/assign
4、自定义分区
5、序列化
6、拦截器

Topic常用API：
package com.dyz.dml;

import org.apache.kafka.clients.admin.*;
import org.apache.kafka.common.KafkaFuture;

import java.util.*;
import java.util.concurrent.ExecutionException;

public class KafkaTopicDml {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

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

        //查询topics列表
        KafkaFuture<Set<String>> nameFutures = adminClient.listTopics().names();
        for (String name : nameFutures.get()) {
            System.out.println(name);
        }

        //创建Topics，异步的
        CreateTopicsResult topicCreate = adminClient.createTopics(Arrays.asList(new NewTopic("topic02", 2, (short) 3)));

        //同步执行
        topicCreate.all().get();

        //删除Topic
        DeleteTopicsResult topicDelete = adminClient.deleteTopics(Arrays.asList("topic02"));
        //同步删除
        topicDelete.all().get();

        //查看Topic详情
        DescribeTopicsResult describeTopics =
                adminClient.describeTopics(Arrays.asList("topic01"));
        Map<String, TopicDescription> tdm = describeTopics.all().get();
        for (Map.Entry<String, TopicDescription> entry : tdm.entrySet()) {
            System.out.println(entry.getKey()+"\t"+entry.getValue());
        }

        //关闭KafkaAdminClient
        adminClient.close();
    }
}
Producer常用API：
package com.dyz.quickstart;

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

import java.util.Properties;

public class KafkaProducerQuickStart {

    public static void main(String[] args) {
        //设置连接信息
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        //创建kafkaproduce
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        //创建10条消息
        for (int i=0;i<10;i++){
            ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic01", "key" + i, "value" + i);
            //发送消息给服务器
            kafkaProducer.send(record);
        }

        //关闭kafka
        kafkaProducer.close();
    }
}
Consumer常用API：
package com.dyz.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.common.serialization.StringDeserializer;

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

public class KafkaConsumerQuickStart {
    public static void main(String[] args) {
        //设置连接配置
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"g2");
        //创建kafkaConsumer
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties);

        //订阅相关的Topics,使用正则表达式：消费所有topic开头的消息
        kafkaConsumer.subscribe(Pattern.compile("^topic.*"));
        //遍历消息队列
        while (true){
            //设置多久消费一次消息
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));
            //如果从队列中取到数据，遍历数据
            if (!consumerRecords.isEmpty()){
                Iterator<ConsumerRecord<String, String>> iterator = consumerRecords.iterator();
                while (iterator.hasNext()){
                    //获取一个消费消息
                    ConsumerRecord<String, String> record = iterator.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+"\t"+offset+"\t"+key+"\t"+value+"" +"\t"+timestamp);
                }
            }
        }
    }
}
自定义分区方式消费消息：
package com.dyz.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.internals.Topic;
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;

public class KafkaConsumerQuickStart_custom {
    public static void main(String[] args) {
        //设置连接配置
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());

        //创建kafkaConsumer
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties);

        //订阅相关的Topics,手动指定消费分区，失去组管理特性
        List<TopicPartition> topicList = Arrays.asList(new TopicPartition("topic01", 0));
        kafkaConsumer.assign(topicList);

        //指定消费分区的位置,（偏移量）
        //从第0个分区，第一个消息开始消费
        kafkaConsumer.seekToBeginning(topicList);

        //从第0个分区的第一个位置开始消费
//        kafkaConsumer.seek(new TopicPartition("topic01",0),1);

        //遍历消息队列
        while (true){
            //设置多久消费一次消息
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));
            //如果从队列中取到数据，遍历数据
            if (!consumerRecords.isEmpty()){
                Iterator<ConsumerRecord<String, String>> iterator = consumerRecords.iterator();
                while (iterator.hasNext()){
                    //获取一个消费消息
                    ConsumerRecord<String, String> record = iterator.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+"\t"+offset+"\t"+key+"\t"+value+"" +"\t"+timestamp);
                }
            }
        }
    }
}
自定义分区方式发送消息：

kafka默认分区策略：new ProducerRecord指定分区，则发送给指定的分区；未指定且有key值，使用hash；无key值使用轮询。

  • 自定义分区策略类：UserDefinePartition（实现kafka的Partitioner接口）
package com.dyz.partition;

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;

public class UserDefinePartition 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 (andIncrement & Integer.MAX_VALUE) % numPartitions;
        }else {
            //取模
            return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
        }
    }

    /**
     * 关闭生产者时的回调方法
     */
    @Override
    public void close() {
        System.out.println("close");
    }

    /**
     * 打印生产者信息
     * @param map
     */
    @Override
    public void configure(Map<String, ?> map) {
        System.out.println(map);
    }
}
  • 使用自定义分区策略，生产者生产消息：
package com.dyz.partition;

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;

public class KafkaProducerPartition {

    public static void main(String[] args) {
        //设置连接信息
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        //指定使用的分区策略实现类
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,UserDefinePartition.class.getName());
        //创建kafkaproduce
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        //创建10条消息
        for (int i=0;i<10;i++){
            ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic01", "key" + i, "value" + i);//指定key值
//            ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic01","value" + i);//不指定key值
            //发送消息给服务器
            kafkaProducer.send(record);
        }


        //关闭kafka
        kafkaProducer.close();
    }
}
自定义序列化消息
  • 自定义序列化：UserDefineSerializer
package com.dyz.serializer;

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

import java.io.Serializable;
import java.util.Map;

/**
 * 自定义实现消费序列化
 */
public class UserDefineSerializer implements Serializer<Object> {
    @Override
    public void configure(Map map, boolean b) {
        System.out.println("configure");
    }

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

    @Override
    public void close() {
        System.out.println("close");
    }
}
  • 自定义反序列化：UserDefineDeSerializer
package com.dyz.serializer;

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

import java.util.Map;

/**
 * 自定义反序列化接口
 */
public class UserDefineDeSerializer implements Deserializer<Object> {
    @Override
    public void configure(Map map, boolean b) {
        System.out.println("configure");
    }

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

    @Override
    public void close() {
        System.out.println("close");
    }
}
  • 创建实体类对象：
package com.dyz.serializer;

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

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

    public User() {
    }

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

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

    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;
    }
}
  • 生产者生产消息：KafkaProducerUser
package com.dyz.serializer;

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

import java.util.Date;
import java.util.Properties;

public class KafkaProducerUser {

    public static void main(String[] args) {
        //设置连接信息
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, UserDefineSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,UserDefineSerializer.class.getName());
        //创建kafkaproduce
        KafkaProducer<String, User> kafkaProducer = new KafkaProducer<String, User>(properties);

        //创建10条消息
        for (int i=0;i<10;i++){
            ProducerRecord<String, User> record = new ProducerRecord<String, User>("topic01",
                    "key" + i,new User("dyz",new Date()) );
            //发送消息给服务器
            kafkaProducer.send(record);
        }


        //关闭kafka
        kafkaProducer.close();
    }
}
  • 消费者消费消息：KafkaConsumerUser
package com.dyz.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 java.time.Duration;
import java.util.Iterator;
import java.util.Properties;
import java.util.regex.Pattern;

public class KafkaConsumerUser {
    public static void main(String[] args) {
        //设置连接配置
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, UserDefineDeSerializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,UserDefineDeSerializer.class.getName());
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"g2");
        //创建kafkaConsumer
        KafkaConsumer<String, User> kafkaConsumer = new KafkaConsumer<String, User>(properties);

        //订阅相关的Topics,使用正则表达式：消费所有topic开头的消息
        kafkaConsumer.subscribe(Pattern.compile("^topic.*"));
        //遍历消息队列
        while (true){
            //设置多久消费一次消息
            ConsumerRecords<String, User> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));
            //如果从队列中取到数据，遍历数据
            if (!consumerRecords.isEmpty()){
                Iterator<ConsumerRecord<String, User>> iterator = consumerRecords.iterator();
                while (iterator.hasNext()){
                    //获取一个消费消息
                    ConsumerRecord<String, User> record = iterator.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+"\t"+offset+"\t"+key+"\t"+value+"" +"\t"+timestamp);
                }
            }
        }
    }
}
自定义拦截器
  • 自定义拦截器：
package com.dyz.interceptors;

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;

public class UserDefineProducerInterceptors implements ProducerInterceptor {
    /**
     * 发送消息时追加信息
     * @param record
     * @return
     */
    @Override
    public ProducerRecord onSend(ProducerRecord record) {
        return new ProducerRecord(record.topic(),record.key(),record.value()+"--我要花开丶");
    }

    /**
     * 通知：发送消息时调用：发送成功或失败都会返回信息
     * @param recordMetadata
     * @param e
     */
    @Override
    public void onAcknowledgement(RecordMetadata recordMetadata, Exception e) {
        System.out.println("recordMetadata:"+recordMetadata+",e:"+e);
    }

    @Override
    public void close() {

    }

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

    }
}
  • 生产者生产消息：
package com.dyz.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;

/**
 * 自定义消息拦截器
 */
public class KafkaProducerInterceptors {

    public static void main(String[] args) {
        //设置连接信息
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        properties.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,UserDefineProducerInterceptors.class.getName());
        //创建kafkaproduce
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        //创建10条消息
        for (int i=0;i<10;i++){
            ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic02", "key" + i, "value" + i);
            //发送消息给服务器
            kafkaProducer.send(record);
        }


        //关闭kafka
        kafkaProducer.close();
    }
}

  • 消费者消费消息：
package com.dyz.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;

public class KafkaConsumerInterceptors {
    public static void main(String[] args) {
        //设置连接配置
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"g1");
        //创建kafkaConsumer
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties);

        //订阅相关的Topics,使用正则表达式：消费所有topic开头的消息
        kafkaConsumer.subscribe(Arrays.asList("topic02"));
        //遍历消息队列
        while (true){
            //设置多久消费一次消息
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));
            //如果从队列中取到数据，遍历数据
            if (!consumerRecords.isEmpty()){
                Iterator<ConsumerRecord<String, String>> iterator = consumerRecords.iterator();
                while (iterator.hasNext()){
                    //获取一个消费消息
                    ConsumerRecord<String, String> record = iterator.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+"\t"+offset+"\t"+key+"\t"+value+"" +"\t"+timestamp);
                }
            }
        }
    }
}

在这里插入图片描述
附录：pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

        <groupId>com.dyz</groupId>
        <artifactId>kafka_mq</artifactId>
        <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
            <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
            <dependency>
                <groupId>org.apache.kafka</groupId>
                <artifactId>kafka-clients</artifactId>
                <version>2.2.0</version>
            </dependency>

            <!-- https://mvnrepository.com/artifact/log4j/log4j -->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.7.25</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.25</version>
            </dependency>

            <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.9</version>
            </dependency>
        </dependencies>
</project>
我要花开丶
关注
专栏目录
Kafka_API_文档
04-04
### Kafka API 文档知识点解析 #### 一、Kafka简介与基本概念 **1.1 Kafka是什么** Kafka是一款开源的分布式消息系统，主要用于构建实时数据管道和流应用。其核心设计思想在于将消息视为一系列分布式日志，通过...
Kafka(四) ：Java 编写简单的kafka生产者和消费者
风之子
04-05 296
一、准备工作 框架：springboot 电脑查看网关是否开启工具：telnet 安装（Mac） 引入依赖： <!--添加kafka --> <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</...
消息中间件
海里鱼的技术博客
10-28 432
abbitmq是一个高级消息队列，而mq呢又是一种分布式应用程序的的通信方法。我们用它来做什么呢？ 消息中间件 我们最近常用的就是将他当作是消息中间件来进行使用，接下来 好好介绍下。 消息队列（消息中间件）已经逐渐成为企业IT系统内部通信的核心手段。它具有低耦合、可靠投递、广播、流量控制、最终一致性等一系列功能，成为异步RPC的主要手段之一。当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、RabbitMQ，炙手可热的Kafka，阿里巴巴自主开发RocketMQ等。 消息中间件的组成 Brok
kafka复习：（17）seekToBeginning的用法
amadeus_liu2的博客
08-25 1790
从分区的开始进行消费，因为kafka会定期清理历史数据，所以分区开始的位移不一定为0。seekToBeginning只是从目前保留的数据中最小的offset进行消费。
kafka从头消费信息
鸭梨的博客
01-01 2326
命令行 1 group id换成新的 2 offset参数设为earliest kafka-console-consumer.sh \ --bootstrap-server mypc01:9092,mypc02:9092,mypc03:9092 \ --topic cat \ --partition 0 \ --group group1 \ --offset earliest 代码 seekToBeginning方法可以让从头开始消费 //从头开始消费 def ConsumerTest3(): Un
Kafka新版消费者API示例（一）
Simon的博客
11-05 6217
Kafka的高阶消费者(high-level consumer)和低阶消费者(low-level consumer，底层用SimpleConsumer实现)是旧版本的consumer中的。 新版本的consumer中没有这两个概念。新版本把高阶消费者和低阶消费者整合到一起了，对应KafkaConsumer类的subscribe和assign方法。 创建消费者： String kafkas =...
kafka基础简介整合材料
04-07
3. **Streams API**：Kafka 提供的 Streams API 允许开发人员对流数据进行复杂处理，如聚合、连接和其他流处理操作。这使得实时分析和转换数据成为可能。 4. **Connector API**：Kafka Connector 允许与其他数据源...
Kafka中文api使用介绍+配置
08-23
流处理API（Streams API）允许应用程序像操作流一样处理数据，这是Kafka用于构建流处理应用的核心API。 配置部分则会详细介绍如何配置Kafka的broker（代理服务器）、生产者和消费者。对于broker的配置，会涉及到它...
kafka基础代码实现
01-02
**Kafka基础知识** Kafka是由Apache开发的分布式流处理平台，它主要被设计用来处理海量实时数据。在本文中，我们将深入探讨Kafka的基础代码实现，包括客户端和服务端的交互。 **1. Kafka架构** Kafka的核心组件...
kafka基础代码
11-09
这个"Kafka基础代码"的主题显然关注于如何在实际编程中与Kafka进行交互，进行消息生产和消费。让我们深入探讨一下Kafka的核心概念、API使用以及在Java中的基本代码封装。 Kafka是一个高吞吐量、低延迟的消息中间件...
Java轻松使用Kafka生产者，消费者
qq_38946379的博客
10-21 1900
Java之 Kafka基础查询解析
KafkaConsumer-kafka消费者的Java客户端
热门推荐
cjf_wei的博客
09-24 1万+
本文介绍KafkaConsumer，一个从kafka集群消费记录的java客户端。该客户端是非线程安全的，关于多线程的使用，参见文章的“Multi-threaded Processing”部分。
kafka的Java客户端-消费者
拒绝熬夜啊的博客
06-29 5706
kafka的Java客户端-消费者
（转）Kafka 消费者 Java 实现
PacosonSWJTU的博客
11-09 7442
转自： Kafka 消费者 Java 实现 - 简书应用程序使用 KafkaConsumer向 Kafka 订阅 Topic 接收消息，首先理解 Kafka 中消费者（consumer）和消费者组（consumer group...https://www.jianshu.com/p/1f9e18e926f6据原文作者，以下内容总结自 《kafka权威指南》； 应用程序使用 KafkaConsumer向 Kafka 订阅 Topic 接收消息，首先理解 Kafka 中消费者（consumer）和消费者组（
kafka消费者：从kafka读取数据（性能提升、JAVA示例）
墨痕诉清风的博客
01-16 7571
以第三章中的序列化器示例，如下写一个反序列化器。try {Customer@Override消费者端也需要实现Customer类，类和序列化器都需要在生产者和消费者的应用程序上匹配。在又许多消费者和生产者共享数据访问权限的大型组织中，这可能会非常有挑战性。反序列化器只是颠倒了了序列化器的逻辑，从字节数字中将Customer对象的ID和名称获取出来，重新构造一个对象。
Java实现Kafka消费者(Consumer)两种方式
最新发布
道祖转生之重修Java
06-05 3811
实现在Spring Boot项目中监听Kafka指定topic中的消息，有两种实现思路：一种是使用Spring Boot提供的注解另外一种是在提供的原生java客户端中，消费者使用定时任务或者采进行消息拉取，这种方式可以避免与parent 版本出现冲突。
Kafka 使用java实现，快速入门
Qynwang的博客
05-10 8646
【代码】Kafka 集成 SpringBoot， 快速入门。
kafka-生产者编程实践
平凡的世界
07-04 239
本文主要实际编程讲解kafka生产者相关内容，版本:kafka_2.11-0.10.1.0 安装 自行百度 实践 依赖 kafka 0.10.1.0版本中采用KafkaProducer对象用来向kafka broker集群发送消息。 编写代码前先引入相关依赖包： <dependency> <groupId>org.apache.kafka</groupId&g...
kafka consumer java_Kafka从上手到实践-实践真知：Kafka Java Consumer
weixin_30046591的博客
02-12 712
这一节来看看如何使用Java编写Kafka Consumer。Java Consumer首先创建Consumer需要的配置信息，最基本的有五个信息：Kafka集群的地址。发送的Message中Key的序列化方式。发送的Message中Value的序列化方式。指定Consumer Group。指定拉取Message范围的策略。Properties properties = new Propertie...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值