Kafka JavaAPI

最新推荐文章于 2024-04-15 08:55:28 发布
最新推荐文章于 2024-04-15 08:55:28 发布
阅读量175 收藏
点赞数
分类专栏： kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DamoLLL/article/details/112179877
版权

Kafka JavaAPI

如果面试问用的是高级API还是低级API时，因为网上对高低级的定义不一致，所以要先问对高低级的定义是什么，有的把手动提交定义为低级，

先导入依赖

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka_2.11</artifactId>
    <version>1.0.2</version>
</dependency>

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

操作主题

package com.bigdata.demo;

import org.apache.kafka.clients.admin.*;
import org.apache.kafka.common.KafkaFuture;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.Collections;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.ExecutionException;

/**
 * Kafka的源码： java + scala
 */
public class KafkaDemo01 {
    private AdminClient client;

    @Before
    public void init(){
        Properties prop = new Properties();
//        prop.setProperty("bootstrap.servers","hadoop101:9092,hadoop102:9092,hadoop103:9092");
        			     prop.setProperty(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        //创建客户端对象
        client = AdminClient.create(prop);
    }

    //创建topic
    @Test
    public void test01() throws ExecutionException, InterruptedException {
        NewTopic topic = new NewTopic("java",2,(short) 3);
        CreateTopicsResult topicsResult = client.createTopics(Collections.singletonList(topic));
        Map<String, KafkaFuture<Void>> map = topicsResult.values();

        Set<Map.Entry<String, KafkaFuture<Void>>> entrySet = map.entrySet();
        for (Map.Entry<String, KafkaFuture<Void>> entry : entrySet) {
            System.out.println(entry.getKey()+","+entry.getValue().get());
        }
    }


    //列出所有的topic
    @Test
    public void test02() throws ExecutionException, InterruptedException {
        ListTopicsResult listTopics = client.listTopics();
        KafkaFuture<Set<String>> names = listTopics.names();
        Set<String> topics = names.get();

        for (String topic : topics) {
            System.out.println(topic);
        }
    }

    //列出所有的topic,包括__consumer_offsets
    @Test
    public void test03() throws ExecutionException, InterruptedException {
        ListTopicsOptions options = new ListTopicsOptions();
        options.listInternal(true);
        ListTopicsResult listTopics = client.listTopics(options);
        KafkaFuture<Set<String>> names = listTopics.names();
        Set<String> topics = names.get();

        for (String topic : topics) {
            System.out.println(topic);
        }
    }

    //查看主题的描述信息
    @Test
    public void test04() throws ExecutionException, InterruptedException {
        DescribeTopicsResult result = client.describeTopics(Collections.singletonList("java"));
        Map<String, KafkaFuture<TopicDescription>> values = result.values();
        Set<Map.Entry<String, KafkaFuture<TopicDescription>>> set = values.entrySet();

        for (Map.Entry<String, KafkaFuture<TopicDescription>> entry : set) {
            System.out.println(entry.getKey()+","+entry.getValue().get().toString());
        }

    }

    //删除主题
    @Test
    public void test05(){
        DeleteTopicsResult result = client.deleteTopics(Collections.singletonList("java"));
    }
    @After
    public void close(){
        client.close();
    }

}

生产数据

package com.bigdata.demo;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

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

/**
 * 生产数据
 * 1、异步  FireAndForgot
 * 2、异步带回调
 * 3、同步(异步带阻塞)
 *
 */
public class KafkaDemo02 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        m01();
//        m02();

        m03();
    }


    //1、异步  FireAndForgot
    public static void m01(){
        Properties prop = new Properties();
        prop.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //获取生产者客户端对象
        KafkaProducer producer = new KafkaProducer(prop);


        ProducerRecord<String, String> record = new ProducerRecord<String, String>("goods","java-demo01");
        //生产数据
        producer.send(record);




    }

    //2、异步带回调
    public static  void m02(){
        Properties prop = new Properties();
        prop.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //获取生产者客户端对象
        KafkaProducer producer = new KafkaProducer(prop);

        for (int i = 0; i < 6; i++) {
            ProducerRecord<String, String> record = new ProducerRecord<String, String>("goods","java-demo00"+i);
            //生产数据
            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {

                    System.out.println(metadata.topic());
                    System.out.println(metadata.partition());
                    System.out.println(metadata.offset());

                    System.out.println("------------------------------");

                }
            });

            producer.flush();
        }


    }

    //3、同步(异步带阻塞)
    public static void m03() throws ExecutionException, InterruptedException {
        Properties prop = new Properties();
        prop.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //获取生产者客户端对象
        KafkaProducer producer = new KafkaProducer(prop);


        ProducerRecord<String, String> record = new ProducerRecord<String, String>("goods","java-demo01");
        //生产数据
        Future future = producer.send(record);
        future.get();//阻塞

        producer.flush();

    }


}

java实现线程

通过java实现线程的例子来说明生产数据 同步(异步带阻塞) 的情况

package com.bigdata.demo;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * java实现线程的三种方式：
 * 1、继承Thread类
 * 2、实现Runnable接口
 * 3、实现Callable接口
 *
 */
public class ThreadDemo {
    static int sum01 = 0;
    static int sum02 = 0;

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

        new ThreadDemo().m02();


    }


    public static  void m01() throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {

                for (int i = 0; i < 3; i++) {
                    sum01 += i;
                }
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 4; i++) {
                    sum02 += i;
                }
            }

        });

        t1.start();
        t1.join();
        t2.start();
        t2.join();

        System.out.println("main---------sum=== " + (sum01 + sum02));
    }


    public void m02() throws ExecutionException, InterruptedException {
        FutureTask<Integer> task01 = new FutureTask<Integer>(new Call01());
        FutureTask<Integer> task02 = new FutureTask<Integer>(new Call02());
        Thread t1 = new Thread(task01);
        Thread t2 = new Thread(task02);

        t1.start();
        t2.start();

        //get  --- 主线程阻塞，等待子线程返回的结果
        System.out.println("main-------sum== " + (task01.get() + task02.get()));


    }


    class Call01 implements Callable<Integer>{

        int s01 = 0;

        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 3; i++) {
                s01 += i;
            }
            return s01;
        }
    }

    class Call02 implements Callable<Integer>{

        int s02 = 0;

        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 4; i++) {
                s02 += i;
            }
            return s02;
        }
    }
}

//结果
main-------sum== 9

生产者默认分区规则

DefaultPartitioner默认的分区规则：

  1. 指定了分区，就使用这个分区 — 不会使用分区器

  2. 没有指定分区，指定了key，使用key的hash进行分区

  3. 没有指定分区和key,使用轮询

    如果指定了自定义的分区器，就使用自己定义的分区规则

自定义分区器

  1. 实现Partitioner接口

  2. 覆写partition方法

    package com.bigdata.demo01;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

import java.util.Map;

public class MyPartitioner implements Partitioner {
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        String ketStr = (String) key;
        if(ketStr.startsWith("a")){
            return 0;
        }else if(ketStr.startsWith("b")){
            return 1;
        }else{
            return 2;
        }

    }

    @Override
    public void close() {

    }

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

    }
}

  3. 设置分区器

    package com.bigdata.demo01;

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.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 * DefaultPartitioner默认的分区规则：
 * 1、指定了分区，就使用这个分区   --- 不会使用分区器
 * 2、没有指定分区，指定了key，使用key的hash进行分区
 * 3、没有指定分区和key,使用轮询
 *
 * 如果指定了自定义的分区器，就使用自己定义的分区规则
 *
 *
 *
 */
public class ProducerDemo01 {

    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        prop.setProperty(ProducerConfig.PARTITIONER_CLASS_CONFIG, MyPartitioner.class.getName());

        List<String> list = new ArrayList<>();
        list.add(MyInterceptor.class.getName());
        prop.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,list);

        //获取生产者客户端对象
        KafkaProducer producer = new KafkaProducer(prop);

        ProducerRecord<String, String> record;
        for (int i = 0; i < 6; i++) {
            if(i % 2 == 0){
                record = new ProducerRecord<String, String>("goods","a"+i,"aaaaaa"+i);
            }else{
                record = new ProducerRecord<String, String>("goods","b"+i,"bbbbbb"+i);
            }

            //生产数据
            producer.send(record);
        }

        producer.flush();

    }
}
自定义拦截器

  1. 实现ProducerInterceptor接口

  2. 根据需要覆写onSend和onAcknowledgement方法

    package com.bigdata.demo01;

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 MyInterceptor implements ProducerInterceptor<String,String> {

    /**
     * 消息发送的时候拦截
     *
     * 将发送的消息 + 时间戳
     */
    @Override
    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> record) {
        String oldValue = record.value();
        String newValue = oldValue + System.currentTimeMillis();
        return new ProducerRecord<String, String>(record.topic(),record.key(),newValue);
    }

    /*
     *  得到响应的时候拦截
     */
    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {

        if(exception == null){
            System.out.println("exception-------");
        }

    }

    @Override
    public void close() {

    }

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

    }
}

  3. 添加配置

    注意：由于拦截器可以有多个，传入的是list集合，不能用prop.setProperty()方法，要用put()

    List<String> list = new ArrayList<>();
list.add(MyInterceptor.class.getName());
prop.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,list);

flume作为生产者

a1.sources = r1
a1.channels = c1
a1.sinks = k1

# 配置source
a1.sources.r1.type = netcat
a1.sources.r1.bind = hadoop101
a1.sources.r1.port = 6666

# 配置channel
a1.channels.c1.type = memory

# 配置sink
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.topic = java
a1.sinks.k1.kafka.bootstrap.servers = hadoop101:9092,hadoop102:9092,hadoop103:9092
a1.sinks.k1.kafka.producer.acks = -1

# 绑定channel
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

消费者拉取数据

package com.bigdata.demo;

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.util.Collections;
import java.util.Iterator;
import java.util.Properties;

/**
 * 消费者
 * enable.auto.commit = true 自动提交偏移量
 * auto.commit.interval.ms = 5000 自动提交偏移量的间隔时间
 *
 *
 * 我们正常的流程应该是数据被消费了之后提交偏移量
 * 假设是从kafka中获取到数据之后将数据存入MySQL数据库，数据存入成功才算被消费
 *
 * 所以实际开发一定是手动提交偏移量
 *
 */
public class KafkaDemo03 {

    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"g01");

        //创建消费者客户端对象
        KafkaConsumer consumer = new KafkaConsumer<String,String>(prop);

        //订阅主题
        consumer.subscribe(Collections.singletonList("goods"));

        while(true){
            //消费数据
            ConsumerRecords records = consumer.poll(3000);
            Iterator<ConsumerRecord<String,String>> it = records.iterator();

            while(it.hasNext()){
                ConsumerRecord<String, String> record = it.next();
                System.out.println(record.key() +"," + record.value());
            }

        }


    }
}


package com.bigdata.demo;

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.util.Collections;
import java.util.Iterator;
import java.util.Properties;

/**
 * 消费者
 * enable.auto.commit = true 自动提交偏移量
 * auto.commit.interval.ms = 5000 自动提交偏移量的间隔时间
 *
 *
 * 我们正常的流程应该是数据被消费了之后提交偏移量
 * 假设是从kafka中获取到数据之后将数据存入MySQL数据库，数据存入成功才算被消费
 *
 * 所以实际开发一定是手动提交偏移量
 *
 */
public class KafkaDemo04 {

    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"g01");
        //禁用自动提交偏移量
        prop.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");

        //创建消费者客户端对象
        KafkaConsumer consumer = new KafkaConsumer<String,String>(prop);

        //订阅主题
        consumer.subscribe(Collections.singletonList("goods"));

//        try {
            while(true){
                //消费数据
                ConsumerRecords<String,String> records = consumer.poll(3000);
                for (ConsumerRecord<String, String> record : records) {
                    System.out.println(record.key() +"," + record.value());
                    //jdbc
                }

                //提交偏移量
                /**
                 * commitSync：同步提交
                 *    优点：
                 *        1、消费者客户端等待提交的响应
                 *        2、失败了可以重试
                 *    缺点：效率低
                 *
                 *   commitAsync //异步提交
                 *     优点：效率高
                 *     缺点: 不知道提交后的结果
                 */
//            consumer.commitSync();//同步提交
                consumer.commitAsync();//异步提交


            }
//        }
        //最后执行同步提交是防止异步提交失败的情况
//        finally {
//            consumer.commitSync();//同步提交
//        }



    }
}

自定义偏移量

package com.bigdata.demo;

import kafka.consumer.SimpleConsumer;
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.util.Collections;
import java.util.Iterator;
import java.util.Properties;

/**
 * 消费者
 * enable.auto.commit = true 自动提交偏移量
 * auto.commit.interval.ms = 5000 自动提交偏移量的间隔时间
 * auto.offset.reset:
 * latest（默认）: 如果没有offset，将从最新的数据开始消费；有offset就从offset开始消费
 * earliest:如果没有offset，将从头开始消费；有offset就从offset开始消费
 *
 */
public class KafkaDemo05 {

    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"g02");
        prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");

        //创建消费者客户端对象
        KafkaConsumer consumer = new KafkaConsumer<String,String>(prop);

        //订阅主题
        consumer.subscribe(Collections.singletonList("goods"));

        while(true){
            //消费数据
            ConsumerRecords records = consumer.poll(3000);
            Iterator<ConsumerRecord<String,String>> it = records.iterator();

            while(it.hasNext()){
                ConsumerRecord<String, String> record = it.next();
                System.out.println(record.key() +"," + record.value());
            }

        }


    }
}

指定消费分区和分区的offset

package com.bigdata.demo01;

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.util.Arrays;
import java.util.Properties;

/**
 * 消费指定分区
 * 指定offset
 */
public class KafkaTest01 {

    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"g02");
        prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");

        //创建消费者客户端对象
        KafkaConsumer consumer = new KafkaConsumer<String,String>(prop);

        //指定消费分区
        TopicPartition tp = new TopicPartition("goods",1);
        consumer.assign(Arrays.asList(tp));

        //指定消费的offset
        consumer.seek(tp,10);

        while(true){
            //poll 轮询
            //timeout:如果缓冲区中没有数据，则轮询中等待所花费的时间(以毫秒为单位)。
            // 如果为0，则立即返回缓冲区中当前可用的所有记录，否则返回空。不能是负的。
            ConsumerRecords<String,String> records = consumer.poll(3000);

            for (ConsumerRecord<String, String> record : records) {
                System.out.println("partition===" + record.partition());
                System.out.println("offset===" + record.offset());
                System.out.println("value===" + record.value());
                System.out.println("-------------------------------");
            }

        }



    }
}

指定消费者同步提交的数据

package com.bigdata.demo01;

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.util.*;

public class KafkaTest02 {

    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop102:9092,hadoop103:9092");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"g02");
        prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");

        //创建消费者客户端对象
        KafkaConsumer consumer = new KafkaConsumer<String,String>(prop);

        consumer.subscribe(Arrays.asList("goods"));


        while(true){
            ConsumerRecords<String,String> records = consumer.poll(3000);
            Set<TopicPartition> set = records.partitions();
            HashMap<TopicPartition,OffsetAndMetadata> map = new HashMap<>();

            for (TopicPartition tp : set) {
                List<ConsumerRecord<String, String>> list = records.records(tp);
                long offset = list.get(list.size()-1).offset() + 1;
                OffsetAndMetadata metadata = new OffsetAndMetadata(offset);
                map.put(tp,metadata);
            }

            consumer.commitSync(map);

        }
    }
}

subscribe方法

  • 订阅主题
  • 如果分区发生变化可以自动重平衡（ConsumerRebalanceListener）
public void subscribe(Collection<String> topics, ConsumerRebalanceListener callback);

assign方法

  • 可以指定分区进行消费
  • 如果分区发生变化不会自动重平衡
DamoLLL
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kafka的api使用时需要的jar包
04-19
kafka的api使用时需要的jar包，将这些jar包导入到工程中即可使用kafka的api来操作kafka集群了
kafka java(api)
weixin_46415189的博客
08-19 1290
前提 在看javaapi演示前你需要了解一些kafka的概念: 1: 至少要会启动 kafka,知道默认端口号,可参看此博客链接: https://blog.csdn.net/weixin_46415189/article/details/119749267 kafka依赖zookeeper,所以,在此之前你最好先了解一下zookeeper,至少会启动 kafka启动时server.properties默认zookeeper地址配置为: 2: kafka只有主题,通过主题发送和订阅消息 3: kafk
Java工程师的进阶之路-Kafka篇（一）
最新发布
2401_84048445的博客
04-15 954
以上是字节二面的一些问题，面完之后其实挺后悔的，没有提前把各个知识点都复习到位。现在重新好好复习手上的。
kafka java api
echo的博客
05-07 460
kafka java api生产者package com.wxa.storm.kafka; import kafka.javaapi.producer.Producer; import kafka.producer.KeyedMessage; import kafka.producer.ProducerConfig; import java.util.Properties; import ja...
Kafka之JavaAPI
大数据跟我学i
03-28 161
文章目录生产者消费者 生产者 /* *kafka程序生产者 * 它会将消息创建出来，并发送到Kafka集群中 * */ public class kafkaProducerTest { public static void main(String[] args) throws ExecutionException, InterruptedException { //1.创建用于连接Kafka的Properties配置 Properties props = new Pr
Kafka——javaAPI
zl13101758272的博客
07-22 339
文章目录Kafka的JavaAPI1.未整合版的Kafka的API1.1 Producer 消息发送端代码1.2 Consumer 消息消费端代码2.Spring Boot整合Kafka2.1 发送者代码(Producer)2.2 发送者代码(Consumer) Kafka的JavaAPI 针对java程序员来说，必定是在代码中对kafka进行操作。 1.未整合版的Kafka的API <dependency> <groupId>org.apache.kafka</grou
KafkaDemo:kafka Java API
05-18
#Kafka Java API案例Producer可选配置，如果不配置，则使用默认的partitioner根据key值value映射到指定的Parition props.put("partitioner.class", "kafka.demo.PartitionerDemo");ConsumerString key=(String)obj; ...
Flink+Kafka的JavaAPI应用
05-30
此案例使用的是IDEA开发工具，项目...使用JavaAPI操作Flink的流处理，Flink从Kafka中获取数据，执行处理后再执行输出。 根据（《Flink入门与实战》徐葳著）教材最后的综合案例改变，适合没有学习不会使用Flume的人使用
Simple-Kafka:易于使用的 Apache Kafka Java API 包装器和实现
06-04
Simple-Kafka 旨在为生产者和消费者提供一个更简单的 Java API。 因此，对 Apache Kafka 知之甚少的人可以轻松地将这个实时消息传递系统集成到他们的项目中。 主要特征 1 : 更简单的Java Producer API，其实现和...
Storm流计算项目：1号店电商实时数据分析系统-07.Kafka Java API 简单开发测试.pptx
11-25
07.Kafka Java API 简单开发测试 08.storm-kafka 详解和实战案例 09.S图表框架HighCharts介绍 10.HBase快速入门 11.基于HBase的Dao基类和实现类开发一 12.基于HBase的Dao基类和实现类开发二 13.项目1-地区销售额-...
2、java调用kafka api
05-29
2、java调用kafka api 网址：https://blog.csdn.net/chenwewi520feng/article/details/130577664 本分介绍java调用kafka api。 本文前置条件是kafka环境搭建好。 本分五部分，即简单的写数据到kafka、从topic中消费...
kafka java 开发 api_kafka java api消费者
weixin_36294980的博客
02-17 64
import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Properties;import kafka.consumer.ConsumerConfig;import kafka.consumer.ConsumerIterator;import kafka.consumer.KafkaS...
java kafka api_kafka java API的使用
weixin_28928727的博客
02-12 247
Kafka包含四种核心的API:1、ProducerAPI支持应用将数据流发送到Kafka集群的主题2、ConsumerAPI支持应用从Kafka集群的主题中读取数据流3、StreamsAPI支持数据流从输入主题转化到输出主题4、ConnectAPI支持实现持续地从一些源系统或应用划入Kafka或者从Kafka推入一些源系统或应用的接口。我们这里主要讨论ProducerAPI和Consu...
Kafka Java API
Bee_Darker的博客
06-07 446
任务目标 1.掌握Kafka Java API的使用 2.了解Kafka Java API中的Producer API与Consumer API
Kafka的JavaAPI操作
qq_45094921的博客
02-25 308
Kafka的JavaAPI操作 官网代码参考： 生产者：生产者 消费者：消费者 生产者代码： public class Producer { public static void main(String[] args) { //创建与kakfa的连接 Properties props = new Properties(); //broker的地址 ...
Java 操作KafKa API
weixin_30617561的博客
07-05 154
生产者: 1 import net.sf.json.JSONObject; 2 import org.apache.kafka.clients.producer.KafkaProducer; 3 import org.apache.kafka.clients.producer.ProducerRecord; 4 5 import java.util.Properties;...
java kafka api_《KAFKA官方文档》5.2 APIs
weixin_42386504的博客
02-24 362
原文链接 译者：flystarflyKafka包含四种核心的API:Producer API支持应用将数据流发送到Kafka集群的主题。Consumer API支持应用从Kafka集群的主题中读取数据流。Streams API支持数据流从输入主题转化到输出主题。Connect API支持实现持续地从一些源系统或应用划入Kafka或者从Kafka推入一些源系统或应用的接口。Kafka通过独立于语言的...
flink+kafka的javaapi应用
12-09
在Flink中使用Kafka的Java API可以实现将Kafka中的数据作为输入源或将处理结果输出到Kafka中。 在Flink中使用Kafka Java API的步骤通常如下： 1. 引入Kafka的依赖：首先需要将Kafka的Java API的依赖添加到Flink的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值