SpringBoot3【① 基本框架原理+常用注解及其底层+AOP底层原理+yaml和日志框架】

SpringBoot3-特性介绍和快速入门

1、简介

1. 前置知识

• Java17
• Spring、SpringMVC、MyBatis
• Maven、IDEA

2. 环境要求

3. SpringBoot是什么

SpringBoot 帮我们简单、快速地创建一个独立的、生产级别的 Spring 应用（说明：SpringBoot底层是Spring）
大多数 SpringBoot 应用只需要编写少量配置即可快速整合 Spring 平台以及第三方技术
特性：

• 快速创建独立 Spring 应用
  • SSM：导包、写配置、启动运行
• 直接嵌入Tomcat、Jetty or Undertow（无需部署 war 包）【Servlet容器】
  • linux java tomcat mysql： war 放到 tomcat 的 webapps下
  • jar： java环境； java -jar
• 重点：提供可选的starter，简化应用整合
  • 场景启动器（starter）：web、json、邮件、oss（对象存储）、异步、定时任务、缓存…
  • 导包一堆，控制好版本。
  • 为每一种场景准备了一个依赖； web-starter。mybatis-starter
• 重点：按需自动配置 Spring 以及 第三方库
  • 如果这些场景我要使用（生效）。这个场景的所有配置都会自动配置好。
  • 约定大于配置：每个场景都有很多默认配置。
  • 自定义：配置文件中修改几项就可以
• 提供生产级特性：如 监控指标、健康检查、外部化配置等
  • 监控指标、健康检查（k8s）、外部化配置
• 无代码生成、无xml

总结：简化开发，简化配置，简化整合，简化部署，简化监控，简化运维。

2、快速体验

场景：浏览器发送 /hello请求，返回"Hello,Spring Boot 3!"

1. 开发流程

1. 创建项目

这里我们创建一个空项目spring-boot-3，然后新建子项目boot3-01-demo，并在父工程导入springboot的依赖。

<!--    所有springboot项目都必须继承自 spring-boot-starter-parent -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.1</version>
    </parent>
1
2
3
4
5
6

2. 导入场景

场景启动器

    <dependencies>
<!--        web开发的场景启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7

3. 主程序

创建boot包，写主程序
我的SpringMVC笔记，看Restful和@ResponceBody部分

//@Controller
//@ResponseBody
@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(){

        return "Hellom Spring Boot 3 !";
    }
}
1
2
3
4
5
6
7
8
9
10
11

4. 业务

然后在boot包内写controller包下写HelloController。
springboot的包扫描逻辑是只扫描主程序当前包及其子包

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(){

        return "Hello,Spring Boot 3!";
    }
}
1
2
3
4
5
6
7
8
9

5. 测试

默认启动访问： localhost:8080

6. 打包

<!--    SpringBoot应用打包插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
1
2
3
4
5
6
7
8
9

mvn clean package把项目打成可执行的jar包
java -jar demo.jar启动项目
如果卡住可能是cmd控制台打开了快速编辑模式

2. 特性小结

1. 简化整合

导入相关的场景，拥有相关的功能。场景启动器
默认支持的所有场景 （官方） ：官方给的场景列表
● 官方提供的场景：命名为：spring-boot-starter-*
● 第三方提供场景：命名为：*-spring-boot-starter

场景一导入，万物皆就绪

2. 简化开发

无需编写任何配置，直接开发业务

3. 简化配置

application.properties：
● 集中式管理配置。只需要修改这个文件就行 。
● 配置基本都有默认值
● 能写的所有配置都在： 官方提供的各种配置的默认值和可配置的参数列表

4. 简化部署

打包为可执行的jar包。
linux服务器上有java环境。

5. 简化运维

修改配置（外部放一个application.properties文件）、监控、健康检查。
…

3. Spring Initializr 创建向导

一键创建好整个项目结构

3、应用分析

1. 依赖管理机制

思考：
1、为什么导入starter-web所有相关依赖都导入进来？

• 开发什么场景，导入什么场景启动器。
• maven依赖传递原则。A-B-C： A就拥有B和C
• 导入 场景启动器。 场景启动器 自动把这个场景的所有核心依赖全部导入进来

2、为什么版本号都不用写？

• 每个boot项目都有一个父项目spring-boot-starter-parent

• parent的父项目是spring-boot-dependencies

• 父项目 版本仲裁中心，把所有常见的jar的依赖版本都声明好了。

• 

• 比如：mysql-connector-j

3、自定义版本号(如果不想使用官方的)

• 可以利用maven的就近原则
  • ①直接在当前项目properties标签中声明父项目用的版本属性的key
  • 
  • ②直接在导入依赖的时候声明版本
  • 

4、第三方的jar包

• boot父项目没有管理的需要自行声明好

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.16</version>
</dependency>
1
2
3
4
5
6

2. 自动配置机制

1. 初步理解

• 自动配置的 Tomcat、SpringMVC 等
  • 导入场景，容器中就会自动配置好这个场景的核心组件。
  • 以前：DispatcherServlet、ViewResolver、CharacterEncodingFilter…
  • 现在：自动配置好的这些组件
  • 验证：容器中有了什么组件，就具有什么功能

    public static void main(String[] args) {

        //java10： 局部变量类型的自动推断
        var ioc = SpringApplication.run(MainApplication.class, args);

        //1、获取容器中所有组件的名字
        String[] names = ioc.getBeanDefinitionNames();
        //2、挨个遍历：
        // dispatcherServlet、beanNameViewResolver、characterEncodingFilter、multipartResolver
        // SpringBoot把以前配置的核心组件现在都给我们自动配置好了。
        for (String name : names) {
            System.out.println(name);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 默认的包扫描规则
  • @SpringBootApplication 标注的类就是主程序类
  • SpringBoot只会扫描主程序所在的包及其下面的子包，自动的component-scan功能，在此包之外，哪怕写了MVC的组件注解也无法扫描存入IOC容器之中
  • 自定义扫描路径(如果非要放在默认之外，需要给注解加内容配置)
    • ①@SpringBootApplication(scanBasePackages = "com.fanxy")
    • ② @ComponentScan("com.fanxy") 直接指定扫描的路径，这是因为上面的 @SpringBootApplication 注解包含内嵌了三个注解：@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan
• 配置默认值
  • 配置文件的所有配置项是和某个类的对象值进行一一绑定的。(可以在配置文件中利用server.port=xxxx配置，然后使用ctrl + 左键 进入对应的一个类ServerProperties)
  • 绑定了配置文件中每一项值的类： 属性类。
  • 比如：
    • ServerProperties绑定了所有Tomcat服务器有关的配置
    • MultipartProperties绑定了所有文件上传相关的配置
    • …参照官方文档：或者参照 绑定的 属性类。
• 按需加载自动配置
  • 导入场景spring-boot-starter-web
  • 场景启动器除了会导入相关功能依赖，导入一个spring-boot-starter，是所有starter的starter，基础核心starter
  • spring-boot-starter导入了一个包 spring-boot-autoconfigure。包里面都是各种场景的AutoConfiguration 自动配置类
  • 虽然全场景的自动配置都在 spring-boot-autoconfigure这个包，但是不是全都开启的。
    • 导入哪个场景就开启哪个自动配置

总结： 导入场景启动器、触发 spring-boot-autoconfigure这个包的自动配置生效、容器中就会具有相关场景的功能

2. 完整流程

思考：
1、SpringBoot怎么实现导一个starter、写一些简单配置，应用就能跑起来，我们无需关心整合
2、为什么Tomcat的端口号可以配置在application.properties中，并且Tomcat能启动成功？
3、导入场景后哪些自动配置能生效？

自动配置流程细节梳理：
1、 导入starter-web：导入了web开发场景

• 1、场景启动器导入了相关场景的所有依赖：starter-json、starter-tomcat、springmvc
• 2、每个场景启动器都引入了一个spring-boot-starter，核心场景启动器。
• 3、核心场景启动器引入了spring-boot-autoconfigure包。
• 4、spring-boot-autoconfigure里面囊括了所有场景的所有配置。
• 5、只要这个包下的所有类都能生效，那么相当于SpringBoot官方写好的整合功能就生效了。
• 6、SpringBoot默认却扫描不到 spring-boot-autoconfigure下写好的所有配置类。（这些配置类给我们做了整合操作），默认只扫描主程序所在的包。但利用下面主程序的注解就做到了导入。

2、 主程序：@SpringBootApplication

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {---------}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 1、@SpringBootApplication由三个注解组成@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan
• 2、SpringBoot默认只能扫描自己主程序所在的包及其下面的子包，扫描不到 spring-boot-autoconfigure包中官方写好的配置类
• 3、@EnableAutoConfiguration：SpringBoot 开启自动配置的核心。
  
  这个注解可以@Import导入下面的类，这个类的作用其实是批量导入组件，@import将指定的类或配置文件导入到当前类中，可以用于导入其他类的定义、配置文件等，但不会将其加入到IOC容器中。这个类内部的方法还获取了一些注册信息，其实调试发现就是主程序所在的包的路径，故帮助我们扫描主程序所在的包和子包路径下所有组件
  

• 1. 是由上图1的注解@Import(AutoConfigurationImportSelector.class)提供功能：批量给容器中导入组件。利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
     调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
     利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader);得到所有的组件
     从META-INF/spring.factories位置来加载一个文件。
     默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
     spring-boot-autoconfigure-x.x.x.RELEASE.jar包里面也有META-INF/spring.factories 最新版本springboot其实换了文件路径——>来自于spring-boot-autoconfigure下 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports**
• 2. SpringBoot启动会默认加载 142个配置类。上面的主程序自带的注解会排除一些
• 3. 这142个配置类来自于spring-boot-autoconfigure下 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件指定的

• 

• 项目启动的时候利用 @Import 批量导入组件机制把 autoconfigure 包下的142 xxxxAutoConfiguration类导入进来（自动配置类）

• 虽然导入了142个自动配置类

• 4、按需生效：

  • 并不是这142个自动配置类都能生效
  • 每一个自动配置类，都有条件注解@ConditionalOnxxx，只有条件成立，才能生效

3、 xxxxAutoConfiguration 自动配置类
● 1、给容器中使用@Bean 放一堆组件。
● 2、每个自动配置类都可能有这个注解@EnableConfigurationProperties(ServerProperties.class)，用来把配置文件中配的指定前缀的属性值封装到 xxxProperties属性类中，而一些组件如Tomcat，内置了带默认值的构造函数，所以带有默认值。而这个自动配置类中有一些定制化器类，如果带有@Bean注解，他们的构造函数可能会带有参数 ServerProperties serverProperties，带有@Bean注解的类的形参如果容器已经有了相同类型的对象，会自动放入赋值
● 3、以 Tomcat 为例：把服务器的所有配置都是以server开头的。配置都封装到了属性类中。
● 4、给容器中放的所有组件的一些核心参数，都来自于xxxProperties。xxxProperties都是和配置文件绑定（这些类都通过@EnableConfigurationProperties(xxxx)注解把前缀修饰）
● 只需要改配置文件的值，核心组件的底层参数都能修改

4、 写业务，全程无需关心各种整合（底层这些整合写好了，而且也生效了）

核心流程总结：
1、导入starter，就会导入autoconfigure包。
2、autoconfigure 包里面 有一个文件 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports,里面指定的所有启动要加载的自动配置类
3、@EnableAutoConfiguration 会自动的把上面文件里面写的所有自动配置类都导入进来。xxxAutoConfiguration 是有条件注解进行按需加载
4、符合需求条件的情况下xxxAutoConfiguration给容器中导入一堆组件，组件都是从 xxxProperties中提取属性值
5、xxxProperties又是和配置文件进行了绑定

效果：导入starter、修改配置文件，就能修改底层行为。

3. 如何学好SpringBoot

框架的框架、底层基于Spring。能调整每一个场景的底层行为。100%项目一定会用到底层自定义
摄影：

• 傻瓜：自动配置好。
• 单反：焦距、光圈、快门、感光度…
• 傻瓜+单反：

1. 理解自动配置原理
   a. 导入starter --> 生效xxxxAutoConfiguration --> 组件 --> xxxProperties --> 配置文件
2. 理解其他框架底层
   a. 如Mybatis的拦截器，和Springboot框架无关，不懂别的框架底层就不可能写好
3. 可以随时定制化任何组件
   a. 配置文件
   b. 自定义组件

普通开发：导入starter，Controller、Service、Mapper、偶尔修改配置文件
高级开发：自定义组件、自定义配置、自定义starter
核心：
● 这个场景自动配置导入了哪些组件，我们能不能Autowired进来使用
● 能不能通过修改配置改变组件的一些默认参数
● 需不需要自己完全定义这个组件
● 场景定制化

最佳实战：

• 选场景，导入到项目
  • 官方：starter
  • 第三方：去仓库搜
• 写配置，改配置文件关键项
  • 数据库参数（连接地址、账号密码…）
• 分析这个场景给我们导入了哪些能用的组件，可以配置文件开启debug=true，生成自动配置报告，然后去分析开启的和没有开启的组件
  • 自动装配这些组件进行后续使用
  • 不满意boot提供的自动配好的默认组件
    • 定制化
      • 改配置
      • 自定义组件
        整合redis：
• 选场景：spring-boot-starter-data-redis
  • 场景AutoConfiguration 就是这个场景的自动配置类
• 写配置：
  • 分析到这个场景的自动配置类开启了哪些属性绑定关系
  • @EnableConfigurationProperties(RedisProperties.class)
  • 修改redis相关的配置
• 分析组件：
  • 分析到 RedisAutoConfiguration 给容器中放了 StringRedisTemplate
  • 给业务代码中自动装配 StringRedisTemplate
• 定制化
  • 修改配置文件
  • 自定义组件，自己给容器中放一个 StringRedisTemplate

4、核心技能

1. 常用注解

SpringBoot摒弃XML配置方式，改为全注解驱动

1. 组件注册

@Configuration、@SpringBootConfiguration
@Bean、@Scope
@Controller、 @Service、@Repository、@Component
@Import
@ComponentScan

以前的步骤：通过spring配置文件，如果纯xml配置，需要写Bean对象，唯一标识id，全类名，然后通过set注入或者其他注入方式注入默认属性值

现在的步骤：
1、@Configuration 编写一个配置类(配置类其实也会被存入IOC容器，可以通过ctrl + 左键点击这个注解发现内嵌了@Component注解)。其实也可以使用上面的@SpringBootConfiguration注解，本质其实一样，所以Spring相关的核心配置使用SpringBoot的，而通用配置使用默认的

2、在配置类中，自定义方法给容器中注册组件。配合@Bean。如果是第三方的我们直接根据类型，写入为配置类的方法，返回它的类型，然后直接return new出来的对象
2.1、@Configuration注解spring 5.2以后多了属性 proxyBeanMethods，可以设置为true或者false，默认为true（效果代表：是不是代理Bean的方法），如果为true说明为代理对象调用方法，我们在获取这个对象的时候，会从容器检查有没有这个类的对象，有就拿，没有就创建 (保持组件单实例)。主要用于解决组件依赖问题。当不更改这个值，组件在配置类配置依赖可以直接通过set方法然后传入配置类的其他组件的注入方法(即带有@Bean的方法)。我们不想有这种依赖关系，设置成false就是轻量级模式。测试设置为false对于单个Bean从容器获取多次还是单实例的，但依赖的情况下，Bean内部其他的Bean就不是ioc容器的那个了，而是一个新new的。

3、或使用@Import 导入第三方的组件（可以写在组件类(@Conponent，@Controller等)或者配置类上面，与配置类的注解放在一起），在括号中写对应类的 .class字节码文件（默认value值，不用写属性，且是一个数组(可以一次导入多个组件到容器)）。或者我们可以使用全类名（推荐：其实不管怎么样默认ioc容器注入的组件的id名称仍是全类名。因为我们开发过程中可能会修改依赖，而如果导入IOC的时候如果删掉之前一些现在用不到的依赖，这种情况下，本身靠字符串的全类名不会引起报错，但是使用字节码文件的时候不存在这个类会大面积报错），对应name属性

2. 条件注解

如果注解指定的条件成立，则触发指定行为 能写在配置类，写了组件注解的类或者是配置类内部的@Bean方法上

@ConditionalOnXxx
@ConditionalOnClass：如果类路径中存在这个类，则触发指定行为
@ConditionalOnMissingClass：如果类路径中不存在这个类，则触发指定行为
@ConditionalOnBean：如果容器中存在这个Bean（组件），则触发指定行为
@ConditionalOnMissingBean：如果容器中不存在这个Bean（组件），则触发指定行为

场景：
● 如果存在FastsqlException这个类，给容器中放一个Cat组件，名cat01，
● 否则，就给容器中放一个Dog组件，名dog01
● 如果系统中有dog01这个组件，就给容器中放一个 User组件，名zhangsan
● 否则，就放一个User，名叫lisi

自定义去实现Condition接口，然后自己写规则

@ConditionalOnBean（value=组件类型，name=组件名字）：判断容器中是否有这个类型的组件，并且名字是指定的值

@ConditionalOnRepositoryType (org.springframework.boot.autoconfigure.data)
@ConditionalOnDefaultWebSecurity (org.springframework.boot.autoconfigure.security)
@ConditionalOnSingleCandidate (org.springframework.boot.autoconfigure.condition)
@ConditionalOnWebApplication (org.springframework.boot.autoconfigure.condition)
@ConditionalOnWarDeployment (org.springframework.boot.autoconfigure.condition)
@ConditionalOnJndi (org.springframework.boot.autoconfigure.condition)
@ConditionalOnResource (org.springframework.boot.autoconfigure.condition)
@ConditionalOnExpression (org.springframework.boot.autoconfigure.condition)
@ConditionalOnClass (org.springframework.boot.autoconfigure.condition)
@ConditionalOnEnabledResourceChain (org.springframework.boot.autoconfigure.web)
@ConditionalOnMissingClass(org.springframework.boot.autoconfigure.condition)
@ConditionalOnNotWebApplication (org.springframework.boot.autoconfigure.condition)
@ConditionalOnProperty (org.springframework.boot.autoconfigure.condition)
@ConditionalOnCloudPlatform (org.springframework.boot.autoconfigure.condition)
@ConditionalOnBean(org.springframework.boot.autoconfigure.condition)
@ConditionalOnMissingBean(org.springframework.boot.autoconfigure.condition)
@ConditionalOnMissingFilterBean (org.springframework.boot.autoconfigure.web.servlet)
@Profile (org.springframework.context.annotation)
@ConditionalOnInitializedRestarter (org.springframework.boot.devtools.restart)
@ConditionalOnGraphQlSchema (org.springframework.boot.autoconfigure.graphql)
@ConditionalOnJava (org.springframework.boot.autoconfigure.condition)

3. 属性绑定

1. 方法① ：@ConfigurationProperties： 声明组件的属性和配置文件哪些前缀开始项进行绑定，可以写在组件Bean上，也可以写到配置类中的配置Bean的方法上

   • 将容器中任意组件（Bean）的属性值和配置文件的配置项的值进行绑定
     • 1、给容器中注册组件
       • ①在配置类外使用@ConfigurationProperties结合@Component，配置类内无需写任何方法
       • ②配置类内使用@Bean结合@ConfigurationProperties，配置类外不用写任何注解
     • 2、使用@ConfigurationProperties 声明组件和配置文件的哪些配置项进行绑定

2. 方法② ： @EnableConfigurationProperties：快速注册注解(这是写于配置类上的注解，使用@Import注解导入的Bean不会进行属性绑定)

   • 场景：SpringBoot默认只扫描自己主程序所在的包。如果导入第三方包，即使组件上标注了 @Component、@ConfigurationProperties 注解，也没用。因为组件都扫描不进来，此时使用这个注解就可以快速进行属性绑定并把组件注册进容器

4. @Scope

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scope {
    
   @AliasFor("scopeName")
   String value() default "";
 
   @AliasFor("value")
   String scopeName() default "";
   
   ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

scopeName
scopeName是为了声明Bean的作用域，在Spring4.2版本以前，有singleton, prototype两种模式，4.2之后新加了web作用域（request, session, globalsession）。

singleton：单例模式，顾名思义即Spring IOC容器对于一个Bean，只会有一个共享的Bean实例。这一个单一的实例会被存储到单例缓存（singleton cache）中，当有请求或者是引用时，IOC容器都会返回存储在singleton cache的同一个实例。
prototype：多实例模式，即当每次客户端向容器获取Bean的时候，IOC容器都会新建一个实例并返回。与单例不同的是，在IOC容器启动的时候并不会创建Bean的实例，并且在有请求创建Bean实例之后也不会管理该实例的生命周期，而是由客户端自行处理。
request：web应用针对每一次HTTP请求都会创建一个新的Bean实例，且该实例仅在该次HTTP请求有效。
session：针对每一个session会创建一个Bean实例，且生命周期为该session有效期间。
globalsession:仅基于portlet的web应用才有意义，否则可以当作session使用。
这五种scopeName的使用方法 (也可以直接写对应的字符串，无视大小写)

@Scope(scopeName = ConfigurableBeanFactory.SCOPE_SINGLETON)
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Scope(scopeName = WebApplicationContext.SCOPE_REQUEST)
@Scope(scopeName = WebApplicationContext.SCOPE_SESSION)
@Scope(scopeName = "globalSession")
1
2
3
4
5

ScopeProxyMode
proxyMode表明了@Scope注解的Bean是否需要代理。

• DEFAULT：proxyMode的默认值，一般情况下等同于NO，即不需要动态代理。
• NO：不需要动态代理，即返回的是Bean的实例对象。
• INTERFACES：代理的对象是一个接口，即@Scope的作用对象是接口，这种情况是基于jdk实现的动态代理。
• TARGET_CLASS：代理的对象是一个类，即@Scope的作用对象是一个类，是以生成目标类扩展的方式创建代理，基于CGLib实现动态代理。 我的Spring6笔记，可以复习动态代理的知识

@Scope(proxyMode = ScopedProxyMode.DEFAULT)
@Scope(proxyMode = ScopedProxyMode.NO)
@Scope(proxyMode = ScopedProxyMode.INTERFACES)
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
1
2
3
4

5. @ImportResource和@Import

如果想把别的xml文件的配置也导入，不想重新手写配置类和注解，可以直接在配置类或者组件类上写@ImportResource("classpath:/xxxxxx.xml")可以把xml的配置文件的组件导入IOC容器

@Import注解提供了三种用法

1. @Import一个普通类 spring会将该类加载到spring容器中，需要有无参构造器
2. @Import一个类，该类实现了ImportBeanDefinitionRegistrar接口，在重写的registerBeanDefinitions方法里面，能拿到BeanDefinitionRegistry bd的注册器，能手工往beanDefinitionMap中注册 beanDefinition，这种方式注册既能进行复杂的判断，也能对Bean进行生命周期和名字更改等功能
3. @Import一个类 该类实现了ImportSelector 重写selectImports方法该方法返回了String[]数组的对象，数组里面的类都会注入到spring容器当中

6. @ComponentScan

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};

    @AliasFor("value")
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};

    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;

    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;

    String resourcePattern() default "**/*.class";

    boolean useDefaultFilters() default true;

    Filter[] includeFilters() default {};

    Filter[] excludeFilters() default {};

    boolean lazyInit() default false;

    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
        FilterType type() default FilterType.ANNOTATION;

        @AliasFor("classes")
        Class<?>[] value() default {};

        @AliasFor("value")
        Class<?>[] classes() default {};

        String[] pattern() default {};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

1. value

首先它的value值对应要扫描的包名，可以是一个数组，放入要扫描的包名。

2. excludeFilters = {@Filter(type=FilterType.xxxx, classes={xxx,xxx,xxx}) …}

可以填入一个数组，类型为@Filter注解数组，可以排除要扫描的包。可以按注解，或者是类的类型，或者是正则排除【几乎不用】，或者是AspectJ语法【几乎不用】，

type=FilterType.ASSUGNABLE_TYPE按类型排除

如我们不扫描@Controller注解的类和@Service注解的类
这里我测试发现排除这个注解，并不会把衍生的@RestController注解的组件排除注册

@ComponentScan(excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {ComponentScan.class,Service.class})
})
1
2
3

3. includeFilters

需要进行设置属性关闭默认扫描规则useDefaultFilters = false
用法和上面没有什么区别

4. 自定义类型扫描

定义一个类，实现TypeFilter接口，实现它的方法
第一个参数metadataReader：可以通过它获取正在扫描的类的信息：如注解，类的信息，类的资源信息。
进一步比如类名，可以用如className.contains("xxx")的方法去判断是否名字包含字符【其实本质不如用上面的正则】
第二个参数metadataReaderFactory可以获得其他的容器组件的信息
使用的时候，只需要@Filter（type=FilterType.CUSTOM，classes={MyFilter})指定使用我们的过滤规则

public class MyFilter implements TypeFilter {
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        return false;
    }
}
1
2
3
4
5
6

7. @Lazy

可以给配置类中加载的Bean上加，即便是单实例Bean，也可以实现懒加载，ioc创建不加载，第一次获取才加载

8. FactoryBean

这里可以参考Spring6学习部分的笔记，大同小异，就是实现FactoryBean接口，然后重写方法，主要是补充：
首先，通过配置类注册@Bean返回工厂Bean 类，得到的仍是我们实现类，不是工厂。（这里已经知道了）
补充：要是想从ioc获得工厂而不是这个实现类，getBean方法输入Bean名称字符串，在字符串前面加 &符号。

9. Bean的生命周期

1. 初始化和销毁方法【栈式初始化和销毁(先初始化的后销毁)】

1. xml

Bean以前在基于xml方式的配置的方法中，我们可以在xml配置参数。

2. @Bean

而springBoot或者说注解的spring中，我们可以在@Bean通过同名的参数指定方法名。这些方法很重要，我们可以在一些数据源初始化的时候把很多信息注入进去。

别忘了多实例Bean是懒加载，而且每次返回不同的Bean，同时容器也不帮你管理这个Bean，容器哪怕销毁，也不会调用这个Bean的destroy，只是可以帮你创建，单实例被单例池引用，spring容器销毁即销毁，多实例在虚拟机GC时销毁

3. 实现InitializingBean和DisposableBean接口

同时也可以不用这个注解，通过实现InitializingBean接口重写初始化方法，通过实现DisposableBean接口重写销毁方法。

4. 注解方式定义初始化方法和销毁方法【来自JSR250规范来自JDK非Spring】

@PostConstruct:在Bean创建完成并属性赋值之后，执行初始化方法
@PreDestroy:在容器销毁之前执行销毁方法

2. Bean的后置处理器: BeanPostProcessor【它也是个组件需要注册】

具体的生命周期过程

• 1 bean对象创建（调用无参构造器）
• 2 给bean对象设置属性
• 3 bean的后置处理器（初始化之前）
• 4 bean对象初始化（需在配置bean时指定初始化方法）
• 5 bean的后置处理器（初始化之后）
• 6 bean对象就绪可以使用
• 7 bean对象销毁（需在配置bean时指定销毁方法）
• 8 IOC容器关闭

1. 基本使用

实现BeanPostProcessor接口并重写前置方法和后置方法
在Bean的初始化前后进行一些操作。
bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行。
方法会获得Object类型的Bean实例，它的返回值是可以对参数获得的Bean，你可以进行包装或者是直接返回

2. 底层原理

至于源码部分可以看雷神的讲解，总而言之就是底层构建ioc容器的时候，在刷新12大步的时候，会给容器注入Bean，而经历Set属性赋值之后，会for循环遍历所有后置处理器，依次执行后置处理器的前置方法。
Spring底层用它完成了很多事情，可以利用Idea去看看它的实现类，比如之前Spring学过的一个接口，如果想给Bean对象获取ioc容器也很简单，实现ApplicationContextAware接口会默认让重写一个set方法，我们设置一个ApplicationContext类的属性，即可在后置处理器方法实现的过程中，调用postProcessBeforeInitialization方法给Bean对象注入进去。
如还有一个AutowireAnnotationBeanPostProcessor类，它就是容器帮我们进行自动装配的。可以说很多的Spring行为在底层都是基于这个后置处理器完成的

10. @Value

使用这个注解标注在我们的Bean类的字段属性上，可以进行赋值。

1. 基本数值
2. 可以写spEL:#{}【很少用】
3. 可以写${}:取出配置文件中的值【在运行环境变量中的值】

11. @PropertySource

使用这个注解在配置类上可以读取外部配置文件读取到环境变量中。
@PropertySource用于指定外部属性文件的位置，可以将属性文件中的属性值注入到Spring Bean中。它通常与@Value注解一起使用，将属性文件中的值注入到单个属性中。
@ConfigurationProperties用于将属性文件中的值绑定到一个Java对象上。它可以将属性文件中的多个属性值注入到一个Java对象中。与@Value注解不同，@ConfigurationProperties可以将属性文件中的值注入到多个属性中。

11. @AutoWired

详情见之前的Spring笔记

这里补充一下一些原理：AutowiredAnnotationBeanPostProcessor在Bean的生命周期中的后置处理器的前置方法，进行注入。同时如果组件只有一个有参构造器，不需要任何注解标注，就能从容器获取嵌套的内部组件

1. @Primary

注册多个相同类型的Bean，用@Autowired，想要指定只能通过@Qualifier，通过名字指定注入哪个，因为@Autowired是根据类型注入的，但是这么太麻烦了，我们可以在注入的组件的注入注解上再写一个@Primary，即可完成注入的情况，如果发现多个同类型的组件，优先把这个注入。同时这两个是可以一起使用的。@Qualifier注解的优先级高于@Primary注解。也就是说，当一个接口有多个实现类时，如果使用了@Qualifier注解指定了要注入哪个实现类，那么即使有一个实现类被标记了@Primary注解，也不会被优先选择。

2. @Resource和@Inject【分别是JSR250规范和JSR330规范的Java注解非Spring】

@Resource默认byName注入，没有指定name时把属性名当做name，根据name找不到时，才会byType注入。byType注入时，某种类型的Bean只能有一个。但是不支持Spring的@Primary功能和@Autowired的默认值功能和required=false功能

想用@Inject需要专门maven依赖，和@Autowired功能一样，支持@Primary了，但是还是不支持@Autowired的默认值功能和required=false功能

3. @Bean标注的方法创建对象的时候，方法参数的值从容器获取【如果有的话】

所以我们不必这种时候写@Autowired注解，如果容器不存在参数写的类型的组件，IDea能识别到，并标识红色波浪号。

12. 想要给Bean组件拿到Spring底层的组件: xxxxxxAware接口【祖宗接口Aware】

类似给Bean注入ioc容器，实现ApplicationContextAware接口重写set方法即可，其他组件类似。本质其实底层是靠对应的xxxxxxxProcessor后置处理器的postProcessorBeforeInitialization方法实现的

13. @Profile

这里后面的Springboot篇章讲了

这里讲讲通过代码的方式，直接通过ioc容器的getEnvironment().setActiveProfiles("xxx", "xxxx"...)可以一次设置单个或多个激活的环境。

2. YAML配置文件

痛点：SpringBoot 集中化管理配置，application.properties
问题：配置多以后难阅读和修改，层级结构辨识度不高

YAML 是 “YAML Ain’t a Markup Language”（YAML 不是一种标记语言）。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（是另一种标记语言）。

• 设计目标，就是方便人类读写
• 层次分明，更适合做配置文件
• 使用.yaml或 .yml作为文件后缀

1. 基本语法

• 大小写敏感
• 使用缩进表示层级关系，k: v，使用空格分割k,v
• 缩进时不允许使用Tab键，只允许使用空格。换行
• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
• # 表示注释，从这个字符一直到行尾，都会被解析器忽略。

支持的写法：

• 对象：键值对的集合，如：映射（map）/ 哈希（hash） / 字典（dictionary）
• 数组：一组按次序排列的值，如：序列（sequence） / 列表（list）
• 纯量：单个的、不可再分的值，如：字符串、数字、bool、日期

2. 示例

@Component
@ConfigurationProperties(prefix = "person") //和配置文件person前缀的所有配置进行绑定
@Data //自动生成JavaBean属性的getter/setter
//@NoArgsConstructor //自动生成无参构造器
//@AllArgsConstructor //自动生成全参构造器
public class Person {
    private String name;
    private Integer age;
    private Date birthDay;
    private Boolean like;
    private Child child; //嵌套对象
    private List<Dog> dogs; //数组（里面是对象）
    private Map<String,Cat> cats; //表示Map
}

@Data
public class Dog {
    private String name;
    private Integer age;
}

@Data
public class Child {
    private String name;
    private Integer age;
    private Date birthDay;
    private List<String> text; //数组
}

@Data
public class Cat {
    private String name;
    private Integer age;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

properties表示法

person.name=张三
person.age=18
person.birthDay=2010/10/12 12:12:12
person.like=true
person.child.name=李四
person.child.age=12
person.child.birthDay=2018/10/12
person.child.text[0]=abc
person.child.text[1]=def
person.dogs[0].name=小黑
person.dogs[0].age=3
person.dogs[1].name=小白
person.dogs[1].age=2
person.cats.c1.name=小蓝
person.cats.c1.age=3
person.cats.c2.name=小灰
person.cats.c2.age=2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

yaml表示法

person:
  name: 张三
  age: 18
  birthDay: 2010/10/10 12:12:12
  like: true
  child:
    name: 李四
    age: 20
    birthDay: 2018/10/10
    text: ["abc","def"]
  dogs:
    - name: 小黑
      age: 3
    - name: 小白
      age: 2
  cats:
    c1:
      name: 小蓝
      age: 3
    c2: {name: 小绿,age: 2} #对象也可用{}表示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 细节

• birthDay 推荐写为 birth-day
• 文本：
  • 单引号不会转义 【\n 则为普通字符串显示】
  • 双引号会转义 【\n会显示为换行符】
• 大文本
  • |开头，大文本写在下层，保留文本格式，换行符正确显示
  • >开头，大文本写在下层，折叠换行符
• 多文档合并
  • 使用---可以把多个yaml文档合并在一个文档中，每个文档区依然认为内容独立，方便阅读

4. 小技巧：lombok

简化JavaBean 开发。自动生成构造器、getter/setter、自动生成Builder模式等

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>compile</scope>
</dependency>
1
2
3
4
5

使用@Data等注解
Lombok注解大全

3. 日志配置

规范：项目开发不要编写System.out.println()，应该用 日志 记录信息

感兴趣日志框架关系与起源可参考：SpringBoot2雷神视频 视频 21~27集

1. 简介

1. Spring使用commons-logging作为内部日志，但底层日志实现是开放的。可对接其他日志框架。
   a. spring5及以后 commons-logging被spring直接自己写了。
2. 支持jul，log4j2,logback。SpringBoot 提供了默认的控制台输出配置，也可以配置输出为文件。
3. logback是默认使用的。
4. 虽然日志框架很多，但是我们不用担心，使用 SpringBoot 的默认配置就能工作的很好。

SpringBoot怎么把日志默认配置好的
1、每个starter场景，都会导入一个核心场景spring-boot-starter
2、核心场景引入了日志的所用功能spring-boot-starter-logging
3、默认使用了logback + slf4j 组合作为默认底层日志
4、日志是系统一启动就要用，xxxAutoConfiguration是系统启动好了以后放好的组件，后来用的。
5、日志是利用监听器机制配置好的。ApplicationListener。
6、日志所有的配置都可以通过修改配置文件实现。以logging开始的所有配置。

2. 日志格式

2023-03-31T13:56:17.511+08:00  INFO 4944 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2023-03-31T13:56:17.511+08:00  INFO 4944 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.7]
1
2

默认输出格式：

• 时间和日期：毫秒级精度
• 日志级别：ERROR, WARN, INFO, DEBUG, or TRACE.
• 进程 ID (其实在cmd里面，我们使用jps命令可以看到当前所有的java进程)
• —： 消息分割符
• 线程名： 使用 [ ] 包含
• Logger 名： 通常是产生日志的类名
• 消息： 日志记录的内容
  注意： logback 没有FATAL级别，对应的是ERROR

默认值：参照：spring-boot包additional-spring-configuration-metadata.json文件
默认输出格式值：%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd'T'HH:mm:ss.SSSXXX}}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
可在配置文件通过logging修改为：'%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{15} ===> %msg%n'

-5 代表左对齐五个字符
%logger 代表当前类
%n 换行

3. 记录日志

Logger logger = LoggerFactory.getLogger(getClass());
1

或者使用Lombok的@Slf4j注解

4. 日志级别

• 由低到高：ALL,TRACE, DEBUG, INFO, WARN, ERROR,FATAL,OFF；
  • 只会打印指定级别及以上级别的日志
  • ALL：打印所有日志
  • TRACE：追踪框架详细流程日志，一般不使用
  • DEBUG：开发调试细节日志
  • INFO：关键、感兴趣信息日志
  • WARN：警告但不是错误的信息日志，比如：版本过时
  • ERROR：业务错误日志，比如出现各种异常
  • FATAL：致命错误日志，比如jvm系统崩溃
  • OFF：关闭所有日志记录
• 不指定级别的所有类，都使用root指定的级别作为默认级别
• SpringBoot日志默认级别是 INFO

1. 在application.properties/yaml中配置logging.level.<logger-name>=<level>指定日志级别，其中<logger-name>可以指定包名，或者是下面的root
2. level可取值范围：TRACE, DEBUG, INFO, WARN, ERROR, FATAL, or OFF，定义在 LogLevel 类中
3. root 的logger-name叫root，可以配置logging.level.root=warn，代表所有未指定日志级别都使用 root 的 warn 级别

5. 日志分组

比较有用的技巧是：
将相关的logger分组在一起，统一配置。SpringBoot 也支持。比如：Tomcat 相关的日志统一设置

logging.group.tomcat=org.apache.catalina,org.apache.coyote,org.apache.tomcat
logging.level.tomcat=trace
1
2

SpringBoot 预定义两个组

6. 文件输出

SpringBoot 默认只把日志写在控制台，如果想额外记录到文件，可以在application.properties中添加logging.file.name or logging.file.path配置项。

7. 文件归档与滚动切割

归档：每天的日志单独存到一个文档中。
切割：每个文件10MB，超过大小切割成另外一个文件。

1. 每天的日志应该独立分割出来存档。如果使用logback（SpringBoot 默认整合），可以通过application.properties/yaml文件指定日志滚动规则。
2. 如果是其他日志系统，需要自行配置（添加log4j2.xml或log4j2-spring.xml）
3. 支持的滚动规则设置如下

8. 自定义配置

通常我们配置 application.properties 就够了。当然也可以自定义。比如：

如果可能，我们建议您在日志配置中使用-spring 变量（例如，logback-spring.xml 而不是 logback.xml）。如果您使用标准配置文件，spring 无法完全控制日志初始化。
最佳实战：自己要写配置，配置文件名加上 xx-spring.xml

9. 切换日志组合

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

log4j2支持yaml和json格式的配置文件

10. 最佳实战

1. 导入任何第三方框架，先排除它的日志包，因为Boot底层控制好了日志
2. 修改 application.properties 配置文件，就可以调整日志的所有行为。如果不够，可以编写日志框架自己的配置文件放在类路径下就行，比如logback-spring.xml，log4j2-spring.xml
3. 如需对接专业日志系统，也只需要把 logback 记录的日志灌倒 kafka之类的中间件，这和SpringBoot没关系，都是日志框架自己的配置，修改配置文件即可
4. 业务中使用slf4j-api记录日志。不要再 sout 了

4. AOP底层【雷神Spring注解驱动课程所学】

spring6的当时学习链接可作为补充

AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现，在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

• 前置通知：使用@Before注解标识，在被代理的目标方法前执行
• 返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
• 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
• 后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
• 环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置。我们手动推动目标方法运行（joinPoint.procced()）

一旦给切面类写切入方法，形参如果有JoinPoint joinPoint必须放在第一位

Springboot想要使用的话需要引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
1
2
3
4

基于注解驱动的情况下，需要给注入切面类的配置文件写注解@EnableAspectJAutoProxy
在Spring Boot中，默认情况下，如果您的项目中存在AOP相关的依赖和切面类，Spring Boot会自动开启AOP功能，不需要显式地使用@EnableAspectJAutoProxy注解。

使用AOP实现代理之后，通过getBean方法获取的对象，它的类没有变成代理类的类，这是因为Spring AOP采用的是基于代理的AOP实现方式，而不是基于字节码的AOP实现方式。
在基于代理的AOP实现方式中，Spring会为目标对象创建一个代理对象，代理对象和目标对象实现了相同的接口，并且代理对象中持有了目标对象的引用。当我们使用getBean方法获取目标对象时，Spring会将代理对象返回给我们，而不是目标对象本身。这个代理对象会拦截我们调用目标对象的方法，并在执行目标对象的方法前后执行一些额外的逻辑，从而实现AOP的功能。
因此，虽然我们通过getBean方法获取的对象看起来和原来的目标对象一样，但实际上它是一个代理对象，并且在调用它的方法时会执行AOP逻辑。如果想要获取代理对象的类，可以通过调用代理对象的getClass()方法来获取。

默认情况下，Spring AOP会将代理类放入IOC容器中，而不会将原始类的对象放入容器中。也就是说，如果你使用getBean()方法获取一个被AOP代理的对象，实际上获取的是代理类的实例对象，而不是原始类的实例对象。
如果你需要将原始类的对象放入IOC容器中，可以使用AspectJ风格的AOP实现方式，并在配置中将proxyTargetClass属性设置为false。这样做会导致Spring不再使用基于代理的AOP实现方式，而是使用基于AspectJ的AOP实现方式，从而可以将原始类的对象放入IOC容器中。
总之，Spring AOP可以将代理类和原始类的对象都放入IOC容器中，但具体如何配置取决于你的需求。

1. AOP原理

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;

    boolean exposeProxy() default false;
}
1
2
3
4
5
6
7
8
9

它给容器导入了组件AspectJAutoProxyRegistrar.class
这个组件实现了ImportBeanDefinitionRegistrar，可以跳回上面复习@Import的四种导入，实现这个接口可以自定义导入组件
利用它自定义给容器注入了一个Bean
internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
基于注解驱动的AspectJ的切面代理创造器

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {}
1

它的继承关系很复杂，主要关注祖宗接口有一个后置处理器的接口(在Bean初始化前后做事情)，还有一个BeanFactoryAware接口，那就说明它能自动装配BeanFactory

文字流程【这里结合下面的ioc容器原理更容易理解】

不懂就去看视频吧

1. 传入配置类，创建ioc容器
2. 注册配置类，调用refresh()刷新容器
3. 刷新十二大步中的registerBeanPostProcessors(beanFactory)注册Bean的后置处理器，方便拦截Bean的创建
   1. 先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor【为什么已经有了定义的后置处理器其实来源于第一步传入配置类的时候，@EnableAspectJAutoProxy注解已经通过上面说的@Import把后置处理器】
   2. 还给容器加入了别的BeanPostProcessor，同时对他们分类放入了不同容器，如是否实现Ordered接口可以排序之类的
   3. 优先注册实现了PriorityOrdered接口的BeanPostProcessor
   4. 然后注册实现了Ordered接口的BeanPostProcessor
   5. 最后注册剩下的
   6. 注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象保存在容器中，创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
      1. 创建Bean的实例
      2. populateBean:给Bean的各种属性赋值
      3. initializeBean:初始化Bean【Bean后置处理器就是在这前后行动的】
         1. invokeAwareMethods()：处理Aware接口的方法回调
         2. applyBeanPostProcessorsBeforeInitialiization应用后置处理器的前置方法
         3. invokeInitMethods()执行自定义的初始化方法，在此期间将前面说的工厂初始化并注入容器了
         4. applyBeanPostProcessorsAfterInitialiization应用后置处理器的后置方法
      4. BeanPostProcessor（AnnotationAwareAspectJAutoProxyCreator）创建成功
   7. 把BeanPostProcessor注册到BeanFactory中
4. 【以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程】
5. 完成BeanFactory的初始化工作后，接着来到了IOC容器的refresh的新的大步finishBeanFactoryInitialization(beanFactory)，注册单实例Bean
   1. 遍历获取容器所有的Bean依次创建对象getBean(beanName) -> getBean -> doGetBean -> getSingleton()
   2. 创建Bean
      1. 先从缓存看有没有，没有就创建【Spring实现单实例的原则：通过缓存机制】
      2. createBean() AnnotationAwareAspectJAutoProxyCreator会在任何Bean创建之前先尝试返回Bean的实例
         1. resolveBeforeInstantiation(beanName, mbdToUse)解析后置处理器前置方法，希望后置处理器能在此返回一个代理对象，如果能返回就返回，如果不能就到下一步。【后置处理器是在Bean对象创建完成初始化前后调用的】【而InstantiationAwareBeanPostProcessor是在创建Bean实例之前就先尝试用后置处理器返回对象】
         2. doCreateBean(beanName, mbdToUse, args)真正的创建一个Bean实例，和3.6流程一致

总而言之，就是通过注入一个特别的【后置处理器】，专门在【普通Bean】实例化之前，拦截它们的创建，先尝试用它试着去创建

AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的作用：

1. 每个Bean创建之前，调用postProcessBeforeInstantiation()方法
   1. 判断当前Bean是否在adviseBeans中（保存了所有需要增强的Bean）
   2. 判断当前Bean是否是基础类型的Advice,Pointcut,Advisor,AopInfrastructureBean或者看看是否是切面类。判断方法无非就是通过类型或者是注解之类的反射原理
   3. 判断是否需要跳过
      1. 获取候选增强器【切面里面的通知方法】【List<Advisor> candidateAdvisors】每一个封装的通知方法的增强器是InstantialtionModelAwarePointcutAdvisor。判断每个增强器是否是AAspectJPointcutAdvisor类型；返回true
      2. 永远返回false
2. 创建对象postProcessAfterInitialization 有需要的情况下包装return wrapIfNecessary(bean,beanName,cacheKey)
   1. 获取当前Bean所有的增强器【通知方法】
      1. 找到候选的所有增强器【找哪些通知方法需要切入当前Bean方法】
      2. 获取能在Bean使用的增强器
      3. 给增强器排序
   2. 保持当前Bean到advisedBeans中
   3. 如果当前Bean需要增强，创建它的代理对象
      1. 获取所有增强器【通知方法】
      2. 保存到proxyFactory
      3. 创建代理对象：Spring自己决定【看是否实现接口】
         1. JDK动态代理
         2. cglib动态代理
   4. 给容器返回当前增强之后的代理组件
   5. 以后容器中获取的对象就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程

目标方法的执行

1. 容器保存了组建的代理对象（cglib增强之后的对象），这个对象里面保存了详细信息【比如增强器，目标对象，xxx】
2. CglibAopProxy.intercept()拦截目标方法的执行
3. 根据ProxyFactory对象获取将要执行的目标方法拦截器链
   1. 获取所有的拦截器和增强器
   2. 遍历所有增强器，转为类型拦截器，然后统一放到一个集合
4. 如果没有拦截器链，直接执行目标方法
5. 如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个CglibMethodInvocation对象，并调用mi.proceed()方法，这个方法返回一个Object对象，会处理这个返回值
6. 执行逻辑类似mvc的，也成功一次索引加一，每个拦截器等待下一个拦截器执行完成返回以后再来执行，这个执行顺序Spring5.3之后变了，先异常或返回，最后是后置
   

2. AOP原理总结

1. @EnableAspectJAutoProxy 在配置类开启AOP功能【springboot中隐式开启】
2. @EnableAspectJAutoProxy会给容器注入一个组件AnnotationAwareAspectJAutoProxtyCreator，这是一个后置处理器
3. 容器的创建流程【refresh()】
   1. registerBeanPostProcessors()注册后置处理器，创建AnnotationAwareAspectJAutoProxtyCreator
   2. finishBeanFactoryInitialization()初始化剩下的单实例Bean
      1. 创建业务逻辑组件和切面组件
      2. AnnotationAwareAspectJAutoProxtyCreator拦截组件的创建过程
      3. 组件创建完之后，判断组件是否需要包装
         1. 是：切面的通知方法包装成增强器（Advisor），给业务逻辑组件创建代理对象
4. 执行目标方法
   1. 代理对象执行目标方法
   2. CglibAopProxy.intercept()
      1. 得到目标丰富的拦截器链（增强器包装成拦截器MethodInterceptor）
      2. 利用拦截器的链式机制，依次进入每个拦截器进行执行【见上面的执行顺序】