kafka结合java_SpringBoot Kafka 整合 实例 源码

1、使用idea新建工程引导方式，创建消息生产工程 springboot-kafka-producer。

工程pom文件代码如下：

1 <?xml version="1.0" encoding="utf-8"?>

2

3 xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

4 4.0.0

5

6 com.miniooc

7 springboot-kafka-producer

8 1.0.0-snapshot

9 jar

10

11 springboot-kafka-producer

12 demo project for spring boot

13

14

15 org.springframework.boot

16 spring-boot-starter-parent

17 2.0.3.release

18

19

20

21

22 finchley.release

23

24

25

26

27 org.springframework.boot

28 spring-boot-starter-web

29

30

31 org.springframework.boot

32 spring-boot-starter-actuator

33

34

35 org.springframework.kafka

36 spring-kafka

37

38

39 org.springframework.boot

40 spring-boot-starter-test

41 test

42

43

44

45

46 com.google.code.gson

47 gson

48 2.8.5

49

50

51

52 org.projectlombok

53 lombok

54 1.16.22

55 provided

56

57

58

59

60

61

62 org.springframework.cloud

63 spring-cloud-dependencies

64 ${spring-cloud.version}

65 pom

66 import

67

68

69

70

71

72

73

74 org.springframework.boot

75 spring-boot-maven-plugin

76

77

78

79

80

81

注释部分为手动添加的 gson、lombok 依赖。

2、创建消息实体类

1 package com.miniooc.kafka.message;

2

3 import lombok.data;

4

5 import java.io.serializable;

6 import java.util.date;

7 import java.util.list;

8

9 @data

10 public class orderbasic implements serializable {

11

12 /**

13 * 订单id

14 */

15 private string orderid;

16 /**

17 * 订单编号

18 */

19 private string ordernumber;

20 /**

21 * 订单日期

22 */

23 private date date;

24 /**

25 * 订单信息

26 */

27 private list desc;

28

29 }

3、创建消息生产类

1 /**

2 *

3 */

4 package com.miniooc.kafka.producer;

5

6 import com.google.gson.gsonbuilder;

7 import com.miniooc.kafka.message.orderbasic;

8 import lombok.extern.java.log;

9 import org.springframework.beans.factory.annotation.value;

10 import org.springframework.kafka.core.kafkatemplate;

11 import org.springframework.stereotype.component;

12

13 import javax.annotation.resource;

14

15 /**

16 * kafka消息生产类

17 */

18 @log

19 @component

20 public class kafkaproducer {

21

22 @resource

23 private kafkatemplate kafkatemplate;

24

25 @value("${kafka.topic.order}")

26 private string topicorder;

27

28 /**

29 * 发送订单消息

30 *

31 * @param orderbasic 订单信息

32 */

33 public void sendordermessage(orderbasic orderbasic) {

34 gsonbuilder builder = new gsonbuilder();

35 builder.setprettyprinting();

36 builder.setdateformat("yyyy-mm-dd hh:mm:ss");

37 string message = builder.create().tojson(orderbasic);

38 kafkatemplate.send(topicorder, message);

39 log.info("\n" + message);

40 }

41 }

4、编辑资源配置文件 application.properties

1 server.port=9526

2 spring.application.name=kafka-producer

3 kafka.bootstrap.servers=localhost:9092

4 kafka.topic.order=topic-order

5 kafka.group.id=group-order

5、启动 zookeeper

d:\kafka>bin\windows\zookeeper-server-start.bat config\zookeeper.properties

6、启动 kafka

d:\kafka>bin\windows\kafka-server-start.bat config\server.properties

7、运行工程，通过控制器调用消息生产类，创建一条消息到kafka

看到红框内容，说明消息发送成功。

8、再使用idea新建工程引导方式，创建消息消费工程 springboot-kafka-producer。

9、创建消息消费类，并监听topic。

1 package com.miniooc.kafka.consumer;

2

3 import com.google.gson.gson;

4 import com.google.gson.gsonbuilder;

5 import com.google.gson.reflect.typetoken;

6 import com.miniooc.kafka.message.orderbasic;

7 import lombok.extern.java.log;

8 import org.springframework.kafka.annotation.kafkalistener;

9 import org.springframework.messaging.handler.annotation.payload;

10 import org.springframework.stereotype.component;

11

12 @log

13 @component

14 public class kafkaconsumer {

15

16 @kafkalistener(topics = "${kafka.topic.order}", containerfactory = "kafkalistenercontainerfactory")

17 public void consume(@payload string message) {

18 gsonbuilder builder = new gsonbuilder();

19 builder.setprettyprinting();

20 builder.setdateformat("yyyy-mm-dd hh:mm:ss");

21 gson gson = builder.create();

22 orderbasic orderbasic = gson.fromjson(message, new typetoken() {

23 }.gettype());

24 string json = gson.tojson(orderbasic);

25 log.info("\n接受并消费消息\n" + json);

26 }

27 }

10、运行工程。

看到红框内容，说明消息消费成功。

springboot kafka 整合完成！

如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！