如何访问应用程序中定义的值。Spring Boot中的properties文件

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

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


userBucket.path=${HOME}/bucket

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

792624 次浏览
小开
最佳答案

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

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

Spring Boot文档的外部化配置部分解释了你可能需要的所有细节。

小开

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

@Autowired
private Environment env;
....


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

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


}
小开

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

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

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


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

你也可以这样做....

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


@Autowired
private Environment env;


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

然后无论你想从应用程序中读取什么。属性，只需将键传递给getConfigValue方法。

@Autowired
ConfigProperties configProp;


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

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

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

java -jar -Drun.profiles=SpringProfileName

指定要使用哪个弹簧概要文件。注意，yml文件的名称应该类似

application-{environmentName}.yml

让他们自动被新兵带走。

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

从申请中读取。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

小开
对我来说，以上这些方法对我都没有直接作用。 我所做的是:

另外，对于@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);
}
}
小开

获取财产价值的最佳方法是使用。

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);
}
小开
< p >目前, 我知道以下三种方法:

1. @Value注释

    @Value("${<property.name>}")
private static final <datatype> PROPERTY_NAME;
    根据我的经验，有些情况下你并不是 能够获取值，或者它被设置为null。 例如, 当你试图在preConstruct()方法或init()方法中设置它时。 这是因为值注入发生在类完全构造之后。 这就是为什么最好使用3'选项的原因

2. @PropertySource注释

@PropertySource("classpath:application.properties")


//env is an Environment variable
env.getProperty(configKey);
  • PropertySouce设置类加载时属性源文件中Environment变量的值(在你的类中)。
  • 可通过系统环境变量访问。

3.@ConfigurationProperties注释。

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

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

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

  • @Configuration基于配置文件变量创建bean。

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


@Autowired
private UserData userData;


userData.getPropertyName();
小开
最好的方法是使用@Value注释，它会自动为你的对象private Environment en赋值。 这将减少你的代码，它将很容易过滤你的文件
小开 
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"));
小开

遵循以下步骤。 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.
}
小开

有两种方法，

  1. 你可以直接在类中使用@Value
    @Value("#{'${application yml field name}'}")
public String ymlField;

或

  1. 为了使它干净，你可以清除@Configuration类，其中你可以添加所有的@value
@Configuration
public class AppConfig {


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

应用程序可以从应用程序中读取3种类型的值。属性文件。

application.properties

     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;

如果你在申请中没有房产。属性，则可以使用默认值

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

我也有这个问题。但是有一个很简单的解决办法。只需要在构造函数中声明你的变量。

我的例子:

application.propperties:

#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);
}
小开
属性中的@Value("${property-name}") 应用程序。属性 @Configuration或@Component.

我尝试的另一种方法是用下面的方式创建一个Utility类来读取属性

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

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

小开

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

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

从应用程序中获取价值有两种方法。属性文件

  1. 使用@Value注释
    @Value("${property-name}")
private data_type var_name;
  1. 使用环境类的实例
@Autowired
private Environment environment;


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


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

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

小开

@ value Spring注释用于向Spring管理的bean中的字段注入值，它可以应用于字段或构造函数/方法参数级别。

例子

  1. 字符串值从注释到字段
    @Value("string value identifire in property file")
private String stringValue;
  1. 我们还可以使用@Value注释注入地图属性。

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

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

并不是说Map中的值必须是单引号。

现在从属性文件中注入这个值作为Map:

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

来获取特定键的值

   @Value("#{${valuesMap}.key1}")
private Integer valuesMapKey1;
  1. 我们还可以使用@Value注释注入列表属性。
   @Value("#{'${listOfValues}'.split(',')}")
private List<String> valuesList;
小开

试类PropertiesLoaderUtils ?

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

例子:

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

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

小开

从属性文件中选择值，我们可以有一个配置读取器类，类似于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
}
现在，我们可以在任何想要访问属性值的地方自动连接读取器类。 例如< / p > 
@Service
class ServiceImpl{
@Autowired
private AppConfigReader appConfigReader;


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

应用程序。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() );
}
}
小开
< p > @ value(“$ {userBucket.path}“)

. private String userBucketPath
小开
也许它可以帮助其他人: 你应该从import org.springframework.core.env.Environment;

注入@Autowired private Environment env;

然后这样使用它: env.getProperty("yourPropertyNameInApplication.properties") < / p >

小开

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

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

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

< p > @ value(“$ {userBucket.path}“) private String userBucketPath

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

  1. 自动装配环境变量到你的类，你需要访问这个属性:
< p > @ autowired private环境环境

  1. 使用环境变量在你需要的行中获取属性值:

environment.getProperty(“userBucket.path");

希望这能回答你的问题!

小开

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

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

您可以访问该应用程序。属性文件值使用:

@Value("${key_of_declared_value}")
小开

有3种方法读取application.properties，

使用@Value, EnvironmentInterface和@ConfigurationProperties..

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

方式2:

@Autowired
private Environment environment;


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

第三道:

@ConfigurationProperties("userbucket")
public class config {


private String path;
//getters setters


}

可以读取与getter和setter ..

引用- 在这里

小开

要读取application.properties或application.yml属性，请遵循以下步骤:

  1. 在应用程序中添加属性。属性或application.yaml
  2. 创建配置类并添加属性
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

现在使用配置类实例化它，你可以手动或依赖注入。

public class Target {


private final JwtConfig jwtConfig;


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


// jwtConfig.getSecretKey()


}
小开

实际上有三种方法来读取应用程序。属性文件,

使用环境,

@Autowired
Environment environment


environment.getProperty({propertyName})

或者使用@Value，

@Value("${property}")

但是@Value的问题是，如果值不在属性文件中，它可能会抛出异常

建议使用@ConfigurationProperties

@ConfigurationProperties("userBucket")
public class test{
private String path;
//getters and setters
}

详细示例- 阅读application.properties


提交答案