学习笔记从零开始的SpringBoot新手教程(WIN10+JDK9+STS4)

Posted 2022-05-20 囚生CY

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了学习笔记从零开始的SpringBoot新手教程(WIN10+JDK9+STS4)相关的知识，希望对你有一定的参考价值。

最近开始学习springboot, 可能相对于django的话, springboot的应用和功能都要更加广泛和全面, 但是从2019年起sts3的下载链接失效, 现在的sts4与sts3存在很多版本上的差异, 让像笔者这样的菜鸟难以找到合适的教程上手, 事实上sts4相对于在eclipse中通过maven来创建springboot项目要容易得多, 也更适合于入门, 总之笔者到现在为止还是不知道怎么配置eclipse里新建的maven工程, 止不住的bug, 流不尽的泪…

1. 安装spring-boot并创建Helloworld项目

启动一个Helloworld项目

前置条件: 安装并配置jdk, 笔者使用的9.0.4, 即jdk9版本, 其他版本应该不会有太大区别
选择下载最新的spring tool suite 4, 注意目前网络上关于sts3版本的下载地址都已经404失效了, sts4的下载地址: https://spring.io/tools, 以windows为例下载下图中的64位WINDOWS的jar包即可👇
解压下载得到的jar包, 运行jar包里sts4.x.x-RELEASE文件夹中的SpringToolSuite4.exe安装即可👇
安装的过程只需要配置一个空目录作为workspace, 其他地方只需要默认下一步, 安装成功后就会打开一个与Eclipse几乎完全相同的IDE界面
点击IDE左栏中的create spring starter project(需要联网, 需要从spring.io镜像上下载文件), 设置项目名称为Helloworld, 其余设置默认, 点击next, 如下图所示, 选择web下的Spring Web, 点击finish即可创建工程👇
因为sts4自带了maven相关的配置, 因此可以不用特别去下载maven, 此时可能需要等待sts4从线上maven镜像中下载工程目录下的pom.xml文件中定义的一系列依赖包, 默认会下载在C:/Users/Administrator/.m2/repository中; 笔者的经验仍然是去http://maven.apache.org/download.cgi下载一个maven的二进制zip包(选binary里的zip包, 不要jar也不要下载源码包, zip包直接解压就可以了, 无需安装), 解压到E盘后配置一下环境变量, 将解压后的根目录作为MAVEN_HOME变量添加到环境变量中, 并将包中的bin文件夹添加到环境变量Path中, 如以下两张图所示👇
此外在MAVEN_HOME目录下的conf文件夹里有一个settings.xml配置文件, 一般需要对它进行修改, 主要是修改本地maven仓库的路径(默认是C:/Users/Administrator/.m2/repository)与设置线上maven仓库镜像来加快本地maven仓库更新速度

通过在修改settings标签下面的localRepository标签中的值(如果没有localRepository标签就自己新建一个), 可以指定存放在F:\\repository\\maven-repository\\repository中, 如下图所示:👇
然后在mirrors标签中插入镜像mirror标签👇
笔者列出一些常用的mirror镜像, 一般来说用阿里的就可以了👇

<!-- 阿里 -->
<mirror>
	<id>alimaven</id>
	<name>aliyun maven</name>
	<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
	<mirrorOf>central</mirrorOf>
</mirror>

<!-- 华为 -->
<mirror>
    <id>huaweicloud</id>
    <name>mirror from maven huaweicloud</name>
    <url>https://mirror.huaweicloud.com/repository/maven/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

<!-- ibiblio -->
<mirror>
    <id>ibiblio</id>
    <name>Mirror from Maven ibiblio</name>
    <url>http://mirrors.ibiblio.org/pub/mirrors/maven2/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

<!-- repo1.maven.org -->
<mirror>
    <id>central</id>
    <name>Maven Repository Switchboard</name>
    <url>http://repo1.maven.org/maven2/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

<!-- repo1.maven.apache.org -->
<mirror>
    <id>central</id>
    <name>Maven Repository Switchboard</name>
    <url>http://repo1.maven.apache.org/maven2/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

<!-- repo2 -->
<mirror>
    <id>repo2</id>
    <name>Mirror from Maven Repo2</name>
    <url>http://repo2.maven.org/maven2/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

<!-- spring.io -->
<mirror>
	<id>sprintio</id>
	<mirrorOf>central</mirrorOf>
	<name>Human Readable Name for this Mirror.</name>
	<url>https://repo.spring.io/libs-snapshot/</url>
</mirror>

<!-- UK -->
<mirror>
    <id>ui</id>
    <name>Mirror from UK</name>
    <url>http://uk.maven.org/maven2/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

<!-- JBoos -->
<mirror>
    <id>jboss-public-repository-group</id>
    <name>JBoss Public Repository Group</name>
    <url>http://repository.jboss.org/nexus/content/groups/public</url>
    <mirrorOf>central</mirrorOf>
</mirror>

<!-- Google -->
<mirror>
    <id>google</id>
    <name>google maven</name>
    <url>https://maven.google.com/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

<!-- Maven china -->
<mirror>
	<id>maven.net.cn</id>
	<name>Mirror from Maven in china</name>
	<url>http://maven.net.cn/content/groups/public/</url>
	<mirrorOf>central</mirrorOf>
</mirror>

<!-- Maven oschina -->
<mirror>
    <id>CN</id>
    <name>OSChinaCentral</name>
    <url>http://maven.oschina.net/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

最后还需要将下载的maven与sts4绑定: 菜单栏window–>Preferences–>Maven–>User Settings, 将刚刚配置好的settings.xml配置文件路径包含进来即可👇

在com.example.demo包中(即HelloWorldApplication.java所在的包), 新建class, 命名为HelloWorldController
在新建的HelloWorldController.java类文件里添加下面的代码👇

package com.example.demo;

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

/*
 * 在这里使用RestController: 等待于Controller和@RequestBody 
 */
@RestController
public class HelloworldController 
	/*
	 * 在这里使用@RequestMapping建立请求映射
	 */
	@RequestMapping(value="/helloworld",method=RequestMethod.GET)
	public String helloworld() 
		return "<h1>Hello world!</h1>";

右键项目文件夹–>Run As–>Spring Boot App
打开浏览器访问http://127.0.0.1:8080/helloworld即可查看Helloworld界面

Helloworld项目相关注解

HelloworldApplication.java项目入口类文件, 随着项目创建自动生成

package com.example.demo;

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

/*
 * 在这里使用@SpringBootApplication指定这是一个spring boot的应用程序
 */

@SpringBootApplication
public class HelloworldApplication 

	public static void main(String[] args) 
		SpringApplication.run(HelloworldApplication.class, args);

@SpringBootApplication: 标记在主程序类上, 表明这是一个springboot项目的入口
SpringApplication.run(HelloworldApplication.class, args): 启动要加载很多内置配置文件, 根据自动化配置加载很多组件到IOC容器

包扫描方式:

按照约定规则自动扫描
- 在springboot环境下, 主启动类所在包, 主启动类所在包的子包会被自动扫描
- 一般放在src/main/java下的com.example下的所有包都可以被自动扫描
手动指定:
- 在主启动类上使用@ComponentScan注解可以指定扫描的包, 但是此时约定规则将会失效
- 即在@SpringBootApplication下面加一行@ComponentScan("com.example1")即可自动扫描另一个包com.example1下的文件

父工程:

我们的工程继承了spring-boot-starter-parent工程, 如pom.xml配置文件中parent标签中的设定👇

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.3.4.RELEASE</version>
	<relativePath/> <!-- lookup parent from repository -->
</parent>

spring-boot-starter-parent工程继承了spring-boot-dependencies工程
spring-boot-dependencies工程中管理的是springboot环境所需要使用的依赖
即加入下面的代码后就不需要再考虑pom.xml配置文件后面dependencies节点中依赖包的版本问题了

版本仲裁: springboot对包的依赖做了严格测试, 不需要开发者额外考虑
场景启动器:

如SQL, AWS, Azure, Spring Cloud, Google Cloud Platform, 包括邮件, jpa等, 详细可见https://blog.csdn.net/neverneverstops_/article/details/78416064
在pom.xml中添加依赖, 即插即用, 比如将下面代码加入dependencies节点中即可使用web服务相关模块

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

打包springboot项目并使用命令行启动(jar包)

打开cmd命令行
进入工程目录, 即pom.xml所在目录
执行mvn package命令
进入target目录: cd target
执行java -jar xxx.jar命令
可能的问题:
- Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.8.1, maven:无效的目标发行版: 11
  - 问题原因: jdk版本不匹配, 且缺少必要的依赖包maven-compiler-plugin:3.8.1
  - 解决方案: 在pom.xml配置文件里添加依赖, 并修改properties节点中的java版本(默认为11)变成1.9(根据你自己的jdk版本进行修改)👇

<dependency>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-compiler-plugin</artifactId>
	<version>3.8.1</version>
</dependency>

<properties>
	<java.version>1.9</java.version>
</properties>

Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.22.1:test
- 问题原因: 项目测试时出错
- 解决方案: 在pom.xml配置文件的//build/plugins/节点下添加新的plugin节点以跳过测试

<!--添加配置跳过测试-->
<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-surefire-plugin</artifactId>
	<version>2.22.1</version>
	<configuration>
		<skipTests>true</skipTests>
	</configuration>
</plugin>

此外想要能打包pom.xml中一定要带有build块, sts4新建项目时会自动生成👇

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

关于junit-test单元测试模块的编写

注意sts4生成的pom.xml配置文件中, dependencies节点里会有单元测试的依赖👇

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-test</artifactId>
	<scope>test</scope>
	<exclusions>
		<exclusion>
			<groupId>org.junit.vintage</groupId>
			<artifactId>junit-vintage-engine</artifactId>
		</exclusion>
	</exclusions>
</dependency>

编写src/test/java/中的com.example.demo包下的HelloworldApplicationTests.java(没有则新建它即可), 右键该文件Run As–>Junit Test即可👇

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class HelloworldApplicationTests 
	/*
	 * 利用Logger日志类来打印
	 */
	Logger logger = LoggerFactory.getLogger(HelloworldApplicationTests.class);
	
	@Test
	void contextLoads() 
		logger.debug("Hello world! Test...");

2. spring-boot配置文件

springboot中有两种配置文件: .properties与.yml文件
默认的文件保存位置是src/main/resources目录, 文件名为application.properties或application.yml, 一般只有一个, 如果存在两个则冲突时以application.properties为准

2.1 properties文件

有jdbc.properies, application.properties, bootstrap.properties等, 新建项目默认只有application.properties
application.properties的配置

配置端口号(默认8080): server.port = 8888
配置根目录(默认为/): server.servlet.context-path = /caoyang
- 这是项目的根目录, 默认/即在http://127.0.0.1:8080/
- 设置成/caoyang则根目录在http://127.0.0.1:8080/caoyang/

2.2 yml文件

yml文件使用的是YAML语言, 并不是和html, xml类似的标记语言, 当中是没有标签的, 以数据为中心, 更适合作为配置文件编写规范
yml文件编写规范:

必须使用空格(一般使用2空格)缩进, 缩进空格数量相等视为同一层级的配置, 因此换行无需逗号或分号
冒号右边必须有一个空格, 左边必须没有空格
键值都是大小写敏感的
单引号和双引号有区别:
- 双引号不会转义其中的特殊字符, 单引号会转义特殊字符, 如换行符在单引号中会变成换行, 双引号则会输出"反斜杠n"

server: 
  port: 8888
  servlet: 
    context-path: /caoyang

yml文件中数值类型及注入

字面量: 普通的字符串(无需引号, 加上引号也可以), 数值, 布尔类型
- 注意: 设置数据库密码的时候如果是以0开头的一串数字会被springboot按照八进制数进行解析, 加上引号即可
对象型: 字典型, 映射型的数据
- 常规写法:
```
student: 
  id: 1
  name: caoyang
```
- 行内写法: student: id: 1, name: caoyang
数组型:
- 常规写法: 使用"-"表示数组中的元素, "-"后必须有单空格, 与markdown语法类似
```
student: 
  id: 1
  name: caoyang
  subject: 
  - java
  - php
  - mysql
```
- 行内写法: 直接用中括号即可, 与json格式类似
```
student: 
  id: 1
  name: caoyang
  subject: [java, php, mysql]
```

将application.yml配置文件中的值注入JavaBean

为了方便整理, 在入口函数所在包com.example.demo下再建一个包model, 用于保存数据模型javabean, 在其中新建一个java类Student作为一个用于注入的bean👇

package com.example.demo.model;

import java.util.Arrays;

/*
 * 用于注入yml配置文件的java类
 */

import java.util.Date;
import java.util.Map;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

/*
 * 当前java类要读取yml配置文件的数据必须要求当前类也在IOC容器中
 */

@Repository("Student")
@Service("Student")
@Component
@ConfigurationProperties(prefix="student")
public class Student 
	private Integer id;
	private String name;
	private String[] subject;
	private Boolean graduated;
	
	// 可以添加一个注解, 用于在web服务中使用日期格式输出, 如果不使用这个注解, 则默认为yyyy/MM/dd, 可以改成标准的"yyyy-MM-dd HH:mm:ss"
	@DateTimeFormat(pattern="yyyy/MM/dd")
	private Date birthday;
	private Map<String, String> teachers;
	private Address address;
	
	public Student() 
		
	
	
	public Student(Integer id, String name, String[] subject, Boolean graduated, Date birthday, Map<String, String> teachers, Address address) 
		super();
		this.id = id;
		this.name = name;
		this.subject = subject;
		this.graduated = graduated;
		this.birthday = birthday;
		this.teachers = teachers;
		this.address = address;
	
	
	@Override
	public String toString()  
		/*
		 * 重写类对象的toString方法 
		 */
		return "Student [id=" + this.id + 
			   ", name=" + this.name + 
			   ", subject=" + Arrays.toString(this.subject) + 
			   ", graduated=" + this.graduated.toString() + 
			   ", birthday=" + this.birthday + 
			   ", teachers=" + this.teachers.toString() + 
			   ", address=" + this.address.toString() + "]";
	

	public Integer getId() 
		return id;
	

	public void setId(Integer id) 
		this.id = id;
	

	public String getName() 
		return name;
	

	public void setName(String name) 
		this.name = name;
	

	public String[] getSubject() 
		return subject;
	

	public void setSubject(String[] subject) 
		this.subject = subject;
	

	public Boolean getGraduated() 
		return graduated;
	

	public void setGraduated(Boolean graduated) 
		this.graduated = graduated;
	

	public Date getBirthday() 
		return birthday;
	

	public void setBirthday(Date birthday) 
		this.birthday = birthday;
	

	public Map<String, String> getTeachers() 
		return teachers;
	

	public void setTeachers(Map<String, String> teachers) 
		this.teachers = teachers;
	

	public Address getAddress() 
		return address;
	

	public void setAddress(Address address) 
		this.address = address;

在com.example.demo再新建一个java类Address供以Student类调用

package com.example.demo.model;
public class Address 
	private String province;
	private String city;
	private String street;
	public Address() 
	
	@Override
	public String toString()  
		/*
		 * 重写类对象的toString方法 
		 */
		return "Adrress [province=" + this.province + ", city=" + this.city + ", street=" + this.street + "]";
	
	
	public String getProvince() 
		return this.province;
	
	
	public void setProvince(String province) 
		this.province = province;
	

	public String getCity() 
		return this.city;
	
	
	public void setCity(String city) 
		this.city = city;
	

	public String getStreet() 
		return this.street;
	
	
	public void setStreet(String street) 
		this.street = street;

使用@Component注解是为了将当前类加入IOC容器, 当前java类要读取yml配置文件的数据必须要求当前类也在IOC容器中
使用@ConfigurationProperties注解是为了将配置文件中的对应属性值注入当前组件
- prefix参数限定了配置文件中的属性范围, 此处指只有student属性中的数据会被注入(确切地说是以student开头的配置项)
在pom.xml配置文件中加入spring-boot-configuration-processor依赖后编写yml配置文件会根据@ConfigurationProperties注解标记的类生成提示👇

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

对应的配置文件application.yml中的student属性👇

student: 
  id: 1
  name: caoyang
  subject:
  - java
  - php
  - mysql
  graduated: false
  birthday: 1998/02/16
  teachers: 
	liweiping: Math
	ana: English
  address: 
	province: shanghai
	city: yangpu
	street: guoding

同理可以在对应的配置文件application.properties中写的student属性👇

student.id = 1
student.name = caoyang
student.subject = java,php,mysql
student.graduated = false
student.birthday = 1998/02/16
student.teachers.liweiping = Math
student.teachers.ana = English
student.address.province = shanghai
student.address.city = yangpu
student.address.street = guoding

最后修改src/test/java/文件夹中的com.example.demo包下的HelloworldApplicationTests.java, 进行单元测试查看javabean注入的情况👇

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.stereotype.Service;

import com.example.demo.model.Student;

@SpringBootTest
class HelloworldApplicationTests 
	
	/*
	 * 利用日志类来打印, 简单System.out.println也可以
	 */
	Logger logger = LoggerFactory.getLogger(HelloworldApplicationTests.class);
	
	@Autowired
	@Qualifier("Student")
	private Student student;
	
	@Test
	void contextLoads() 
		System.out.println(student.toString());
		logger.info("Hello world! Test...");
		logger.info(student.toString());

此时整个Helloworld目录架构应该如下所示（红框中的部分是本文已经提及的部分, 红线划掉的一个package和Demo.java是本文到此还没有提及的部分, 暂时没有不影响其他模块运行）

右键HelloworldApplicationTests.java(没有则新建它即可), 右键该文件Run As–>Junit Test即可, 可以看到测试结果显示了我们在HelloworldApplicationTests.java中logging的内容, 这表明Student类已经成功注入了application.yml配置文件中的信息👇
javabean注入中可能出现的问题:
- Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'java.lang.Integer' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations:
  - 关于No qualifying bean of type这种错误在百度上查询下来的解决方案千奇百怪, 不同人遇到的问题都不一样, 大概就是让你把Service, Component, Repository这些注解器添加全, 比如HelloworldApplicationTests.java中的@Qualifier("Student")与中的Student.java中的@Service("Student")就是配对的两个注解器, 前者调用bean时添加, 后者创建bean时调用, 其实笔者测试下来不添加这两个也不会报错; 或者又添加一些奇怪的依赖; 笔者最后排查出的结果是作为javabean的Student类忘记定义一个空的构造函数, 注意上文中的Student.java文件中是有两个构造参数的, 第一个是空构造函数, 这是bean所必要的, 否则就会无法识别为bean从而报错

Value注解器读取配置文件

@Value注解能够以更简单的方式读取配置文件中的值, 但是仅限于简单类型

配置文件

caoyang:
  message:
    config: "Hello world!"

单元测试

@Value("$caoyang.message.config")
private String message;

@Test
public void testValueAnnotation() 
	System.out.println(message);

日志输出级别配置: 编辑application.yml

全局配置(debug级别及以下的全部输出): 设置logging.level.root属性

logging:
  level:
    root: debug

指定某个包(以com.example.demo.model包为例)的日志打印级别:

logging: 
  level:
    com.example.demo.model: debug

3. spring-boot相关注解

Spring开发分基于xml和基于注解的开发

@Configuration:

用于注解一个类, 使得这个类成为配置类, 加载这个类中的配置可以取代以前的XML配置文件
基于注解类而不是XML配置文件创建IOC容器对象的代码如下:

ApplicationContext iocContainer = ew AnnotationConfigApplicationContext(SpringAnnotaionConfig.class)

@Bean:

相当于XML配置文件中的<bean>...</bean>标签, 用于把一个组件加入IOC容器

@Configuration
public class SpringAnnotationConfig 

    @Bean
    public EmployeeService getEmployeeService() 
        return new EmployeeService();

@Import

相对于@Bean注解, 可以更便捷地把一个组件加入IOC容器

@Configuration
@Import(EmployeeHandler.class)
public class SpringAnnotationConfig 
    # ...

@Conditional

一个类在满足特定条件时才会被加入IOC容器
下面包含很多的子注解器
- @ConditionalOnBean
- @ConditionalOnAvaliableEndpoint
- @ConditionalOnClass
- @ConditionalOnCloudPlatform
- …

@ComponentScan

指定IOC容器扫描的包, 相当于在XML中配置context:component-scan

@ComponentScan(
    value="com.example.demo.model",
    useDefaultFilters=false,
    includeFilters=@Filter(type=FilterType.ANNOTATION, classes=Controller.class),
    excludeFilters=@Filter(type=FilterType.ANNOTATION, classes=Service.class),
)

@SpringBootConfiguration

这就是@Configuration的spring-boot版本
源码中就是在SpringBootConfiguration类上添加了一个@Configuration注解

@EnableAutoConfiguration

启动自动化配置
SpringBoot通过@Import注解中的AutoConfigurationImportSelector.class将所有需要导入的组件以全类名的形式返回; 这些组件就会被添加到容器中, 给容器中导入非常多的自动配置类(xxxxAutoConfiguration), 这样就给容器中导入了这个场景需要的所有组件, 并配置好这些组件, 而这些组件以前是需要手动在XML中配置才能加入IOC容器的

@AutoConfigurationPackage

指定自动化配置的包
spring-boot通过@Import注解中的AutoConfigurationPackage.Registrar.class将主启动类所在的包和它的子包中所有组件扫描到IOC容器
避免了手动编写配置类

@SpringBootApplication

表明这是一个spring-boot类, 加上这个注解就相当于把6,7,8这些注解都包含进来了

4. spring-boot工作原理

读取spring.factories文件

spring-boot启动时会读取spring-boot-autoconfiguration-2.1.6.RELEASE.jar包下的META-INF/spring, 读取org.springframework.boot.autoconfigure.EnableAutoConfiguration属性的值加载自动配置类

加载XXXProperties类

根据自动配置类中指定的XXXProperties类设置自动配置的属性值, 开发者也可以根据XXXProperties类中指定的属性在yml配置文件中修改自动配置

根据@ConditionalXXX注解决定加载哪些组件

spring-boot通过@ConditionalXXX注解指定特定组件加入IOC容器时所需要具备的特定条件, 这个组件会在满足条件时加入IOC容器

流程一: pom.xml–> spring-boot-xxx-starter–> XXXAutoConfiguration–> @XXXConditional–> 决定加载到IOC容器的组件

流程二: pom.xml–> spring-boot-xxx-starter–> XXXAutoConfiguration–> ``XXXProperties` --> 读取默认配置(需要修改则到application.yml/.properties配置文件中修改)

主启动类上可能需要写这些注解@EnableXXX``````@ComponentScan``````@MapperScan

Next雷丰阳SpringBoot详细教程

以上是关于学习笔记从零开始的SpringBoot新手教程(WIN10+JDK9+STS4)的主要内容，如果未能解决你的问题，请参考以下文章

从零开始: Emacs 安装配置使用教程

《从零开始学Swift》学习笔记（Day4）——用Playground工具编写Swift

从零开始搭建框架SSM+Redis+Mysql之摘要

嘿从零开始基于SpringBoot 打造在线聊天室（4.4W字最长博文）

如何从零开始学python

python自学免费教程-怎样自学python编程？从零开始学习python，python开发入门到精通