`spring-boot-kafka-io.programb.example` 是一个示例项目，展示了如何使用 Spring Boot 集成 Kafka 进行消息传递

Bol5261

已于 2025-02-02 09:57:13 修改

阅读量142

点赞数

CC 4.0 BY-SA版权

于 2020-05-25 16:01:36 首次发布

本文链接：https://blog.csdn.net/blog_programb/article/details/106335110

SpringBoot(TomcatJettyServlet) 同时被 2 个专栏收录

806 篇文章

订阅专栏

Kafka(Scala Java ecosystem)

62 篇文章

订阅专栏

本文详细介绍Spring Kafka的配置参数，如group-id、auto-offset-reset等，并通过实例展示如何在Spring Boot项目中实现消息的生产和消费，包括配置文件、生产者和消费者的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring Boot 的自动配置原理是基于 Spring 框架的依赖注入（Dependency Injection）和条件化配置（Conditional Configuration）。其核心思想是在项目启动时，通过分析项目的依赖和环境配置，自动加载相应的配置类和组件。

具体来说，Spring Boot 会自动扫描项目中的类路径，寻找带有特定注解（如 @EnableAutoConfiguration）的配置类。这些配置类中包含了许多预定义的自动配置类，它们会根据当前项目的实际需求进行条件化加载。例如，如果项目依赖了 H2 数据库，那么 Spring Boot 会自动加载 H2 相关的配置类；如果项目依赖了 Thymeleaf 模板引擎，那么 Spring Boot 会自动加载 Thymeleaf 相关的配置类。

此外，Spring Boot 还支持自定义的自动配置类。开发者可以通过实现特定的接口或使用特定的注解来创建自己的自动配置类，并将其添加到 Spring Boot 的自动配置列表中。这样，当满足特定条件时，Spring Boot 就会自动加载并应用这些自定义的配置类。

总的来说，Spring Boot 的自动配置原理是通过分析项目的依赖和环境配置，自动加载相应的配置类和组件，以简化开发过程并提高开发效率。

Spring Boot 自动配置的原理是通过条件注解和默认配置来实现的。Spring Boot 会自动扫描项目中的依赖库，并根据这些依赖库来推断需要的配置类。然后，它会根据这些配置类中的条件注解来判断是否需要启用某个配置。如果条件满足，Spring Boot 就会自动加载相应的配置类，并使用默认的配置值进行初始化。

具体来说，Spring Boot 会自动扫描项目中的所有jar包和class文件，并查找带有@Configuration注解的类。然后，它会检查这些类中是否包含@ConditionalOnClass、@ConditionalOnMissingBean等条件注解。如果条件满足，Spring Boot 就会将该配置类注册为一个bean，并使用默认的配置值进行初始化。

此外，Spring Boot 还提供了一些默认的配置属性，可以通过application.properties或application.yml文件来覆盖这些默认值。用户也可以自定义自己的配置属性，并通过@Value注解将其注入到配置类中。

总之，Spring Boot 自动配置的原理是通过条件注解和默认配置来实现的，它可以大大简化开发者的配置工作，提高开发效率。

Spring Boot 的自动配置是通过其核心功能之一实现的，旨在简化 Spring 应用的开发。它通过以下几种方式来实现：

自动扫描和加载：Spring Boot 会自动扫描项目中的类路径，寻找带有特定注解（如 @Configuration、@EnableAutoConfiguration）的类，并自动加载这些配置类。
条件化配置：Spring Boot 使用了一系列的条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean 等）来决定是否启用某个自动配置类。这些条件注解会根据类路径中是否包含特定的类或者某个 Bean 是否已经定义来动态决定是否应用某个配置。
默认配置：Spring Boot 提供了一组默认的配置属性，这些属性可以通过配置文件（如 application.properties 或 application.yml）进行覆盖。开发者可以方便地修改这些默认配置来满足具体需求。
自定义 Starter：开发者可以创建自己的 Spring Boot Starter，通过引入必要的依赖和自动配置类，使得第三方库能够轻松集成到 Spring Boot 应用中。
自动装配：Spring Boot 利用 Spring 的依赖注入机制，自动装配 Bean，从而减少显式的 XML 配置。

通过这些机制，Spring Boot 大大减少了开发 Spring 应用时的配置工作量，使开发者能够专注于业务逻辑的实现。

Spring Boot 是 Spring 框架的一个扩展，旨在简化新Spring应用程序的创建和开发。以下是 Spring Boot 的一些核心特性：

自动配置: Spring Boot 会根据添加的jar依赖自动配置Spring应用，从而减少了手动配置的需要。它会自动配置Spring以及第三方库中的大多数组件。
嵌入式Web服务器: Spring Boot 内置了如 Tomcat、Jetty 或 Undertow 等嵌入式Web服务器，使得开发者可以快速启动和测试Web应用，而不需要部署到外部的Web服务器上。
独立运行: 通过将Spring Boot打包成可执行的jar文件，可以在没有外部依赖的情况下独立运行Spring应用。这使得部署变得更加简单。
无代码生成和XML配置: Spring Boot 鼓励使用基于Java的配置类来替代传统的XML配置文件，同时减少或消除了样板代码的需求。
健康检查和指标: Spring Boot 提供了健康检查和指标端点，可以用于监控应用的状态和性能。这些功能对于构建微服务架构尤其有用。
外部化配置: Spring Boot 支持多种方式进行外部化配置，包括属性文件、YAML文件、环境变量和命令行参数，方便在不同环境中进行配置管理。
广泛的插件支持: Spring Boot 提供了对各种开发工具（如Maven、Gradle）的广泛支持，并且有丰富的社区插件生态，便于集成其他技术栈。
安全特性: Spring Boot 提供默认的安全配置，并支持与Spring Security集成，帮助开发者轻松实现认证和授权功能。
测试支持: Spring Boot 为单元测试和集成测试提供了强大的支持，包括内嵌的Web服务器和测试框架集成，使测试变得更加便捷。
社区和文档: Spring Boot 拥有活跃的社区和详尽的官方文档，开发者可以轻松找到资源和支持。

Spring Boot 是一个开源的 Java 框架，用于简化 Spring 应用的创建和开发。它通过提供默认配置、自动配置和嵌入式 Web 服务器等特性，使开发者能够快速启动和运行 Spring 应用程序。

spring-boot-kafka-io.programb.example 是一个示例项目，展示了如何使用 Spring Boot 集成 Kafka 进行消息传递。Kafka 是一个分布式流处理平台，广泛用于构建实时数据管道和流式应用。

在这个示例项目中，你可以看到如何配置 Kafka 生产者和消费者，以及如何在 Spring Boot 应用中使用它们来发送和接收消息。以下是一些关键组件：

依赖管理: 在 pom.xml 文件中添加了必要的依赖项，如 Spring Boot Starter、Kafka 客户端等。
配置类: 使用 @Configuration 注解创建了一个配置类，用于定义 Kafka 模板和监听器容器工厂。
生产者: 通过注入 Kafka 模板，实现了一个简单的消息生产者，可以向指定的 Kafka 主题发送消息。
消费者: 使用 @KafkaListener 注解定义了一个消息监听器，当有新消息到达指定主题时，会自动调用该方法处理消息。
主应用程序类: 标记为 @SpringBootApplication 的主类，是整个 Spring Boot 应用的入口点。

这个示例项目可以帮助你理解如何在 Spring Boot 应用中集成和使用 Kafka，实现高效的消息传递功能。

Spring Kafka配置：
Kafka的组标识 group-id
auto-offset-reset
属性设置为earliest，这意味着当消费者没有发现偏移量(指针)时，消费者将开始从最早的消息中读取消息。
连接Kafka的服务器，在这种情况下，如果您使用单节点配置，则是唯一可用的服务器。请注意，如果使用默认值
localhost:9092，则此属性是多余的。

package io.programb.kafka;

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;


@Component
public class MsgConsumer {

    @KafkaListener(topics = {"programb-1","programb-2"})
    public void processMessage(String content) {

        System.out.println("programb"+content);
    }

}

package io.programb.kafka;

import org.apache.kafka.clients.producer.RecordMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.ProducerListener;
import org.springframework.stereotype.Component;


@Component
public class MsgProducer {

    private static final Logger log = LoggerFactory.getLogger(MsgProducer.class);

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void sendMessage(String topicName, String jsonData) {
        log.info("programb", jsonData);
        try {
            kafkaTemplate.send(topicName, jsonData);
        } catch (Exception e) {
            log.error("programb", topicName, jsonData);
            log.error("programb", e);
        }

        kafkaTemplate.setProducerListener(new ProducerListener<String, String>() {
            @Override
            public void onSuccess(String topic, Integer partition, String key, String value, RecordMetadata recordMetadata) {
            }

            @Override
            public void onError(String topic, Integer partition, String key, String value, Exception exception) {
            }

            @Override
            public boolean isInterestedInSuccess() {
                log.info("programb");
                return false;
            }
        });
    }

}

package io.programb.kafka.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;


@Configuration
@EnableKafka
public class KafkaConfiguration {

}

package io.programb.kafka.run;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;


@SpringBootApplication
@ComponentScan(value = {"io.programb.kafka"})
public class Startup {

    public static void main(String[] args) {
        SpringApplication.run(Startup.class, args);
    }
}

spring.application.name=spring-boot-kafka

#kafka

spring.kafka.bootstrap-servers=YZ-PTEST-APP-HADOOP-02:9092,YZ-PTEST-APP-HADOOP-04:9092

spring.kafka.listener.concurrency=3

spring.kafka.producer.batch-size=1000

spring.kafka.consumer.group-id=programb

spring.kafka.template.default-topic=topic-1

logging.level.root=info

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>io.programb.example</groupId>
    <artifactId>spring-boot-kafka</artifactId>
    <packaging>jar</packaging>

    <version>1.0-SNAPSHOT</version>
    <name>spring-boot-kafka</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
	
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>0.10.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skip>true</skip>
                    <testFailureIgnore>true</testFailureIgnore>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>