《《《Spring Boot视频学习笔记

Spring Boot视频学习笔记

视频学习地址:https://www.bilibili.com/video/BV1Et411Y7tQ?p=1

尚硅谷springboot核心篇+整合篇配套资料
链接: https://pan.baidu.com/s/1Yfv05ncJoP_gOHB6cm9jdg 提取码: 9h5i 

1、如果在线解压提示有密码，请下载后解压。下载后解压都没有密码。
2、强烈建议先保存到自己的网盘内再下载，以免出现无法下载等情况。
3、如果百度云盘下载资料较慢，可进群下载。配套资料已全部上传至群文件。群文件下载速度较快。
3、SpringBoot技术交流： 939763282  
4、如果资源失效请您加群反馈，谢谢。

Spring Boot视频学习笔记——笔记：https://www.cnblogs.com/lidar/p/13371369.html

★★★★★★ 要学会看官方文档 ★★★★★★

P1 01、尚硅谷_SpringBoot_入门简介

P2 02、尚硅谷_入门-微服务简介
P3 03、尚硅谷_入门-环境准备

1.maven设置

2.idea设置

P4 04、尚硅谷_入门-springboot-helloworld

1.创建springBoot项目（忽略这种创建方法去P7看快速创建——》P7 07、尚硅谷_入门-使用向导快速创建Spring Boot应用）

右下角提示导入选择 Enable-Auto-Import（自动导入，后面写依赖就会自己导入）

2.导入springBoot相关的依赖

去springBoot官网（可以参考springBoot官方文档添加项目依赖）

3.编写主程序启动springBoot应用

4.编写相关Controller，Service等

5.启动项目

默认端口为8080

6.部署项目

调出侧边栏

打包

将打的 jar包拷贝出来

右键属性查看所在位置,并且复制位置

调出cmd窗口

输入cd+文件路径

项目启动成功

访问

1.父项目

2.导入的依赖

P5 05、尚硅谷_入门-HelloWorld细节-场景启动器（starter）

P6 06、尚硅谷_入门-HelloWorld细节-自动配置

P7 07、尚硅谷_入门-使用向导快速创建Spring Boot应用

注意：这种创建方式需要联网创建Spring Boot项目

注意：选择需要的模块，向导会联网创建Spring Boot项目

删除无用文件

查看pom.xml文件，已经导入部分依赖

新建一个类并写个测试方法测试

启动项目并测试

总结：

P8 08、尚硅谷_配置-yaml简介

yaml等于yml

P9 09、尚硅谷_配置-yaml语法

对空格多少个没有具体要求，但是要对应起来

P10 10、尚硅谷_配置-yaml配置文件值获取

新建Person的java类（里面包含Dog类）

新建Dog的java类

配置yml时候，比如lists中的内容如果写对了下面会显示对应的信息

配置时警告提示

问题：

Spring Boot configuration annotation processor not found in classpath

翻译：在类路径中找不到Spring Boot配置注释处理器

解决办法：点击Open Documentation...

跳转到提示网页

翻译：

通过使用springboot配置处理器jar，您可以很容易地从用@ConfigurationProperties注释的项生成自己的配置元数据文件。jar包含一个Java注释处理器，在编译项目时调用它。要使用处理器，请包含对springboot配置处理器的依赖性。

对于Maven，应将依赖项声明为可选，如下例所示：

打开连接https://docs.spring.io/spring-boot/docs/2.0.1.RELEASE/reference/html/configuration-metadata.html#configuration-metadata-annotation-processor，看下到底是什么回事，发现直接给了解决方法，那就是在pom.xml文件中加入依赖spring-boot-configuration-processor，至此问题解决。代码如下：

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

导入到pom.xml

导入完成之后提示重新运行SpringBoot

添加

@Component注解

@ConfigurationProperties(prefix = "")来绑定属性

prefix="yml中需要绑定的属性"

单元测试

yml中的值

P11 11、尚硅谷_配置-properties配置文件编码问题

测试出现中文乱码（乱码原因：idea默认使用的时utf-8）

解决办法

File—》Setting—》File Ebcoding

中文变成乱码，再重新写一下就好了

执行查看控制台

P12 12、尚硅谷_配置-@ConfigurationProperties与@Value区别

——————————————————————————————————————————————————————————————

P13 13、尚硅谷_配置-@PropertySource、@ImportResource、@Bean

resource—》new—》File

@PropertySource注解

测试

@ImportResource、@Bean

Spring Boot推荐用下面的方式给容器添加组件

P14 14、尚硅谷_配置-配置文件占位符

P15 15、尚硅谷_配置-Profile多环境支持

properties文件

示例：主配置文件

设置环境：

一：开发环境

设置开发环境端口号为 sercer.port=8082

生产环境端口号为 sercer.port=80

主配置文件激活环境

spring.profiles.active=

比如激活开发环境

yml文件

注意：

如果yml中不写

spring:
   profiles:
      active: dev

则默认

service
   port: 8081

P16 16、尚硅谷_配置-配置文件的加载位置

P17 17、尚硅谷_配置-外部配置加载顺序

查看控制台启动端口

查看网页 localhost:端口号/项目名称/接口名称

P18 18、尚硅谷_配置-自动配置原理

具体的自动配置类，参考官方文档

P19 19、尚硅谷_配置-@Conditional&自动配置报告

P20 20、尚硅谷_日志-日志框架分类和选择

P21 21、尚硅谷_日志-slf4j使用原理

slf4具体使用方法参考slf4官网 http://www.slf4j.org/

Java的简单日志记录外观（SLF4J）可作为各种日志记录框架（例如java.util.logging，logback和log4j）的简单外观或抽象。SLF4J允许最终用户在部署时插入所需的日志记录框架。请注意，启用SLF4J的库/应用程序意味着仅添加一个强制性依赖项，即 slf4j-api-2.0.0-alpha2-SNAPSHOT.jar。

日志的作用：日志是用来记录信息的,比如服务器的日志主要是用来记录一些运行信息,以便出现状况时,可以根据日志来判断原因。

类似于java代码中System.our.printly("需要打印的信息")功能

图片网址 http://www.slf4j.org/manual.html

P22 22、尚硅谷_日志-其他日志框架统一转换为slf4j

具体网址 http://www.slf4j.org/legacy.html

比如其他框架使用了其他的日志进行日志打印，可以根据slf4官方文档进行替换依赖的底层jar包，进行同意使用slf4进行输出

P23 23、尚硅谷_日志-SpringBoot日志关系

查看pom中的依赖关系

打开pom.xml—》在pom文件中鼠标右键—》Diagrams—》show Dependecies...

以图谱的方式展示整个依赖关系

springBoot底层依赖关系

P24 24、尚硅谷_日志-SpringBoot默认配置

单元测试日志级别

application.properties中配置日志

P25 25、尚硅谷_日志-指定日志文件和日志Profile功能

logback-spring.xml文件名（要加上-spring，不然不能识别）

激活开发环境

P26 26、尚硅谷_日志-切换日志框架

P27 27、尚硅谷_SpringBoot_web开发-简介

P28 28、尚硅谷_web开发-webjars&静态资源映射规则

启动项目，访问引入的jquery依赖路径，看是否访问成功

P29 29、尚硅谷_web开发-引入thymeleaf

参考thymeleaf官方文档，查看thymeleaf的使用方法

引入Thymeleaf依赖

SpringBoot默认的Thymeleaf是2.1.6版本，版本太低可以进行更改版本

百度去githup查找最新版本（Thymeleaf主要在githup上）

点击release

在springBoot官网复制下面内容，手动更改版本号就可以

在githup搜索thymeleaf-layout-dialect

点击

修改后的依赖

P30 30、尚硅谷_web开发-thymeleaf语法

写个接口测试templates

在templates下新建一个html

访问接口

参考thymeleaf官方文档，查看thymeleaf的使用方法

https://www.thymeleaf.org/

可以找的thymeleaf的pdf版本进行保存

在下载下来的pdf中找到Using Texts

在html文件中导入下xmlns:th="http://www.thymeleaf.org"(作用：可以语法提示)

html文件中获取controlle中的map中的"你好"

1.不经过模板引擎thymeleaf解析

如果把html文件复制到本地

显示的是前端信息

双击打开

2.经过模板引擎thymeleaf解析

P31 31、尚硅谷_web开发-SpringMVC自动配置原理

https://www.bilibili.com/video/BV1Et411Y7tQ?p=31

视图解析器
P32 32、尚硅谷_web开发-扩展与全面接管SpringMVC

https://www.bilibili.com/video/BV1Et411Y7tQ?p=32
P33 33、尚硅谷_web开发-【实验】-引入资源

登录跳转页面

登录方法一（直接写接口的方式)：

登录方式二（使用视图解析器）：

修改登录页名称

P34 34、尚硅谷_web开发-【实验】-国际化

P35 35、尚硅谷_web开发-【实验】-登陆&拦截器

密码校验接口

登录拦截器（比如在谷歌浏览器账号密码登录了，把链接地址复制粘贴到火狐浏览器也可以访问。使用登录拦截器没有登录不让其访问）

实现HandlerInterceptor方法

添加未实现的方法

Alt+Enter键

作用：就是登录状态检查的拦截器

把登录信息放在session中（用户就会在session中存在）

P36 36、尚硅谷_web开发-【实验】-Restful实验要求
P37 37、尚硅谷_web开发-【实验】-员工列表-公共页抽取
P38 38、尚硅谷_web开发-【实验】-员工列表-链接高亮&列表完成
P39 39、尚硅谷_web开发-【实验】-员工添加-来到添加页面
P40 40、尚硅谷_web开发-【实验】-员工添加-添加完成
P41 41、尚硅谷_web开发-【实验】-员工修改-重用页面&修改完成
P42 42、尚硅谷_web开发-【实验】-员工删除-删除完成
P43 43、尚硅谷_web开发-错误处理原理&定制错误页面
P44 44、尚硅谷_web开发-定制错误数据
P45 45、尚硅谷_web开发-嵌入式Servlet容器配置修改

P46 46、尚硅谷_web开发-注册servlet三大组件
P47 47、尚硅谷_web开发-切换其他嵌入式Servlet容器
P48 48、尚硅谷_web开发-嵌入式Servlet容器自动配置原理
P49 49、尚硅谷_web开发-嵌入式Servlet容器启动原理
P50 50、尚硅谷_web开发-使用外部Servlet容器&JSP支持
P51 51、尚硅谷_web开发-外部Servlet容器启动SpringBoot应用原理
P52 52、尚硅谷_Docker-简介
P53 53、尚硅谷_Docker-核心概念
P54 54、尚硅谷_Docker-linux环境准备
P55 55、尚硅谷_Docker-docker安装&启动&停止
P56 56、尚硅谷_Docker-docker镜像操作常用命令
P57 57、尚硅谷_Docker-docker容器操作常用命令
P58 58、尚硅谷_Docker-docker安装MySQL
P59 59、尚硅谷_数据访问-简介

P60 60、尚硅谷_数据访问-JDBC&自动配置原理

新建一个项目

通过上面选择的 mysql，jdbc

创建好项目之后自动引入的依赖 mysql，jdbc的依赖

新建一个数据库

数据库名称:jdbc

yml配置连接数据库

测试

测试结果

项目启动在数据库自动创建表

方式一：

1.把拷贝的建表的sql放到文件夹resources文件夹下

2.把拷贝的sql文件改成名字为:schema-all.sql（必须改成这个名称，不然不识别）

schema-all.sql

启动项目

控制台显示创建sql语句成功

去数据库查看创建的表

方式二：

1.把拷贝的建表的sql放到文件夹resources文件夹下

2.把拷贝的sql文件名字不改为schema-all.sql配置yml也可以实现

schema:
   - classpath:department.sql

自动配置原理

controller接口测试

数据库添加一条数据进行测试

访问接口

P61 61、尚硅谷_数据访问-整合Druid&配置数据源监控

引入druid数据源

yml中指定数据源的属性

查看控制台中的数据源变成DruidDataSource

把参数放到yml中（注意对齐）

创建一个类

查看控制台

整合Druid数据源

 1 导入druid数据源
 2 @Configuration
 3 public class DruidConfig {
 4 
 5     @ConfigurationProperties(prefix = "spring.datasource")
 6     @Bean
 7     public DataSource druid(){
 8        return  new DruidDataSource();
 9     }
10 
11     //配置Druid的监控
12     //1、配置一个管理后台的Servlet
13     @Bean
14     public ServletRegistrationBean statViewServlet(){
15         ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
16         Map<String,String> initParams = new HashMap<>();
17 
18         initParams.put("loginUsername","admin");
19         initParams.put("loginPassword","123456");
20         initParams.put("allow","");//默认就是允许所有访问
21         initParams.put("deny","192.168.15.21");
22 
23         bean.setInitParameters(initParams);
24         return bean;
25     }
26 
27 
28     //2、配置一个web监控的filter
29     @Bean
30     public FilterRegistrationBean webStatFilter(){
31         FilterRegistrationBean bean = new FilterRegistrationBean();
32         bean.setFilter(new WebStatFilter());
33 
34         Map<String,String> initParams = new HashMap<>();
35         initParams.put("exclusions","*.js,*.css,/druid/*");
36 
37         bean.setInitParameters(initParams);
38 
39         bean.setUrlPatterns(Arrays.asList("/*"));
40 
41         return  bean;
42     }
43 }

P62 62、尚硅谷_数据访问-整合MyBatis（一）-基础环境搭建

新建项目

选模块

MySql：数据库，JDBC：配置数据源

新建数据库

yml中配置数据库

整合Druid数据源

 1 导入druid数据源
 2 @Configuration
 3 public class DruidConfig {
 4 
 5     @ConfigurationProperties(prefix = "spring.datasource")
 6     @Bean
 7     public DataSource druid(){
 8        return  new DruidDataSource();
 9     }
10 
11     //配置Druid的监控
12     //1、配置一个管理后台的Servlet
13     @Bean
14     public ServletRegistrationBean statViewServlet(){
15         ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
16         Map<String,String> initParams = new HashMap<>();
17 
18         initParams.put("loginUsername","admin");
19         initParams.put("loginPassword","123456");
20         initParams.put("allow","");//默认就是允许所有访问
21         initParams.put("deny","192.168.15.21");
22 
23         bean.setInitParameters(initParams);
24         return bean;
25     }
26 
27 
28     //2、配置一个web监控的filter
29     @Bean
30     public FilterRegistrationBean webStatFilter(){
31         FilterRegistrationBean bean = new FilterRegistrationBean();
32         bean.setFilter(new WebStatFilter());
33 
34         Map<String,String> initParams = new HashMap<>();
35         initParams.put("exclusions","*.js,*.css,/druid/*");
36 
37         bean.setInitParameters(initParams);
38 
39         bean.setUrlPatterns(Arrays.asList("/*"));
40 
41         return  bean;
42     }
43 }

把上面的 “导入druid数据源” 的代码放到新建DruidConfig类中

访问

配置sql建表语句

数据库中表创建成功

根据数据库创建javaBean

注意数据库中创建表成功，在yml中把创建表配置给注释掉

P63 63、尚硅谷_数据访问-整合MyBatis（二）-注解版MyBatis

方式一：注解配置的方式写sql语句

新建一个Mapper用来操作数据库

用注解的方式写增删改查

写一个Controller进行测试

Controller层直接引入Mapper层

测试

插入时返回id为空，

比如：

在Mapper中配置下

@Options注解

配置完

数据库中字段名称使用下划线方式，用在Mapper中使用注解方式无法获取到值

比如：

departmentName——》department_name

改为

修改Mapper中字段，与数据库保持一致

测试

没有查到数据（封装不上）

原因：因为实例类中的字段为departmentName数据库中的字段为department_name 所以匹配不上

解决方法

新建一个表在代码中开启驼峰命名法

测试

把Mapper中的@Mapper注解给注释掉，在SpringBootApplication中添加MapperScan("")注解统一配置

在启动类中配置@MapperScan("") 让其自动扫描Mapper包中的Mapper文件

P64 64、尚硅谷_数据访问-整合MyBatis（二）-配置版MyBatis

方式二：xml 配置文件的方式写sql语句

创建一个Mapper接口类

mybatis映射文件托管到github中，百度搜索查找

在搜索框输入 mybatis 并查询

往下拉找到 mybatis3/mybatis3-3 并点击

找到下面，复制粘贴出来

配置sql映射文件

全局配置文件：在resource/mybatis下新建mybatis-config.xml全局配置文件

把拷贝出来的代码放到新建的mybatis-config.xml文件中，并删除部分不用代码

删除后的样子

找到 Exploting Mapped SQL Statements

sql映射文件：在resource/mybatis下新建mapper文件夹，并新建EmployeeMapper.xml映射文件

复制粘贴到新建的EmployeeMapper.xml文件中

写方法

配置yml

mybatis引入mybatis.config-location(Location of ...)

全局配置中开启驼峰命名法

测试

输入地址测试

P65 65、尚硅谷_数据访问-SpringData JPA简介

P66 66、尚硅谷_数据访问-整合JPA

新建一个工程项目

配置数据源

1.新建一个数据库

2.新建一个实体类

3.编写一个Dao接口来操作实体类对应的数据表（Repository）

JpaRepository<实体类，主键的数据类型>

yml

新建一个controller并测试

测试

-----------------------------------------------------------------------------------------------------------------------------

1）、编写一个实体类（bean）和数据表进行映射，并且配置好映射关系；

//使用JPA注解配置映射关系
@Entity //告诉JPA这是一个实体类（和数据表映射的类）
@Table(name = "tbl_user") //@Table来指定和哪个数据表对应;如果省略默认表名就是user；
public class User {

    @Id //这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
    private Integer id;

    @Column(name = "last_name",length = 50) //这是和数据表对应的一个列
    private String lastName;
    @Column //省略默认列名就是属性名
    private String email;

2）、编写一个Dao接口来操作实体类对应的数据表（Repository）

//继承JpaRepository来完成对数据库的操作
public interface UserRepository extends JpaRepository<User,Integer> {
}

3）、基本的配置JpaProperties

spring:  
 jpa:
    hibernate:
#     更新或者创建数据表结构
      ddl-auto: update
#    控制台显示SQL
    show-sql: true

P67 67、尚硅谷_原理-第一步：创建SpringApplication

启动配置原理

几个重要的事件回调机制

配置在META-INF/spring.factories

ApplicationContextInitializer

SpringApplicationRunListener

只需要放在ioc容器中

ApplicationRunner

CommandLineRunner

启动流程：

1、创建SpringApplication对象

 1 initialize(sources);
 2 private void initialize(Object[] sources) {
 3     //保存主配置类
 4     if (sources != null && sources.length > 0) {
 5         this.sources.addAll(Arrays.asList(sources));
 6     }
 7     //判断当前是否一个web应用
 8     this.webEnvironment = deduceWebEnvironment();
 9     //从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来
10     setInitializers((Collection) getSpringFactoriesInstances(
11         ApplicationContextInitializer.class));
12     //从类路径下找到ETA-INF/spring.factories配置的所有ApplicationListener
13     setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
14     //从多个配置类中找到有main方法的主配置类
15     this.mainApplicationClass = deduceMainApplicationClass();
16 }

P68 68、尚硅谷_原理-第二步：启动应用

运行run方法

具体代码

 1 public ConfigurableApplicationContext run(String... args) {
 2    StopWatch stopWatch = new StopWatch();
 3    stopWatch.start();
 4    ConfigurableApplicationContext context = null;
 5    FailureAnalyzers analyzers = null;
 6    configureHeadlessProperty();
 7     
 8    //获取SpringApplicationRunListeners；从类路径下META-INF/spring.factories
 9    SpringApplicationRunListeners listeners = getRunListeners(args);
10     //回调所有的获取SpringApplicationRunListener.starting()方法
11    listeners.starting();
12    try {
13        //封装命令行参数
14       ApplicationArguments applicationArguments = new DefaultApplicationArguments(
15             args);
16       //准备环境
17       ConfigurableEnvironment environment = prepareEnvironment(listeners,
18             applicationArguments);
19                //创建环境完成后回调SpringApplicationRunListener.environmentPrepared()；表示环境准备完成
20        
21       Banner printedBanner = printBanner(environment);
22        
23        //创建ApplicationContext；决定创建web的ioc还是普通的ioc
24       context = createApplicationContext();
25        
26       analyzers = new FailureAnalyzers(context);
27        //准备上下文环境;将environment保存到ioc中；而且applyInitializers()；
28        //applyInitializers()：回调之前保存的所有的ApplicationContextInitializer的initialize方法
29        //回调所有的SpringApplicationRunListener的contextPrepared()；
30        //
31       prepareContext(context, environment, listeners, applicationArguments,
32             printedBanner);
33        //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded（）；
34        
35        //s刷新容器；ioc容器初始化（如果是web应用还会创建嵌入式的Tomcat）；Spring注解版
36        //扫描，创建，加载所有组件的地方；（配置类，组件，自动配置）
37       refreshContext(context);
38        //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
39        //ApplicationRunner先回调，CommandLineRunner再回调
40       afterRefresh(context, applicationArguments);
41        //所有的SpringApplicationRunListener回调finished方法
42       listeners.finished(context, null);
43       stopWatch.stop();
44       if (this.logStartupInfo) {
45          new StartupInfoLogger(this.mainApplicationClass)
46                .logStarted(getApplicationLog(), stopWatch);
47       }
48        //整个SpringBoot应用启动完成以后返回启动的ioc容器；
49       return context;
50    }
51    catch (Throwable ex) {
52       handleRunFailure(context, listeners, analyzers, ex);
53       throw new IllegalStateException(ex);
54    }
55 }

P69 69、尚硅谷_原理-事件监听机制相关测试

配置在META-INF/spring.factories

ApplicationContextInitializer

public class HelloApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
    }
}

SpringApplicationRunListener

public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {

    //必须有的构造器
    public HelloSpringApplicationRunListener(SpringApplication application, String[] args){

    }

    @Override
    public void starting() {
        System.out.println("SpringApplicationRunListener...starting...");
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        Object o = environment.getSystemProperties().get("os.name");
        System.out.println("SpringApplicationRunListener...environmentPrepared.."+o);
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...contextPrepared...");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...contextLoaded...");
    }

    @Override
    public void finished(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("SpringApplicationRunListener...finished...");
    }
}

配置（META-INF/spring.factories）

org.springframework.context.ApplicationContextInitializer=
com.atguigu.springboot.listener.HelloApplicationContextInitializer

org.springframework.boot.SpringApplicationRunListener=
com.atguigu.springboot.listener.HelloSpringApplicationRunListener

只需要放在ioc容器中

ApplicationRunner

@Component
public class HelloApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner...run....");
    }
}

CommandLineRunner

@Component
public class HelloCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
    }
}

P70 70、尚硅谷_原理-自定义starter

starter：

1、这个场景需要使用到的依赖是什么？

2、如何编写自动配置

@Configuration  //指定这个类是一个配置类
@ConditionalOnXXX  //在指定条件成立的情况下自动配置类生效
@AutoConfigureAfter  //指定自动配置类的顺序
@Bean  //给容器中添加组件

@ConfigurationPropertie结合相关xxxProperties类来绑定相关的配置
@EnableConfigurationProperties //让xxxProperties生效加入到容器中

自动配置类要能加载
将需要启动就加载的自动配置类，配置在META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,

3、模式：

启动器只用来做依赖导入；

专门来写一个自动配置模块；

启动器依赖自动配置；别人只需要引入启动器（starter）

mybatis-spring-boot-starter；自定义启动器名-spring-boot-starter

步骤：

1）、启动器模块

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <modelVersion>4.0.0</modelVersion>
 6 
 7     <groupId>com.atguigu.starter</groupId>
 8     <artifactId>atguigu-spring-boot-starter</artifactId>
 9     <version>1.0-SNAPSHOT</version>
10 
11     <!--启动器-->
12     <dependencies>
13 
14         <!--引入自动配置模块-->
15         <dependency>
16             <groupId>com.atguigu.starter</groupId>
17             <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
18             <version>0.0.1-SNAPSHOT</version>
19         </dependency>
20     </dependencies>
21 
22 </project>

2）、自动配置模块

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 4    <modelVersion>4.0.0</modelVersion>
 5 
 6    <groupId>com.atguigu.starter</groupId>
 7    <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
 8    <version>0.0.1-SNAPSHOT</version>
 9    <packaging>jar</packaging>
10 
11    <name>atguigu-spring-boot-starter-autoconfigurer</name>
12    <description>Demo project for Spring Boot</description>
13 
14    <parent>
15       <groupId>org.springframework.boot</groupId>
16       <artifactId>spring-boot-starter-parent</artifactId>
17       <version>1.5.10.RELEASE</version>
18       <relativePath/> <!-- lookup parent from repository -->
19    </parent>
20 
21    <properties>
22       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
23       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
24       <java.version>1.8</java.version>
25    </properties>
26 
27    <dependencies>
28 
29       <!--引入spring-boot-starter；所有starter的基本配置-->
30       <dependency>
31          <groupId>org.springframework.boot</groupId>
32          <artifactId>spring-boot-starter</artifactId>
33       </dependency>
34 
35    </dependencies>
36 
37 </project>

 1 package com.atguigu.starter;
 2 
 3 import org.springframework.boot.context.properties.ConfigurationProperties;
 4 
 5 @ConfigurationProperties(prefix = "atguigu.hello")
 6 public class HelloProperties {
 7 
 8     private String prefix;
 9     private String suffix;
10 
11     public String getPrefix() {
12         return prefix;
13     }
14 
15     public void setPrefix(String prefix) {
16         this.prefix = prefix;
17     }
18 
19     public String getSuffix() {
20         return suffix;
21     }
22 
23     public void setSuffix(String suffix) {
24         this.suffix = suffix;
25     }
26 }

 1 package com.atguigu.starter;
 2 
 3 public class HelloService {
 4 
 5     HelloProperties helloProperties;
 6 
 7     public HelloProperties getHelloProperties() {
 8         return helloProperties;
 9     }
10 
11     public void setHelloProperties(HelloProperties helloProperties) {
12         this.helloProperties = helloProperties;
13     }
14 
15     public String sayHellAtguigu(String name){
16         return helloProperties.getPrefix()+"-" +name + helloProperties.getSuffix();
17     }
18 }

 1 package com.atguigu.starter;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
 5 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 6 import org.springframework.context.annotation.Bean;
 7 import org.springframework.context.annotation.Configuration;
 8 
 9 @Configuration
10 @ConditionalOnWebApplication //web应用才生效
11 @EnableConfigurationProperties(HelloProperties.class)
12 public class HelloServiceAutoConfiguration {
13 
14     @Autowired
15     HelloProperties helloProperties;
16     @Bean
17     public HelloService helloService(){
18         HelloService service = new HelloService();
19         service.setHelloProperties(helloProperties);
20         return service;
21     }
22 }

P71 71、尚硅谷_SpringBoot基础阶段_结束语

搜索

示例代码的文件夹