zoukankan      html  css  js  c++  java

  • 《《《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基础阶段_结束语
    

     
    



     搜索
    

    



     
    


     示例代码的文件夹
    

    



    更多SpringBoot整合示例
    

    https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples
    


    P72 72_尚硅谷-SpringBoot高级-缓存-JSR107简介
    P73 73_尚硅谷-高级-缓存-Spring缓存抽象简介
    P74 74-高级-缓存-基本环境搭建
    P75 75-高级-缓存-@Cacheable初体验
    P76 76-尚硅谷-高级-缓存-缓存工作原理&@Cacheable运行流程
    P77 77-高级-缓存-@Cacheable其他属性
    P78 78-高级-缓存-@CachePut
    P79 79-高级-缓存-@CacheEvict
    P80 80-高级-缓存-@Caching&@CacheConfig
    P81 81-高级-缓存-搭建redis环境&测试
    P82 82-高级-缓存-RedisTemplate&序列化机制
    P83 83-高级-缓存-自定义CacheManager
    P84 84-高级-消息-JMS&AMQP简介
    P85 85-高级消-息-RabbitMQ基本概念简介
    P86 86-高级消息-RabbitMQ运行机制
    P87 87-高级-消息-RabbitMQ安装测试
    P88 88-高级-消息-RabbitTemplate发送接受消息&序列化机制
    P89 89-高级-消息-@RabbitListener&@EnableRabbit
    P90 90-高级-消息-AmqpAdmin管理组件的使用
    P91 91-高级-检索-Elasticsearch简介&安装
    P92 92-高级-检索-Elasticsearch快速入门
    P93 93-高级-检索-SpringBoot整合Jest操作Elasticsearch
    P94 94-高级-检索-整合SpringDataElasticsearch
    P95 95-高级-任务-异步任务
    

    新建一个service项目
    

    


    @Async和@EnableAsync要配合使用。service中添加的@Async注解表示告诉spring这是一个异步方法，启动类中添加@EnableAsync注解
    

    启动类中添加@EnableAsync注解
    

    

    新建一个controlle层进行测试
    

    

    P96 96-高级-任务-定时任务
    

    

     新建一个service文件夹，并添加@Scheduled(corn=)注解
    

    

    service中@Scheduled(corn=)注解和 启动类中@EnableScheduling注解要同时存在
    

    在启动类中添加@EnableScheduling注解，开启基于注解的定时任务
    

     测试查看控制台
    

    

    P97 97-高级-任务-邮件任务
    

    


    以qq邮箱发送给163邮箱为例：
    

     引入pom依赖
    

    


    邮箱发送的图解 
    

    


     1.简单的右键发送
    

    配置
    

    


     username:qq号
    

    password:填写授权码，不是qq邮箱的密码(见1.1)
    

    host:填写主机地址(见1.2)
    

    


     1.1
    

    


    把收到的授权码放为password
    

     
    

    1.2
    

    点击
    

    


    填写SMTP服务器中的内容
    

     
    

     启动并测试测试
    

    



     2.复杂邮件
    

     
    



     文件路径地址
    

    

    

    邮件中添加的内容样式没有变化，在后面添加true 进行开启
    

    


    测试
    

    

    P98 98-高级-安全-测试环境搭建
    

    

    P99 99-高级-安全-登录&认证&授权
    


    P100 100-高级-安全-权限控制&注销
    P101 101-高级-安全-记住我&定制登陆页
    P102 102-高级-分布式-dubbo简介
    P103 103-高级-分布式-docker安装zookeeper
    P104 104-尚硅谷-高级-分布式-SpringBoot、Dubbo、Zookeeper整合
    P105 105-高级-分布式-SpringCloud-Eureka注册中心
    P106 106-高级-分布式-服务注册
    P107 107-高级-分布式-服务发现&消费
    P108 108-高级-热部署-devtools开发热部署
    P109 109-高级-监管-监管端点测试
    P110 110-高级-监管-定制端点
    P111 111-高级-监管-自定义HealthIndicator
    


    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  linux初始化宏__init, __exit
                    
    linux内核initcall
                    
    常用命令合集
                    
    df
                    
    ln
                    
    cat
                    
    grep
                    
    find
                    
    IE11浏览器传时间格式不兼容，c.a.d.c.advice.AdcDaBaseExceptionAdvice : JSON parse error
                    
    js 图片不保存的回显功能/图片尺寸验证/图片大小验证 /图片类型验证
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/lidar/p/12951058.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看