Kafka之JavaAPI

生产者

使用同步等待方式发送消息

public class kafkaProducerTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建用于连接Kafka的Properties配置
        Properties props = new Properties();
        //bootstrap.servers：kafka的服务器地址
        props.put("bootstrap.servers", "node1:9092");
        //acks：表示生产者生产数据到kafka中，kafka会以什么样的策略返回
        props.put("acks", "all");
        //key.serializer：Kaka中的消息是以key, value键值对存储的,而且生产者生产的消息是需要在网络上传到的,这里指定的是StringSerializer方式,就是以字符串方式发送(将来还可以使用其他的一些序列化框架)
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //value.serializer：同key.serializer
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //使用同步等待的方式发送消息
        synchronization(props);
    }
    /*
    * 使用同步等待的方式发送消息
    * */
    public static void synchronization(Properties props) throws ExecutionException, InterruptedException {
        System.out.println("使用同步等待的方式发送消息");
        //2.创建一个生产者对象KafkaProducer
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        //3.发送1-100的消息到指定的topic中
        for (int i = 0; i < 100; i++) {
            //创建一个消息，并指定主题
            ProducerRecord<String, String> record = new ProducerRecord<>("test", null, i + "");
            //将消息发送出去，获取返回值Future，对象封装了返该回值
            Future<RecordMetadata> future = producer.send(record);
            //调用一个Future.get()方法等待响应
            future.get();
            System.out.println("第"+i+"条消息");
        }
        //4.关闭消费者
        producer.close();
    }

使用异步回调方式发送消息

• 使用匿名内部类实现Callback(回调)接口，该接口中表示kafka服务器响应给客户端，会自动调用onCompletion方法

metadata：消息的元数据(属于哪个topic、属于哪个partition、对应的offset是什么)
exception:这个对象Katka生产消息封装了出现的异常,如果为null,表示发送成功,如果不为null, 表示出现异常。

public class kafkaProducerTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建用于连接Kafka的Properties配置
        Properties props = new Properties();
        //bootstrap.servers：kafka的服务器地址
        props.put("bootstrap.servers", "node1:9092");
        //acks：表示生产者生产数据到kafka中，kafka会以什么样的策略返回
        props.put("acks", "all");
        //key.serializer：Kaka中的消息是以key, value键值对存储的,而且生产者生产的消息是需要在网络上传到的,这里指定的是StringSerializer方式,就是以字符串方式发送(将来还可以使用其他的一些序列化框架)
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //value.serializer：同key.serializer
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        
        //使用异步回调方式发送消息
        asynchronization(props);
    }
/*
    *使用异步回调方式发送消息
    * */
    public static void asynchronization(Properties props) throws ExecutionException, InterruptedException {
        System.out.println("使用异步回调的方式发送消息");
        //2.创建一个生产者对象KafkaProducer
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        //3.发送1-100的消息到指定的topic中
        for (int i = 0; i < 100; i++) {
            //创建一个消息，并指定主题
            ProducerRecord<String, String> record = new ProducerRecord<>("test", null, i + "");
            //将消息发送出去，获取返回值Future，对象封装了返该回值
            Future<RecordMetadata> future = producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    //recordMetadat：消息的元数据
                    //判断消息是否发送成功
                    if (e == null){
                        //发送成功
                        //获取主题名
                        String topic = recordMetadata.topic();
                        //获取分区id
                        int partition = recordMetadata.partition();
                        //获取偏移量
                        long offset = recordMetadata.offset();
                        System.out.println("发送消息到Kafka中的名字为" + topic + "的主题，第" + partition + "分区，第" + offset + "条数据成功!");
                    }else{
                        //发送错误
                        System.out.println("生产消息出现错误！");
                        //打印异常消息
                        System.out.println(e.getMessage());
                        //打印调用栈
                        System.out.println(e.getStackTrace());
                    }
                }
            });

        }
        //4.关闭消费者
        producer.close();
    }
}

消费者

public class kafkaConsumerTest {
    public static void main(String[] args) {
        //1.创建用于连接Kafka的Properties配置
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "node1:9092");
        //消费者组(使用消费者组将若干个消费者组织到一起，共同消费kafka中topic的数据)
        //每个消费者需要指定一个消费者组，如果组名相同，那么他们就在同一组中
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "true");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        //2.创建kafka消费者
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(props);

        //3.订阅要消费的主题
        //指定消费者从哪个topic中拉取数据
        kafkaConsumer.subscribe(Arrays.asList("test"));

        //4.使用一个while循环，不断从kafka中拉取数据
        while (true){
            //kafka的消费者一批一批拉取数据
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(5));
            //将拉取的一批数据遍历出来
            for (ConsumerRecord<String, String> record : consumerRecords) {
                System.out.println(record.value());
            }
        }

    }
}