如何在 Spring 引导中访问 application.properties 文件中定义的值

Question

我想访问 application.properties 中提供的值，例如：

logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR
logging.file=${HOME}/application.log

userBucket.path=${HOME}/bucket

我想在 Spring 引导应用程序的主程序中访问 userBucket.path。

Answer 1

您可以使用 @Value 注释并在您使用的任何 Spring bean 中访问属性

@Value("${userBucket.path}")
private String userBucketPath;

Spring 引导文档的 Externalized Configuration 部分解释了您可能需要的所有详细信息。

Answer 2

另一种方法是将 org.springframework.core.env.Environment 注入您的 bean。

@Autowired
private Environment env;
....

public void method() {
    .....  
    String path = env.getProperty("userBucket.path");
    .....
}

Answer 3

@ConfigurationProperties 可用于将值从 .properties（也支持 .yml）映射到 POJO。

考虑以下示例文件。

.properties

cust.data.employee.name=Sachin
cust.data.employee.dept=Cricket

Employee.java

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@ConfigurationProperties(prefix = "cust.data.employee")
@Configuration("employeeProperties")
public class Employee {

    private String name;
    private String dept;

    //Getters and Setters go here
}

现在可以通过自动装配 employeeProperties 访问属性值，如下所示。

@Autowired
private Employee employeeProperties;

public void method() {

   String employeeName = employeeProperties.getName();
   String employeeDept = employeeProperties.getDept();

}

Answer 4

如果您要在一个地方使用这个值，您可以使用 @Value 从 application.properties 加载变量，但是如果您需要一种更集中的方式来加载这个变量 @ConfigurationProperties 是更好的方法。

此外，如果您需要不同的数据类型来执行验证和业务逻辑，您还可以加载变量并自动转换它们。

application.properties
custom-app.enable-mocks = false

@Value("${custom-app.enable-mocks}")
private boolean enableMocks;

Answer 5

你也可以这样做....

@Component
@PropertySource("classpath:application.properties")
public class ConfigProperties {

    @Autowired
    private Environment env;

    public String getConfigValue(String configKey){
        return env.getProperty(configKey);
    }
}

然后无论你想从 application.properties 读取什么，只需将密钥传递给 getConfigValue 方法即可。

@Autowired
ConfigProperties configProp;

// Read server.port from app.prop
String portNumber = configProp.getConfigValue("server.port");

Answer 6

Spring-boot 允许我们通过多种方法提供外部化配置，您可以尝试使用 application.yml 或 yaml 文件代替属性文件并提供不同的属性文件设置根据不同的环境。

我们可以将每个环境的属性分离到单独的 yml 文件中 spring profiles.Then 在部署期间您可以使用：

java -jar -Drun.profiles=SpringProfileName

指定 spring 配置文件 use.Note yml 文件的名称应类似于

application-{environmentName}.yml

让它们被 springboot 自动占用。

参考：https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-profile-specific-properties

要从 application.yml 或属性文件读取：

从属性文件或 yml 中读取值的 最简单的方法 是使用 spring @value annotation.Spring 自动加载从 yml 到 spring 环境的所有值，因此我们可以直接使用环境中的这些值，如：

@Component
public class MySampleBean {

@Value("${name}")
private String sampleName;

// ...

}

或者spring提供的另一种读取强类型bean的方法如下：

YML

ymca:
    remote-address: 192.168.1.1
    security:
        username: admin

对应POJO读取yml :

@ConfigurationProperties("ymca")
public class YmcaProperties {
    private InetAddress remoteAddress;
    private final Security security = new Security();
    public boolean isEnabled() { ... }
    public void setEnabled(boolean enabled) { ... }
    public InetAddress getRemoteAddress() { ... }
    public void setRemoteAddress(InetAddress remoteAddress) { ... }
    public Security getSecurity() { ... }
    public static class Security {
        private String username;
        private String password;
        public String getUsername() { ... }
        public void setUsername(String username) { ... }
        public String getPassword() { ... }
        public void setPassword(String password) { ... }
    }
}

上述方法适用于 yml 文件。

参考：https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

Answer 7

对我来说，上面的 none 确实对我有用。我所做的如下：

除了@Rodrigo Villalba Zayas 的回答，我还添加了
implements InitializingBean 到 class
并实现了方法

@Override
public void afterPropertiesSet() {
    String path = env.getProperty("userBucket.path");
}

所以看起来像

import org.springframework.core.env.Environment;
public class xyz implements InitializingBean {

    @Autowired
    private Environment env;
    private String path;

    ....

    @Override
    public void afterPropertiesSet() {
        path = env.getProperty("userBucket.path");
    }

    public void method() {
        System.out.println("Path: " + path);
    }
}

Answer 8

获取属性值的最佳方法是使用。

1.使用值注释

@Value("${property.key}")
private String propertyKeyVariable;

2。使用环境 bean

@Autowired
private Environment env;

public String getValue() {
    return env.getProperty("property.key");
}

public void display(){
  System.out.println("# Value : "+getValue);
}

Answer 9

目前，我知道以下三种方式：

1. @Value注解

    @Value("${<property.name>}")
    private static final <datatype> PROPERTY_NAME;

根据我的经验，在某些情况下您并不能够获取该值或将其设置为 null。例如，当您尝试在 preConstruct() 方法或 init() 方法中设置它时。发生这种情况是因为值注入发生在 class 完全构建之后。这就是为什么最好使用第三个选项。

2。 @PropertySource注解

@PropertySource("classpath:application.properties")

//env is an Environment variable
env.getProperty(configKey);

PropertySouce 在 Environment 变量（在您的 class 中）中设置来自属性源文件的值。这样您就可以轻松获取后记。
可通过系统环境变量访问。

3。 @ConfigurationProperties 注释。

这在Spring项目中主要用于加载配置属性。
它根据属性数据初始化一个实体。
@ConfigurationProperties 标识要加载的属性文件。

@Configuration 根据配置文件变量创建一个bean。

@ConfigurationProperties(prefix = "user")
  @Configuration("UserData")
  class user {
    //Property & their getter / setter
  }

  @Autowired
  private UserData userData;

  userData.getPropertyName();

Answer 10

最好的办法是使用 @Value 注释，它会自动为您的对象 private Environment en 赋值。这将减少您的代码，并且可以轻松过滤您的文件。

Answer 11

1.Injecting a property with the @Value annotation is straightforward:
@Value( "${jdbc.url}" )
private String jdbcUrl;

2. we can obtain the value of a property using the Environment API

@Autowired
private Environment env;
...
dataSource.setUrl(env.getProperty("jdbc.url"));

Answer 12

按照以下步骤操作。 1:- 创建你的配置 class 如下你可以看到

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;

@Configuration
public class YourConfiguration{

    // passing the key which you set in application.properties
    @Value("${userBucket.path}")
    private String userBucket;

   // getting the value from that key which you set in application.properties
    @Bean
    public String getUserBucketPath() {
        return userBucket;
    }
}

2:- 当你有配置时 class 然后从你需要的配置中注入变量。

@Component
public class YourService {

    @Autowired
    private String getUserBucketPath;

    // now you have a value in getUserBucketPath varibale automatically.
}

Answer 13

有两种方法，

你可以直接用@Value在你class

    @Value("#{'${application yml field name}'}")
    public String ymlField;

或

要使其清洁，您可以清洁 @Configuration class，您可以在其中添加所有 @value

@Configuration
public class AppConfig {

    @Value("#{'${application yml field name}'}")
    public String ymlField;
}

Answer 14

应用程序可以从 application.properties 文件中读取 3 种类型的值。

application.properties

     my.name=kelly

my.dbConnection ={connection_srting:'http://localhost:...',username:'benz',password:'pwd'}

class 文件

@Value("${my.name}")
private String name;

@Value("#{${my.dbConnection}}")
private Map<String,String> dbValues;

如果您在 application.properties 中没有属性那么您可以使用默认值

        @Value("${your_name : default value}")
         private String msg;

Answer 15

我也有这个问题。但是有一个非常简单的解决方案。只需在构造函数中声明变量即可。

我的例子：

application.propperties:

#Session
session.timeout=15

SessionServiceImpl class:

private final int SESSION_TIMEOUT;
private final SessionRepository sessionRepository;

@Autowired
public SessionServiceImpl(@Value("${session.timeout}") int sessionTimeout,
                          SessionRepository sessionRepository) {
    this.SESSION_TIMEOUT = sessionTimeout;
    this.sessionRepository = sessionRepository;
}

Answer 16

您可以使用@ConfigurationProperties 它可以简单轻松地访问 application.properties

中定义的值

#datasource
app.datasource.first.jdbc-url=jdbc:mysql://x.x.x.x:3306/ovtools?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
app.datasource.first.username=
app.datasource.first.password=
app.datasource.first.driver-class-name=com.mysql.cj.jdbc.Driver
server.port=8686
spring.jpa.hibernate.ddl-auto=update
spring.jpa.generate-ddl=true
spring.jpa.show-sql=true
spring.jpa.database=mysql

@Slf4j
@Configuration
public class DataSourceConfig {
    @Bean(name = "tracenvDb")
    @Primary
    @ConfigurationProperties(prefix = "app.datasource.first")
    public DataSource mysqlDataSourceanomalie() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "JdbcTemplateenv")
    public JdbcTemplate jdbcTemplateanomalie(@Qualifier("tracenvDb") DataSource datasourcetracenv) {
        return new JdbcTemplate(datasourcetracenv);
    }

Answer 17

您可以使用 @Value("${property-name}") 来自 application.properties 如果你的 class 被注释为 @Configuration 或 @Component.

我尝试的另一种方法是制作实用程序 class 以下列方式读取属性 -

 protected PropertiesUtility () throws IOException {
    properties = new Properties();
    InputStream inputStream = 
   getClass().getClassLoader().getResourceAsStream("application.properties");
    properties.load(inputStream);
}

您可以使用静态方法获取作为参数传递的键的值。

Answer 18

您可以使用 @Value 注释从应用程序中读取值。properties/yml 文件。

@Value("${application.name}")
private String applicationName;

Answer 19

有两种方法可以从 application.properties 文件中访问值

使用@Value 注解

    @Value("${property-name}")
    private data_type var_name;

使用环境实例Class

@Autowired
private Environment environment;

//access this way in the method where it's required

data_type var_name = environment.getProperty("property-name");

您还可以使用构造函数注入或自己创建 bean 来注入环境实例

Answer 20

@Value Spring注解用于向Spring-mangedbean中的字段注入值，可应用于字段或constructor/method参数级别。

例子

String 值从注解到字段

    @Value("string value identifire in property file")
    private String stringValue;

我们也可以使用@Value注解来注入一个Map 属性.

首先，我们需要在属性文件中以 {key: ‘value' } 形式定义属性：

   valuesMap={key1: '1', key2: '2', key3: '3'}

并不是说 Map 中的值必须用单引号括起来。

现在从属性文件中将此值作为映射注入：

   @Value("#{${valuesMap}}")
   private Map<String, Integer> valuesMap;

获取特定键的值

   @Value("#{${valuesMap}.key1}")
   private Integer valuesMapKey1;

我们也可以使用@Value注解来注入一个List 属性.

   @Value("#{'${listOfValues}'.split(',')}")
   private List<String> valuesList;

Answer 21

试过ClassPropertiesLoaderUtils?

这种方法不使用 Spring 引导的注释。传统的 Class 方式。

示例：

Resource resource = new ClassPathResource("/application.properties");
    Properties props = PropertiesLoaderUtils.loadProperties(resource);
    String url_server=props.getProperty("server_url");

使用 getProperty() 方法传递密钥并访问属性文件中的值。

Answer 22

从属性文件中选择值，我们可以有一个配置 reader class 类似 ApplicationConfigReader.java 然后根据属性定义所有变量。参考下面的例子，

application.properties

myapp.nationality: INDIAN
myapp.gender: Male

下面对应reader class.

@Component
@EnableConfigurationProperties
@ConfigurationProperties(prefix = "myapp") 
class AppConfigReader{
    private String nationality;
    private String gender

    //getter & setter
}

现在我们可以在我们想要访问属性值的任何地方自动连接 reader class。例如

@Service
class ServiceImpl{
    @Autowired
    private AppConfigReader appConfigReader;

    //...
    //fetching values from config reader
    String nationality = appConfigReader.getNationality() ; 
    String gender = appConfigReader.getGender(); 
}

Answer 23

application.yml 或 application.properties

config.value1: 10
config.value2: 20
config.str: This is a simle str

我的配置class

@Configuration
@ConfigurationProperties(prefix = "config")
public class MyConfig {
    int value1;
    int value2;
    String str;

    public int getValue1() {
        return value1;
    }

    // Add the rest of getters here...      
    // Values are already mapped in this class. You can access them via getters.
}

想要访问配置值的任何 class

@Import(MyConfig.class)
class MyClass {
    private MyConfig myConfig;

    @Autowired
    public MyClass(MyConfig myConfig) {
        this.myConfig = myConfig;
        System.out.println( myConfig.getValue1() );
    }
}

Answer 24

@Value("${userBucket.path}") 私人字符串 userBucketPath;

Answer 25

也许它可以帮助其他人：你应该从 import org.springframework.core.env.Environment;

注入 @Autowired private Environment env;

然后这样使用它： env.getProperty("yourPropertyNameInApplication.properties")

Answer 26

您可以使用@Value 注释并访问 spring bean

中的属性

@Value("${userBucket.path}")
private String userBucketPath;

Answer 27

最简单的方法是使用 Spring Boot.您需要在 class 级别定义一个变量。例如：

@Value("${userBucket.path}") 私有字符串 userBucketPath

您还可以通过环境 Class 执行此操作。例如：

将环境变量自动连接到您的 class，您需要在其中访问此属性:

@Autowired 私人环境环境

使用环境变量在您需要的行中获取属性值：

environment.getProperty("userBucket.path");

希望这能回答您的问题！

Answer 28

另一种在配置中查找 key/value 的方法。

...
import org.springframework.core.env.ConfigurableEnvironment;
...
@SpringBootApplication
public class MyApplication {

    @Autowired
    private ConfigurableEnvironment  myEnv;

...
  
    @EventListener(ApplicationReadyEvent.class)
    public void doSomethingAfterStartup() 
    throws Exception {
        
        LOG.info("myEnv (userBucket.path): " + myEnv.getProperty("userBucket.path"));
    }
}

Answer 29

您可以使用以下方法访问 application.properties 文件值：

@Value("${key_of_declared_value}")

Answer 30

application.properties、

有3种读法

使用@Value、EnvironmentInterface 和@ConfigurationProperties..

@Value(${userBucket.path})
private String value;

第二种方式：

@Autowired
private Environment environment;

String s = environment.getProperty("userBucket.path");

第三种方式：

@ConfigurationProperties("userbucket")
public class config {

private String path;
//getters setters

}

可以用 getter 和 setter 读取..

参考 - here

Answer 31

您有多种方法可以从属性文件中读取值。

使用@Value 注解

@服务 public class 电子邮件服务 {

    @Value("${email.username}")
    private String username;

 }

使用@ConfigurationProperties 注释

   @Component
   @ConfigurationProperties("email")
   public class EmailConfig {

        private String   username;

         public String getUsername() {
                  return username;
          }

   }

参考资料：How to read Properties file in Spring Boot

Answer 32

要读取 application.properties 或 application.yml 属性，请按照以下步骤操作：

在 application.properties 或 application.yaml
创建配置 class 并添加您的属性

application.jwt.secretKey=value
application.jwt.tokenPrefix=value
application.jwt.tokenExpiresAfterDays=value ## 14

application:
  jwt:
    secret-key: value
    token-prefix: value
    token-expires-after-days: value ## 14

@Configuration("jwtProperties") // you can leave it empty
@EnableConfigurationProperties
@ConfigurationProperties(prefix = "application.jwt") // prefix is required
public class JwtConfig {
    private String secretKey;
    private String tokenPrefix;
    private int tokenExpiresAfterDays;

    // getters and setters
}

注意：在 .yaml 文件中，您必须使用 kabab-case

现在要使用配置 class 只需实例化它，您可以手动或使用依赖注入来完成此操作。

public class Target {

  private final JwtConfig jwtConfig;

  @Autowired
  public Target(JwtConfig jwtConfig) {
      this.jwtConfig = jwtConfig;
  }

  // jwtConfig.getSecretKey()

}

如何在 Spring 引导中访问 application.properties 文件中定义的值

How to access a value defined in the application.properties file in Spring Boot

java

spring-boot

properties-file

class 文件