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

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

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

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

---

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

@Autowired
private Environment env;
....

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

---

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

考虑以下示例文件。

。特性

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

雇员.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();

}

---

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

<强> 1。 @Value 注释

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

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

<强> 2。 @PropertySource 注释

@PropertySource("classpath:application.properties")

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

加载类时，PropertySouce 在环境变量（在您的类中）中设置属性源文件中的值。因此，您可以轻松获取后记。

可通过系统环境变量访问。

<强> 3。 @ConfigurationProperties 注释。

这主要在 Spring 项目中用于加载配置属性。

它基于属性数据初始化实体。

@ConfigurationProperties 标识要加载的属性文件。

@Configuration 根据配置文件变量创建一个 bean。 @ConfigurationProperties(prefix = "user") @Configuration("UserData") class user { //Property & their getter / setter } @Autowired private UserData userData; userData.getPropertyName();

---

你也可以这样做......

@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"); 

---

按着这些次序。 1：- 创建您的配置类，如下所示，您可以看到

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：- 当你有一个配置类时，然后从你需要的配置中注入变量。

@Component
public class YourService {

    @Autowired
    private String getUserBucketPath;

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

---

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

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

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

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

---

如果您的类使用 @Configuration 或 @Component 注释，您可以使用 application.properties 中的 @Value("${property-name}")。

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

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

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

---

@Value Spring 注解用于将值注入 Spring-manged beans 中的字段，它可以应用于字段或构造函数/方法参数级别。

例子

从注释到字段的字符串值

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

我们还可以使用 @Value 注解来注入 Map 属性。首先，我们需要在属性文件的 {key: 'value' } 表单中定义属性：

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

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

现在将属性文件中的这个值作为 Map 注入：

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

获取特定键的值

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

我们还可以使用@Value 注解来注入 List 属性。

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

---

也许它可以帮助其他人：您应该从 import org.springframework.core.env.Environment; 注入 @Autowired private Environment env;

然后以这种方式使用它：env.getProperty("yourPropertyNameInApplication.properties")

---

要从属性文件中选择值，我们可以有一个类似 ApplicationConfigReader.java 的配置读取器类，然后针对属性定义所有变量。参考下面的例子，

application.properties

myapp.nationality: INDIAN
myapp.gender: Male

下面是相应的阅读器类。

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

    //getter & setter
}

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

@Service
class ServiceImpl{
    @Autowired
    private AppConfigReader appConfigReader;

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

---

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

应用程序属性

     my.name=kelly

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

类文件

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

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

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

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

---

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

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

---

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

我们可以将每个环境的属性分离到单独的 spring 配置文件下的单独的 yml 文件中。然后在部署期间您可以使用：

java -jar -Drun.profiles=SpringProfileName

指定要使用的弹簧配置文件。注意 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 注解。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

---

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

1.使用Value注解

@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);
}

---

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"));

---

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

使用@Value 注解

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

使用环境类的实例

@Autowired
private Environment environment;

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

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

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

---

有3种方法可以读取application.properties，

使用@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

---

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

---

有两种方式，

您可以在课堂上直接使用@Value

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

或者

为了使其干净，您可以清理 @Configuration 类，您可以在其中添加所有 @value

@Configuration
public class AppConfig {

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

---

试过类PropertiesLoaderUtils？

这种方法不使用 Spring boot 的注解。传统的 Class 方式。

例子：

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

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

---

在配置中查找键/值的另一种方法。

...
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"));
    }
} 

---

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

@Value("${key_of_declared_value}")

---

对我来说，以上都没有直接为我工作。我所做的是以下内容：

除了@Rodrigo Villalba Zayas 的回答之外，我将
implements InitializingBean 添加到类
并实现了该方法

@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);
    }
}

---

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

我的例子：

应用程序属性：

#Session
session.timeout=15

SessionServiceImpl 类：

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;
}

---

您可以使用 @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);
    }

---

application.yml 或 application.properties

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

MyConfig 类

@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.
}

任何想要访问配置值的类

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

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

---

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

---

您可以使用 @Value 注释并访问 spring bean 中的属性

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

---

最简单的方法是使用 Spring Boot 提供的 @Value 注解。您需要在类级别定义一个变量。例如：

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

还有另一种方法可以通过环境类来做到这一点。例如：

将环境变量自动连接到您需要访问此属性的类：

@Autowired 私有环境环境

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

environment.getProperty("userBucket.path");

希望这能回答你的问题！

---