Java编程 — Kafka的基本操作

qq_38634896

已于 2022-06-20 19:43:15 修改

阅读量756

点赞数

文章标签： kafka java 分布式

于 2022-06-19 15:45:37 首次发布

本文链接：https://blog.csdn.net/qq_38634896/article/details/125346954

版权

Java编程操作Kafka

文章目录

Java编程操作Kafka
一、导入Maven Kafka POM依赖
二、导入log4j.properties
三.创建包cn.itcast.kafka，并创建KafkaProducerTest类。
四.代码开发
5.从Kafka的topic中消费消息
5.异步使用带有回调函数方法生产消息

一、导入Maven Kafka POM依赖

<repositories><!-- 代码库 -->
    <repository>
        <id>central</id>
        <url>http://maven.aliyun.com/nexus/content/groups/public//</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
            <updatePolicy>always</updatePolicy>
            <checksumPolicy>fail</checksumPolicy>
        </snapshots>
    </repository>
</repositories>

<dependencies>
  <!-- kafka客户端工具 -->
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>2.4.1</version>
    </dependency>
    <!-- 工具类 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-io</artifactId>
        <version>1.3.2</version>
    </dependency>
<!-- SLF桥接LOG4J日志 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.6</version>
    </dependency>
        <!-- SLOG4J日志 -->
    <dependency>
     <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.16</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

二、导入log4j.properties

将log4j.properties配置文件放到resource 文件夹中

log4j.rootLogger=INFO,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.layout.ConversionPattern=%5p - %m%n

三.创建包cn.itcast.kafka，并创建KafkaProducerTest类。

四.代码开发

1.创建用于连接Kafka的Properties配置

Properties props = new Properties();
props.put("bootstrap.servers", "192.168.88.100:9092");
# 确保主分区和副本都同步 再返回结果
props.put("acks", "all");
# 序列化器 数据是以<key,value>形式进行传输 指定是以什么样的序列化的方式进行传输
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

2.创建生产者对象KafkaProducer

3.调用send 发送100条消息到指定的Topic test 并且获取返回值Furture,该对象封装了返回值

4.关闭生产者

	代码示例：

public class KafkaProducerTest {
	public static void main(String[] args) {
		//1.创建用于连接Kafka的Properties配置
		Properties props = new Properties();
		props.put("bootstrap.servers", "192.168.88.100:9092");
		# 确保主分区和副本都同步 再返回结果
		props.put("acks", "all");
		# 序列化器 数据是以<key,value>形式进行传输 指定是以什么样的序列化的方式进行传输
		props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		
		//2.创建生产者对象KafkaProducer
		KafkaProducer<String, String> producer = new KafkaProducer<String, String>(pros);
		//3.调用send 发送1-100条消息指定Topic
		for(int i = 0; i < 100; ++i) {
			try{
			//获取返回值Future 该对象封装了返回值
			Future<RecordMetadata> future = producer.send(new ProducerRecord<String, String>("test", null, i + ""));
			//调用一个Future.get()方法等待响应
			future.get();
			}catch (InterruptedException e) {
			  e.printStackTrace();
			}
		}
		//5.关闭生产者
		producer.close();
	}
	}

5.从Kafka的topic中消费消息

5.1 需求

从test Topic ,将消息都消费，并且记录的offer、key,value都打印出来

5.2 准备工作

在cn.itcast.kafka包下创建KafkaConsumerTest类

5.3 创建kafka消费者配置

Properties props = new Properties();
//连接的主机
props.setProperty("bootstrap.servers", "node1.itcast.cn:9092");
//消费者组（可以使用消费者组将若干个消费者组织到一起，共同消费kafka中的offer数据）
//每一个消费者需要制定一个消费者组，若消费者的组名是一样的，就表示这几个消费者是一个组
props.setProperty("group.id", "test");
//自动提交offer
props.setProperty("enable.auto.commit", "true");
//自动提交offer的时间间隔
props.setProperty("auto.commit.interval.ms", "1000");
//制定<key,value>反序列化的方式
props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

5.4 创建kafka消费者

5.5 订阅需要消费的主题

5.6 使用while循环不断从主题中拉取消息

5.7 将记录（record）的offer、key、value 都打印出来

	代码示例：

public class KafkaConsumerTest {
	public static void main(String[] args) {
		//1.创建用于连接Kafka的Properties配置
		Properties props = new Properties();
		props.setProperty("bootstrap.servers", "node1.itcast.cn:9092");
		//消费者组（可以使用消费者组将若干个消费者组织到一起，共同消费kafka中的offer数据）
		//每一个消费者需要制定一个消费者组，若消费者的组名是一样的，就表示这几个消费者是一个组
		props.setProperty("group.id", "test");
		//自动提交offer
		props.setProperty("enable.auto.commit", "true");
		//自动提交offer的时间间隔
		props.setProperty("auto.commit.interval.ms", "1000");
		//制定<key,value>反序列化的方式
		props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		
		//2.创建消费者对象KafkaConsumer
		KafkaConsumer<String, String> consumer= new KafkaConsumer<String, String>(pros);
		//3.订阅消息主题 制定消息主题从哪个topic中拉取数据
		consumer.subscribe(Array.asList('test"));
		
        kafkaConsumer.subscribe(Arrays.asList("test-topic"));

		 while(true) {
		  //4.消费者一次可以拉取一批数据
		   ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(5));
		     // 5、将记录（ConsumerRecords）的offset、key、value都打印出来
            for(ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                // 主题名字
                String topic = consumerRecord.topic();
                // offset
                long offset = consumerRecord.offset();
                // key / value
                String key = consumerRecord.key();
                String value = consumerRecord.value();
 
                System.out.println("topic:" + topic + " offset:" + offset + " key:" + key + " value" + value);
            }
        }
    }

5.异步使用带有回调函数方法生产消息

如果我们想获取生产者消息是否成功，或者成功生产消息到kafka之后，执行其他一些具体的操作，这时候我们能够使用回调函数来发送消息；

需求：
在出现异常时候，能够及时打印异常信息
在发送消息成功时候，可以打印kafka的topic的名称，分区id，offset

使用匿名内部类实现Callback接口，该接口表示kafka服务器响应给客户端，会自动调用onCompletion()方法
metadata:消息元数据（属于哪个partition,哪个topic，对应的offset 是什么）
exception:这个对象封装了kafka生产消息的异常信息，如果为null，表示发送成功，如果不为空，表示消息生产失败


public class KafkaProducerTest {
	
    public static void main(String[] args) throws ExecutionException, InterruptedException {
		//创建连接kafka服务器的配置文件
		Properties props = new Properties();
        props.put("bootstrap.servers", "127.0.0.1:9092");
        props.put("acks", "all");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

		//创建kafka消息生产者对象
		kafkaProducer<String,String> kafkaProducer = new kafkaProducer<String,String>(props);

		//发送1-100条消息到指定的topic 中
        for (int i = 0; i < 100; i++) {
            // 方式1：使用同步等待方式发送消息
            // 构建一条消息ProducerRecord
//          ProducerRecord<String, String> producerRecord = new ProducerRecord<>("test-topic", null, i + "");
//          ProducerRecord<String, String> producerRecord = new ProducerRecord<>("test-topic", null, i + "");
			//调用Future.get()方法等待响应
	// 	feture.get();
//          System.out.println("第" + i + "条消息写入成功！");

		//方式二： 使用异步回调的方式发送消息
		ProducerRecord<String,String> producerRecord = new ProducerRecord<String,String>("test-topic", null, i + "");
		 kafkaProducer.send(producerRecord, new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e){
                	//判断消息是否发送成功
                	if(e == null){
                		//消息发送成功
                		//主题
                		String topic = recordMetadata.topic(); 
                		// 分区id
                        int partition = recordMetadata.partition();
                        // 偏移量
                        long offset = recordMetadata.offset();
                        System.out.println("topic:" + topic + " 分区id:" + partition + " 偏移量:" + offset);
                         // 发送失败
                        System.out.println("生产消息出现异常！");
                        // 打印异常消息
                        System.out.println(e.getMessage());
                        // 打印调用栈
                        System.out.println(e.getStackTrace());

                	}
                }
		 });
			
		}
		//关闭调用者
		kafkaProducer.close();
	}
}