table of Contents
0 Getting Started Document
https://www.yuque.com/atguigu/springboot/qb7hy2
1 Dependency management
Commonly used dependencies and their version numbers are declared in SpringBoot. You can declare the required dependencies directly in pom.xml, without the version number:
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
The import dependency is as follows:
If you need to change the version, check the version number declaration format in the parent dependency, and change
it in pom.xml to modify it according to its format:
<properties>
<mysql.version>5.1.43</mysql.version>
</properties>
The import dependencies are as follows:
2 Automatic configuration
2.1 IOC container components
package App;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class MainApp {
public static void main(String[] args) {
// 1. 返回IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);
// 2. 查看容器里的组件
String[] beanDefinitionNames = run.getBeanDefinitionNames();
for (String name : beanDefinitionNames) {
System.out.println(name);
}
}
}
SpringBoot will provide commonly used components
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
......（省略）
multipartResolver
spring.servlet.multipart-org.springframework.boot.autoconfigure.web.servlet.MultipartProperties
org.springframework.aop.config.internalAutoProxyCreator
2.2 Scanning of packages
SpringBoot will automatically scan the package where the main program is located and all sub-packages below it. How to
change the scan path:
@SpringBootApplication(scanBasePackages = "App.Controller")
3 Container function
3.1 @Configuration
Directory structure:
configuration class MyConfig:
- @Configuration(proxyBeanMethods = false): The default proxyBeanMethods is true
- @Bean("user02"): custom component name
package App.config;
import App.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//@Configuration // 配置类 full模式，获取单实例对象
@Configuration(proxyBeanMethods = false) // 配置类 lite轻量级模式，每次调用会产生一个新的对象，跳过判断，SpringBoot启动快
public class MyConfig {
@Bean // 给容器中添加组件，以方法名作为组件的ID
public User user01(){
//返回类型就是组件的类型，返回的值就是组件在容器中的实例
return new User("zhangsan",18);
}
@Bean("user02") // 自定义组件名称
public User user007(){
return new User("zhangsan",18);
}
}
Test class MainApp:
- @SpringBootApplication(scanBasePackages = "App"): Here to scan the entire package
package App;
import App.bean.User;
import App.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
//@SpringBootApplication(scanBasePackages = "App.Controller")
@SpringBootApplication(scanBasePackages = "App")
public class MainApp {
public static void main(String[] args) {
// 1. 返回IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);
// 2. 查看容器里的组件
String[] beanDefinitionNames = run.getBeanDefinitionNames();
// for (String name : beanDefinitionNames) {
// System.out.println(name);
// }
for (String name : beanDefinitionNames) {
if(name.startsWith("u")){
System.out.println(name);
}
}
// 3.从容器中获取组件，注册的组件默认是单实例的
User u1 = run.getBean("user01", User.class);
User u2 = run.getBean("user01", User.class);
System.out.println("是否为单实例: "+(u1==u2));
MyConfig myConfig = run.getBean(MyConfig.class); // 配置类本身也是组件
System.out.println(myConfig);
System.out.println(myConfig.user01()); // 调用配置类的方法获取的都是之前注册的单实例（proxyBeanMethods = true）
}
}
The output is as follows:
- user01: the default bean
- user02: a bean with a custom name
- The two objects obtained are the same, indicating a single instance
- Get the configuration class object (configuration class is also a component)
- Call the method of the configuration class
3.2 @Import
@Import({
User.class, Pet.class}) // 给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
4 Configure binding
4.1 @Component+@ConfigurationProperties
Add the following configuration to the configuration file application.properties:
mypet.name=hellomicki
mypet.age=3
New entity class Pet
- @Component: The component in the container
- @ConfigurationProperties: corresponding configuration file
package App.bean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "mypet")
public class Pet {
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;
}
@Override
public String toString() {
return "Pet{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Automatic injection and jump are added to the Controller class HelloController:
@Autowired
Pet pet;
@RequestMapping("/pet")
public Pet pet(){
return pet;
}
Run the test:
4.2 @EnableConfigurationProperties + @ConfigurationProperties
Only @ConfigurationProperties is used in the entity class:
//@Component
@ConfigurationProperties(prefix = "mypet")
public class Pet {
...
}
Add a comment to the configuration class MyConfig:
@EnableConfigurationProperties(Pet.class)
The Controller class is the same as 4.1, running the test, the result is the same:
