<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-dependencies</artifactId>
		<version>1.5.9. RELEASE</version>
		<relativePath>. /.. /spring-boot-dependencies</relativePath>
	</parent>
Copy the code

• Add dependencies to the SpringBoot application. Add dependencies to the SpringBoot application. Add dependencies to the SpringBoot application.

• @springBootApplication: Identifies the main configuration class in SpringBoot. SpringBoot will run the main method of that class to start the SpringBoot application.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration 	//SpringBoot configuration class, similar to configuration files. Configuration classes are also components in the container. The annotation identifies a SpringBoot configuration class on the class
@EnableAutoConfiguration	// Enable SpringBoot automatic configuration
@ComponentScan( excludeFilters = {@Filter( type = FilterType.CUSTOM, classes = {TypeExcludeFilter.class} ), @Filter( type = FilterType.CUSTOM, classes = {AutoConfigurationExcludeFilter.class} )} )
public @interface SpringBootApplication {
    @AliasFor( annotation = EnableAutoConfiguration.class, attribute = "exclude" )Class<? >[] exclude()default {};

    @AliasFor( annotation = EnableAutoConfiguration.class, attribute = "excludeName" )
    String[] excludeName() default {};

    @AliasFor( annotation = ComponentScan.class, attribute = "basePackages" )
    String[] scanBasePackages() default {};

    @AliasFor( annotation = ComponentScan.class, attribute = "basePackageClasses" )Class<? >[] scanBasePackageClasses()default {};
}
Copy the code

• @springBootConfiguration: SpringBoot configuration class, similar to a configuration file. Configuration classes are also components in the container. The annotation identifies a SpringBoot configuration class on the class

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration	// Indicates that this class is a Spring configuration class
public @interface SpringBootConfiguration {
	@AliasFor( annotation = Configuration.class )
	boolean proxyBeanMethods(a) default true;
}
Copy the code

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component	// Indicates that the class is a component of Spring
public @interface Configuration {
	@AliasFor( annotation = Component.class )
	String value default "";
	
	boolean proxyBeanMethods(a) default true; 
}
Copy the code

• @enableAutoConfiguration: Enables automatic SpringBoot configuration

package org.springframework.boot.autoconfigure;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.context.annotation.Import;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration"; Class<? >[] exclude()default {};

    String[] excludeName() default {};
}
Copy the code

• @AutoConfigurationPackage: The auto-configuration package is done via @import ({mail.class}). Look at the Registrar source to find the package containing the main configuration class, the @SpringBootApplication tagged class, and then scan all the components in the sub-packages into the Spring container

• The @import is the underlying Spring annotation that imports a component to the container, specified via Registr.class.

• AutoConfigurationImportSelector: import component selector, all you need to import the components of the name of the class to return, such components can be added into the container

  • Automatic configuration classes are imported into the container: that is, all the components of the scene are imported into the container and configured. This eliminates the need to manually write configurations and inject functional components

• SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader) :

  • Get the value specified by EnableAutoConfiguration from meta-INF/Spring.Factories under the classpath

• Process summary:

  • SpringBoot gets the value specified by EnableAutoConfiguration from the META-INF/ Spring. factories in the classpath at startup
  • Import these values into the container as auto-configuration classes, and the auto-configuration classes take effect to do the configuration.

• The entire J2EE integration solution and auto-configuration is in spring-boot-Autoconfigure-2.0.1.release.jar

Resources folder in the SpringBoot project:

• Static: Saves all static resources, such as JS, CSS, and images
• Templates: Saves all the template pages. The default JAR package in SpringBoot uses embedded Tomcat and does not support JSP pages by default. You can use template engines: Freemarker, Thymeleaf
• Application. The properties: SpringBoot application configuration file, you can modify some of the default Settings

SpringBoot uses a global configuration file with a fixed configuration file name:

• application.properties
• application.yml
• The configuration file is used to change the default SpringBoot automatic configuration.

• Key: value (Indicates a pair of key-value pairs. Value must be preceded by a space.

• The hierarchy is denoted by indented Spaces. Any left-aligned column is a 1 of the same hierarchy. 2. The number of indent Spaces is not important, as long as elements of the same level are aligned to the left

• Properties and values are case sensitive

• Value written as:

  • Literals: ordinary values (numbers, strings, Booleans)

• Key: value: literal value written directly. Strings are not quoted by default.

• Single quotes – escape characters are printed as normal strings

• Double quotes – Escape characters are converted to format

• Objects, maps (properties and values, key-value pairs) :

  • Object or key: value

friends:
          lastName: Chova
          firstName: Vea
Copy the code

Written in line:

friends: {lastName: Chova.firstName: Vea}
Copy the code

• Array (List, Set)

  • The – value represents the element in the array

pets:
  - dog
  - cat
  - pig
Copy the code

Written in line:

pets: [dog.cat.pig]
Copy the code

• You have to use @ConfigurationProperties
• JSR303 data verification: @Validate-@Email

• RandomValuePropertySource: the configuration file can use a random number

1. ${random. Value} 2. ${random. Int} 3. ${random. Int (10)} 4. ${random. Int [1024655] 36}Copy the code

• ${app.name: default} to specify the default value if the value of the attribute cannot be found

• The SpringBoot startup scans the application.properties or application.yml file in the following location as the default SpringBoot configuration file

1. file:./config/
2. file:./
3. classpath:/config
4. classpath:/

• In order of priority, all files will be loaded, complementary configuration. High-priority content overwrites low-priority content.
• You can change the default configuration location by configuring **- -spring.config.location** : After the project is packaged, specify the new location of the configuration file when the project is started using command line arguments. The specified configuration file and the default loaded configuration file will work together to supplement the configuration.

• When SpringBoot starts, the main configuration class is loaded and the automatic configuration function @enableAutoConfiguration is enabled
• @ EnableAutoConfiguration role: use EnableAutoConfigurationImportSelector to container import components. See the selectImports() method for an implementation:

List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes); Obtain the candidate configuration SpringFactoriesLoader. LoadFactoryNames (); Scan meta-INF /spring.factories under the classpath of all JAR packages. The scanning to the contents of these files are packaged into a properties object, from the properties to EnableAutoConfiguration. The class (class name) the value of the class and then add them in the containerCopy the code

Add all the EnableAutoConfiguration values configured in meta-INF/Spring. factories under the classpath to the container.

• Each auto-configuration class performs auto-configuration functions.

@Configuration	// indicates that this is a configuration class, similar to a configuration file, that can add components to the container
@EnableConfigurationProperties({HttpProperties.class})	// Enable the ConfigurationProperties function for the specified class
@ ConditionalOnWebApplication (/ / Spring bottom @ conditional comments, according to different conditions, if meet the specified conditions, The configuration in the entire configuration class takes effect (to determine whether the current application is a Web application) type = type.servlet)
@ConditionalOnClass({CharacterEncodingFilter.class})	/ / judge the current project to have the class, CharacterEncodingFilter: for SpringMVC in garbled filter
Prefix = "spring.http.encoding", value = {"enabled"}, MatchIfMissing = true / / even if the configuration file is not configured spring. HTTP. Encoding. The enable = true, is also the default effect)
public class HttpEncodingAutoConfiguration {
Copy the code

Depending on the current conditions, to determine whether the configuration class is valid or not, the @bean adds various components to the container, whose values need to be retrieved from properties, each of which is bound to a configuration file. Note:

• @Conditional derived annotations (from the underlying Spring annotation @Conditional) 1. Action: Only if the condition specified by @Conditional is true, can a component be added to the container, and all the contents in the configuration take effect. 2. The automatic configuration class takes effect only under certain conditions: in the configuration file

	debug=true
Copy the code

You can print an automatic configuration report on the console to see which automatic configurations are effective and which are not.