How to read custom properties configuration file under SpringBoot

1. Create a new .properties file in resource

Create a new config folder in the resource directory, and then create a new .properties file and place it in the folder. As shown in the figure remote.properties

2. Write the configuration file

remote.uploadFilesUrl=/resource/files/
remote.uploadPicUrl=/resource/pic/

3. Create a new one Configuration class RemoteProperties.java

@Configuration
@ConfigurationProperties(prefix = "remote", ignoreUnknownFields = false)
@PropertySource("classpath:config/remote.properties")
@Data
@Component
public class RemoteProperties {
  private String uploadFilesUrl;
  private String uploadPicUrl;
}

where

@Configuration indicates that this is a configuration class
@ConfigurationProperties(prefix = "remote", ignoreUnknownFields = false) This annotation is used Binding properties. prefix is ​​used to select the prefix of the attribute, which is "remote" in the remote.properties file. ignoreUnknownFields is used to tell SpringBoot to throw an exception when there is an attribute that cannot match the declared field.
@PropertySource("classpath:config/remote.properties") Configuration file path
@Data This is a lombok annotation, used to generate getter&setter methods
@Component is identified as Bean

4. How to use?

Annotate EnableConfigurationProperties(RemoteProperties.class) on the class table where you want to use the configuration file method
and automatically inject

@Autowired
RemoteProperties remoteProperties;

Use remoteProperties.getUploadFilesUrl( in the method ) to get the configuration content.

@EnableConfigurationProperties(RemoteProperties.class)
@RestController
public class TestService{
  @Autowired
  RemoteProperties remoteProperties;

  public void test(){
    String str = remoteProperties.getUploadFilesUrl();
    System.out.println(str);
  }
}

Str here is "/resource/files/" in the configuration file.

PS: Let’s take a look at the two ways to read the config configuration file in Spring-boot

Those who have learned about spring-Boot technology should know Spring-Boot The core configuration file application.properties, of course, you can also customize the configuration file information through annotations.

How Spring-Boot reads the configuration file:

1. Read the contents of the core configuration file information application.properties

Core configuration file It refers to the application.properties or application.yml configuration file in the resources root directory. There are two ways to read these two configuration files, both of which are relatively simple.

The content of the core configuration file application.properties is as follows:

test.msg=Hello World SpringBoot

Method 1: Use @Value method (commonly used)

package Solin.controller; 
import org.springframework.beans.factory.annotation.Value; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RestController; 
@RestController 
public class WebController { 
  @Value("${test.msg}") 
  private String msg; 
  @RequestMapping("/index1")  
  public String index1(){ 
    return "方式一:"+msg; 
  } 
}

Note: in @Value The ${} contains the key name in the core configuration file. Adding @RestController to the Controller class means that all views in this class will be displayed in JSON, similar to adding @ResponseBody to the view method.
When accessing: http://localhost:8088/index1, we get: "Method 1: Hello World SpringBoot"

Method 2: Use Environment method

package Solin.controller; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.beans.factory.annotation.Value; 
import org.springframework.core.env.Environment; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RestController; 
@RestController 
public class WebController { 
  @Autowired 
  private Environment env; 
   
  @RequestMapping("/index2")  
  public String index2(){ 
    return "方式二:"+env.getProperty("test.msg"); 
  } 
}

Note: This method is completed by dependency injection Evnironment. Add the @Autowired annotation to the created member variable private Environment env to complete the dependency injection, and then use env.getProperty("key name") to read the corresponding value.
When accessing: http://localhost:8088/index2, we get: "Method 2: Hello World SpringBoot"

2. Read the custom configuration file information, for example: author.properties

In order not to destroy the original ecology of the core file, but also need to have customized configuration information, usually a custom configuration file will be selected to put this customized information, which is created here in the resources directory. The content of the configuration file author.properties

resources/author.properties is as follows:

author.name=Solin 
author.age=22

Create an entity class for management configuration:

package Solin.controller; 
 
import org.springframework.boot.context.properties.ConfigurationProperties; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.stereotype.Component; 
 
//加上注释@Component，可以直接在其他地方使用@Autowired来创建其实例对象 
@Component 
@ConfigurationProperties(prefix = "author",locations = "classpath:author.properties")   
public class MyWebConfig{ 
  private String name; 
  private int age; 
  public String getName() { 
    return name; 
  } 
  public void setName(String name) { 
    this.name = name; 
  } 
  public int getAge() { 
    return age; 
  } 
  public void setAge(int age) { 
    this.age = age; 
  } 
}

Note:

There are two properties in the @ConfigurationProperties annotation:

locations: Specify the location of the configuration file
prefix: Specify the prefix of the key name in the configuration file (in my configuration file here All key names start with author.)

Using @Component allows the class to be relied upon in other places, that is, using the @Autowired annotation to create instances.

Create Test Controller

package Solin.controller; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Controller; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.ResponseBody; 
@Controller  
public class ConfigController { 
  @Autowired 
  private MyWebConfig conf; 
   
  @RequestMapping("/test")  
  public @ResponseBody String test() { 
    return "Name:"+conf.getName()+"---"+"Age:"+conf.getAge();  
  } 
}

Note: Since the @Component annotation is added to the Conf class, you can use @Autowired directly here to create its instance object.

When accessing: http://localhost:8088/test, I got: "Name:Solin---Age:22"

The above is the detailed content of How to read custom properties configuration file under SpringBoot. For more information, please follow other related articles on the PHP Chinese website!