尚硅谷Spring注解开发学习笔记

前言

此笔记为尚硅谷Spring注解驱动教程(雷丰阳源码级讲解)学习笔记

1、课程安排

根据上面这张脑图，我把整个专栏分成了三个大的部分，分别是：容器、扩展原理以及Web。

1.1、容器

容器作为整个专栏的第一大部分，内容包括：

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

1.2、扩展原理

扩展原理作为整个专栏的第二大部分，内容包括：

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

1.3、Web

Web作为整个专栏的第三大部分，内容包括：

• servlet3.0
• 异步请求

这部分，其实就是SpringMVC，在这个部分中，我们会重点来说异步请求。

2、配置文件开发

2.1、导入Spring-context依赖包

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

2.2、编写Spring配置文件

在 resources 目录下创建 application.xml 文件

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

beans>

2.3、编写Person类

public class Person {
    
    private String name;
    private Integer age;
	
    // 省略构造方法，get/set方法，toString方法
}

2.4、在Spring配置文件中创建Bean

<bean id="person" class="com.xjhqre.pojo.Person">
    <property name="name" value="xjhqre"/>
    <property name="age" value="18"/>
bean>

2.5、编写测试类

public class SpringTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        Person person = (Person) applicationContext.getBean("person");
        System.out.println(person);
    }
}

测试结果：

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

3、注解开发简单案例

3.1、创建配置类

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

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

// 配置类等同于xml配置文件
@Configuration // 告诉Spring这是一个配置类
public class MainConfig {

    // 给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
    @Bean("person")
    public Person person01(){
        return new Person("lisi", 20);
    }
}

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='lisi', age=20}

4、包扫描

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

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

4.1、配置文件包扫描

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

4.2、注解扫描

在配置类上添加注解@ComponentScan

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

4.3、排除扫描

Filter[] excludeFilters() default {};

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

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

• ANNOTATION：按注解排除，常用
• ASSIGNABLE_TYPE：按类型排除，常用
• ASPECTJ：按AspectJ 类型模式表达式排除，不常用
• REGEX：按正则表达式排除
• CUSTOM：自定义排除

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

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

4.4、指定扫描

扫描的时候只需要包含哪些组件，编写方式和excludeFilters一样

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

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

在 jdk8 之后可以写多个@ComponentScan，写法如下：

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

4.5、按类型扫描

@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 可以获取其他任何类的信息
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        // 获取当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();

        // 获取当前正在扫描类的信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();

        // 获取当前类的资源信息（类的路径）
        Resource resource = metadataReader.getResource();

        String className = classMetadata.getClassName();
        System.out.println(className);
        return className.contains("er");
    }
}

4.6.2、修改配置类

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

5、@scope注解

5.1、默认单实例

5.1.1、编写配置类

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

    @Bean("person")
    public Person person() {
        return new Person("张三", 25);
    }
}

5.1.2、编写测试

@Test
public void test2() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    Person bean = applicationContext.getBean(Person.class);
    Person bean2 = applicationContext.getBean(Person.class);
    System.out.println(bean.hashCode());
    System.out.println(bean2.hashCode());
}

输出结果：

com.xjhqre.config.MainConfig2
com.xjhqre.config.MyTypeFilter
com.xjhqre.controller.BookController
com.xjhqre.pojo.Person
404214852
404214852

可以看到 bean 和 bean2 是同一个实例

5.2、@scope参数

ConfigurableBeanFactory.SCOPE_PROTOTYPE,

ConfigurableBeanFactory.SCOPE_SINGLETON,

org.springframework.web.context.WebApplicationContext.SCOPE_REQUEST,

org.springframework.web.context.WebApplicationContext.SCOPE_SESSION, value

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

在ConfigurableBeanFactory中有两个常量：

// 单实例，默认值，在IOC容器启动时就会调用方法创建对象，以后每次获取直接从容器中拿（map.get()）
String SCOPE_SINGLETON = "singleton";
// 多实例，在使用getBean()获取bean对象时才会创建
String SCOPE_PROTOTYPE = "prototype";

WebApplicationContext中的两个常量

// 同一次请求创建一个实例
String SCOPE_REQUEST = "request";
// 同一个session创建一个实例
String SCOPE_SESSION = "session";

5.3、测试多实例

5.3.1、修改配置类

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

}

5.3.2、测试代码

@Test
public void test2() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    Person bean = applicationContext.getBean(Person.class);
    Person bean2 = applicationContext.getBean(Person.class);
    System.out.println(bean.hashCode());
    System.out.println(bean2.hashCode());
}

测试结果：

com.xjhqre.config.MainConfig2
com.xjhqre.config.MyTypeFilter
com.xjhqre.controller.BookController
com.xjhqre.pojo.Person
961712517
1928931046

可以看到两个 bean 的哈希值不同

5.4、懒加载

针对单实例设置，因为单实例是在容器启动时创建对象

懒加载就是不让单实例在容器启动时创建，在第一次获取Bean时创建对象并初始化。

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

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

    @Bean("person")
    @Lazy
    public Person person() {
        return new Person("张三", 25);
    }

}

6、@Conditional注解(重点)

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

@Conditional源码

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

    // 传入一个Condition数组
    Class<? extends Condition>[] value();

}

Condition接口源码：

@FunctionalInterface
public interface Condition {

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

}

6.1、业务场景

如果是linux系统则注册linus，如果是windows系统则注册bill Gates

6.2、编写WindowsCondition

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

public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 判断是否是Windows系统
        // 1. 获取到IOC使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 2. 获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        // 3. 获取运行环境
        Environment environment = context.getEnvironment();
        // 4. 获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();

        // 容器中是否包含person,判断容器中的bean注册情况，也可以给容器中注册bean
        boolean person = registry.containsBeanDefinition("person");

        // 运行环境是否是Windows
        String property = environment.getProperty("os.name");
        assert property != null;
        return property.contains("Windows");
    }
}

6.3、编写LinuxCondition

public class LinuxCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        String property = environment.getProperty("os.name");
        assert property != null;
        return property.contains("linux");
    }
}

6.4、编写配置类

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

    @Bean("bill")
    @Conditional({WindowsCondition.class})
    public Person person() {
        return new Person("bill gates", 62);
    }

    @Bean("linus")
    @Conditional({LinuxCondition.class})
    public Person person2() {
        return new Person("linus", 48);
    }

}

6.5、编写测试

@Test
public void test3() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig3.class);
    Map<String, Person> beansOfType = applicationContext.getBeansOfType(Person.class);
    System.out.println(beansOfType);
}

测试结果：

{bill=Person{name='bill gates', age=62}}

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

7、组件注册方法

1. 包扫描 + 组件标注注解（@Controller、@Service、@Repository、@Component），这种方式只能注册自己写的类
2. @Bean，可以注册第三方包的类
3. @Import：快速给容器中导入一个组件，id默认是全类名
   1. ImportSelector：一个接口，返回需要导入的组件的全类名数组
   2. ImportBeanDefinitionRegistrar：一个接口，手动注册bean到容器中
4. 使用Spring提供的FactoryBean（工厂Bean）

7.1、@Import(重点)

7.1.1、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
@Import({Color.class, Red.class}) // 导入组件，id默认是组件的全类名
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.xjhqre.pojo.Color
com.xjhqre.pojo.Red

7.2、ImportSelector

7.2.1、编写MyImportSelector

// 自定义逻辑，返回需要导入的组件
public class MyImportSelector implements ImportSelector {
    // 返回值就是要导入到容器中的组件的全类名
    // AnnotationMetadata：当前标注@Import注解类的所有信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.xjhqre.pojo.Blue", "com.xjhqre.pojo.Yellow"};
    }
}

7.2.2、修改配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
@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.xjhqre.pojo.Color
com.xjhqre.pojo.Red
com.xjhqre.pojo.Blue
com.xjhqre.pojo.Yellow

7.3、ImportBeanDefinitionRegistrar

7.3.1、编写MyImportBeanDefinitionRegistrar

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     * AnnotationMetadata：当前类的注解信息
     * BeanDefinitionRegistry：注册类
     * 把所有需要添加到容器中的bean，调用BeanDefinitionRegistry.registerBeanDefinition手动注册
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 查询容器中是否存在red组件
        boolean red = registry.containsBeanDefinition("com.xjhqre.pojo.Red");
        if (red) {
            // 指定bean的定义信息（bean的类型，bean的scope）
            BeanDefinition beanDefinition = new RootBeanDefinition(Purple.class);
            // 第一个参数指定bean的id
            registry.registerBeanDefinition("purple", beanDefinition);
        }
    }
}

7.3.2、修改配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
@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
purple

7.4、FactoryBean

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

7.4.1、编写ColorFactoryBean

public class ColorFactoryBean implements FactoryBean<Color> {

    // 返回一个Color对象，这个对象会添加到容器中
    @Override
    public Color getObject() throws Exception {
        return new Color();
    }

    @Override
    public Class<?> getObjectType() {
        return Color.class;
    }

    // 返回是否为单例，如果为false，则每次创建时调用getObject()方法
    @Override
    public boolean isSingleton() {
        return true;
    }
}

7.4.2、编写配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
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.xjhqre.pojo.Color
class com.xjhqre.pojo.ColorFactoryBean

8、Bean生命周期

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

容器管理bean的生命周期

我们可以自定义初始化和销毁方法

构造(对象创建)

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

初始化

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

销毁

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

初始化和销毁方法：

1. 通过@Bean注解指定init-method和destroy-method
2. 实现InitializingBean和DisposableBean接口，重写里面的destroy和afterPropertiesSet方法
3. 使用@PostConstruct和@PreDestroy注解
4. BeanPostProcessor：接口，bean后置处理器，在bean初始化前后进行一些处理

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

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

8.1.1、创建Car类

public class Car {

    public Car() {
        System.out.println("car构造方法");
    }

    public void init() {
        System.out.println("car初始化方法");
    }

    public void destroy() {
        System.out.println("car销毁方法");
    }
}

8.1.2、创建配置文件

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

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

8.1.3、测试

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

测试结果：

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

8.2、InitializingBean和DisposableBean

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

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

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

8.2.1、创建Cat类

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.xjhqre.pojo")
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.xjhqre.pojo")
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
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("id为" + beanName + "的bean对象：" + bean + "执行postProcessBeforeInitialization");
        return bean;
    }

    @Override
    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.xjhqre.pojo")
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.xjhqre.config.MainConfig7$$EnhancerBySpringCGLIB$$aef15d18@7c469c48执行postProcessBeforeInitialization
id为mainConfig7的bean对象：com.xjhqre.config.MainConfig7$$EnhancerBySpringCGLIB$$aef15d18@7c469c48postProcessAfterInitialization
创建狗对象
id为dog的bean对象：com.xjhqre.pojo.Dog@1534f01b执行postProcessBeforeInitialization
初始化狗对象
id为dog的bean对象：com.xjhqre.pojo.Dog@1534f01bpostProcessAfterInitialization
销毁狗对象

8.4.4、BeanPostProcessor执行过程

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

9、@Value注解

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

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

9.1、修改Person类

public class Person {

    @Value("xjhqre")
    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 + '\'' +
                '}';
    }
}

9.2、配置类

@PropertySource(value = {"classpath:/person.properties"})
@ComponentScan(value = "com.xjhqre.pojo")
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='xjhqre', age=18, email='[email protected]'}
xjhqre@qq.com

10、自动装配

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

10.1、@AutoWired

给属性自动注入值

默认优先按照类型去容器中找对应的组件，找到就赋值。

如果该类型的组件有多个，再将属性名作为组件的id去容器中查找

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

@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需要和@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.xjhqre.pojo")
public class MainConfig10 {
}

11.3、测试

@Test
public void test10() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig9.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 // 告诉Spring这是一个配置类
@PropertySource("classpath:/db.properties")
public class MainConfig11 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

   

2. 使用代码方式：

   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、编写配置类

@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAop {

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

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

13.1.2、编写切面类

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

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

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

@Aspect
public class LogAspects {

    //抽取公共的切入点表达式
    //1、本类引用
    //2、其他的切面引用，引用方法的全类名："com.atguigu.aop.LogAspects.pointCut()"
    @Pointcut("execution(public int com.xjhqre.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.4、编写被增强类

public class MathCalculator {

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

}

13.1.5、测试

@Test
public void test12() {
    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;

}

该注解引入了AspectJAutoProxyRegistrar，AspectJAutoProxyRegister给容器中导入了给容器中导入了一个AspectJAutoProxyRegistrar自定义给容器注册bean

在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