SpringBoot project reads the application.properties configuration file by default. If you need to customize properties files, how to read them?
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 this folder. As shown in remote.properties in the figure
2. Write configuration files
remote.uploadFilesUrl=/resource/files/remote.uploadPicUrl=/resource/pic/
3. Create a new configuration class RemoteProperties.java
@Configuration@ConfigurationProperties(prefix = "remote", ignoreUnknownFields = false)@PropertySource("classpath:config/remote.properties")@Data@Componentpublic class RemoteProperties { private String uploadFilesUrl; private String uploadPicUrl;}in
@Configuration indicates that this is a configuration class
@ConfigurationProperties(prefix = "remote", ignoreUnknownFields = false) This annotation is used to bind properties. prefix is used to select the prefix of the property, that is, "remote" in the remote.properties file. ignoreUnknownFields is used to tell SpringBoot to throw an exception when a property cannot match the declared domain.
@PropertySource("classpath:config/remote.properties") Configuration file path
@Data This is a lombok annotation, used to generate getter&setter methods. For details, please refer to the lombok related information.
@Component Identified as Bean
4. How to use it?
Annotate EnableConfigurationProperties(RemoteProperties.class) on the table on the class where the method you want to use the configuration file is located.
And automatically inject
@AutowiredRemoteProperties remoteProperties;
Use remoteProperties.getUploadFilesUrl() in the method to get the configuration content.
@EnableConfigurationProperties(RemoteProperties.class)@RestControllerpublic class TestService{ @Autowired RemoteProperties remoteProperties; public void test(){ String str = remoteProperties.getUploadFilesUrl(); System.out.println(str); }}Here str is "/resource/files/" in the configuration file.
PS: Let’s take a look at two ways to read config configuration files in Spring-boot
If you have understood the spring-Boot technology, you should know the application.properties of Spring-Boot's core configuration file, and of course you can also annotate the information of custom configuration file.
How Spring-Boot reads configuration files:
1. Read the core configuration file information of application.properties
The core configuration file refers to the application.properties or application.yml configuration file in the root directory of resources. There are two ways to read these two configuration files, both of which are relatively simple.
The core configuration file application.properties content 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 "Method 1:"+msg; } } Note: The ${} of @Value is included in the key name in the core configuration file. Adding @RestController to the Controller class means that all views in this class are displayed in JSON, similar to adding @ResponseBody to the view method.
When visiting: http://localhost:8088/index1, you will 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 "Method 2:"+env.getProperty("test.msg"); } } Note: This method is to use Evnironment to complete the dependency injection. 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 visiting: http://localhost:8088/index2, you get: "Method 2: Hello World SpringBoot"
2. Read 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, in general, custom configuration files are selected to place these custom information. Here, the configuration file author.properties is created in the resources directory.
The resources/author.properties content is as follows:
author.name=Solin author.age=22
Create an entity class for managing configuration:
package Solin.controller; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Configuration; import org.springframework.stereotype.Component; //Add to the comment @Component, you can use @Autowired directly to create its instance object in other places @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; } }Notice:
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 (all key names in the configuration file here start with author.)
Using @Component is to enable the class to be dependent on other places, that is, to create instances using @Autowired annotation.
Create a 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 @Component is added to the Conf class, you can directly use @Autowired to create its instance object.
When visiting: http://localhost:8088/test, you get: "Name:Solin---Age:22"
Summarize
The above is the method of reading custom properties configuration files under SpringBoot introduced to you by the editor. I hope it will be helpful to you. If you have any questions, please leave me a message and the editor will reply to you in time. Thank you very much for your support to Wulin.com website!