Description: refer to Raytheon springboot2 in station b
Video reference
Note reference

1, Basic introduction

1. SpringBoot benefits

• Create a stand-alone Spring application

• Embedded web server

  Previously, you need to package the war package and put it into tomcat to run

• Automatic starter dependency to simplify build configuration

  starter, automatic dependency

• Automatically configure Spring and third-party functions

• Provide production level monitoring, health inspection and external configuration

• No code generation, no need to write XML

SpringBoot is a one-stop framework that integrates the Spring technology stack

SpringBoot is a rapid development scaffold that simplifies the Spring technology stack

2. SpringBoot disadvantages

• The iteration is fast and needs to pay attention to changes all the time
• The package is too deep, the internal principle is complex, and it is not easy to master

3. Background of the times

Microservices, distributed, cloud native

2, HelloWord

1. Version requirements

Maven	3.5+
Gradle	6.8.x, 6.9.x, and 7.x

2,maven

Configure Alibaba cloud warehouse to download faster
<mirrors>
      <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>central</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
      </mirror>
  </mirrors>
 
  <profiles>
         <profile>
              <id>jdk-1.8</id>
              <activation>
                <activeByDefault>true</activeByDefault>
                <jdk>1.8</jdk>
              </activation>
              <properties>
                <maven.compiler.source>1.8</maven.compiler.source>
                <maven.compiler.target>1.8</maven.compiler.target>
                <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
              </properties>
         </profile>
  </profiles>

3. Create project

Note that maven is configured in idea

pom.xml

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
</parent>

<!-- add to web rely on-->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Main function

package com.mys.boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }

}

//Business logic
package com.mys.boot.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

//@ResponseBody / / the data returned by each method is directly returned to the browser instead of jump
//@Controller
@RestController //Contains @ ResponseBody @Controller
public class HelloController {

    @RequestMapping("/hello")
    public String handle01() {
        return "hello";
    }
}

Spring Boot unified configuration file: application.properties

server.port=8888

Simplify deployment: install the plug-in, type the project into a jar package, and execute it directly on the target server

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
</build>

3, Automatic configuration principle

1. Dependency management

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
</parent>

His parent project
 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.4.RELEASE</version>
  </parent>

It declares the version number of almost all dependencies commonly used in development,Automatic version arbitration mechanism

You can modify the default version number

1,see spring-boot-dependencies It specifies the current dependent version key. 
2,Rewrite the configuration in the current project
    <properties>
        <mysql.version>5.1.43</mysql.version>
    </properties>

2. Scene launcher

1,See a lot spring-boot-starter-* :  *Just some kind of scene
2,Just introduce starter，We will automatically introduce all the dependencies required for this scenario
3,SpringBoot All supported scenarios
https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4,See  *-spring-boot-starter:  The third party provides us with a scenario launcher to simplify development.
5,The lowest level dependency of all scenario initiators
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

1,By default, no version can be written when importing dependencies
2,Introducing non version arbitrations jar，To write the version number.

3. Auto configuration

• Automatically configure tomcat

1. Introduce tomcat dependency

2. Configure tomcat

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-tomcat</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

• Automatically configure spring MVC

  1. Introduce a complete set of spring MVC components

  2. Automatically configure common spring MVC components

• Automatically configure common web functions, such as character coding

  Spring boot configures all common scenarios for web development

• Default package structure

  The package where the main program is located and the components of all its sub packages will be scanned by default. There is no need to configure the previous package scanning

  • To change the scanning path, @ SpringBootApplication(scanBasePackages = "com.atguigu")

  • Or * * @ ComponentScan * * specify the scan path

    @SpringBootApplication
     Equivalent to
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan("com.mys.boot")
    

• Various configurations have default values

  • The default configuration is ultimately mapped to a class, such as MultipartProperties

    The value of the configuration file will eventually be bound to each class, which will create objects in the container

    To change the default property value, modify the corresponding value in application.properties

• Load all auto configuration items on demand

  • What scenarios are introduced and the automatic configuration of this scenario will be enabled
  • All spring boot autoconfigure functions are in the spring boot autoconfigure package

4. Container

4.1 component addition

1,@Configuration

Full(proxyBeanMethods = true)      Usage scenario: component dependency
Lite(proxyBeanMethods = false)
If only a component is registered in the container and others do not rely on this component, select false，This can speed up container startup

package com.mys.boot.config;

import com.mys.boot.bean.Pet;
import com.mys.boot.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 1.The @ Bean annotation is used in the configuration class to register components for the container on the method. The default is single instance
 * 2.The configuration class itself is also a component
 * 3.proxyBeanMethods: Method of proxy bean
 */

@Configuration(proxyBeanMethods = false)//Tell springboot that this is a configuration class = = configuration file
public class MyConfig {
    /**
     * Add a component to the container, take the method name as the component id, the return type is the component type, and the return value is the instance of the component in the container
     * No matter how many external calls are made to the component registered in the configuration class, the single instance object previously registered in the container is obtained
     * @return
     */
    @Bean
    public User user01() {
        User user = new User("zhangshan", 18);
        //The user component depends on the pet component
        user.setPet(tomcatPet());
        return user;
    }

    @Bean("tom")//If you do not want the method name as the component name, you can modify it
    public Pet tomcatPet() {
        return new Pet("tomcat");
    }
}

package com.mys.boot;

import com.mys.boot.bean.Pet;
import com.mys.boot.bean.User;
import com.mys.boot.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {

        //1. Return to IOC container
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2. Check the components in the container
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        //3. The components registered in the container are single instance
        Pet tom01 = run.getBean("tom", Pet.class);
        Pet tom02 = run.getBean("tom", Pet.class);
        System.out.println("Components:" + (tom01 == tom02));

        //4. Get the components of the configuration class in the container
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        //5. Configure the class to call the components declared in the container to determine whether they are taken from the container or directly called
        //MyConfig proxy object calls method 
        //proxyBeanMethods defaults to true, indicating that the registered single instance object is taken from the container
        //If proxyBeanMethods=false is set, the MyConfig obtained from the container is not a proxy object
        User user1 = bean.user01();
        User user2 = bean.user01();
        System.out.println(user1 == user2);

        //6. Test component dependencies
        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);
        System.out.println("User's pet:" + (user01.getPet() == tom));
    }
}

@Bean @Component @Controller @Service @Repository @ComponentScan

2,@Import

Import a component of the specified type and automatically create the imported component in the container. The default component name is the full class name

@Import({User.class, DBHelper.class})

3. Conditional assembly

ConditionalOnBean,ConditionalOnMissingBean

4. @ ImportResource("classpath:beans.xml") imports the spring configuration file

4.2 configuration binding

1,@ConfigurationProperties+@Component

package com.mys.boot.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component//Only the components in the container have the functions provided by spring boot
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private Integer price;
		......
}

//Set the property value in application.properties
mycar.brand=BYD
mycar.price=10000

2,@EnableConfigurationProperties

@EnableConfigurationProperties(Car.class)
//1. Enable the configuration binding function of car
//2. Automatically register the car component into the container

4.3 principle analysis

1. Boot load autoconfiguration class

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

• @Springboot configuration stands for springboot

  @Configuration represents the current configuration class

• @ComponentScan package scan

• @EnableAutoConfiguration

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

(1)@AutoConfigurationPackage autoconfiguration package

@Import(AutoConfigurationPackages.Registrar.class)//Import components into container
public @interface AutoConfigurationPackage {}

//Use Register to import a series of components into the container
    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

		//AnnotationMetadata: Annotation (AutoConfigurationPackage) meta information
		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            //Obtain the package name by using the annotation meta information, and encapsulate the package name into an array
			register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
		}

		@Override
		public Set<Object> determineImports(AnnotationMetadata metadata) {
			return Collections.singleton(new PackageImports(metadata));
		}

	}

Under the package of MainApplication

(2)@Import(AutoConfigurationImportSelector.class)

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
   if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
   }
   AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
   return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

1. Use getautoconfigurationentry (annotation metadata); Batch import some components into the container

2. Use list < string > configurations = getcandidateconfigurations (annotation metadata, attributes); Get all the components that need to be imported into the container (127 components)

3. Use factory loading to get all components

List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
      getBeanClassLoader());

Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {

4. Load a file from META-INF/spring.factories.

Scan all META-INF/spring.factories files in our current system by default

spring-boot-autoconfigure-2.3.4.RELEASE.jar package also contains META-INF/spring.factories

It is written in the file that all configuration classes to be loaded into the container as soon as spring boot is started

spring-boot-autoconfigure-2.3.4.RELEASE.jar/META-INF/spring.factories

2. Turn on automatic configuration items on demand

Although all the automatic configurations of our 127 scenarios are loaded by default when they are started.

Xxxautoconfiguration is assembled according to the Conditional assembly rule (@ Conditional) and will be configured as needed.

3. Modify default configuration

    @Bean
    @ConditionalOnBean(MultipartResolver.class)  //There are components of this type in the container
	//There is no component with this name multipartResolver in the container
    @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) 
    public MultipartResolver multipartResolver(MultipartResolver resolver) {
            //If the method labeled @ Bean passes in an object parameter, the value of this parameter will be found from the container
            //SpringMVC multipartResolver.  Prevent the file upload parser configured by some users from not conforming to the specification
      // Detect if the user has created a MultipartResolver but named it incorrectly
      return resolver;
    }
Add a file upload parser to the container;

SpringBoot will configure all components at the bottom by default. However, if the user has configured it himself, the user's priority shall prevail

@Bean
  @ConditionalOnMissingBean
  public CharacterEncodingFilter characterEncodingFilter() {
    }

Summary:

• SpringBoot loads all the autoconfiguration classes xxxxconfiguration first

• Each automatic configuration class takes effect according to conditions, and will bind the value specified in the configuration file by default. Take it from xxproperties. xxxProperties is bound to the configuration file

• The effective configuration class will assemble many components in the container

• As long as these components are in the container, they are equivalent to these functions

• Customized configuration

• • Users directly replace the underlying components with @ Bean
  • The user can modify the value of the configuration file obtained by this component. application.properties

Xxxxxxautoconfiguration - > component - > xxxxproperties - > get the value - > application.properties

5. Best practices

• See which are automatically configured

• • After self analysis, the automatic configuration corresponding to the imported scenario generally takes effect
  • debug=true in the configuration file enables the automatic configuration report. Negative \ Positive

• Need to modify

  Modify configuration items by referencing documents https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-application-properties.html#common-application-properties

  Analyze yourself. Which of the configuration files are bound by xxproperties.

• Custom add or replace components

• @Bean,@Component. . .

• Customizer xxxxxxcustomizer;

4, Development tips

1,Lombok

Simplify JavaBean development

1.Introduce dependency
<dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
</dependency>
2.settings Installing plug-ins under

@Data//get set
@ToString//toString
@AllArgsConstructor//Parametric constructor
@NoArgsConstructor//Parameterless constructor

@EqualsAndHashCode//Override HashCode

2,dev-tools

After the item or page is modified: Ctrl+F9；
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

3,spring initializr

Project initialization Wizard

Create project structure dependent main program classes