讲解 Spring 实例化的不同方式及相关生命周期源码剖析

已于 2023-04-24 18:39:36 修改
阅读量2.4k 收藏 8
点赞数 8
分类专栏： Spring 文章标签： spring java mybatis
于 2023-04-24 11:41:25 首次发布
vnjohn
本文链接：https://blog.csdn.net/vnjohn/article/details/130234362
版权

在这里插入图片描述

前言

说到 Spring 创建对象的不同方式，其实和它的生命周期是息息相关的，在 Spring 体系专栏文章【Spring 核心方法 refresh 刷新流程简要概述及相关源码扩展实现（二）】讲解到了 实例化单例对象->核心 DefaultListableBeanFactory#preInstantiateSingletons 方法，此文讲解 Spring 创建对象不同的方式的入口也基于此方法，下面就走入此方法探测它是如何通过不同方式去创建对象的～此文内容篇幅较长，若你能耐心看完，一定能给你带来不一样的收获，文中会有满满干货！

BeanDefinition 接口

BeanDefinition 是 Spring 一个关键的接口，顾名思义就是 Bean 定义信息，它内部承载了名称、类型、代理标识以及与其他类型之间的关联信息，在 Spring 实例化、初始化 Bean 时，要先准备好所有的 BeanDefinition 信息，它最终都会存入到 DefaultListableBeanFactory#beanDefinitionMap、DefaultListableBeanFactory#beanDefinitionNames 集合中，对 BeanDefinition 接口不同子类作的梳理如下：

在这里插入图片描述

实例化 Bean 不同方式

前者讲到了 BeanDefinition，在进入到 preInstantiateSingletons 方法阶段，这些 Bean 定义信息会被冻结，不可再进行修改！

在 Spring 中有很多种实例化 Bean 方式，不一定所有的 Bean 创建都是经过：getBean->doGetBean->createBean->doCreateBean 这样的流程去进行创建的～

在这里插入图片描述

preInstantiateSingletons 方法前置源码如下：

public void preInstantiateSingletons() throws BeansException {
    if (logger.isTraceEnabled()) {
        logger.trace("Pre-instantiating singletons in " + this);
    }
    // 将所有 BeanDefinition 名字创建一个集合
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    // 触发所有非延迟加载单例 bean 的初始化，遍历集合的对象
    for (String beanName : beanNames) {
        // 合并父类 BeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 条件判断，抽象，单例，非懒加载
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 判断是否实现了 FactoryBean 接口
            if (isFactoryBean(beanName)) {
                // 根据 &+beanName 来获取具体的对象
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                // 进行类型转换
                if (bean instanceof FactoryBean) {
                    FactoryBean<?> factory = (FactoryBean<?>) bean;
                    // 判断这个 FactoryBean 是否希望立即初始化
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(
                            (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                            getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                       ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    //  如果希望急切的初始化，则通过beanName获取bean实例
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            else {
                // 如果beanName对应的bean不是FactoryBean，只是普通的bean，通过beanName获取bean实例
                getBean(beanName);
            }
        }
    }
    // 遍历 beanNames，触发所有 SmartInitializingSingleton 后初始化回调
    for (String beanName : beanNames) {
        // 获取 beanName 对应的 bean 实例
        Object singletonInstance = getSingleton(beanName);
        // 判断 singletonInstance 是否实现了 SmartInitializingSingleton 接口
        if (singletonInstance instanceof SmartInitializingSingleton) {
            // 类型转换
            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            // 触发 SmartInitializingSingleton 实现类的 afterSingletonsInstantiated 方法
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

以上源码中：!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()
此判断表示 BeanDefinition 中非抽象类、单例类、非懒加载的，Bean 定义信息才允许被执行实例化、初始化操作

AbstractBeanFactory#getMergedBeanDefinition

在进入实例化阶段前，先对 BeanDefinition 进行适配，把所有基础的 BeanDefinition 对象转换成 RootBeanDefinition，一般的都是对 GenericBeanDefinition、ScannedGenericBeanDefinition 进行缓存

在 Spring 5.x 引入了 @Indexed 注解，它减少了 Spring 容器启动的时长，它对应的 BeanDefinition 类型：ScannedGenericBeanDefinition

准备好 Bean 定义信息以后，后面在需要进行实例化时，直接可以获取定义信息；若当前定义信息中包含了父类，那么必须先加载完父类才能再去加载子类；若没有父类的话直接加载当前类即可

在这里插入图片描述

只有 ChildBeanDefinition、GenericBeanDefinition 类型以及它的子类才支持设置 parentName 属性，RootBeanDefinition 类型设置会抛出异常！

在查看源码时，很多地方都可以看到 beanFactory.getBeanNamesForType 这样的方法，在它里面的实现也会调用 getMergedLocalBeanDefinition 方法，先获取再将 BeanDefinition 合并的信息存入到缓存中，方便在这边后续进行实例化时可以直接取用，不需要再次去进行获取

FactoryBean

if (isFactoryBean(beanName)) {
	// 根据&+beanName来获取具体的对象
	Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
	// 进行类型转换
	if (bean instanceof FactoryBean) {
		FactoryBean<?> factory = (FactoryBean<?>) bean;
		// 判断这个FactoryBean是否希望立即初始化
		boolean isEagerInit;
		if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
			isEagerInit = AccessController.doPrivileged(
					(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
					getAccessControlContext());
		}
		else {
			isEagerInit = (factory instanceof SmartFactoryBean &&
					((SmartFactoryBean<?>) factory).isEagerInit());
		}
		//  如果希望急切的初始化，则通过beanName获取bean实例
		if (isEagerInit) {
			getBean(beanName);
		}
	}
}

在这里插入图片描述

对以上流程进行阐述，首先会先加载实例化 FactoryBean、SmartFactoryBean 接口的子类，将它们以类名【比如：PersonFactoryBean->personFactoryBean】按照流程（getBean->doGetBean->createBean->doCreateBean）存入到一级缓存中，随即通过 FactoryBean 接口不同类型区分：FactoryBean、SmartFactoryBean，SmartFactoryBean 是 FactoryBean 的子接口，它们之间的区别在于后者多了一个 isEagerInit、isPrototype 方法，isEagerInit 方法较为重要的是，当它返回 true 时会提前实例化内置对象【接口修饰的泛型，即 getObject 方法返回的类型】

FactoryBean#getObject 方法中返回的类，只有在我们进行获取时才会去加载，如：beanFactory.getBean(FactoryBean id or name)，但是它还有一个子接口提供更灵活的方法->SmartFactoryBean 中的 isEagerInit 方法如果返回 true，代表需要立即初始化，就会同 SmartFactoryBean 子类一同进行获取，不需要等到调用时才去加载.

在这里插入图片描述
具体代码实例如下：
内置的普通对象

public class User {
    private String username;

    public User() { }

    public User(String username) { this.username = username; }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }
}

FactoryBean 接口实现类：MyFactoryBean


public class MyFactoryBean implements FactoryBean<User> {
    @Override
    public User getObject() throws Exception {
        //任何创建对象的操作
        return new User("zhangsan");
    }

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

    @Override
    public boolean isSingleton() {
        // 如果返回 false，那么 getObject 返回的对象不会存入到缓存中，而是每一次进行调用都是生成新的对象
        // 如果返回 true，那么 getObject 返回的对象会存入到缓存中，每一次拿到的对象都是相同的内存地址
        return false;
    }
}

FactoryBean 子接口 SmartFactoryBean 实现类 MySmartFactoryBean

public class MySmartFactoryBean implements SmartFactoryBean<User> {

    @Override
    public User getObject() throws Exception {
        return new User();
    }

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

	// 返回 true，会与当前接口对象以及 getObject 获取的对象一起实例化，按 isSingleton 方法返回是否要存入到一级缓存中~
    @Override
    public boolean isEagerInit() {
        return true;
    }

    @Override
    public boolean isSingleton() {
        // 如果返回 false，那么 getObject 返回的对象不会存入到缓存中，而是每一次进行调用都是生成新的对象
        // 如果返回 true，那么 getObject 返回的对象会存入到缓存中，每一次拿到的对象都是相同的内存地址
        return true;
    }
}

通过 XML 配置，让 Spring 容器解析它去加载实例

<bean id="myFactoryBean" class="com.vnjohn.factorybean.MyFactoryBean"/>
<bean id="mySmartFactoryBean" class="com.vnjohn.factorybean.MySmartFactoryBean"/>

启动测试类

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("factoryBean.xml");
        MyFactoryBean bean = (MyFactoryBean) ac.getBean( "&myFactoryBean");
        System.out.println(bean);
        User bean1 = (User) ac.getBean("myFactoryBean");
        System.out.println(bean1.getUsername());
        User bean2 = (User) ac.getBean("myFactoryBean");
        System.out.println(bean2.getUsername());
        // 若 MyFactoryBean#isSingleton 方法返回 true，以下会返回 true，否则会返回 false
        System.out.println(bean1==bean2);
    }
}

在微服务组件中 open-feign 引入了 FeignClientFactoryBean 客户端类，来实现自定义的一些操作流程～

FactoryBean、BeanFactory 这两者经常会用来进行对比，都是用来创建对象的，只是其用处、作用不同，如下：

  • FactoryBean 接口：不需要遵守 Spring 生命周期顺序实例化类型，getObject—>返回对象、getObjectType—>返回对象类型、isSingleton—>判断是否属于单例；FactoryBean 一共创建了两个对象：第一个是实现 FactoryBean 接口的子类，第二个是通过 getObject 返回的类型，这两个都是交由给 Spring 进行管理的，但需要注意的是，实现 FactoryBean 接口的对象是存放在一级缓存里，但是调用 getObject 方法的对象如果其【isSingleton】方法返回为 false，则每次进行获取时都要去加载一个新的对象，返回 true 是会存入到 FactoryBeanRegistrySupport#factoryBeanObjectCache 中的，下次获取直接从缓存中取用即可.
  • BeanFactory 接口：必须要严格遵守 Spring 生命周期创建对象，从实例化—>初始化、invokeAwareMethod、BPP#before、BPP#after，此流程非常复杂且麻烦

InstantiationAwareBeanPostProcessor

InstantiationAwareBeanPostProcessor 接口实现了 BeanPostProcessor 接口，简称 BPP；一般的 BPP 都是在初始化前后进行调用的，此接口会提前在 createBean 方法内，判别它的实例化前/后方法是否会提前进行 Bean 实例创建，通过 InstantiationAwareBeanPostProcessor 类可以提前生成代理对象，就不会再去执行 doCreateBean 方法

之前在介绍 AbstractApplicationContext#refresh 方法内一些核心的方法时，有提到 registerBeanPostProcessors，它会提前将 Spring 容器中所有 BeanPostProcessor 接口实现类进行注册且创建好实例对象，随即在后续创建业务对象时就可以用到这些 BPP 配置类来进行额外的加载和配置工作了～

关于 InstantiationAwareBeanPostProcessor 方法提前实例化的核心逻辑在 createBean 方法内的 resolveBeforeInstantiation 方法进行实现的，流程图如下：

在这里插入图片描述
在 AbstractBeanFactory#addBeanPostProcessor 方法中会判别是否有自定义的 BPP 实现了 InstantiationAwareBeanPostProcessor 接口，若有的话设置 hasInstantiationAwareBeanPostProcessors=true，后续对所有类型进行该 BPP 调用，若满足对应的类型，那么就提前完成实例化、初始化操作！

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
	Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
	// 后添加的 BeanPostProcessor 会覆盖之前的，先删除，然后在添加
	this.beanPostProcessors.remove(beanPostProcessor);
	// 此处是为了设置某些状态变量，这些状态变量会影响后续的执行流程，只需要判断是否是指定的类型，然后设置标志位即可
	if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
		// 该变量表示 Beanfactory 是否已注册过 InstantiationAwareBeanPostProcessor
		this.hasInstantiationAwareBeanPostProcessors = true;
	}
	if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
		// 该变量表示 beanFactory 是否已注册过 DestructionAwareBeanPostProcessor
		this.hasDestructionAwareBeanPostProcessors = true;
	}
	// 将 beanPostProcessor 添加到 beanPostProcessors 缓存中
	this.beanPostProcessors.add(beanPostProcessor);
}

先调用 InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 方法完成实例化前操作，在这里可以完成赋值，基于动态代理实现；后调用 InstantiationAwareBeanPostProcessorAdapter#postProcessAfterInitialization 方法完成初始化后操作

在 postProcessBeforeInstantiation 方法执行期间其实就是提前生成该类的 CGLIB 子类代理对象返回，以下代码是创建代理对象的一般过程

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(beanClass);
enhancer.setCallback(new MyMethodInterceptor());
enhancer.create();

关于扩展此 BPP 类型的整个流程讲解

1、定义一个需要提前被 BPP 实现类实例化、初始化的类型

public class BeforeInstantiation {

    public void doSomething(){
        System.out.println("invoke doSomething....");
    }
}

2、自定义实现 MethodInterceptor 接口，用于拦截调用的方法

public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("目标方法执行之前：" + method);
        Object o1 = methodProxy.invokeSuper(o, objects);
        System.out.println("目标方法执行之后：" + method);
        return o1;
    }
}

3、自定义扩展实现 InstantiationAwareBeanPostProcessor 接口

public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    /**
     * 初始化之前处理
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("beanName:" + beanName + "----执行postProcessBeforeInitialization方法");
        return bean;
    }

    /**
     * 初始化之后处理
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("beanName:" + beanName + "----执行postProcessAfterInitialization方法");
        return bean;
    }
    
    /**
     * 实例化之前处理
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("beanName:" + beanName + "----执行postProcessBeforeInstantiation方法");
        if (beanClass == BeforeInstantiation.class) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(beanClass);
            enhancer.setCallback(new MyMethodInterceptor());
            BeforeInstantiation beforeInstantiation = (BeforeInstantiation) enhancer.create();
            System.out.println("创建代理对象："+beforeInstantiation);
            return beforeInstantiation;
        }
        return null;
    }

    /**
     * 实例化之后处理
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("beanName:" + beanName + "----执行postProcessAfterInstantiation方法");

        return false;
    }

    /**
     * 使用注解时，属性注入处理方法
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        System.out.println("beanName:" + beanName + "----执行postProcessProperties方法");
        return pvs;
    }
}

4、resolveBeforeInstantiation.xml 配置文件，让 Spring 容器能够解析到

<bean id="beforeInstantiation" class="com.vnjohn.resolveBeforeInstantiation.BeforeInstantiation"/>
<bean id="myInstantiationAwareBeanPostProcessor" class="com.vnjohn.resolveBeforeInstantiation.MyInstantiationAwareBeanPostProcessor"/>

5、测试基类

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("resolveBeforeInstantiation.xml");
        BeforeInstantiation bean = ac.getBean(BeforeInstantiation.class);
        bean.doSomething();
    }
}

如此处理之后，BeforeInstantiation 这个 Bean 就会提前在 resolveBeforeInstantiation 方法之后就返回了，不会再继续往下面调用 doCreateBean 方法创建实例对象了！

在 Spring 生命周期中，只执行了实例化之前、初始化之后这两个方法，其他的未做任何处理工作

Supplier

由 Supplier 下函数式接口进行对象创建的操作，不会再去通过反射创建对象，它不局限于具体通过什么方法去创建对象实例，相比 FactoryBean 接口而言，它要求的是类必须实现其接口且必须通过 getObject 方法来返回具体的实例对象，其属于接口规范的范畴.

Supplier 属于 AbstractBeanDefinition 类下的一个属性值【Supplier<?> instanceSupplier】若该 BeanDefinition 有设置这个属性才会提前去创建，没有则不管，按照后续正常 Spring 生命周期加载实例的流程去进行获取

在这里插入图片描述
在这里插入图片描述
下面通过扩展 Spring 来演示如何实现通过这种方式进行 Bean 实例加载

1、普通类，待加载的对象

public class User {
    private String username;

    public User() { }

    public User(String username) { this.username = username; }

    public String getUsername() { return username; }

    public void setUsername(String username) { this.username = username; }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }
}

2、函数式编程接口实现，定义一个返回对象的方法

public class CreateSupplier {

    public static User createUser(){
        return new User("vnjohn");
    }
}

3、扩展实现 BFPP，主要为了修改某个对象的 BeanDefnition 信息，为它设置 Supplier 属性

// 在执行 BFPP 时会为 beanName 为 user 的 beanDefinition 添加回调方法，返回的是 user 对象
public class SupplierBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinition user = beanFactory.getBeanDefinition("user");
        GenericBeanDefinition genericBeanDefinition = (GenericBeanDefinition) user;
        genericBeanDefinition.setInstanceSupplier(CreateSupplier::createUser);
        genericBeanDefinition.setBeanClass(User.class);
    }
}

4、 supplier.xml 配置文件，让 Spring 容器能够解析到

<bean id="user" class="com.vnjohn.supplier.User"/>
<bean class="com.vnjohn.supplier.SupplierBeanFactoryPostProcessor"/>

5、测试基类

public class TestSupplier {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("supplier.xml");
        User bean = ac.getBean(User.class);
        System.out.println(bean.getUsername());
    }
}

FactoryMethod

当需要验证不同的重载方法中，参数只有一个时具体加载那个：通过权重值来取用对应的构造方法候选者创建实例

在这里插入图片描述
通过 factory-method 方式创建对象有两种方式：

  • 通过静态工厂方法创建，要在 bean 标签中指定 factory-method、class 属性为对应的静态工厂 Bean
  • 通过实例工厂方法创建，需要在 bean 标签中指定 factory-bean(实例工厂 Bean) 引用、factory- method(实际工厂中具体要调用的方法)

下面通过 Spring 来演示如何通过实例工厂方法、静态工厂方法这两种方式进行 Bean 实例加载
1、实例工厂、静态工厂要创建的对象

public class Person {
    private int id;
    private String name;

    public int getId() { return id; }

    public void setId(int id) { this.id = id; }

    public String getName() { return name; }

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

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

2、实例工厂类

public class PersonInstanceFactory {
    public Person getPerson(String name){
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        return person;
    }
}

3、静态工厂类

public class PersonStaticFactory {
    public static Person getPerson(int age) {
        System.out.println("getPerson >>>> age");
        return new Person();
    }

    public static Person getPerson(String name) {
        System.out.println("getPerson >>>> name");
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        return person;
    }

    public static Person getPerson(String name, int id) {
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        return person;
    }
}

4、 factoryMethod.xml 配置文件，让 Spring 容器能够解析到它们之间的依赖关系

<bean id="person" class="com.vnjohn.factoryMethod.PersonStaticFactory" factory-method="getPerson">
  <constructor-arg value="123" type="int"/>
</bean>
<bean id="personInstanceFactory" class="com.vnjohn.factoryMethod.PersonInstanceFactory"/>
<bean id="person2" class="com.vnjohn.factoryMethod.Person" factory-bean="personInstanceFactory" factory-method="getPerson">
  <constructor-arg value="vnjohn"/>
</bean>

constructor-arg：可以为方法指定参数和类型，如果未指定 int 类型的话，那么就会调用类型为 String 参数的方法，因为它会优先按照实际的参数类型来进行调用的
静态工厂直接指定方法即可，class 需指定静态工厂类
实例工厂需要指定工厂实例对象，同时需要指定方法，class 为工厂需要创建的类

5、测试基类

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

构造方法注入

通过反射获取实例，主要是先获取到 Bean 构造器集合，然后选择不同的构造函数（有参、无参）进行实例化，可以通过配置文件来配置构造参数，也可以在构造函数上定义 @Autowire 注解

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// 确认需要创建的 bean 实例类可以实例化
	Class<?> beanClass = resolveBeanClass(mbd, beanName);
	// 确保 class 不为空，并且访问权限是 public
	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}
	// 判断当前 beanDefinition 中是否包含实例供应器，此处相当于一个回调方法，利用回调方法来创建 bean
	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}
	// 如果工厂方法不为空则使用工厂方法初始化策略
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}
	// 一个类可能有多个构造器，所以 Spring 根据参数个数、类型确定需要调用的构造器
	// 在使用构造器创建实例后，Spring 会将解析过后确定下来的构造器或工厂方法保存在缓存中，避免再次创建相同 bean 时再次解析
	// 标记下，防止重复创建同一个bean
	boolean resolved = false;
	// 是否需要自动装配
	boolean autowireNecessary = false;
	// 如果没有参数
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			// 一个类可能由多个构造函数，所以需要根据配置文件中配置的参数或传入的参数来确定最终调用的构造函数
			// 因为判断过程会比较，所以 Spring 会将解析、确定好的构造函数缓存到 BeanDefinition#resolvedConstructorOrFactoryMethod 字段中
			// 在下次创建相同时直接从RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod缓存的值获取，避免再次解析
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	// 有构造参数的或者工厂方法
	if (resolved) {
		// 构造器有参数
		if (autowireNecessary) {
			// 构造函数自动注入
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			// 使用默认构造函数构造
			return instantiateBean(beanName, mbd);
		}
	}
	// Bean 后置处理器中为自动装配寻找构造方法, 有且仅有一个有参构造或者有且仅有 @Autowired 注解构造
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	// 以下情况符合其一即可进入
	// 1、存在可选构造方法
	// 2、自动装配模型为构造函数自动装配
	// 3、给 BeanDefinition 中设置了构造参数值
	// 4、有参与构造函数参数列表的参数
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		return autowireConstructor(beanName, mbd, ctors, args);
	}
	// 找出最合适的默认构造方法
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		// 构造函数自动注入
		return autowireConstructor(beanName, mbd, ctors, null);
	}
	// 使用默认无参构造函数创建对象，如果没有无参构造且存在多个有参构造且没有 @AutoWired 注解构造，会报错
	return instantiateBean(beanName, mbd);
}
  1. 首先从 BeanDefinition 缓存中读取当前 Bean 是否存在，若存在直接取用进行实例化，无须再次进行解析
  2. autowireConstructor：通过构造函数注入，若没有传入构造器时，就会筛选类中所有的构造器候选者集合
  3. 一般传入的构造器不为空时，都是通过 @Autowire 注解标注的构造方法，第一次加载的 Bean 都会经过 determineConstructorsFromBeanPostProcessors 方法去扫描，然后存入到缓存中，后续就可以直接从 autowireConstructor 直接获取，无法再次进行扫描.

First：初始化 Bean，进行包装，将一些转换器、属性编辑器注入 BeanDefinition 中，然后从缓存中取出当前 bean，是否存在构造函数、参数，存在就直接实例化
Second：判断传入的构造器是否为空，为空的话就通过反射获取到所有的构造方法， 若构造器只有一个并且不需要参数【一般默认无参构造直接是调用->instantiateBean 方法，这里主要是通过 @Autowire 注解标注了无参构造方法，直接就可以实例化】
Thirty：解析配置文件的构造器参数，再对所有构造器进行排序（1-访问修饰符、2-参数个数多少）遍历构造器集合，筛选出更合适的一个构造器进行实例化，若遇到了冲突的构造函数，按照权重值匹配更合适的
Four：将当前匹配到的构造器存入缓存中：ConstructorResolver.ArgumentsHolder#storeCache
Five：按匹配到的构造器、参数进行实例化操作

determineConstructorsFromBeanPostProcessors：实现于 SmartInstantiationAwareBeanPostProcessor 接口的类才会有此方法实现，若没有开启注解扫描，此处会被忽略，具体实现类->AutowiredAnnotationBeanPostProcessor，由它来完成对构造函数的解析及推断，以下是其方法 AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors 处理的流程图：

在这里插入图片描述

  1. @Lookup 注解扫描，无论其是否含有 @Lookup 修饰的方法，过滤完成以后都会放入到集合中，证明此 Bean 已经完成了 @Lookup 检查
  2. 通过注解扫描，获取构造器集合会有以下几种情况：

1、若有多个 @Autowired，required 属性为 true，不管有没有默认构造方法，都会报异常：Invalid autowire-marked constructor: public com.vnjohn.reflection.Person(int,java.lang.String). Found constructor with 'required' Autowired annotation already: public com.vnjohn.reflection.Person(int)
2、若只有一个 @Autowired，required 为 false，没有默认构造方法，会报警告：Inconsistent constructor declaration on bean with name ‘person’: single autowire-marked constructor flagged as optional - this constructor is effectively required since there is no default constructor to fall back to: public com.vnjohn.reflection.Person(int)
3、若没有 @Autowired 注解，定义了两个及以上有参数的构造方法，没有无参构造方法，就会报错：No default constructor found; nested exception is java.lang.NoSuchMethodException: com.vnjohn.reflection.Person.<init>()
4、其他情况都可以，但首先以有 @Autowired 注解修饰的构造方法优先，然后才是默认构造方法

  1. 此方法处理完以后，将所有的满足条件的构造器选出以后，又会调用 autowireConstructor 方法继续去进行实例化操作

实例化策略

在 Spring 反射注入方式，要先区分它对应的实例化策略，分为普通对象实例化、动态代理对象实例化，动态代理对象实例化类 继承 普通对象实例化类

在这里插入图片描述

在 Spring 中，默认的实例化策略实现类是 CGLIB

// bean的生成策略，默认是 CGLIB
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

处理 FactoryMethod、有参构造、无参构造的实例化使用的是 SimpleInstantiationStrategy 简单对象实例化策略类，CGLIB 继承于 Simple，所有 CGLIB 类自然包含了 Simple 可以处理的逻辑，CGLIB 主要处理的就是带有 MethodOverrides 信息的

  • 首先生成 CGLIB 代理子类
  • 最后再设置 Lookup、Replace 拦截器回调

若通过有参构造进行实例化时，会提前将 Bean 进行包装处理，将一些转换器、属性编辑器注入 BeanDefinition 中，但处理无参构造时，是先将其实例化完成，然后再进行设置；两者都是为了对 Bean 进行基础信息的封装，无其他的特殊性

MethodOverrides

MethodOverrides 是 AbstractBeanDefinition 的一个集合属性，它主要是为了记录 lookup-method、replace-method 元素的信息，它在 Spring 几处会进行解析，同时对有修饰此属性的对象，会为它生成代理对象

在这里插入图片描述

LookupMethod

主要用来解决单例引用原型 Bean 的问题： 如果未加任何处理的话，单例 Bean 对象中会一直引用最先开始创建的原型 bean 实例，后面原型 Bean 重新获取后单例内的属性引用并不会发生任何的改变，那么我们的原型 Bean 的存在就没有意义了.

这样就违背了原型模式的初衷，没有作任何处理的话，原型 Bean 会随着单例 Bean 引用一并存入到一级缓存中，此时就需要 LookupMethod 了，可以用 loopup-method 标签或 @Lookup 注解来解决此问题

下面通过一个实际的案例来介绍 Spring 中如何使用 lookup-method 标签来解决此问题
1、单例 Bean>Apple，引用原型 Bean>Banana

public class Apple {
	// 普通方式进行引用就会出现原型引用不会进行改变的问题
    private Banana banana;
    public Apple() {
        System.out.println("I got a fresh apple");
    }
    public Banana getBanana() {
        return banana;
    }

    public void setBanana(Banana banana) {
        this.banana = banana;
    }
}

public class Banana {
    public Banana() {
        System.out.println("I got a  fresh bananer");
    }
}

2、methodOverride.xml 配置文件，处理它们之间的依赖关系

<bean id="apple" class="com.vnjohn.methodOverrides.lookup.Apple">
    <!-- 当我们手动进行 getBean 时会去调用 lookupInterceptor 类进行创建 banana，所以通过 lookup 能够达到我们想要的效果 -->
    <lookup-method name="getBanana" bean="banana"/>
</bean>
<bean id="banana" class="com.vnjohn.methodOverrides.lookup.Banana" scope="prototype"/>

3、测试基类

public class TestMethodOverride {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("methodOverride.xml");
        Apple bean1 = ac.getBean(Apple.class);
        System.out.println(bean1);
        Apple bean2 = ac.getBean(Apple.class);
        System.out.println(bean2);
        System.out.println(bean1.getBanana());
        System.out.println(bean1.getBanana());
    }
}

以上的方式可以解决我们在单例 Bean 下引用原型 Bean 的问题，还有其他的方式可以进行处理，比如：调用我们具体的对象时，通过方法手动的去进行 getBean【在原型模式下调用时每次都会创建新的实例】这样也可以解决，但我们目的就是采用 Spring 方式解决该问题.

下面我们来看具体的 LookupOverrideMethodInterceptor 拦截器是如何处理的～

private static class LookupOverrideMethodInterceptor extends CglibIdentitySupport implements MethodInterceptor {

  private final BeanFactory owner;

  public LookupOverrideMethodInterceptor(RootBeanDefinition beanDefinition, BeanFactory owner) {
    super(beanDefinition);
    this.owner = owner;
  }

  @Override
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
    // 获取到 lookup-method 标签信息：方法名、类名
    LookupOverride lo = (LookupOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
    Assert.state(lo != null, "LookupOverride not found");
    Object[] argsToUse = (args.length > 0 ? args : null);  // if no-arg, don't insist on args at all
    // owner 通过 beanFactory 调用 getBean 进行实例化，如果是原型模式每次获取的都是新的实例
    if (StringUtils.hasText(lo.getBeanName())) {
      return (argsToUse != null ? this.owner.getBean(lo.getBeanName(), argsToUse) :
              this.owner.getBean(lo.getBeanName()));
    }
    else {
      return (argsToUse != null ? this.owner.getBean(method.getReturnType(), argsToUse) :
              this.owner.getBean(method.getReturnType()));
    }
  }
}

ReplaceMethod

主要是用来替换方法体及返回值，与 LookupMethod 执行逻辑是相似的，都是需要 CGLIB 子类后通过拦截器进行处理的

下面通过一个实际的案例来介绍 Spring 中如何使用 replace-method 标签
1、原始类处理逻辑

public class OriginalDog {
	public void sayHello() {
		System.out.println("Hello,I am a black dog...");
	}

	public void sayHello(String name) {
		System.out.println("Hello,I am a black dog, my name is " + name);
	}
}

2、替换类处理逻辑

public class ReplaceDog implements MethodReplacer {
	@Override
	public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
		System.out.println("Hello, I am a white dog...");

		Arrays.stream(args).forEach(str -> System.out.println("参数:" + str));
		return obj;
	}
}

3、replaceMethodOverride.xml 配置文件，处理它们之间的依赖关系

<bean id="dogReplaceMethod" class="com.vnjohn.methodOverrides.replace.ReplaceDog"/>

<bean id="originalDogReplaceMethod" class="com.vnjohn.methodOverrides.replace.OriginalDog">
  <replaced-method name="sayHello" replacer="dogReplaceMethod">
    <arg-type match="java.lang.String"/>
  </replaced-method>
</bean>

4、测试基类

public class TestReplaceMethodOverride {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("replaceMethodOverride.xml");
        OriginalDog originalDog = ac.getBean(OriginalDog.class);
        originalDog.sayHello("vnjohn");
    }
}

只是处理 lookup-method 的类是 LookupOverrideMethodInterceptor，处理 replace-method 的类是 ReplaceOverrideMethodInterceptor，都是通过 CGLIB 子类拦截器来进行实现，下面我们来看具体的 ReplaceOverrideMethodInterceptor 拦截器是如何处理的～

private static class ReplaceOverrideMethodInterceptor extends CglibIdentitySupport implements MethodInterceptor {

  private final BeanFactory owner;

  public ReplaceOverrideMethodInterceptor(RootBeanDefinition beanDefinition, BeanFactory owner) {
    super(beanDefinition);
    this.owner = owner;
  }

  @Override
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
    ReplaceOverride ro = (ReplaceOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
    Assert.state(ro != null, "ReplaceOverride not found");
    // 获取到自定义的 replacer 替换实现类后进行调用
    MethodReplacer mr = this.owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class);
    return mr.reimplement(obj, method, args);
  }
}

总结

该篇博文，先介绍了 BeanDefinition 接口以及与它子类之间的关系，主要分析的是在 Spring 中不同的实例化方式，如：FactoryBean、FactoryMethod、Supplier、自定义 BPP 接口实现类、反射注入，反射注入是 Spring 中比较核心的，它一般可以通过无参构造、有参构造去注入 Bean 实例；最后，MethodOverrides 此属性虽然在工作中很少应用，但我们应该要知道此【单例 Bean 引用原型 Bean 问题】问题的解决方案，希望博文能够帮助你快速的理解 Spring 实例化过程～

关于 Spring 生命周期源码剖析，目前只介绍了它的实例化过程，后面还有填充属性、初始化 Bean 源码流程未作介绍 TODO，请敬请期待

稍微总结一下 Spring 正常创建 Bean 整个生命周期过程如下：

  1. 实例化 bean 对象：getBean->doGetBean->createBean->doCreateBean->createBeanInstance
  2. 填充对象属性
  3. 检查 Aware 相关接口并设置相关依赖
  4. BeanPostProcessors 初始化前置处理方法 postProcessBeforeInitialization
  5. 检查是否有实现 InitializingBean 以决定是否调用 afterPropertiesSet 方法
  6. 检查是否配置有自定义的 init-method，调用执行
  7. BeanPostProcessors 初始化后置处理方法 postProcessAfterInitialization
  8. 实现 DestructionAwareBeanPostProcessor 接口的类，销毁前调用方法 postProcessBeforeDestruction
  9. 检查是否有实现 DisposableBean 以决定是否调用 destroy 方法
  10. 检查是否配置有自定义的 destroy-method，调用执行

如果觉得博文不错，关注我 vnjohn，后续会有更多实战、源码、架构干货分享！
大家的「关注❤️ + 点赞👍 + 收藏⭐」就是我创作的最大动力！谢谢大家的支持，我们下文见！

vnjohn
关注
专栏目录
Spring中Bean的实例化方式：全面解析
xycxycooo的博客
08-12 612
基于构造器的实例化是Spring中最常用的实例化方式。Spring容器通过调用Bean类的构造器来创建Bean实例。这种方式简单直观，适用于大多数场景。基于静态工厂方法的实例化是指Spring容器通过调用Bean类的静态工厂方法来创建Bean实例。这种方式适用于需要通过静态方法创建实例的场景。基于实例工厂方法的实例化是指Spring容器通过调用另一个Bean的实例方法来创建Bean实例。这种方式适用于需要通过实例方法创建实例的场景。基于FactoryBean的实例化是指Spring容器通过调用实现了。
spring源码剖析
07-08
《Spring源码剖析：深入理解对象管理机制》 在软件开发领域，Spring框架以其强大的功能和灵活的设计，成为了Java企业级应用的事实标准。其核心特性之一就是依赖注入（Dependency Injection，DI），它使得应用程序的...
06-Spring中的实例化方式有哪些
小魏快起床的博客
11-07 885
​ 前面讲到了Spring创建对象Spring项目搭建，如何通过Spring创建对象_小魏快起床的博客-CSDN博客，那么在Spring中创建对象方式有哪些呢，这个问题也是外面很多面试官会问到的问题，这里小魏就带各位看官进入了解一下 ​
spring中bean的配置(别名，实例化方法)
qq_52351978的博客
08-14 826
bean标签中除了IOC容器可以通过Id命名得到对应的实体类，也可以通过name属性的取名创建实体类。此时创建的不是UserDaoFactoryBean的实体类，而是getObject方法返回的实体类。表现层对象，业务层对象，数据层对象，工具对象适合交给容器进行管理(只用创建一次即可)FactoryBean实例化bean(实例工厂初始化对象的改良)(实用方法)spring中bean默认创建的对象是单例对象。1.创建工厂类提供静态方法创建需要创建的对象。首先创建工厂的实体类，在创建所需类的bean。
Spring | Spring源码解析之Bean实例化流程
苏老师的博客
10-17 738
spring 源码 spring Bean实例化的流程
Spring的对象实例化
coobee的博客
05-14 1314
Overview Spring实例化对象，主要通过三种方式： @Component applicationContext.xml @Configuration + @Bean @Component 现在开发最常用的方式, 通过标注声明告诉Spring容器，让其扫描时将其实例化。 主要标注为@Component，以及它的别名@Service，@Controller， @Resource， @Repository等。 Spring会扫描@ComponentScan(basePackages={
spring 实例化对象的3种方式
健康平安的活着的专栏
01-03 1000
一.无惨构造方法实例化 <!--userDao的创建 ，这个bean的id可以任意起名， 默认使用构造函数实例化对象 <bean id="userDaoDemo" class="com.ljf.spring.demo.ioc.dao.impl.UserDaoImpl" scope="singleton"></bean> 二.工厂静态方法实例化 <!--userDao的创建 ，这个bean的id可以任意起名， 静态工厂方式实例化化对
Spring源码解析手册
02-21
《Spring源码解析手册》是2023年针对Java开发者深入理解Spring框架的重要参考资料，旨在用通俗易懂的方式解析Spring的核心源码，帮助开发者掌握Spring的内部工作原理。本手册将通过实例、代码调试和GitHub资源来详细...
spring源码视频教程
05-22
Bean可以通过XML配置文件、注解或者Java配置类进行定义，容器根据这些信息实例化、初始化、装配Bean，并管理其生命周期。 5. **数据访问集成**：Spring支持多种数据访问技术，如JDBC、ORM（Hibernate、MyBatis）、...
Spring+3.x企业应用开发实战光盘源码(全)
03-27
　第3章：讲解Spring IoC容器的知识，通过具体的实例详细地讲解IoC概念。同时，对Spring框架的三个最重要的框架级接口进行了剖析，并对Bean的生命周期进行讲解。 　第4章：讲解如何在Spring配置文件中使用Spring 3.0...
spring基础实例源码
07-03
此外，还涉及了bean的生命周期状态，如单例bean的实例化时机以及原型bean的每次请求都会创建新实例等。 2. **Spring_0700_IOC_Collections**： 在这个主题中，我们探讨了如何在Spring配置中处理集合类型属性，如...
Spring6 - （08） Bean 的实例化方法
chenyouchang的博客
03-26 453
java.util.Date在Spring中被当做简单类型，简单类型在注入的时候可以直接使用value属性或value标签来完成。但我们之前已经测试过了，对于Date类型来说，采用value属性或value标签赋值的时候，对日期字符串的格式要求非常严格，必须是这种格式的：Mon Oct 10 14:30:26 CST 2022。其他格式是不会被识别的。如以下代码：第一步：创建DateBean类} }第二步：配置beans.xml
Spring实例化Bean的三种方法
unber的博客
08-09 4047
在面向对象的程序中，要想调用某个类的成员方法，就需要先实例化该类的对象。
用spring管理和实例化对象的四种方式
weixin_42880145的博客
09-19 3551
用spring管理和实例化对象的四种方式 方式一:无参构造函数(最常用) 对象是spring创建,创建的对象还要交给spring容器管理 bean:豆子 id:在spring容器中Hello对象的名,在容器中id的值必须唯一 class:要对哪个类实例化对象,遵守 包名.类名 底层:Object obj=Class.forName(“包名.类名”).newInstance();（反射原理） 如何断...
Spring实例化Bean的三种方式及其优缺点
最新发布
weixin_52721608的博客
09-30 240
除了上述两种方式，Spring还支持直接通过@Autowired注解来实例化Bean。在Spring中，我们可以通过构造函数的方式将需要的依赖注入到Bean中。与构造函数注入方式相比，setter方法注入方式更加灵活。
spring bean实例化的三种方法
weixin_63802890的博客
07-20 2278
**/**无参构造器，创建对象时必须要用，在此处代码如果运行了，就代表创建对象时运行了此代码，对于构造器的理解看看example公共的和私有的都可以访问，有无都可以1.结论实例化bean就是用构造方法来实例化对象**/publicBookDaoImpl(){System.out.println("bookdao构造器isrunning....");}}}}}............
Spring
work4j的博客
04-07 353
谈谈对Spring的理解 2. 谈谈对Spring IOC的理解 IOC：控制反转。以前代码中的对象都是我们自己通过new的方式，自己来管理，在Spring中，我们可以将整个对象交给Spring容器来管理。（是一种思想理论） DI：依赖注入。以前我们在对象中设置属性，可以通过new、setter、construtor的方式注入，在Spring中，可以通过@Autowared、@Resource、populateBean方法，将对应的属性注入到具体的对象中。 容器：用来存储管理对象的bean工厂。使用map.
Spring框架实现实例化有哪些几种方式?
CZ-001的博客
01-12 1392
Spring框架实现实例化的三种方式： 第1种：使用构造器实例化Bean 这是最简单的方式，Spring IoC容器即能使用默认空构造器也能使用有参数构造器两种方式创建Bean。 第2种：使用静态工厂方式实例化Bean 使用这种方式除了指定必须的class属性，还要指定factory-method属性来指定实例化Bean的方法，该方法必须是静态方法。而且使用静态工厂方法也允许指定方法参数，spring IoC容器将调用此属性指定的方法来获取Bean。 第3种：使用实例工厂方法实例化Bean..
Spring基础之实例化方式
Hatty1920的博客
01-03 738
文章目录前言一、默认构造二、静态工厂三、实例工厂总结 前言 本篇主要介绍了spring实例化的三种方式：默认构造、静态工厂、实例工厂。 一、默认构造 这种方式其实在入门案例中已经看到了，是spring中很常见的一种实例化方式，也很简单。在xml中配置如下： <bean id="xxx" class="xxx.xxx" /> 这样的配置方式就是默认构造了。这里需要注意的一点是，使用这种方式实例化一定要有默认构造，没有默认构造的话会报错。 （如果创建一个类不写构造，会默认继承父类的无参构造，这
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

vnjohn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值