进阶学习(源码级) -Spring注解驱动开发

1、Spring

1.1、容器

• AnnotationConfigApplicationContext
• 组件添加
• 组件赋值
• 组件注入
• AOP
• 声明式事务

1.2、扩展原理

• BeanFactoryPostProcessor
• BeanDefinitionRegistryPostProcessor
• ApplicationListener
• Spring容器创建过程

1.3、Web

• servlet3.0
• 异步请求

2、配置文件开发简单案例

1、导入依赖 spring-context

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.2.5.RELEASEversion>
dependency>

2、编写Spring配置文件 beans.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">


beans>

3、编写一个实体类 Person

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Person {
    private String name;
    private int age;

4、在Spring配置文件中配置Bean

<context:component-scan base-package="com.hh">context:component-scan>
<bean id="person" class="com.hh.bean.Person">
    <property name="name" value="haohao">property>
    <property name="age" value="18">property>
bean>

5、编写测试类

public class MainTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Person person = context.getBean("person", Person.class);
        System.out.println(person);
    }
}

6、测试

Person{name='haohao', age=18}

3、注解开发简单案例

3.1、创建配置类

• 在方法上面加上@Bean注解后，Spring会以方法返回类型作为组件的类型，方法名作为组件的 id

• 当向@Bean中添加参数时，默认添加的第一个参数是value，强制给组件赋值id

//配置类==配置文件beans.xml
@Configuration //告诉Spring这是一个配置类
@ComponentScan(value = "com.hh",includeFilters={
//        @ComponentScan.Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
//        @ComponentScan.Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),
        @ComponentScan.Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})

},useDefaultFilters=false)
//Filter[] excludeFilters()  指定扫描的时候按照什么规则排除那些组件
//ComponentScan.Filter[] includeFilters() default {}; 指定扫描的时候只需要包含那些组件
//FilterType.ANNOTATION  按照注解  常用
//FilterType.ASSIGNABLE_TYPE  按照类型  常用
//FilterType.ASPECTJ   按照ASPECTJ表达式，不太常用
//FilterType.REGEX   按照正则指定
//FilterType.CUSTOM   使用自定义规则  常用


public class MainConfig {
    //给容器中注册一个Bean,类型就是返回值的类型，id默认方法名
    @Bean
    public Person person(){
        return new Person("haohao",5);
    }
}

3.2、测试

public static void main(String[] args) {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    Person bean = applicationContext.getBean(Person.class);
    System.out.println(bean);
}

结果：

Person{name='haohao', age=5}

4、包扫描

只要标注了@Controller、@Service、@Repository、@Component的，都会被扫描加入到容器里

注意：配置类自身也会被扫描到容器中，如果存在多个配置类，则多个配置类里的所有bean对象都会被扫描进容器中

4.1、配置文件扫描

<context:component-scan base-package="com.hh">context:component-scan>

4.2、注解扫描

在配置类上添加注解@ComponentScan(value="")

//配置类==配置文件
@Configuration //告诉Spring这是一个配置类
@ComponentScan(value = "com.hh",includeFilters={
      @ComponentScan.Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
      @ComponentScan.Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),
      @ComponentScan.Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})

},useDefaultFilters=false)
//Filter[] excludeFilters()  指定扫描的时候按照什么规则排除那些组件
//ComponentScan.Filter[] includeFilters() default {}; 指定扫描的时候只需要包含那些组件
//FilterType.ANNOTATION  按照注解
//FilterType.ASSIGNABLE_TYPE  按照类型
//FilterType.ASPECTJ   按照ASPECTJ表达式，不太常用
//FilterType.REGEX   按照正则指定
//FilterType.CUSTOM   使用自定义规则


public class MainConfig {
	//...
}

4.3、排除扫描

注解排除excludeFilters的返回类型为Filter[]

Filter 的排除类型 FilterType 有以下几种：

• FilterType.ANNOTATION 按照注解
• FilterType.ASSIGNABLE_TYPE 按照类型
• FilterType.ASPECTJ 按照ASPECTJ表达式，不太常用
• FilterType.REGEX 按照正则指定
• FilterType.CUSTOM 使用自定义规则

下面以ANNOTATION按注解排除来示例：

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})
})
public class MainConfig {
    // ...
}

4.4、指定扫描

• ComponentScan.Filter[] includeFilters() default {}; 指定扫描的时候只需要包含那些组件

• 注意要关闭默认的扫描过滤器

• Filter 的指定类型 FilterType 同上

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh", includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})
}, useDefaultFilters = false)
public class MainConfig {
    // ...
}

4.5、按类型扫描

• FilterType.ASSIGNABLE_TYPE 按照类型

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre", includeFilters = {
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {BookController.class})
}, useDefaultFilters = false)
public class MainConfig {
    // ...
}

4.6、自定义扫描

4.6.1、编写TypeFilter的实现类(理解)

• public class MyTypeFilter implements TypeFilter {
      /**
       *
       * @param metadataReader ：读取到的当前正在扫描的类的信息
       * @param metadataReaderFactory：可以获取到其他任何类的信息
       * @return
       * @throws IOException
       */
      public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
          //获取当前类注解的信息
          ClassMetadata classMetadata = metadataReader.getAnnotationMetadata();
          //获取当前正在扫描的类的类信息
          ClassMetadata classMetadata1 = metadataReader.getClassMetadata();
          //获取当前类资源(类的路径)
          Resource resource = metadataReader.getResource();
          String className = classMetadata.getClassName();
          System.out.println("--->"+className);
          if(className.contains("er")){
              return true;
          }
          return false;
      }
  }
  

4.6.2、修改配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh", includeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})
}, useDefaultFilters = false)
public class MainConfig {
    // ...
}

5、@scope注解-设置组件作用域

5.1、@scope(默认单实例)

5.1.1、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh")
public class MainConfig2 {

    @Bean("person")
    public Person person(){
        System.out.println("给容器中添加Person--");
        return new Person("吉吉", 3);
    }
}

5.1.2、编写测试

@Test
public  void Test2(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String name : beanDefinitionNames) {
        System.out.println(name);
    }
    System.out.println("ioc容器创建完成......");
    Object person1 = applicationContext.getBean("person");
    Object person2 = applicationContext.getBean("person");
    System.out.println(person1==person2);//true    默认是单实例 要是Scope改为prototype 则是false
}

5.2、@scope参数

• ConfigurableBeanFactory#SCOPE_PROTOTYPE prototype 单实例

• ConfigurableBeanFactory#SCOPE_SINGLETON singleton 多实例

• org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST request

• org.springframework.web.context.WebApplicationContext#SCOPE_SESSION session

后两个需要导入 Spring web 的jar包，且基本不用，只讨论前两个

在ConfigurableBeanFactory中有两个常量：

• String SCOPE_SINGLETON = "singleton";

  • 单实例的(默认值) :ioc容器启动会调用方法创建对象放到ioc容器中，以后每次获取都是直接从容器中拿，可以理解成(map.get())

• String SCOPE_PROTOTYPE = “prototype”;

  • 多实例的：ioc容器启动并不会去调用方法创建对象放在容器中，每次获取的时候才会调用方法创建对象。

WebApplicationContext中的两个常量

• String SCOPE_REQUEST = “request”;

  • 同一次请求创建一个实例

• String SCOPE_SESSION = “session”;

  • 同一个session创建一个实例

5.3、多实例 prototype 测试

5.3.1、修改配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh")
public class MainConfig2 {
    
    @Bean("person")
    @Scope("prototype")
    public Person person() {
        return new Person("haohao", 5);
    }

}

5.3.2、测试

@Test
public  void Test2(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    System.out.println("ioc容器创建完成......");
    Object person1 = applicationContext.getBean("person");
    Object person2 = applicationContext.getBean("person");
    System.out.println(person1==person2);//false   默认是单实例 要是Scope改为prototype 则是false
}

5.4、懒加载

懒加载：

• 单实例bean,默认在容器启动的时候创建对象
• 懒加载：容器启动不创建对象，第一次使用(获取)Bean创建对象，并初始化

只需要在方法上添加注解 @Lazy

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh")
public class MainConfig2 {

    @Lazy
    @Bean("person")
    public Person person(){
        System.out.println("给容器中添加Person--");
        return new Person("吉吉", 3);
    }

}

6、@Conditional注解(重点)

• 按照一定的条件进行判断，满足条件给容器中注册Bean

@Conditional 源码

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {

   /**
    * All {@link Condition Conditions} that must {@linkplain Condition#matches match}
    * in order for the component to be registered.
    */
   Class<? extends Condition>[] value();

}

Condition接口源码：

@FunctionalInterface
public interface Condition {

    /**
     * ConditionContext：判断条件能使用的上下文环境
     * AnnotatedTypeMetadata：注释信息
     */
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);

}

6.1、业务场景

• 如果系统是windows,就给容器中注册(“jiji”)
• 如果系统是Linux,就给容器中注册(“haohao”)

6.2、编写WindowsConditional

编写windows条件，需要实现接口Condition，重写matches方法

public class WindowsConditional implements Condition {
    
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();//获取环境
        String property = environment.getProperty("os.name");//获取属性
        if(property.contains("Windows")){
            return true;
        }
        return false;
    }
}

6.3、编写LinuxConditional

/**
 * 判断是否是Linux系统
 */
public class LinuxConditional implements Condition {
    /**
     *
     * @param context  :判断条件能使用的上下文环境
     * @param metadata  ：注释信息
     * @return
     */
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //是否Linux环境
        //1、能获取到ioc使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //2.获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        //3、获取当前环境信息
        Environment environment = context.getEnvironment();
        //4.获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        //5.可以判断容器中的bean注册情况，也可以给容器中注册bean
        registry.containsBeanDefinition("person");
        
        String property = environment.getProperty("os.name");
        if(property.contains("Linux")){
            return true;
        }

        return false;
    }
}

6.4、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh")
public class MainConfig3 {

    @Conditional({WindowsConditional.class})
    @Bean("jiji")
    public Person person1(){
        return  new Person("吉吉国王",5);
    }
    @Conditional(LinuxConditional.class)
    @Bean("haohao")
    public Person person2(){
        return  new Person("好好",3);
    }


}

6.5、测试

@Test
public void Test3(){
    
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig3.class);
    Environment environment = applicationContext.getEnvironment();
    //动态获取环境变量的值 ： Windows 10
    String property = environment.getProperty("os.name");
    System.out.println(property);// Windows 10
    Map<String, Person> person = applicationContext.getBeansOfType(Person.class);
    System.out.println(person);
}

结果：

{jiji=Person{name='吉吉国王', age=5}}

当@Conditional配置在类上时，表示只有满足条件时，这个配置类配置的所有bean才会生效

7、组件注册方法

给容器中注册组件：

• 包扫描+组件标注注解(@controller/@Service/@Repository/@Component):自己写的类

• @Bean:导入的第三方包

• @Import:快速的给容器中导入一个组件

  • @Import(要导入到容器中的组件)：容器就会自动注册这个组件，id 默认是全类名

  • ImportSelector 接口: 实现类返回需要导入的组件的全类名数组

  • ImportBeanDefinitionRegistrar实现类，会调用接口的方法，使用BeanDefinitionRegistry注册bean

  • 使用Spring提供的FactoryBean(工厂Bean)

    • 默认获取到的是工厂bean 调用getObject 创建的对象
    • 要获取工厂Bean本身，我们需要给id前面加一个**&**，例如&colorFactoryBean

7.1、@Import(重点)

7.1.1、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh")
//@Import导入组件,id默认是全类名 com.hh.bean.Color
@Import({Color.class, Red.class})
public class MainConfig3 {

}

7.1.2、编写测试

@Test
public void test4() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig3.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
        System.out.println(beanDefinitionName);
    }
}

测试：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig3
com.hh.bean.Color
com.hh.bean.Red

7.2、ImportSelector

7.2.1、编写MyImportSelector

/**
 * 自定义逻辑返回需要导入的组件
 */
public class MyImportSelector implements ImportSelector {
    /**
     * AnnotationMetadata  当前标注@Import注解的类的所有注解信息
     * @param importingClassMetadata
     * @return   返回值 就是导入到容器中的组件全类名
     */
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {

        return new String[]{"com.hh.bean.Blue","com.hh.bean.Yellow"};
    }
}

7.2.2、修改配置类

@Configuration // 告诉Spring这是一个配置类 
@ComponentScan(value = "com.hh") 
@Import({Color.class, Red.class, MyImportSelector.class}) // 导入组件，id默认是组件的全类名 
public class MainConfig3 {}

7.2.3、测试

@Test
public void test4() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig3.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
        System.out.println(beanDefinitionName);
    }
}

结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig3
com.hh.bean.Color
com.hh.bean.Red
com.hh.bean.Blue
com.hh.bean.Yellow

7.3、ImportBeanDefinitionRegistrar

7.3.1、编写MyImportBeanDefinitionRegistrar

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     *
     * @param importingClassMetadata
     * @param registry
     * @param importBeanNameGenerator
     * AnnotationMetadata  当前类的注解信息
     * BeanDefinitionRegistry    BeanDefinition注册类
     *    把所有需要添加到容器中的bean:调用
     *    BeanDefinitionRegistry.registerBeanDefinition 手工注册进来
     */
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        boolean definition1 = registry.containsBeanDefinition("com.hh.bean.Red");
        boolean definition2 = registry.containsBeanDefinition("com.hh.bean.Blue");
        if(definition1&&definition2){
            //指定bean的定义信息，bean的类型
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Rainbow.class);
            //注册一个bean
            registry.registerBeanDefinition("rainBow",beanDefinition);
        }
    }
}

7.3.2、修改配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh")
@Import({Color.class, Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class MainConfig3 {}

7.3.3、测试

@Test
public void test4() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig3.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
        System.out.println(beanDefinitionName);
    }
}

测试结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
mainConfig3
com.xjhqre.pojo.Color
com.xjhqre.pojo.Red
com.xjhqre.pojo.Blue
com.xjhqre.pojo.Yellow
rainBow

7.4、FactoryBean

FactoryBean是一个接口，我们需要自己实现

7.4.1、编写ColorFactoryBean

/**
 * 创建一个Spring定义的FactoryBean
 */
public class ColorFactoryBean implements FactoryBean<Color> {
    //返回一个Color对象，这个对象会添加到容器中
    public Color getObject() throws Exception {
        System.out.println("ColorFactoryBean...");
        return new Color();
    }

    public Class<?> getObjectType() {

        return Color.class;
    }
    /**
     *  控制是单例吗？
     *  true :这个bean是单实例，在容器中保存一份
     *  false: 多实例 , 每次获取都会创建一个新的bean
     */
    public boolean isSingleton() {
        return false;
    }
}

7.4.2、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh")
public class MainConfig4 {

    @Bean
    public ColorFactoryBean colorFactoryBean() {
        return new ColorFactoryBean();
    }
}

7.4.3、测试

@Test
public void test5() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig4.class);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    // 工厂bean获取的是调用getObject创建的对象
    Object colorFactoryBean = applicationContext.getBean("colorFactoryBean");
    System.out.println(colorFactoryBean.getClass());

    // 如果想要拿到colorFactoryBean对象，则需要在传入的id前加一个&标识
    Object colorFactoryBean2 = applicationContext.getBean("&colorFactoryBean");
    System.out.println(colorFactoryBean2.getClass());
}

测试结果：

class com.hh.pojo.Color
class com.hh.pojo.ColorFactoryBean

8、Bean生命周期

• bean从创建 ----> 初始化 -----> 销毁的过程

• 容器管理bean的生命周期

• 我们可以自定义初始化和销毁方法：容器在bean进行到当前生命周期的时候调用我们自定义的初始化和销毁方法

构造(对象创建)

• 单实例：在容器启动的时候创建对象
• 多实例**：在每次获取的时候创建对象**

初始化

• 对象完成创建，并赋值好后，调用初始化方法

销毁

• 单实例：在容器关闭的时候销毁
• 多实例：容器不会管理这个bean，所以不会调用销毁方法

初始化和销毁方法：

• 通过@Bean注解指定init-method和destroy-method
• 通过让Bean实现 InitializingBean(定义初始化逻辑)，DisposableBean(定义销毁逻辑)接口，重写里面的destroy和afterPropertiesSet方法
• 可以使用JSR250：
  • @PostConstruct: 在bean创建完成并且属性赋值完成，来执行初始化方法
  • @PreDestroy : 在容器销毁bean之前通知我们进行清理工作
• BeanPostProcessor：接口，bean后置处理器，在bean初始化前后进行一些处理

  •  postProcessBeforeInitialization ：在初始化之前工作
    

  •  postProcessAfterInitialization ：在初始化之后工作
    

Spring底层对 BeanPostProcessor 的使用

•  bean赋值，注入其他组件，@AutoWired ，生命周期注解功能，@Async ,xxx 都用到BeanPostProcessor
  

8.1、自定义初始化和销毁方法

通过@Bean注解指定init-method和destroy-method

8.1.1、创建Car类

public class Car {
    public Car(){
        System.out.println("car  constructor...");
    }
    public void init(){
        System.out.println("car  init...");
    }
    public void destroy(){
        System.out.println("car  destroy...");
    }
}

8.1.2、创建配置文件

@ComponentScan("com.hh.bean")
@Configuration
public class MainConfigOfLifeCycle {

    @Bean(initMethod = "init",destroyMethod = "destroy")
    public Car car(){
        return new Car();
    }

}

8.1.3、测试

public class IOCTest_LifeCycle {
    @Test
    public void test1() throws InterruptedException {
        //1.创建ioc容器
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
     
        //关闭容器
        applicationContext.close();
    }
}

测试结果：

car构造方法
car初始化方法
car销毁方法

8.2、InitializingBean和DisposableBean 接口

• 通过让bean实现InitializingBean接口来定义初始化逻辑

• 通过让bean实现DisposableBean接口来定义销毁逻辑

在InitializingBean中有一个方法afterPropertiesSet，该方法在bean创建并赋值后调用

8.2.1、创建Cat类

@Component
public class Cat implements InitializingBean, DisposableBean {

    public Cat() {
        System.out.println("创建猫对象");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("销毁猫对象");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("初始化猫对象");
    }
}

8.2.2、创建配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh.bean")
public class MainConfig6 {

    @Bean
    public Cat cat() {
        return new Cat();
    }
}

8.2.3、测试

@Test
public void test7() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig6.class);
    applicationContext.close();
}

测试结果：

创建猫对象
初始化猫对象
销毁猫对象

8.3、@PostConstruct和@PreDestroy

• @PostConstruct：在bean创建完成并且属性赋值完成后进行初始化

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PostConstruct {
}

• @PreDestroy：在容器销毁bean之前执行

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PreDestroy {
}

8.3.1、创建Dog类

public class Dog {

    public Dog() {
        System.out.println("创建狗对象");
    }
    //对象创建并赋值之后调用
    @PostConstruct
    public void init() {
        System.out.println("初始化狗对象");
    }
    //容器移除对象之前
    @PreDestroy
    public void destroy() {
        System.out.println("销毁狗对象");
    }
}

8.3.2、配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh.bean")
public class MainConfig7 {

    @Bean
    public Dog dog() {
        return new Dog();
    }
}

8.3.3、测试

@Test
public void test8() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig7.class);
    applicationContext.close();
}

测试结果：

创建狗对象
初始化狗对象
销毁狗对象

8.4、BeanPostProcessor

BeanPostProcessor接口中有两个方法：

• postProcessBeforeInitialization：在初始化之前执行
• postProcessAfterInitialization：在初始化之后执行

8.4.1、编写MyBeanPostProcessor

/**
 * 后置处理器：初始化前后进行处理
 * 将后置处理器加入到容器中
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * @param bean 刚创建好的实例
     * @param beanName 实例的id
     */
    
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("id为" + beanName + "的bean对象：" + bean + "执行postProcessBeforeInitialization");
        return bean;
    }
    
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("id为" + beanName + "的bean对象：" + bean + "postProcessAfterInitialization");
        return bean;
    }
}

8.4.2、配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh.bean")
public class MainConfig7 {

    @Bean
    public Dog dog() {
        return new Dog();
    }
}

8.4.3、测试

@Test
public void test8() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig7.class);
    applicationContext.close();
}

测试结果：

id为mainConfig7的bean对象：com.hh.config.MainConfig7$$EnhancerBySpringCGLIB$$aef15d18@7c469c48执行postProcessBeforeInitialization
id为mainConfig7的bean对象：com.hh.config.MainConfig7$$EnhancerBySpringCGLIB$$aef15d18@7c469c48postProcessAfterInitialization
创建狗对象
id为dog的bean对象：com.hh.bean.Dog@1534f01b执行postProcessBeforeInitialization
初始化狗对象
id为dog的bean对象：com.hh.bean.Dog@1534f01bpostProcessAfterInitialization
销毁狗对象

8.4.4、BeanPostProcessor原理

• 执行populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
• 开始initializeBean初始化bean
  • 先执行applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);，遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
  • 然后执行invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
  • 最后执行applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

BeanPostProcessor 原理：
initializeBean{   applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName);
invokeInitMethod(beanName,wrappedBean,mbd);执行自定义初始化   applyBeanPostProcessorsAfterInitialization(wrappedBean,beanName);
}

9、@Value注解

使用@Value赋值，赋值方法：

1. 直接在@Value中写基本数值
2. 使用SpEL表达式：#{}
3. 使用${}：取出配置文件中的值（在运行环境变量里的值）

9.1、修改Person类

public class Person {

    @Value("hh")
    private String name;

    @Value("#{20-2}")
    private Integer age;

    @Value("${person.email}")
    private String email;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

配置文件 person.properties
person.email =2066@qq.com    

9.2、配置类

//用@PropertySource读取外部配置文件中的k/v 保存到运行的环境变量中；加载完外部的配置文件之后使用${}取出配置文件的值
@PropertySource(value = {"classpath:/person.properties"})
@Configuration
public class MainConfig9 {

    @Bean
    public Person person() {
        return new Person();
    }
}

9.3、测试类

@Test
public void test9() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig9.class);
    Person person = applicationContext.getBean(Person.class);
    System.out.println(person);

    // 也可以使用环境变量取出（牛逼牛逼）
    ConfigurableEnvironment environment = applicationContext.getEnvironment();
    String property = environment.getProperty("person.email");
    System.out.println(property);
}

测试结果：

Person{name='hh', age=18, email='[email protected]'}
[email protected]

10、自动装配

Spring利用依赖注入（DI），完成对IOC容器中各个组件的依赖关系赋值

10.1、@AutoWired

• 给属性自动注入值

• 默认优先按照类型去容器中找对应的组件：applicationContext.getBean(BookDao.class)，找到就赋值。

• 如果该类型的组件有多个，再将属性名作为组件的id去容器中查找applicationContext.getBean(“bookDao”)

• @AutoWired可以在构造器、参数、方法、属性上标注

• 自动装配默认一定要将属性赋值好，没有就会报错

  •  可以使用@Autowired(required=false);
    

源码：

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

   boolean required() default true;

}

10.1.1、required属性

• @AutoWired可以给required属性赋值，类型为boolean，默认为true。表示该组件是否必须。

• 当required=false时，表示这个组件不是必须的，在调用getBean方法时如果找不到对应的组件时不会直接抛出异常，而是返回一个null

10.1.2、标注在方法上

• 标注在方法上，Spring容器创建当前对象，就会调用方法，完成赋值

• 方法使用的参数，自定义类型的值从IOC容器中获取

@Autowired
public void setCar(Car car) {
    this.car = car;
}

10.1.3、标注在构造器上

• 默认加在IOC容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作

• 我们可以在有参构造函数上标注@Autowired，让IOC容器创建组件时调用该类的有参构造方法

• 如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以从容器中获取

@Autowired
public Boss(Car car) {
    this.car = car;
}

10.1.3、标注在参数上

public Boss(@Autowired Car car) {
    this.car = car;
}

@Bean标注的方法创建对象的时候，方法参数的值从容器中获取

// 参数car会从IOC容器中获取,可以省略Car前的@Autowired
@Bean
public Color color(Car car) {
    return new Color();
}

10.2、@Qualifier

• 使用@Qualifier指定需要装配的组件的id，而不是用属性名 如：@Qualifier(“bookDao”)

• @Qualifier需要和@AutoWired一起使用

10.3、@Primary

• 该注解可以让Spring进行自动装配的时候，默认使用首选的bean

• 也可以继续使用@Qualifier指定需要装配的bean的名字

• 无论是否有依赖注入，@Primary标注的bean都会被容器创建

源码：

/**
 * 指示当多个候选者有资格自动装配单值依赖项时，应优先考虑 bean。如果候选中恰好存在一个“主”bean，则它将是自动装配的值。
 * 这个注解在语义上等同于 Spring XML 中元素的primary属性。
 * 可用于任何直接或间接使用@Component注释的类或使用Bean注释的方法。
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Primary {
}

10.4、@Resource

可以和@Autowired一样实现自动装配功能，但默认是按组件名称进行装配

可以给属性name赋值，自定义组件名称

@Resource(name="bookDao2")
private BookDao bookDao;

但该注解没有支持@Primary、@Autowired(require=false)的功能

10.5、@Inject

需要导入javax.inject依赖

和@Autowired功能一样，但没有required=false的功能

@Inject
private BookDao bookDao;

@Resource和@Inject都是java的规范

11、使用Spring容器底层组件

自定义组件想要使用Spring容器底层的一些组件（ApplicationContext、BeanFactory），需要自定义组件实现xxxAware接口

在创建对象的时候，会调用接口规定的方法，注入相关的组件

Aware的子接口

定义一个类使用Spring底层的组件

11.1、编写Red类

@Component
public class Red implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

    private ApplicationContext applicationContext;

    // 获取IOC容器
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("IOC容器：" + applicationContext);
        this .applicationContext = applicationContext;
    }

    // 获取当前bean对象的名称
    @Override
    public void setBeanName(String name) {
        System.out.println("当前bean的名字：" + name);
    }

    // 解析String语句中的占位符 $ 或 #
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        String s = resolver.resolveStringValue("你好${os.name}， 我是#{20*18}");
        System.out.println("解析的字符串：" + s);
    }
}

11.2、配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.hh.bean")
public class MainConfig10 {
}

11.3、测试

@Test
public void test10() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig10.class);
}

测试结果：

当前bean的名字：red
解析的字符串：你好Windows 10， 我是360
IOC容器：org.springframework.context.annotation.AnnotationConfigApplicationContext@77468bd9, started on Sun Feb 27 18:53:21 CST 2022

每一个xxxAware都有一个对应的xxxAwareProcessor，用来处理相关逻辑

以ApplicationContextAwareProcessor为例

12、@Profile注解

@Profile注解是Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能

例子：在不同环境下使用不同的数据源，在开发环境下使用A数据源，在测试环境下使用B数据源，在生产环境下使用C数据源

需要导入c3p0依赖C3p0:JDBC DataSources/Resource Pools和数据库驱动依赖MySQL Connector

12.1、编写db.properties

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=123456

12.2、编写配置类

@Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定的话在任何环境下都能注册这个组件

加了环境标识的bean，只有在这个环境被激活的时候才能注册到容器中，默认环境为default，即@Profile("default")

@Profile注解写在类上时，只有当指定的环境被激活时，整个类才会被注册

@Configuration
@PropertySource("classpath:/db.properties")
public class MainConfigOfProfile implements EmbeddedValueResolverAware {

    @Value("${jdbc.username}")
    private String user;

    private StringValueResolver valueResolver;

    // 测试数据库
    @Profile("test")
    @Bean("testDataSource")
    public DataSource dataSourceTest(@Value("${jdbc.password}")String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true");
        String driverClass = valueResolver.resolveStringValue("${jdbc.driverClassName}");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    // 开发数据库
    @Profile("dev")
    @Bean("devDataSource")
    public DataSource dataSourceDev(@Value("${jdbc.password}")String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/atguigu?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true");
        String driverClass = valueResolver.resolveStringValue("${jdbc.driverClassName}");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    // 生产数据库
    @Profile("prod")
    @Bean("prodDataSource")
    public DataSource dataSourceProd(@Value("${jdbc.password}")String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true");
        String driverClass = valueResolver.resolveStringValue("${jdbc.driverClassName}");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.valueResolver = resolver;
    }
}

12.3、环境激活方式

激活运行环境方式：

1. 命令行方式，在虚拟机选项中输入：-Dspring.profiles.active=test

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yd7OJT2w-1657193423611)(C:\Users\小曾\Desktop\博客图片\image-20220706102314163.png)]

1. 使用代码方式：
   1. 使用无参构造器创建application，AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
   2. 设置需要激活的环境：applicationContext.getEnvironment().setActiveProfiles("test", "dev");
   3. 注册主配置类：applicationContext.register(MainConfig11.class);
   4. 刷新容器：applicationContext.refresh();

12.4、测试

测试中使用代码方式激活环境

@Test
public void test11() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
    applicationContext.getEnvironment().setActiveProfiles("test", "dev");
    applicationContext.register(MainConfig11.class);
    applicationContext.refresh();
    String[] dataSources = applicationContext.getBeanNamesForType(DataSource.class);
    for (String dataSource : dataSources) {
        System.out.println(dataSource);
    }
}

测试结果：

testDataSource
devDataSource

13、AOP

AOP：底层【动态代理】，指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；

AOP使用步骤：

1. 导入aop包；Spring AOP：(spring-aspects)
2. 定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法运行之前、方法运行结束、方法正常返回、方法出现异常，xxx）
3. 定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；
4. 给切面类的目标方法标注何时何地运行（通知注解）
5. 将切面类和业务逻辑类（目标方法所在类）都加入到容器中
6. 必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
7. 给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】

通知方法说明：

• 前置通知(@Before)：logStart：在目标方法(div)运行之前运行
• 后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
• 返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
• 异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
• 环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）

*表示所有方法，…表示任意类型的形参

13.1、AOP测试

13.1.1、编写业务逻辑类MathCalculator

public class MathCalculator {

    public int div(int i, int j) {
        System.out.println("MathCalculator...div...");
        return i / j;
    }

}

13.1.2、编写日志切面类LogAspects

• 切面表达式 "execution(public int com.hh.aop.MathCalculator.*(..))"中 *表示所有方法，…表示任意类型的形参。

• JoinPoint joinPoint必须写在形参的第一位。

• joinPoint可以获取被增强方法的签名，如方法名、参数列表、方法的返回值、方法抛出的异常等等

@Aspect  //告诉Spring哪个类是切面类
public class LogAspects {

    //抽取公共的切入点表达式
    //1、本类引用
    //2、若其他的切面引用，引用方法的全类名："com.hh.aop.LogAspects.pointCut()"
    @Pointcut("execution(public int com.hh.aop.MathCalculator.*(..))")
    public void pointCut() {
    }


    //@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
    @Before("pointCut()")
    public void logStart(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        System.out.println("" + joinPoint.getSignature().getName() + "运行。。。@Before:参数列表是：{" + Arrays.asList(args) + "}");
    }

    @After("pointCut()")
    public void logEnd(JoinPoint joinPoint) {
        System.out.println("" + joinPoint.getSignature().getName() + "结束。。。@After");
    }

    //JoinPoint一定要出现在参数表的第一位
    @AfterReturning(value = "pointCut()", returning = "result")
    public void logReturn(JoinPoint joinPoint, Object result) {
        System.out.println("" + joinPoint.getSignature().getName() + "正常返回。。。@AfterReturning:运行结果：{" + result + "}");
    }

    @AfterThrowing(value = "pointCut()", throwing = "exception")
    public void logException(JoinPoint joinPoint, Exception exception) {
        System.out.println("" + joinPoint.getSignature().getName() + "异常。。。异常信息：{" + exception + "}");
    }
}

13.1.3、编写配置类

@EnableAspectJAutoProxy //开启基于注解的aop模式
@Configuration
public class MainConfigOfAop {

    //业务逻辑类加入容器中
    @Bean
    public MathCalculator calculator() {
        return new MathCalculator();
    }

    //切面类加入到容器中
    @Bean
    public LogAspects logAspects() {
        return new LogAspects();
    }
}

13.1.5、测试

@Test
public void test() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAop.class);
    MathCalculator bean = applicationContext.getBean(MathCalculator.class);
    bean.div(1, 1);
}

测试结果：

div运行。。。@Before:参数列表是：{[1, 1]}
MathCalculator...div...
div正常返回。。。@AfterReturning:运行结果：{1}
div结束。。。@After

13.1.6、AOP使用总结

AOP使用的三个步骤：

1. 将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）
2. 在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）
3. 开启基于注解的aop模式；@EnableAspectJAutoProxy

13.2、AOP原理

• 看给容器中注册了什么组件
• 这个组件什么时候工作
• 这个组件的功能是什么

13.2.1、@EnableAspectJAutoProxy

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 引入AspectJAutoProxyRegister.class对象
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

    // true——使用CGLIB基于类创建代理；false——使用java接口创建代理
    boolean proxyTargetClass() default false;

    // 是否通过aop框架暴露该代理对象，aopContext能够访问.
    boolean exposeProxy() default false;

}

@EnableAspectJAutoProxy是什么？

• @Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar
• 利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion

在AspectJAutoProxyRegistrar中有一个registerBeanDefinitions方法，在该方法中使用AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);语句注册了一个名为internalAutoProxyCreator的组件，该组件的类型为AnnotationAwareAspectJAutoProxyCreator

13.2.2、AnnotationAwareAspectJAutoProxyCreator分析

以下是AnnotationAwareAspectJAutoProxyCreator的层次结构：

这里主要关注后置处理器和自动装备BeanFactory相关的方法：SmartInstantiationAwareBeanPostProcessor(后置处理器), BeanFactoryAware(自动装配BeanFactory).

接下来去AnnotationAwareAspectJAutoProxyCreator及其父类中寻找有关后置处理器和BeanFactory相关的方法

AbstractAutoProxyCreator：

• setBeanFactory
• postProcessAfterInitialization
• postProcessBeforeInstantiation
• postProcessProperties

AbstractAdvisorAutoProxyCreator：

• setBeanFactory，在该方法中调用了initBeanFactory方法

AnnotationAwareAspectJAutoProxyCreator：

• initBeanFactory

13.2.3、注册AnnotationAwareAspectJAutoProxyCreator流程

断点测试程序执行流程：

注册AnnotationAwareAspectJAutoProxyCreator的后置处理器的方法registerBeanPostProcessors(beanFactory)在IOC创建的refresh()方法中

registerBeanPostProcessors(beanFactory)：注册bean的后置处理器来方便拦截bean的创建；

1. 先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

2. 给容器中加别的BeanPostProcessor

3. 优先注册实现了PriorityOrdered接口的BeanPostProcessor

4. 再给容器中注册实现了Ordered接口的BeanPostProcessor

5. 注册没实现优先级接口的BeanPostProcessor；

6. 注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；下面以创建internalAutoProxyCreator(

   类型为AnnotationAwareAspectJAutoProxyCreator

   )的后置处理器BeanPostProcessor步骤为例：

   1. 创建Bean的实例
   2. populateBean；给bean的各种属性赋值
   3. initializeBean：初始化bean步骤：
      1. invokeAwareMethods()：处理Aware接口的方法回调
      2. applyBeanPostProcessorsBeforeInitialization()：应用所有后置处理器的postProcessBeforeInitialization()，初始化前的逻辑
      3. invokeInitMethods()；执行自定义的初始化方法
      4. applyBeanPostProcessorsAfterInitialization()；执行所欲后置处理器的postProcessAfterInitialization()；初始化后的逻辑
   4. AnnotationAwareAspectJAutoProxyCreator的后置处理器创建成功，生成aspectJAdvisorsBuilder

7. 把BeanPostProcessor注册到BeanFactory中：beanFactory.addBeanPostProcessor(postProcessor)

注册AnnotationAwareAspectJAutoProxyCreator的后置处理器流程图：

13.2.4、AnnotationAwareAspectJAutoProxyCreator执行时机

我们来分析IOC创建方法refresh()中的finishBeanFactoryInitialization(beanFactory);方法

1. finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean

   1. 遍历获取容器中所有的Bean，依次创建对象getBean(beanName)；getBean->doGetBean()->getSingleton()->

   2. 创建bean

      1. 先从缓存中获取当前bean：Object sharedInstance = getSingleton(beanName);，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；只要创建好的Bean都会被缓存起来

      2. createBean()；创建bean；

         1. resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续

            1. 后置处理器先尝试返回对象；

               bean = applyBeanPostProcessorsBeforeInstantiation();

               拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor，就执行postProcessBeforeInstantiation

               如果不是则执行bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);

            2. 若后置处理器返回对象失败，则会真正的去创建一个bean实例：doCreateBean(beanName, mbdToUse, args);

AnnotationAwareAspectJAutoProxyCreator执行时机流程图：

总结：

• AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，它继承了InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()方法
• AnnotationAwareAspectJAutoProxyCreator会在任何bean创建之前先尝试返回bean的实例，
• BeanPostProcessor是在Bean对象创建完成初始化前后调用的
• InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象

13.2.5、AnnotationAwareAspectJAutoProxyCreator作用

AnnotationAwareAspectJAutoProxyCreator的类型是InstantiationAwareBeanPostProcessor

1. 每一个bean创建之前，调用

   postProcessBeforeInstantiation()

   1. 判断当前bean是否在advisedBeans中（里面保存了所有需要增强bean， 如MathCalculator）
   2. 判断当前bean是否是基础类型的，是否实现了Advice、Pointcut、Advisor、AopInfrastructureBean接口，或者是否是切面（是否标注了@Aspect注解）
   3. 判断是否需要跳过，获取候选的增强器（切面里面的通知方法）封装在List candidateAdvisors集合中，判断每一个增强器是否是 AspectJPointcutAdvisor 类型的，如果是则返回true，但我们的增强器是InstantiationModelAwarePointcutAdvisor类型，所以返回false

2. 创建对象后，调用

   postProcessAfterInitialization

   ，该方法返回一个包装bean，

   return wrapIfNecessary(bean, beanName, cacheKey)

   包装如果需要的情况下

   1. 调用

      getAdvicesAndAdvisorsForBean

      方法获取当前bean的所有增强器（通知方法），封装在集合

      Object[] specificInterceptors

      中

      1. 找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
      2. 获取到能在bean使用的增强器。
      3. 给增强器排序

   2. 保存当前bean在advisedBeans中

   3. 如果当前bean需要增强，调用

      createProxy

      创建当前bean的代理对象；

      1. 获取所有增强器（通知方法）
      2. 保存到proxyFactory
      3. 调用proxyFactory.getProxy创建代理对象：Spring自动决定，创建JdkDynamicAopProxy(config)jdk动态代理或ObjenesisCglibAopProxy(config)cglib的动态代理；

   4. 给容器中返回当前组件使用cglib增强了的代理对象；

   5. 以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；

AnnotationAwareAspectJAutoProxyCreator配置代理流程图：

13.2.6、拦截器链分析

容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；

1. CglibAopProxy.intercept();拦截目标方法的执行

2. 根据ProxyFactory对象获取将要执行的目标方法拦截器链；

   List