Generally in a project, there will always be a lot of environments. Like what:
Production environment, pre-release environment, test environment, development environment
The configuration files on each environment are always different, and even the environment of each developer in the development environment may be a little differently, and configuring reading is a bit of a headache.
Spring Boot provides a mechanism of priority configuration reading to help us get out of this dilemma.
In general, we all know that spring boot configuration is read fromapplication.properties. In fact, aresourcefile read from the directoryapplication.propertiesis a link in the Spring boot configuration chain.
Externally-configured configuration
Spring 3.1 introduces a new environment (environment) and profile API, which is a more flexible way to handle different environments and configuration files. However, the problem with these configuration management methods in Spring is that there are too many choices to make developers at a loss. Spring Boot provides a unified way to manage the configuration of your app, allowing developers to define different priority configuration values using property files, YAML files, environment variables, and command-line parameters.
The configuration priority order provided by Spring Boot is more complex. In order of precedence from highest to lowest, the specific list is as follows.
This configuration priority of Spring Boot may seem complicated, but it's quite reasonable. For example, command-line parameters are set to the highest priority.
The benefit is that you can quickly modify configuration parameter values in a test or production environment without having to repackage and deploy the app.
The Springapplication class defaults to converting command-line arguments starting with "--" to configuration parameters that can be used in the app, such as "--name=alex", which sets the value of the configuration parameter "name" to " Alex. " If this feature is not required, you can use the springapplication. setaddcommandlineproperties (false) "Disables parsing of command-line arguments.
Randomvaluepropertysource can be used to generate a variety of different types of random values required for testing, eliminating the hassle of generating in code. Randomvaluepropertysource can generate numbers and strings. The type of the number contains int and long, which can limit the size range of the number. With "random." The configuration property name as a prefix is generated by Randomvaluepropertysource, as shown in code Listing 3.
Listing 3. Configuration properties generated by using Randomvaluepropertysource
user.id=${random.value}
user.count=${random.int}
user.max=${random.long}
user.number=${random.int(100)}
user.range=${random.int[100, 1000]}
Properties file
The above order also indicates the priority of the properties file that is contained in the location. Priority is arranged in order from highest to lowest. You can specify a different property file name by using the "Spring.config.name" configuration property. You can also use "spring.config.location" To add additional properties to the file's search path . If you have multiple profiles in your app, you can define individual properties files for each profile and name them according to "Application-{profile}".
For configuration properties, you can use "@Value" in your code, as shown in Listing 4.
Listing 4. Using the configuration properties with "@Value"
@RestController
@EnableAutoConfiguration
public class Application {
@Value("${name}")
private String name;
@RequestMapping("/")
String home() {
return String.format("Hello %s!", name);
}
}
In code Listing 4, the value of the variable name comes from the "name" property in the configuration property.
Yaml
spring: profiles: development db: url: jdbc:hsqldb:file:testdb username: sa password: --- spring: profiles: test db: url: jdbc:mysql://localhost/test username: test password: test
The Yaml file in Listing 5 also gives the configuration information for the development and test two different profiles, which is one of the advantages of the Yaml file relative to the properties file. In addition to using the @Value annotation binding to configure property values, you can use a more flexible approach. The Code Listing 6 shows the Java class that uses the YAML file in code Listing 5. With the @ConfigurationProperties (prefix= "db") annotation, the attribute value prefixed with "DB" in the configuration attribute is automatically bound to a domain of the same name in the Java class, such as the value of the URL field corresponding to the property "Db.url". You can enable the auto-bind feature by simply adding the "@EnableConfigurationProperties" annotation to the app's configuration class.
Listing 6. Java classes that use YAML files@Component @ConfigurationProperties(prefix="db") public class DBSettings { private String url; private String username; private String password; }
Http://www.ibm.com/developerworks/cn/java/j-lo-spring-boot/index.html
This means that if spring boot finds the configuration in a higher priority location , it ignores the low-priority configuration .
For example, Iapplication.propertieswrite the configuration of the local MySQL in the directory:
db.jdbc.driver=com.mysql.jdbc.Driver db.jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8 db.jdbc.username=username db.jdbc.password=password
During the commissioning phase of your project, the project will always use the local MySQL database. And once packaged, declare one externallytest_evn.properties.
When you start the jar package, specify an external configuration file:
java -jar demo.jar --spring.config.location=/path/test_evn.properties
In this way, we always use our own configuration on the developer's machine, and one to the corresponding environment, we will use the configuration of the advanced location.
It is also very convenient to read these configurations in code, in the logic of the code, it is not necessary to care about where the configuration comes from, only with the attention can get what configuration is enough.
public class ApplicationConfigure {
@Value("${db.jdbc.driver}")
private String jdbcDriver;
@Value("${db.jdbc.url}")
private String jdbcUrl;
@Value("${db.jdbc.username}")
private String jdbcUsername;
@Value("${db.jdbc.password}")
private String jdbcPassword;
// mysql config class
// .....
}
Sometimes when we start the project, we always need to start some initialization classes, the previous common practice is to write thestaticblock, Spring Boot provides anCommandLineRunnerinterface, the implementation of this interface class will always be priority to start, and prioritize the implementationCommandLineRunnerof the interface provided in therun()Method.
public class ApplicationConfigure implements CommandLineRunner {
@Value("${db.jdbc.driver}")
private String jdbcDriver;
@Value("${db.jdbc.url}")
private String jdbcUrl;
@Value("${db.jdbc.username}")
private String jdbcUsername;
@Value("${db.jdbc.password}")
private String jdbcPassword;
// mysql config class
// .....
@Override
public void run(String... strings) throws Exception {
// Some methods, classes, and properties are preloaded.
}
}
If you have more than oneCommandLineRunnerinterface implementation class, you can use annotations@Orderto specify the order in which all implementation classes are run.
With the help of this series of APIs, Spring boot makes the environment much easier to configure.
Http://www.cnblogs.com/whthomas/p/5270917.html
Http://www.ibm.com/developerworks/cn/java/j-lo-spring-boot/index.html
Tomcat
Tomcat is the default container for spring boot, and here are a few common configurations:
[Java]
Jetty
If you are going to choose jetty, it is also very simple to exclude the Tomcat dependency in Pom and add the dependency of the jetty container as follows:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
<dependencies>
Packaged
E:\SPRING-BOOT-SAMPLE>MVN Clean Package
You can append a parameter -dmaven.test.skip=true (-dskiptests) to skip the test.
The packaged files are stored in the target directory under the project, such as: Spring-boot-sample-0.0.1-snapshot.jar
Spring-boot-sample-0.0.1-snapshot.war If the POM is configured with a war package
Second. deploy to a Java EE container
1.Modify the startup class, inherit Springbootservletinitializer , and override the Configure method
public class SpringBootSampleApplication extends SpringBootServletInitializer{ private static final Logger logger = LoggerFactory.getLogger(SpringBootSampleApplication.class); @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) { return builder.sources(this.getClass()); } }
2.Modify the jar in the Pom file as war
<!-- <packaging>jar</packaging> --> <packaging>war</packaging>
3.Modify Pom to exclude Tomcat plugins
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> </dependency>
4.Package deployment to a container
Use the command MVN clean package to deploy to a web container just like a generic Java EE project.
Third, the use Profile Differentiate the environment
1. Configuration files
Using configuration files Application.yml and application.properties differ
Take Application.properties as an example, distinguish environment application-{profile }.properties by file name
Application.properties
app.name=MyApp server.port=8080 spring.profiles.active=dev
Application-dev.properties
server.port=8081
Application-stg.properties
server.port=8082
Specify the specific configuration to use when starting the program by adding –spring.profiles.active={profile}
For example we perform Java-jar Demo.jar –spring.profiles.active=Dev So how will the contents of the above 3 files be applied?
Spring Boot Loads the default configuration file first, and then overwrites the default configuration with the configuration in the specified profile.
spring.profiles.active Specifies the dev environment by default, and if we specify –SPRING.PROFILES.ACTIVE=STG at run time, the STG environment is applied and the final Server.port value is 8082
2. @profile annotations in Java class
The following 2 different classes implement the same interface, @Profile annotations specify the specific environment
// Interface definition
Public interface SendMessage {
// Send SMS method definition
Public void send();
}
// Dev environment implementation class
@Component
@Profile("dev")
Public class DevSendMessage implements SendMessage {
@Override
Public void send() {
System.out.println(">>>>>>>>Dev Send()<<<<<<<<<");
}
}
// Stg environment implementation class
@Component
@Profile("stg")
Public class StgSendMessage implements SendMessage {
@Override
Public void send() {
System.out.println(">>>>>>>>Stg Send()<<<<<<<<<");
}
}
// start class
@SpringBootApplication
Public class ProfiledemoApplication {
@Value("${app.name}")
Private String name;
@Autowired
Private SendMessage sendMessage;
@PostConstruct
Public void init(){
sendMessage.send();// will instantiate the corresponding class according to the environment specified by the profile
}
}
3, Logback-spring.xml also support the node to support the distinction
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<include resource="org/springframework/boot/logging/logback/base.xml" />
<logger name="org.springframework.web" level="INFO"/>
<springProfile name="default">
<logger name="org.springboot.sample" level="TRACE" />
</springProfile>
<springProfile name="dev">
<logger name="org.springboot.sample" level="DEBUG" />
</springProfile>
<springProfile name="staging">
<logger name="org.springboot.sample" level="INFO" />
</springProfile>
</configuration>
Again, do not use the Logback.xml file name. Use Logback-spring.xml
Fourth. specifying the external configuration file
Some systems, such as information about databases or other third-party accounts, are not configured to be exposed to developers in the project because of security issues.
In this case, when we run the program, we can specify an external configuration file through the parameters.
Taking Demo.jar as an example, the method is as follows:
Java-jar Demo.jar --spring.config.location=/opt/config/application.properties
Where the file name is arbitrarily defined, no fixed requirements.
Fifth. Create an SH script for a Linux application
#!/bin/sh rm -f tpid nohup java -jar /data/app/myapp.jar --spring.profiles.active=stg > /dev/null 2>&1 & echo $! > tpid
stop.sh
Tpid= ' Cat Tpid | awk ' {print '} '
tpid=`ps -aef | grep $tpid | awk ‘{print $2}‘ |grep $tpid`
if [ ${tpid} ]; then
kill -9 $tpid
fi
check.sh
tpid=`cat tpid | awk ‘{print $1}‘`
tpid=`ps -aef | grep $tpid | awk ‘{print $2}‘ |grep $tpid`
if [ ${tpid} ]; then
echo App is running.
else
echo App is NOT running.
fi
kill.sh
#!/bin/sh
# Kill-9 ' ps-ef|grep project name |awk ' {print $} '
Kill-9 ' ps-ef|grep Demo|awk ' {print $} '
Http://www.cnblogs.com/duyinqiang/p/5696342.html
Spring Boot Configuration Priority order
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
