Spring容器学习小抄

在 Spring 应用中，所有组件都被以 Bean 的方式管理，Spring 负责创建 Bean 实例，并管理他们的生命周期。Bean 在 Spring 容器中运行，无须感受 Spring 容器的存在，一样可以接受 Spring 的依赖注入。

Spring 有两个核心接口：BeanFactory 和 ApplicationContext，其中 ApplicationContext 是 BeanFactory 的子接口。他们都可代表 Spring 容器，Spring 容器是生成 Bean 实例的工厂，并且管理容器中的 Bean，包括整个的生命周期的管理——创建、装配、销毁。

Bean 是 Spring 管理的基本单位，在基于 Spring 的 Java EE 应用中，所有的组件都被当成 Bean 处理，包括数据源、Hibernate 的 SessionFactory、事务管理器等。在 Spring 中，Bean 的是一个非常广义的概念，任何的 Java 对象、Java 组件都被当成 Bean 处理。

Spring 容器负责创建 Bean 实例，所以需要知道每个 Bean 的实现类，Java 程序面向接口编程，无须关心 Bean 实例的实现类；但是 Spring 容器必须能够精确知道每个 Bean 实例的实现类，因此 Spring 配置文件必须精确配置 Bean 实例的实现类

Spring-注解驱动开发

BeanFactory

Spring 容器最基本的接口就是 BeanFactory。BeanFactory 负责配置、创建、管理 Bean，ApplicationContext 是它的子接口，因此也称之为 Spring 上下文。Spring 容器负责管理 Bean 与 Bean 之间的依赖关系。

BeanFactory 接口包含以下几个基本方法：

Boolean containBean(String name)：判断 Spring 容器是否包含 id 为 name 的 Bean 实例。
Object getBean(String name)：返回 Spring 容器中 id 为 name 的 Bean 实例。
<T> getBean(Class<T> requiredType)：获取 Spring 容器中属于 requiredType 类型的唯一的 Bean 实例。
<T> T getBean(String name, Class requiredType)：返回容器中 id 为 name，并且类型为 requiredType 的 Bean
Class <?> getType(String name)：返回容器中指定 Bean 实例的类型。
调用者只需使用 getBean() 方法即可获得指定 Bean 的引用，无须关心 Bean 的实例化过程，即 Bean 实例的创建过程完全透明。

这些方法可以参考之前的笔记https://chanshiyu.gitbook.io/blog/hou-duan/spring/15springboot-guan-li-bean
创建 Spring 容器实例时，必须提供 Spring 容器管理的 Bean 的详细配置信息。Spring 的配置信息通常采用 xml 配置文件来设置，因此，创建 BeanFactory 实例时，应该提供 XML 配置文件作为参数。

XML 配置文件通常使用 Resource 对象传入。Resource 接口是 Spring 提供的资源访问接口，通过使用该接口，Spring 能够以简单、透明的方式访问磁盘、类路径以及网络上的资源。一般使用如下方式实例化 BeanFactory：

// 搜索当前文件路径下的bean.xml文件创建Resource对象
InputStreamSource isr = new FileSystemResource("bean.xml");
// 以Resource对象作为参数创建BeanFactory实例
XmlBeanFactory factory = new XmlBeanFactory((Resource) isr);

// 搜索类加载路径下的bean.xml文件创建Resource对象
ClassPathResource res = new ClassPathResource("bean.xml");
XmlBeanFactory factory = new XmlBeanFactory(res);

在使用 BeanFactory 接口时，我们一般都是使用这个实现类：org.springframework.beans.factory.xml.XmlBeanFactory。然而 ApplicationContext 作为 BeanFactory 的子接口，使用它作为 Spring 容器会更加方便。它的实现类有：

FileSystemXmlApplicationContext：以基于文件系统的 XML 配置文件创建 ApplicationContext 实例。
ClassPathXmlApplicationContext：以类加载路径下的 XML 配置文件创建 ApplicationContext 实例。
XmlWebApplicationContext：以 web 应用下的 XML 配置文件创建 ApplicationContext 实例。
AnnotationConfigApplicationContext：以 java 的配置类创建 ApplicationContext 实例。

食用方式：

// 搜索CLASSPATH路径，以classpath路径下的bean.xml、service.xml文件创建applicationContext
ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"bean.xml","service.xml"});

// 以指定路径下的bean.xml、service.xml文件创建applicationContext
ApplicationContext ctx1 = new FileSystemXmlApplicationContext(new String[]{"bean.xml","service.xml"});

组件注册

我们举个栗子，比较传统的 xml 配置文件注册 bean 和注解方式注册 bean 两种方式。
Spring-Context依赖

给容器中注册组件有以下几种方式：

@Bean：导入第三方包里面的组件
@ComponentScan 包扫描 + 组件标注注解 @Controller/@Service/@Repository/@Component：导入自己写的类
@Import：快速给容器中导入一个组件
使用 Spring 提供的 FactoryBean（工厂 Bean）

@bean

1**.使用 xml 配置文件**

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <bean id="person" class="com.chanshiyu.bean.Person">
        <property name="name" value="zhangsan"/>
        <property name="age" value="18"/>
    </bean>
</beans>

然后通过 ClassPathXmlApplicationContext 引入类路径下的配置文件来注册 bean：

1
2
3

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Person bean = (Person) applicationContext.getBean("person");
System.out.println(bean);

2.使用注解方式

// 配置类 == 配置文件
@Configuration
public class MainConfig {

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

}

然后通过 AnnotationConfigApplicationContext 引入注解配置文件来注册 bean：

1
2
3

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
Person bean = applicationContext.getBean(Person.class);
System.out.println(bean);

需要注意：@Bean 注册 Bean，类型为返回值类型，id 默认为方法名，@Bean(name) 可以指定 bean id。

@componentscan
@ComponentScan 包扫描：只要标注了 @Controller、@Service、@Repository、@Component 注解的类都可以被自动注册为 bean。

1.使用 xml 配置文件

在 beans.xml 中加入：

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

2.使用注解方式

1
2
3

@Configuration
@ComponentScan(value = "com.chanshiyu")
public class MainConfig {}

自定义过滤规则：

/**
 * @ComponentScan  value:指定要扫描的包
 * excludeFilters = Filter[]：指定扫描的时候按照什么规则排除那些组件
 * includeFilters = Filter[]：指定扫描的时候只需要包含哪些组件
 * FilterType.ANNOTATION：按照注解
 * FilterType.ASSIGNABLE_TYPE：按照给定的类型
 * FilterType.ASPECTJ：使用ASPECTJ表达式
 * FilterType.REGEX：使用正则指定
 * FilterType.CUSTOM：使用自定义规则
 */
@ComponentScan(value = "com.chanshiyu", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class}),
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {BookService.class})
})

这里重点介绍一下 FilterType.CUSTOM 自定义过滤规则，先自定义自己的规则类：

public class MyTypeFilter implements TypeFilter {

    /**
     * metadataReader：读取到的当前正在扫描的类的信息
     * metadataReaderFactory: 可以获取到其他任何类信息的工厂
     */
    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();
        // 所有类名包含 Controller 的类都可以被扫描到
        return className.contains("Controller");
    }
}

食用自定义规则：

@Configuration
@ComponentScan(value = "com.chanshiyu", includeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})
}, useDefaultFilters = false)

使用包扫描的两个注意点：

注意 includeFilters 需要配合 useDefaultFilters 一起使用，禁用默认的过滤规则，因为默认的规则就是扫描所有的组件。

1	<context:component-scan base-package="com.chanshiyu" use-default-filters="false"/>

1
2
3

@ComponentScan(value = "com.chanshiyu", includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class}),
}, useDefaultFilters = false)

如果使用的 jdk8 版本以上，@ComponentScan 可以重复使用，即可以多次使用该注解定义规则。如果版本在 jdk8 以下，可以使用 @ComponentScans 注解定义多个扫描规则。

@ComponentScans(value = {
        @ComponentScan(value = "com.chanshiyu", includeFilters = {
                @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class}),
        }, useDefaultFilters = false)
})

时雨：@Configuration 只是配置文件，不会自动扫描包，需要配合 @ComponentScan 指定路径才会自动扫描注册。

https://github.com/scope
@Scope 调整组件注册作用域，默认情况下，组件注册是单实例的，注册后每次从容器中获取的实例都是同一个。

/**
 * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中，每次获取的时候才会调用方法创建对象；
 * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中，以后每次获取就是直接从容器（map.get()）中拿；
 * request：同一次请求创建一个实例
 * session：同一个session创建一个实例
 */
@Scope
@Bean("person")
public Person person() {
    return new Person("lisi", 20);
}

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();

Person bean = (Person) applicationContext.getBean("person");
Person bean2 = (Person) applicationContext.getBean("person");
System.out.println(bean == bean2); // true

@lazy
@Lazy 懒加载，针对上节提到的单实例 bean，单实例 bean 默认在容器启动的时候创建对象，通过懒加载让容器启动时不创建对象。第一次使用 Bean 时创建对象，并初始化。

@Lazy
@Bean("person")
public Person person() {
    return new Person("lisi", 20);
}

@conditional
@Conditional 按照一定的条件进行判断，满足条件给容器中注册 bean，它既可以作用在方法上，也可以作用在类上，当作用于类上时，满足当前条件时，这个类中配置的所有 bean 注册才能生效。

类中组件统一设置:

// 如果系统是windows，给容器中注册 bill
@Conditional({ WindowsCondition.class })
@Bean("bill")
public Person person01() {
    return new Person("bill", 60);
}

// 如果是linux系统，给容器中注册 linus
@Conditional({ LinuxCondition.class })
@Bean("linus")
public Person person02() {
    return new Person("linus", 50);
}

判断是否 windows 系统：

public class WindowsCondition implements Condition {
    /**
     * ConditionContext：判断条件能使用的上下文（环境）
     * AnnotatedTypeMetadata：注释信息
     */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        Environment environment = conditionContext.getEnvironment();
        String property = environment.getProperty("os.name");
        return property.contains("Windows");
    }
}

在上下文环境中可以获取很多有用信息：

//1、能获取到 ioc 使用的 beanfactory
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//2、获取类加载器
ClassLoader classLoader = context.getClassLoader();
//3、获取当前环境信息
Environment environment = context.getEnvironment();
//4、获取到 bean 定义的注册类
BeanDefinitionRegistry registry = context.getRegistry();

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

https://github.com/import
@Import 导入组件，id 默认是组件的全类名。

@Import：容器中就会自动注册这个组件，id 默认是全类名
ImportSelector：返回需要导入的组件的全类名数组；
ImportBeanDefinitionRegistrar：手动注册 bean 到容器中

1	@Import({Color.class, Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})

MyImportSelector：

public class MyImportSelector implements ImportSelector {

    // 返回值，就是到导入到容器中的组件全类名
    // AnnotationMetadata: 当前标注 @Import 注解的类的所有注解信息
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{ "com.chanshiyu.bean.Blue", "com.chanshiyu.bean.Green" };
    }
}

MyImportBeanDefinitionRegistrar：

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     * AnnotationMetadata：当前类的注解信息
     * BeanDefinitionRegistry：BeanDefinition 注册类，把所有需要添加到容器中的 bean；调用 BeanDefinitionRegistry.registerBeanDefinition 手工注册进来
     */
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        boolean definition = beanDefinitionRegistry.containsBeanDefinition("com.chanshiyu.bean.Red");
        boolean definition2 = beanDefinitionRegistry.containsBeanDefinition("com.chanshiyu.bean.Blue");
        if(definition && definition2){
            // 指定 Bean 定义信息
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Black.class);
            // 注册一个 Bean，指定 bean 名
            beanDefinitionRegistry.registerBeanDefinition("black", beanDefinition);
        }
    }
}

FactoryBean

public class ColorFactoryBean implements FactoryBean<Color> {
    // 返回一个Color对象，这个对象会添加到容器中
    public Object getObject() throws Exception {
        return new Color();
    }

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

    // 是否单实例
    public boolean isSingleton() {
        return false;
    }
}

注册 Bean：

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

//工厂Bean获取的是调用getObject创建的对象
Object bean2 = applicationContext.getBean("colorFactoryBean");
Object bean3 = applicationContext.getBean("colorFactoryBean");
System.out.println("bean2 的类型：" + bean2.getClass()); // com.chanshiyu.bean.Color
System.out.println(bean2 == bean3); // false，因为 isSingleton 设置的是非单实例

Object bean4 = applicationContext.getBean("&colorFactoryBean");
System.out.println("bean4 的类型：" + bean4.getClass()); // com.chanshiyu.bean.ColorFactoryBean

需要注意：使用 Spring 提供的 FactoryBean，默认获取到的是工厂 bean 调用 getObject 创建的对象，要获取工厂 Bean 本身，我们需要给 id 前面加一个 &，如 &colorFactoryBean。

如上栗子：@Bean 返回 ColorFactoryBean，默认获取 com.chanshiyu.bean.Color，需要加上 & 才返回 com.chanshiyu.bean.ColorFactoryBean。

生命周期

bean 的生命周期：创建 --> 初始化 --> 销毁的过程。容器管理 bean 的生命周期。

指定初始化和销毁方法：通过 @Bean 指定 initMethod 和 destroyMethod；
通过让 Bean 实现 InitializingBean（定义初始化逻辑）和 DisposableBean（定义销毁逻辑）接口；
可以使用 JSR250：

   `@PostConstruct`：在 bean 创建完成并且属性赋值完成，来执行初始化方法

   `@PreDestroy`：在容器销毁 bean 之前通知进行清理工作

BeanPostProcessor【interface】：bean 的后置处理器，在 bean 初始化前后进行一些处理工作

      `postProcessBeforeInitialization`：在初始化之前工作

        `postProcessAfterInitialization`：在初始化之后工作

初始化和销毁
我们可以通过 @Bean 指定 initMethod 和 destroyMethod 自定义初始化和销毁方法，容器在 bean 进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法。

初始化：对象创建完成，并赋值好，调用初始化方法，单实例在容器创建时创建对象，多实例在获取时候创建对象。
销毁：单实例在容器关闭的时候销毁，多实例下容器不会管理这个 bean，容器不会调用销毁方法。

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 ...");
    }

}

@Configuration
public class MainConfigOfLifeCycle {

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

}

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
System.out.println("容器创建成功...");

applicationContext.close();
System.out.println("容器关闭...");

打印日志：
car … constructor …
car … init …
容器创建成功…
car … destroy …
容器关闭…

**InitializingBean 和 DisposableBean**
```java
@Component
public class Cat implements InitializingBean, DisposableBean {

    public Cat() {
        System.out.println("cat ... constructor ...");
    }


    public void destroy() throws Exception {
        System.out.println("cat ... destroy ...");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("cat ... afterPropertiesSet ...");
    }
}

cat ... constructor ...
cat ... afterPropertiesSet ...
容器创建成功...
cat ... destroy ...
容器关闭...