kafka整合springMVC(消费者)

kafka整合springMVC(消费者)

由于公司项目是mvc的,所以不得不用mvc进行整合,mvc的xml配置属实头疼,头疼也得开始搞。

开始之前,需要先在虚拟机安装环境,网上教程很多,我就不介绍了,但是有几个配置文件需要注意,如下:

首先是需要关闭虚拟机防火墙

systemctl stop firewalld

kafka的配置文件server.properties,大约三十多行的地方,两个地址,需要填你自己的ip地址(我的虚拟机地址)
在这里插入图片描述
还有一个topic信息,网上大多使用的是如下命令查看所有的topic信息,我的不知道为啥不行,我在zookeeper中进行查看

./kafka-topics.sh --list --zookeeper 192.168.153.134:2181

进入zookeeper安装bin目录,执行如下命令

./zkCli.sh

之后进入命令行

ls /brokers/topics

其中的test,test1是我自己新建的topic
在这里插入图片描述

java项目部分

首先是pom文件
添加如下依赖

		<!-- kafka客户端支持包 -->
		<dependency>
			<groupId>org.apache.kafka</groupId>
			<artifactId>kafka-clients</artifactId>
			<version>0.11.0.1</version>
		</dependency>
		<!-- spring支持kafka -->
		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka</artifactId>
			<version>2.0.4.RELEASE</version>
		</dependency>

新建配置文件,application-kafka.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:task="http://www.springframework.org/schema/task"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit-2.1.xsd
        ">

    <!--kafka配置参数-->
    <bean id="consumerProperties" class="java.util.HashMap">
        <constructor-arg>
            <map>
                <!--Kafka服务地址,集群环境时地址使用","隔开-->
                <!--就是上边让填写的listen地址-->
                <entry key="bootstrap.servers" value="192.168.153.134:9092" />
                <!--kafka组id-->
                <entry key="group.id" value="test-consumer-group"></entry>
                <entry key="enable.auto.commit" value="true" />
                <entry key="session.timeout.ms" value="15000 " />
                <entry key="key.deserializer" value="org.apache.kafka.common.serialization.StringDeserializer" />
                <entry key="value.deserializer" value="org.apache.kafka.common.serialization.StringDeserializer" />
            </map>
        </constructor-arg>
    </bean>

    <!--消费者消费kafka信息的java类-->
    <bean id="messageListernerConsumerService" class="你的类实现类路径" />
    <!--第二监听类,用于监听多个topic-->
    <bean id="messageListernerConsumerService2" class="你的类实现类路径" />
    
    <!-- 创建consumerFactory bean,加载上边的配置信息-->
    <bean id="consumerFactory" class="org.springframework.kafka.core.DefaultKafkaConsumerFactory">
        <constructor-arg>
            <ref bean="consumerProperties"/>
        </constructor-arg>
    </bean>
    <!-- test是指定的第一个topic,和相应的监听类进行绑定-->
    <bean id="containerProperties" class="org.springframework.kafka.listener.config.ContainerProperties">
        <constructor-arg value="test"/>
        <property name="messageListener" ref="messageListernerConsumerService"/>
    </bean>
     <!-- test1是指定的第二个topic,和相应的监听类进行绑定-->
    <bean id="containerProperties2" class="org.springframework.kafka.listener.config.ContainerProperties">
        <constructor-arg value="test1"/>
        <property name="messageListener" ref="messageListernerConsumerService2"/>
    </bean>
     <!-- 绑定consumerFactory和containerProperties-->
    <bean id="messageListenerContainer1" class="org.springframework.kafka.listener.KafkaMessageListenerContainer" init-method="doStart">
        <constructor-arg ref="consumerFactory"/>
        <constructor-arg ref="containerProperties"/>
    </bean>
    <bean id="messageListenerContainer2" class="org.springframework.kafka.listener.KafkaMessageListenerContainer" init-method="doStart">
        <constructor-arg ref="consumerFactory"/>
        <constructor-arg ref="containerProperties2"/>
    </bean>
</beans>

上边配置文件中指定了两个监听tpoic的监听类

	<!--消费者消费kafka信息的java类-->
    <bean id="messageListernerConsumerService" class="XXX.XXX.XXX.KafkaConsumerListener" />
    <!--第二监听类,用于监听多个topic-->
    <bean id="messageListernerConsumerService2" class="XXX.XXX.XXX.KafkaConsumerListener2" />

配置文件介绍:

consumerProperties: kafka的配置bean,配置参数都在这里

messageListernerConsumerService、messageListernerConsumerService2: 声明两个监听类

consumerFactory: 把consumerProperties配置的参数加载进来

containerProperties和containerProperties2: 第一个是test,第二个是test1,分别绑定两个topic,指定监听类需要监听kafka服务中的那个topic

messageListenerContainer1和messageListenerContainer2: 把topic和监听类的绑定信息加载进服务中

监听类如下:

继承了MessageListener,需要实现其中的onMessage方法,上边bean配置中配置了两个监听类,所以需要创建出两个监听类,其中一个如下

public class KafkaConsumerListener implements MessageListener<Integer, String> {
    @Override
    public void onMessage(ConsumerRecord<Integer, String> integerStringConsumerRecord) {
        System.err.println("=============");
        System.err.println(integerStringConsumerRecord.value());
    }
}

我本地的是Linux环境,启动zookeeper,启动kafka
打开kafka消息提供者控制台,准备推送消息
这个ip地址就是你在配置文件中填的地址,–topic后边就是kafka的topic

./kafka-console-producer.sh --broker-list 192.168.153.134:9092 --topic test

在这里插入图片描述
输入你好,回车后返回控制台可以查看到信息
在这里插入图片描述

### 回答1: Spring Boot可以很容易地与Kafka集成,下面是整合Kafka消费者的步骤: 1. 添加Kafka依赖 在pom.xml文件中添加以下依赖: ``` <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>2.5.4.RELEASE</version> </dependency> ``` 2. 配置Kafka消费者 在application.properties文件中添加以下配置: ``` spring.kafka.consumer.bootstrap-servers=localhost:9092 spring.kafka.consumer.group-id=my-group spring.kafka.consumer.auto-offset-reset=earliest ``` 3. 创建Kafka消费者 创建一个Kafka消费者类,使用@KafkaListener注解指定要监听的主题和方法: ``` @Component public class MyKafkaConsumer { @KafkaListener(topics = "my-topic", groupId = "my-group") public void consume(String message) { System.out.println("Received message: " + message); } } ``` 4. 运行应用程序 启动应用程序并发送消息到“my-topic”主题,您应该能够在控制台上看到消费者接收到的消息。 以上就是整合Kafka消费者的步骤,希望对您有所帮助。 ### 回答2: Spring Boot是目前非常流行的Java Web框架,而Kafka则是一个高性能、高并发的分布式消息队列。本文将重点介绍如何在Spring Boot项目中整合Kafka消费者。 1. 引入依赖 首先,我们需要在Spring Boot项目的pom.xml中引入kafka-client和spring-kafka两个依赖。 ``` <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>2.5.0</version> </dependency> <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>2.5.6.RELEASE</version> </dependency> ``` 2. 配置消费者 接下来,在application.properties文件中添加Kafka消费者相关的配置。 ``` # kafka server地址 spring.kafka.bootstrap-servers=localhost:9092 # 消费者配置 spring.kafka.consumer.group-id=test-group spring.kafka.consumer.auto-offset-reset=earliest spring.kafka.consumer.enable-auto-commit=false spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer spring.kafka.consumer.value-deserializer=org.springframework.kafka.support.serializer.JsonDeserializer spring.kafka.consumer.value-deserializer.use.type.headers=false ``` 这里需要注意的是,配置文件中的Kafka主题名称应该和实际使用的主题名称一致。 3. 创建消费者 接下来,我们需要创建一个Kafka消费者类,用于接收消息并处理。 ``` @Service public class KafkaConsumer { @KafkaListener(topics = "test-topic", groupId = "test-group") public void consumeMessage(MyMessage message) { // 处理消息 } } ``` 上面的代码中,@KafkaListener注解指定了要监听的主题和消费者组ID。当监听到该主题上有新消息时,Kafka会自动调用consumeMessage方法,并将消息传入该方法中。 4. 运行代码 最后,在Spring Boot项目中编写需要调用Kafka消费者的代码即可。在执行该代码时,程序就会自动连接到Kafka服务器,从指定的主题中接收到消息后,经过处理并打印在控制台上。 ``` @Autowired private KafkaConsumer kafkaConsumer; public void run() { kafkaConsumer.consumeMessage(); } ``` 通过以上步骤,我们就成功地将Kafka消费者集成到了Spring Boot项目中。这样的架构不仅能够实现高性能、高并发的消息传输,还能让开发者更加方便地管理和维护项目。 ### 回答3: Kafka是一个高吞吐量的分布式发布订阅消息系统,Spring Boot是一个快速开发应用程序的框架。Spring Boot中集成Kafka可以使得开发者轻松地在应用程序中利用消息传递。本文将介绍如何使用Spring Boot整合Kafka消费者。 在开始整合Kafka消费者之前,需要明确以下几点: 1. Spring Boot版本 - 需要使用2.0及以上的版本,因为这些版本支持使用Kafka Client来消费消息。 2. Kafka版本 - 需要使用2.0及以上的版本。 3. 使用Spring Boot注解实现 - Spring Boot提供了很多注解,使得开发者能够快速集成Kafka。 步骤如下: 1.在pom.xml文件中添加Kafka Client依赖。 <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>2.6.0</version> </dependency> 2.创建配置类并注入KafkaTemplate。 @Configuration @EnableKafka public class KafkaConsumerConfig { @Value("${spring.kafka.bootstrap-servers}") private String bootstrapServers; @Bean public Map<String, Object> consumerConfigs() { Map<String, Object> props = new HashMap<>(); props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers); props.put(ConsumerConfig.GROUP_ID_CONFIG, "group-id"); props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); return props; } @Bean public ConsumerFactory<String, String> consumerFactory() { return new DefaultKafkaConsumerFactory<>(consumerConfigs()); } @Bean public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() { ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>(); factory.setConsumerFactory(consumerFactory()); return factory; } @Bean public KafkaTemplate<String, String> kafkaTemplate() { return new KafkaTemplate<>(producerFactory()); } } 3.创建Kafka消费者。 @Component public class KafkaConsumer { @KafkaListener(topics = "test-topic") public void consume(String message) { System.out.println("Received message: " + message); } } 在这里使用@KafkaListener注解将Spring Boot应用程序中的方法标记为Kafka消费者。在本例中,消费者监听“test-topic”主题。 4.将消息发送到Kafka。 在之前的配置类中注入KafkaTemplate,然后发送消息。 @Autowired private KafkaTemplate<String, String> kafkaTemplate; @Test void sendMessage() { kafkaTemplate.send("test-topic", "Hello, Kafka!"); } 5.运行Spring Boot应用程序。 在上述步骤完成后,运行Spring Boot应用程序并检查控制台输出。 通过以上步骤可以实现在Spring Boot应用程序中整合Kafka消费者,并在应用程序中实现使用消息传递的功能。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值