springboot application.properties 写多个配置文件怎么写

Posted 2023-04-13

springboot application.properties 写多个配置文件的方法：

# 文件编码

banner.charset= UTF-8

# 文件位置

banner.location= classpath:banner.txt

# 日志配置

# 日志配置文件的位置。 例如对于Logback的`classpath：logback.xml`

logging.config= 

# ％wEx#记录异常时使用的转换字。

logging.exception-conversion-word= 

# 日志文件名。 例如`myapp.log`

logging.file= 

# 日志级别严重性映射。 例如`logging.level.org.springframework =  DEBUG`

logging.level.*= 

# 日志文件的位置。 例如`/ var / log

logging.path= 

# 用于输出到控制台的Appender模式。 只支持默认的logback设置。

logging.pattern.console=

# 用于输出到文件的Appender模式。 只支持默认的logback设置。

logging.pattern.file= 

# 日志级别的Appender模式（默认％5p）。 只支持默认的logback设置。

logging.pattern.level=

#注册日志记录系统的初始化挂钩。

logging.register-shutdown-hook= false

# AOP 切面

# 添加@EnableAspectJAutoProxy。

spring.aop.auto= true

# 是否要创建基于子类（CGLIB）的代理（true），而不是基于标准的基于Java接口的代理（false）。

spring.aop.proxy-target-class= false

# 应用程序上下文初始化器

# 应用指标。

spring.application.index= 

# 应用程序名称。

spring.application.name= 

# 国际化（消息源自动配置）
#
spring.messages.basename= messages

# 以逗号分隔的基础名称列表，每个都在ResourceBundle约定之后。

# 加载的资源束文件缓存到期，以秒为单位。 设置为-1时，软件包将永久缓存。

spring.messages.cache-seconds= -1

# 消息编码。

spring.messages.encoding= UTF-8

# 设置是否返回到系统区域设置，如果没有找到特定语言环境的文件。

spring.messages.fallback-to-system-locale= true

# REDIS (Redis 配置)

# 连接工厂使用的数据库索引。

spring.redis.database= 0

# Redis服务器主机。

spring.redis.host= localhost

# 登录redis服务器的密码。

spring.redis.password= 

# 给定时间池可以分配的最大连接数。 使用负值为无限制。

spring.redis.pool.max-active= 8

# 池中“空闲”连接的最大数量。 使用负值来表示无限数量的空闲连接。

spring.redis.pool.max-idle= 8

# 连接分配在池耗尽之前在抛出异常之前应阻止的最大时间量（以毫秒为单位）。 使用负值无限期地阻止。

spring.redis.pool.max-wait= -1

# 定义池中维护的最小空闲连接数。 此设置只有在正值时才有效果。

spring.redis.pool.min-idle= 0

# redis服务器端口

spring.redis.port= 6379

# redis服务器名称

spring.redis.sentinel.master=

# spring.redis.sentinel.nodes= 

# 连接超时（毫秒）。

spring.redis.timeout= 0

# 管理员 （Spring应用程序管理员JMX自动配置）

# 开启应用管理功能。

spring.application.admin.enabled= false

# JMX应用程序名称MBean。

spring.application.admin.jmx-name= org.springframework.boot:type= Admin,name= SpringApplication

# 自动配置

# 自动配置类排除。

spring.autoconfigure.exclude= 

# spring 核心配置

# 跳过搜索BeanInfo类。

spring.beaninfo.ignore= true

# spring 缓存配置

# 由底层缓存管理器支持的要创建的缓存名称的逗号分隔列表。

spring.cache.cache-names= 

# 用于初始化EhCache的配置文件的位置。

spring.cache.ehcache.config= 

# 用于创建缓存的规范。 检查CacheBuilderSpec有关规格格式的更多细节。

spring.cache.guava.spec= 

# 用于初始化Hazelcast的配置文件的位置。

spring.cache.hazelcast.config= 

# 用于初始化Infinispan的配置文件的位置。

spring.cache.infinispan.config= 

# 用于初始化缓存管理器的配置文件的位置。

spring.cache.jcache.config= 

# 用于检索符合JSR-107的缓存管理器的CachingProvider实现的完全限定名称。 只有在类路径上有多个JSR-107实现可用时才需要。

spring.cache.jcache.provider= 

# 缓存类型，默认情况下根据环境自动检测。

spring.cache.type= 

# spring配置 （配置文件应用侦听器）

# 配置文件位置。

spring.config.location= 

# 配置文件名。

spring.config.name= application

Springboot的多配置文件是指：系统中存在多个配置文件，在不同的运行环境使用不同的配置文件即可。

启动项目的方法一般有两种 ：

1、 运行RootApplication中的main方法。

2、 使用命令：mvn spring-boot:run

这两方法默认都是使用application.properties中的配置信息，如果有指spring.profiles.active则使用指定的配置信息，这种方式一般用在产品运行时，在开发和测试的时候则需要指定配置文件。

参考技术A 我的文章：《Springboot 之 多配置文件》里面有：

在程序开发过程中可能会有这样的需求：开发和部署的配置信息可能会不同，以传统的方式就是在配置文件里面写好配置，在部署的时候再去修改这些配置，这样肯定会有很多问题，比如忘记修改、修改错误等。 而Springboot提供了多配置文件的支持解决了这一问题。
Springboot的多配置文件是指：系统中存在多个配置文件，在不同的运行环境使用不同的配置文件即可。
创建测试项目
新建的study04项目的文件结构如下：
|-study04(项目名称)
| - src
| | - main
| | | - java
| | | | - com.zslin
| | | | | - RootApplication.java
| | | - resources
| | | | - application.properties
| | | | - application-dev.properties
| | | | - application-test.properties
| | - test
| | | - java
| | | | - com.zslin
| | | | | - MyTest.java
| - pom.xml
| - study04.iml

RootApplication.java
@SpringBootApplication
public class RootApplication

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



这个Java文件没有什么特别，只是一个最基本的Springboot的入口
application.properties
spring.profiles.active=dev

在核心配置文件里面的spring.profiles.active=dev这个设置表示系统默认使用dev（即application-dev.properties）中的配置。
application-dev.properties
server.port=2222
test.msg=this is dev config

在这个配置文件里面只设置了端口为2222，和配置test.msg为this is dev config
application-test.properties
server.port=1111
test.msg=this is test config

在这个配置文件里面和application-dev.properties中的配置一样，只是对应值有所不同。
现在在系统中已经有两种不同的配置信息，只是默认是使用application-dev.properties中的配置。
MyTest.java
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTest

@Value("$test.msg")
private String msg;

@Test
public void testConfig()
System.out.println("cur msg is : "+ msg);



这里的输入结果是：cur msg is : this is dev config，说明现在使用的配置文件是application-dev.properties
注意： 当将application.properties的内容修改为spring.profiles.active=test后，再运行这个测试方法时将得到结果：cur msg is : this is test config
在单元测试中指定配置文件
@RunWith(SpringRunner.class)
@SpringBootTest
@ActiveProfiles("test")
public class MyTest2

@Value("$test.msg")
private String msg;

@Test
public void testConfig()
System.out.println("cur msg is : "+ msg);



MyTest2与MyTest唯一的区别就是在MyTest2的类上多加了一个注释@ActiveProfiles("test")，加上这个注释就表示现在使用application-test.properties这个配置文件，同样换成dev也就是使用application-dev.properties中的配置。
运行测试方法即可得到对应配置文件中的信息。
启动项目时指定不同的配置文件
启动项目的方法一般有两种 ：
1、 运行RootApplication中的main方法。
2、 使用命令：mvn spring-boot:run
这两方法默认都是使用application.properties中的配置信息，如果有指定spring.profiles.active则使用指定的配置信息，这种方式一般用在产品运行时，在开发和测试的时候则需要指定配置文件。
运行main可以在运行里的Config里面来配置，这个我基本没有使用过，我用的是第二种方法：
mvn spring-boot:run -Dspring.profiles.active=dev 即使用application-dev.properties中的配置信息，此时可以看到控制台显示系统使用的端口是dev中的2222
多配置文件这块我应用的较多的是在数据库的配置，开发过程中的数据库肯定是在本机，用户名和密码也是本机数据库的，而当项目部署到服务器时，数据库的地址、用户名和密码就得修改，所以使用了多配置文件，只需要在启动项目的时候指定配置文件即可。
示例代码：https://github.com/zsl131/spring-boot-test/tree/master/study04本回答被提问者采纳

Kafka中@KafkaListener如何动态指定多个topic

点击关注公众号，实用技术文章及时了解

来源：blog.csdn.net/qq_35457078/

article/details/88838511

说明：本项目为springboot+kafak的整合项目，故其用了springboot中对kafak的消费注解@KafkaListener

首先，application.properties中配置用逗号隔开的多个topic。

方法：利用Spring的SpEl表达式，将topics 配置为：@KafkaListener(topics = “#{’${topics}’.split(’,’)}”)

运行程序，console打印的效果如下：

因为只开了一条消费者线程，所以所有的topic和分区都分配给这条线程。

如果你想开多条消费者线程去消费这些topic,添加@KafkaListener注解的参数concurrency的值为自己想要的消费者个数即可(注意，消费者数要小于等于你开的所有topic的分区数总和)

运行程序，console打印的效果如下：

总结一下大家问的最多的一个问题：

如何在程序运行的过程中，改变topic，消费者能够消费修改后的topic?

ans: 经过尝试，使用@KafkaListener注解实现不了此需求，在程序启动的时候，程序就会根据@KafkaListener的注解信息初始化好消费者去消费指定好的topic。如果在程序运行的过程中，修改topic，不会让此消费者修改消费者的配置再重新订阅topic的。

不过我们可以有个折中的办法，就是利用@KafkaListener的topicPattern参数来进行topic匹配。

具体如何操作的可以看下这位老哥的blog:

https://blog.csdn.net/songzehao/article/details/103091486

终极方法：

思路：

不使用@KafkaListener，使用kafka原生客户端依赖，手动初始化消费者，开启消费者线程。在消费者线程中，每次循环都从配置、数据库或者其他配置源获取最新的topic信息，与之前的topic比较，如果发生变化，重新订阅topic或者初始化消费者。

实现

1.加入kafka客户端依赖(本次测试服务端kafka版本：2.12-2.4.0)

<dependency>
 <groupId>org.apache.kafka</groupId>
 <artifactId>kafka-clients</artifactId>
 <version>2.3.0</version>
</dependency>

2.代码

@Service
@Slf4j
public class KafkaConsumers implements InitializingBean {

    /**
     * 消费者
     */
    private static KafkaConsumer<String, String> consumer;
    /**
     * topic
     */
    private List<String> topicList;

    public static String getNewTopic() {
        try {
            return org.apache.commons.io.FileUtils.readLines(new File("D:/topic.txt"), "utf-8").get(0);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 初始化消费者（配置写死是为了快速测试，请大家使用配置文件）
     *
     * @param topicList
     * @return
     */
    public KafkaConsumer<String, String> getInitConsumer(List<String> topicList) {
        //配置信息
        Properties props = new Properties();
        //kafka服务器地址
        props.put("bootstrap.servers", "192.168.9.185:9092");
        //必须指定消费者组
        props.put("group.id", "haha");
        //设置数据key和value的序列化处理类
        props.put("key.deserializer", StringDeserializer.class);
        props.put("value.deserializer", StringDeserializer.class);
        //创建消息者实例
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        //订阅topic的消息
        consumer.subscribe(topicList);
        return consumer;
    }

    /**
     * 开启消费者线程
     * 异常请自己根据需求自己处理
     */
    @Override
    public void afterPropertiesSet() {
        // 初始化topic
        topicList = Splitter.on(",").splitToList(Objects.requireNonNull(getNewTopic()));
        if (org.apache.commons.collections.CollectionUtils.isNotEmpty(topicList)) {
            consumer = getInitConsumer(topicList);
            // 开启一个消费者线程
            new Thread(() -> {
                while (true) {
                    // 模拟从配置源中获取最新的topic（字符串，逗号隔开）
                    final List<String> newTopic = Splitter.on(",").splitToList(Objects.requireNonNull(getNewTopic()));
                    // 如果topic发生变化
                    if (!topicList.equals(newTopic)) {
                        log.info("topic 发生变化：newTopic:{},oldTopic:{}-------------------------", newTopic, topicList);
                        // method one：重新订阅topic:
                        topicList = newTopic;
                        consumer.subscribe(newTopic);
                        // method two：关闭原来的消费者，重新初始化一个消费者
                        //consumer.close();
                        //topicList = newTopic;
                        //consumer = getInitConsumer(newTopic);
                        continue;
                    }
                    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                    for (ConsumerRecord<String, String> record : records) {
                        System.out.println("key:" + record.key() + "" + ",value:" + record.value());
                    }
                }
            }).start();
        }
    }
}

说一下第72行代码：

ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));

上面这行代码表示：在100ms内等待Kafka的broker返回数据.超市参数指定poll在多久之后可以返回，不管有没有可用的数据都要返回。

在修改topic后，必须等到此次poll拉取的消息处理完，while(true)循环的时候检测topic发生变化，才能重新订阅topic.

poll()方法一次拉取得消息数默认为：500，如下图，kafka客户端源码中设置的。

如果想自定义此配置，可在初始化消费者时加入

3.运行结果(测试的topic中都无数据)

注意：KafkaConsumer是线程不安全的，不要用一个KafkaConsumer实例开启多个消费者，要开启多个消费者，需要new 多个KafkaConsumer实例。

●【练手项目】基于SpringBoot的ERP系统，自带进销存+财务+生产功能

●分享一套基于SpringBoot和Vue的企业级中后台开源项目，代码很规范！

●能挣钱的，开源 SpringBoot 商城系统，功能超全，超漂亮！

PS：因为公众号平台更改了推送规则，如果不想错过内容，记得读完点一下“在看”，加个“星标”，这样每次新文章推送才会第一时间出现在你的订阅列表里。点“在看”支持我们吧！