1. Devtools global settings properties on your home directory (~/.spring-boot-devtools.properties when devtools is active).
2. @TestPropertySource annotations on your tests.
3. properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.
4. Command line arguments.
5. Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).

   1. The SPRING_APPLICATION_JSON properties can be supplied on the command line with an environment variable. For example, you could use the following line in a UN*X shell:
      
      $ SPRING_APPLICATION_JSON='{"acme":{"name":"test"}}' java -jar myapp.jar
      
      In the preceding example, you end up with acme.name=test in the Spring Environment. You can also supply the JSON as spring.application.json in a System property, as shown in the following example:
      
      $ java -Dspring.application.json='{"name":"test"}' -jar myapp.jar
      
      You can also supply the JSON by using a command line argument, as shown in the following example:
      
      $ java -jar myapp.jar --spring.application.json='{"name":"test"}'
      
      You can also supply the JSON as a JNDI variable, as follows: java:comp/env/spring.application.json.

6. ServletConfig init parameters.
7. ServletContext init parameters.
8. JNDI attributes from java:comp/env.
9. Java System properties (System.getProperties()).
10. OS environment variables.
11. A RandomValuePropertySource that has properties only in random.*.
12. Profile-specific application properties outside of your packaged jar (application-{profile}.properties and YAML variants).
13. Profile-specific application properties packaged inside your jar (application-{profile}.properties and YAML variants).

    1. The spring.profiles.active property follows the same ordering rules as other properties: The highest PropertySource wins. This means that you can specify active profiles in application.properties and then replace them by using the command line switch.

       Sometimes, it is useful to have profile-specific properties that add to the active profiles rather than replace them. The spring.profiles.include property can be used to unconditionally add active profiles. The SpringApplication entry point also has a Java API for setting additional profiles (that is, on top of those activated by the spring.profiles.active property). See the setAdditionalProfiles() method in SpringApplication.

       For example, when an application with the following properties is run by using the switch, --spring.profiles.active=prod, the proddb and prodmq profiles are also activated:

    2. ---
       
       my.property: fromyamlfile
       
       ---
       
       spring.profiles: prod
       
       spring.profiles.include:
       
         - proddb
       
         - prodmq

14. Application properties outside of your packaged jar (application.properties and YAML variants).
15. Application properties packaged inside your jar (application.properties and YAML variants).
    1. 　

       SpringApplication loads properties from application.properties files in the following locations and adds them to the Spring Environment:

       1. A /config subdirectory of the current directory
       2. The current directory
       3. A classpath /config package
       4. The classpath root

       The list is ordered by precedence (properties defined in locations higher in the list override those defined in lower locations).

    2. If you do not like application.properties as the configuration file name, you can switch to another file name by specifying a spring.config.name environment property. You can also refer to an explicit location by using the spring.config.location environment property (which is a comma-separated list of directory locations or file paths). The following example shows how to specify a different file name:

       $ java -jar myproject.jar --spring.config.name=myproject

       The following example shows how to specify two locations:

       $ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

16. @PropertySource annotations on your @Configuration classes.
17. Default properties (specified by setting SpringApplication.setDefaultProperties).

# LOGGING

logging.path=/var/logs

logging.file=myapp.log

logging.config= # location of config file (default classpath:logback.xml for logback)

logging.level.*= # levels for loggers, e.g. "logging.level.org.springframework=DEBUG" (TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF)

# EMBEDDED SERVER CONFIGURATION (ServerProperties)

server.port=

server.address= # bind to a specific NIC

server.session-timeout= # session timeout in seconds

server.context-parameters.*= # Servlet context init parameters, e.g. server.context-parameters.a=alpha

server.context-path= # the context path, defaults to '/'

server.servlet-path= # the servlet path, defaults to '/'

SpringApplication application = new SpringApplication(Application.class);

Map<String, Object> defaultMap = new HashMap<String, Object>();

defaultMap.put("name", "Isea-Blog");

//还可以是Properties对象

application.setDefaultProperties(defaultMap);

application.run(args);

@SpringBootApplication

public class App

{

    public static void main( String[] args )

    {

        SpringApplication.run(App.class, args);

    }

}