Spring官网阅读（一）容器及实例化

我们再从代码的角度进行一波分析，这里我们直接定位到 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance 这个方法中，具体定位步骤不再演示了，大家可以通过形如下面这段代码：

// 这里我们通过xml配置实例化一个容器
ClassPathXmlApplicationContext cc = new ClassPathXmlApplicationContext("classpath:application.xml");
MyServiceImpl luBan = (MyServiceImpl) cc.getBean("myServiceImpl");

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        // 1.获取这个bean的class属性，确保beanDefinition中beanClass属性已经完成解析
        // 我们通过xml从<bean>标签中解析出来的class属性在刚刚开始的时候必定是个字符串
        Class<?> beanClass = resolveBeanClass(mbd, beanName);

        // 省略异常判断代码.....
        
        // 2.通过beanDefinition中的supplier实例化这个bean
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }
        
        // 3.通过FactoryMethod实例化这个bean
        if (mbd.getFactoryMethodName() != null) {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        // 4.下面这段代码都是在通过构造函数实例化这个Bean,分两种情况，一种是通过默认的无参构造，一种 是通过推断出来的构造函数
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
    
    
   
        if (resolved) {
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                return instantiateBean(beanName, mbd);
            }
        }

        // Candidate constructors for autowiring?
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // Preferred constructors for default construction?
        ctors = mbd.getPreferredConstructors();
        if (ctors != null) {
            return autowireConstructor(beanName, mbd, ctors, null);
        }

        // No special handling: simply use no-arg constructor.
        return instantiateBean(beanName, mbd);
    }

经过断点测试，发现这种情况下，在实例化对象时会进入上面的supplier方法。下面是测试代码：

public static void main(String[] args) {
    // AnnotationConfigApplicationContext是GenericApplicationContext的一个子类
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
        ac.registerBean("service", Service.class,Service::new);
        ac.refresh();
        System.out.println(ac.getBean("service"));
    }

测试代码：

public class Main {
    public static void main(String[] args) {
        // 通过配置类扫描
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
        System.out.println(ac.getBean(Service.class));
    }
}

@Component
public class Service {

}

测试代码：

public class Main {
    public static void main(String[] args) {
        // 通过配置类扫描
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
        // 这里将测试对象换为config即可，同时记得将条件断点更改为beanName.equlas("config")
        System.out.println(ac.getBean(config.class));
    }
}

测试代码：

@Configuration
@ComponentScan("com.dmz.official")
public class Config {
    @Bean
    public Service service(){
        return new Service();
    }
}

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac =
                new AnnotationConfigApplicationContext(Config.class);
        System.out.println(ac.getBean("service"));
    }
}

测试代码：

public static void main(String[] args) {
    ClassPathXmlApplicationContext cc = new ClassPathXmlApplicationContext("application.xml");
    System.out.println(cc.getBean("service"));
}

<?xml version="1.0" encoding="UTF-8"?>
<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">
<!-- <bean id="myServiceImpl" class="com.dmz.official.service.Service"/>-->

    <!-- the factory bean, which contains a method called get() -->
    <bean id="myFactoryBean" class="com.dmz.official.service.MyFactoryBean">
        <!-- inject any dependencies required by this locator bean -->
    </bean>

    <!-- 测试实例工厂方法创建对象-->
    <bean id="clientService"
          factory-bean="myFactoryBean"
          factory-method="get"/>

    <!--测试静态工厂方法创建对象-->
    <bean id="service"
          class="com.dmz.official.service.MyFactoryBean"
          factory-method="staticGet"/>
</beans>

测试代码（配置文件不变）：

public static void main(String[] args) {
    ClassPathXmlApplicationContext cc =
        new ClassPathXmlApplicationContext("application.xml");
    System.out.println(cc.getBean("clientService"));
}

断点如下：