[Spring]Bean与BeanDefinition

IOC容器

IOC容器主要的职责有:

Spring IOC 可以从配置文件或者注解中根据每个Bean的定义，将这些Java对象解析成BeanDefinition,最后注册到IOC容器
依赖注入(DI),构造一个对象可以通过构造函数、静态工厂方法、工厂方法。日常开发中在Controller中使用@Autowired注入Service就是依赖注入的过程。
管理Bean的生命周期，Spring可以管理Bean的作用域、加载时机等信息。
日常使用中，ApplicationContext接口代表Spring IOC 容器

Spring官网对容器的概述图,业务Java对象加上元数据的配置，被Spring IOC进行读取、解析、注册到IOC容器后，对外界提供使用。

IOC

Bean

交由Spring IOC容器管理的Java对象称为Bean
Bean的本质还是Java对象，只不过在此基础上，IOC负责了这个Java对象的生命周期。
除了本身的Java对象内容外，Spring提供了一系列的配置项让开发者更好的去定义Bean，比如一个配置项，你希望它是单例的，那么你可以在xml中配置成scope="singleton"
命名Bean可以在xml中指定id或者name,如果不提供，则默认按首字母小写的驼峰规则生成
别名alias: 除了name之外，你可以指定Bean的别名，即你可以通过其他的命名来从容器中获取这个Bean.

PersonFactory

@Component
public class PersonFactory {

    /**
     * 这个Bean即可以为personC,也可以为Kobe
     */
    @Bean({"personC", "Kobe"})
    public Person getPerson() {
        return new Person("I am Kobe who created by PersonFactory");
    }
}

Demo

@Configuration
@ComponentScan(value = "com.xjm")
public class BeanDefinitionDemoByAnnotation {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AnnotationContextDemo.class);
        Person kobe = (Person) applicationContext.getBean("Kobe");
        System.out.println(kobe.toString());
    }
}

BeanDefinition

根据配置，用来描述Bean的BeanDefinition,它是一个接口，主要定义了一些Bean该有的方法,让下层实现类去实现这些功能,以下声明的属性均不在BeanDefinition中，只是便于理解，实际上Beandefinition只是定义了它们的getter和setter:

beanClassName:bean的类名称
scope:bean的作用域
lazyInit:是否懒加载
primary:如果存在多个实现类，优先以这个为首选实现类
factoryBeanName:指定要使用的工厂bean（如果有）。这是用于调用指定工厂方法的bean的名称
factoryMethod:指定工厂方法（如果有）。将使用构造函数参数调用此方法，如果未指定，则不使用任何参数。该方法将在指定的工厂bean（如果有）上被调用，否则将作为本地bean类上的静态方法被调用。
constructorArgumentValues:获取构造函数的参数,只读，内部用LinkedHashMap按照index存储参数。
propertyValues:Bean实例的属性值。可以在bean工厂后处理期间修改返回的实例。
dependsOn:设置该bean依赖于初始化的bean的名称。 Bean工厂将确保首先初始化这些Bean。
autowiredCandidate:设置此bean是否适合自动连接到其他bean,只影响基于type类型的自动装配，不影响基于name的自动装配。以及布尔方法:isAutowireCandidate()
initMethodName:初始化的函数名
destroyMethodName:销毁方法名
description:给bean添加可读性较友好的描述
parentName:bean的parent名称

Bean的作用域

Bean的作用域 ,可以指定值为:singleton、prototype、request、session、application。

范围	描述
singleton	默认的作用域，单例
prototype	原型模式，也就是可以创建多个对象实例
request	生命周期为一个Http请求的Bean。即每个Http请求都会产生一个自己的Bean实例。仅在ApplicationContext中有效
session	生命周期为整个Http的Bean。仅在ApplicationContext中有效
application	作用域限定为ServletContext的生命周期

我们从xml或者注解中定义的内容都会被解析成BeanDefinition,再根据BeanDefinition产生Bean实例，这就跟Person.java->Person.class->Person是类似的。

实例化对象的几种方式

spring-config.xml

Person

public class Person {

    private String name;

    private Integer age;

    public Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

PersonFactory

public class PersonFactory {

    public Person getPerson() {
        return new Person("I am Kobe who created by PeronFactory");
    }
}

PersonStaticFactory

public class PersonStaticFactory {

    public static Person getPerson() {
        return new Person("I am James who created by PersonStaticFactory");
    }
}

demo

@SuppressWarnings("all")
public class BeanDefinitionDemo {
    public static void main(String[] args) {
        // 1. 声明配置类路径
        String xmlPath = "D:\\Spring\\spring-framework-5.1.x\\spring-demo\\src\\main\\resources\\spring\\spring-config.xml";
        // 2. 加载xml配置类
        ApplicationContext applicationContext = new FileSystemXmlApplicationContext(xmlPath);
        System.out.println("****************Before Spring********************");
        // 默认的构造函数
        Person person = new Person();
        System.out.println(person.toString());
        // 使用静态方法创建Person
        Person kobe = PersonStaticFactory.getPerson();
        System.out.println(kobe.toString());
        // 使用工厂创建Person
        PersonFactory personFactory = new PersonFactory();
        System.out.println(personFactory.getPerson().toString());
        System.out.println("****************Using Spring********************");
        // 默认构造函数创建Bean
        Person personA = (Person) applicationContext.getBean("personA");
        // 通过静态工厂方法创建Bean
        Person personB = (Person) applicationContext.getBean("personB");
        // 通过工厂方法创建Bean
        Person personC = (Person) applicationContext.getBean("personC");
        System.out.println(personA.toString()+"hashcode:"+personA.hashCode());
        System.out.println(personB.toString()+"hashcode:"+personB.hashCode());
        System.out.println(personC.toString()+"hashcode:"+personC.hashCode());
        System.out.println("************Singleton*********************");
        Person personAA = (Person) applicationContext.getBean("personA");
        Person personBB = (Person) applicationContext.getBean("personB");
        Person personCC = (Person) applicationContext.getBean("personC");
        System.out.println(personAA.toString()+"hashcode:"+personAA.hashCode());
        System.out.println(personBB.toString()+"hashcode:"+personBB.hashCode());
        System.out.println(personCC.toString()+"hashcode:"+personCC.hashCode());
    }
}

可以看到，在xml配置好对应的初始化方式后，Spring就会根据配置的方式对对象实例进行初始化。

demo

AbstractBeanDefinition

AbstractBeanDefinition是BeanDefinition接口的抽象实现，也就是说它负责定义下层子类可以复用的代码，提供一些公共参数。

Class:beanClass,Bean的class对象或是类的全限定名,用来实例化Bean
Name: Bean的命名
Scope:scope,Bean的作用域
Constructor arguments: constructorArgumentValues,构造器参数,在依赖注入的时候用到
Properties:propertyValues,属性，在依赖注入的时候用到
Autowiring mode:AUTOWIRE_NO、AUTOWIRE_BY_NAME、AUTOWIRE_BY_TYPE、AUTOWIRE_CONSTRUCTOR,自动装配方式,byName,byType,byConstructor
Lazy initialization mode：lazyInit,懒加载方式
Initialization method:initMethodName,实例化方法，在实例化时的钩子函数
Destruction method:destroyMethodName,销毁方法，在销毁时的钩子函数
Autowire candidate: autowireCandidate,声明该bean是否可以作为被自动装配的目标
primary(@Primary):primary,设置为true的bean会是优先的实现类,用在一个Bean有多个实现类的场景
Factory bean name:factoryBeanName,工厂类名
Factory method:factoryMethodName, 指定工厂方法（如果有）。将使用构造函数参数调用此方法，如果未指定，则不使用任何参数。该方法将在指定的工厂bean（如果有）上被调用，否则将作为本地bean类上的静态方法被调用。

以下是AbstractBeanDefinition中定义的一些属性

BeanDefinition	XML
scope
lazyInit
beanClass
autowireCandidate
primary
factoryMethodName	单独使用getPerson需要为static
factoryBeanName	可以理解为先创建personFactory，实现FactoryBean的接口，然后根据getObject再调用里面的getPerson方法

BeanDefinition的UML图

UML

OK,我们看到AbstractBeanDefinition是在Beandefinition上做了一些简单的属性声明与构造器，具体的实现还是由GenericBeanDefinition、RootBeanDefinition、ChildBeanDefinition去实现的，那么这三者之间有什么联系呢?下章见分晓

总结

Spring为了管理Java对象，创造了Bean和Beandefinition，然后提供了xml和注解的方式来读取这些配置信息，解析成Beandefinition，最后生成Bean注册到IOC容器中。
实例化bean的方式可以为:构造函数、静态工厂方法、工厂实例方法(先创建工厂再调用方法)
自动装配的方式有:byName、byType、byConstructor
Bean的生命周期可以是:singleton、prototype、request、session、application等
IOC容器中默认的Bean命名方式为首字母的驼峰规则,可以通过指定别名来获取你的Bean