Spring容器及实例化

最新推荐文章于 2024-04-12 11:18:41 发布

java_eehehe

最新推荐文章于 2024-04-12 11:18:41 发布

阅读量631

点赞数

分类专栏： spring 文章标签： java spring

本文链接：https://blog.csdn.net/java_eehehe/article/details/106366796

版权

spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

spring容器

容器是什么？

我们先看官网中的一句话：

The org.springframework.context.ApplicationContext interface represents the Spring IoC container and is responsible for instantiating, configuring, and assembling the beans.

翻译下来大概就是：

Spring IOC容器就是一个org.springframework.context.ApplicationContext的实例化对象
容器负责了实例化，配置以及装配一个bean
那么我们可以说：
从代码层次来看：Spring容器就是一个实现了ApplicationContext接口的对象，
从功能上来看： Spring 容器是 Spring 框架的核心，是用来管理对象的。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。
容器如何工作？
我们直接看官网上的一张图片，如下：

Spring容器通过我们提交的pojo类以及配置元数据产生一个充分配置的可以使用的系统
这里说的配置元数据，实际上我们就是我们提供的XML配置文件，或者通过注解方式提供的一些配置信息

Spring Bean

如何实例化一个Bean？
从官网上来看，主要有以下三种方法
在这里插入图片描述
1.构造方法
2.通过静态工厂方法
3.通过实例工厂方法
这三种例子，官网都有具体的演示，这里就不再贴了，我们通过自己查阅部分源码，来验证我们在官网得到的结论，然后通过debug等方式进行验证。

们再从代码的角度进行一波分析，这里我们直接定位到

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance

这个方法中,具体定位步骤不再演示了，大家可以通过形如下面这段代码：

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

直接main方法运行，然后在

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance

这个方法的入口打一个断点，如图：
在这里插入图片描述
接下来我们对这个方法进行分析，其实这个方法在springbean的生命周期中算是比较重要的一个方法了，这个方法完成了springbean的生命周期中调用第二次bean的后置处理器中的推断构造方法的方法。而且spring中这个方法会返回一个BeanWrapper对象，在外面可以通过调用BeanWrapper的getWrappedInstance()方法然后可以返回包装的Bean对象.这个BeanWrapper其实就是对spring中bean对象的一个封装，spring中对对象的封装使用的是淋漓尽致，其中就包括BeanWrapper和后面会看到一个Holder对象，这些都是后话了，还是回到这个方法上来，首先看看这个方法的参数，首先传了一个String类型的beanName，这个参数肯定是不用说的，因为在spring中如何将这么多个bean存储起来呢，肯定就是通过名字,而且spring中还有一个专门用来存储beanName的一个集合

private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

然后传了一个RootBeanDefinition的一个参数，这个参数如果要说的话可以说一篇文章，所以这里我就先不说了，等后面说到这里的时候再说，这里先提一下这个参数的大概用途，在spring中我们一般都是用BeanDefinition来描述一个bean，就相当于java中用一个Class对象来描述一个类一样，都是对一个对象的一个建模.而BeanDefinition则有很多实现，每个实现都有自己不可或缺的功能,其中这个RootBeanDefinition可以用来做bean的模板(这里要利用到setAbstract这个方法)，然后还可以作为一个真是的bean存在，这里主要是可以用作父bd出现，但是不能做子bd，因为在org.springframework.beans.factory.support.RootBeanDefinition#setParentName方法里直接抛出了异常，说明不能设置父bd.关于RootBeanDefinition先说到这里,后面再详细介绍.

还是说回到这个方法，这个方法一上来就判断了类的访问权限，因为spring默认情况下对于非public的类是允许访问的，后面提到的FactoryMethod也是很重要的，后面再说.

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		// 检测一个类的访问权限, spring默认情况下对于非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());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		/**
		 * factoryMethod, 如果工厂方法不为空, 则通过工厂方法构建bean对象
		 * 这种构建bean的方式可以自己写个demo去试试, 源码就不做深入分析了
		 *
		 * 如果有FactoryMethod, 就调用FactoryMethod创建对象
		 * 需要用xml测试, 不知道注解中是否可以用factoryMethod
		 * <bean id="xxx" class="xxx.xxx.xxx" factory-method="test()"></>
		 * 其实是bd被改变了, 把bd里的beanClass属性给改成了factoryMethod指定的
		 */
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		/**
		 * 从spring的原始注释可以知道这个是一个Shortcut, 什么意思呢?
		 * 当多次构建同一个bean时, 可以使用这个Shortcut, 也就是说不再需要每次推断应该使用哪种方式构造bean
		 * 比如在多次构建同一个prototype类型的bean时, 就可以走此处的Shortcut
		 *
		 * 这里的resolved和mbd.constructorArgumentsResolved将会在bean第一次实例化的过程中被设置，后面来证明
		 *
		 *
		 * shortCut: 快捷方式, 当我们重新创建同一个bean时, 可以利用这个快捷方式; 就是spring在构建一个对象的时候, 他要知道这个对象如何来构建, 利用构造方法还是默认的构造方法, 通过这个值来记录, 当new一个原型对象的时候, resolved这个值就起到作用了, 下边就不用再判断了
		 */
		boolean resolved = false;
		boolean autowireNecessary = false;		// 是不是必须要自动装配
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				// 如果缓存的已解析的构造函数或工厂方法不为空
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					// constructorArgumentsResolved字段是构造函数参数标记为已解析, 即如果已经解析了构造方法的参数, 则下面必须要通过一个带参构造方法来实例
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				// 通过构造方法自动装配的方式构造bean对象
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				// 通过默认的无参构造方法进行初始化
				return instantiateBean(beanName, mbd);
			}
		}

		// Candidate constructors for autowiring?
		// 如果(args不为空)或(args为空 且 缓存的已解析的构造函数或工厂方法也为空), 才会走到这里
		/**
		 * 第二次执行后置处理器
		 * SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors
		 * 推断构造方法
		 */
		// Candidate constructors for autowiring?
		// 查找是否存在候选的自动注入构造器, 由后置处理器决定返回哪些构造方法
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			// 通过构造方法自动装配的方式(注入的方式)调用构造器实例化bean对象
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
		// 使用默认的无参构造方法进行初始化(利用反射newInstance)
		return instantiateBean(beanName, mbd);
	}

我们主要关注进行实例化的几个方法：

通过BeanDefinition中的instanceSupplier直接获取一个实例化的对象。这个instanceSupplier属性我本身不是特别理解，在xml中的标签以及注解的方式都没有找到方式配置这个属性。后来在org.springframework.context.support.GenericApplicationContext这个类中找到了以下两个方法

经过断点测试，发现这种情况下，在实例化对象时会进入上面的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"));
	}

可以发现进入了这个方法进行实例化
这个方法一般不常用，平常我们也使用不到，就不做过多探究，笔者认为，这应该是Spring提供的一种方便外部扩展的手段，让开发者能够更加灵活的实例化一个bean。
2.接下来我们通过不同的创建bean的手段，来分别验证对象的实例化方法
通过@compent,@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 {

}

可以发现，代码执行到最后一行，同时我们看代码上面的注释可以知道，当没有进行特殊的处理的时候，默认会使用无参构造函数进行对象的实例化

• 通过普通XML的方式（同@compent注解，这里就不赘诉了）
• 通过@Configuration注解的方式
测试代码：

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

这里断点进入的方法跟上一种情况是一样的，都是走的默认无参的构造方法去实例化对象的,我就不截图进行验证了。

•通过@Bean的方式
测试代码：

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

在这里插入图片描述
通过打断点进去可以看出是在上面的方法进行实例化的，因此可以看出在@Bean这种方法下，spring的底层在这里是采用的一个FactoryMethod的一个方法进行实例化对象的，spring会在我们需要实例化这个对象对应的beanDefinition的时候记录这个bean对应的factoryBeanName(在上面的例子中，factoryBeanName就是config)，同时会记录创建这个对象的factoryMethodName是什么，最后通过factoryBeanName获取一个bean然后通过反射调用factoryMethod实例化一个对象。

这里我们需要注意几个概念：
1.这里所说的通过静态工厂方式通过factoryBeanName获取一个Bean，注意，这个Bean，不是一个FactoryBean。也就是说不是一个实现了org.springframework.beans.factory.FactoryBean接口的Bean。至于什么是FactoryBean我们在后面的文章会认真分析
2.提到了一个概念BeanDefinition，它就是Spring对自己所管理的Bean的一个抽象。至于这个BeanDefinition就更加重要了，这个类就相当于是jdk中的Class类一样，只不过Class类是对java中类的抽象，这个Class是用来描述java中的一个类的，而spring中的BeanDefinition则是对spring中的bean的抽象，这个BeanDefinition则是用来描述spring中的bean的，而关于bean和对象的区别这个问题就不用再重复了。上面也说了这个类的重要性。

•通过静态工厂方法的方式
测试代码：

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="myFactoryBean" class="com.service.MyFactoryBean">
	</bean>

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

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

在这里插入图片描述
可以发现，这种情况也进入了instantiateUsingFactoryMethod方法中。通过静态工厂方法这种方式特殊之处在于，包含这个静态方法的类，不需要实例化，不需要被Spring管理。Spring的调用逻辑大概是：
1.通过bean标签中的class属性得到一个Class对象
2.通过这个Class对象获得对应的方法名称的Method对象
3.最后反射调用Method.invoke(null,args)，这里是静态方法，所以在执行的时候，不需要一个对象

•通过实例工厂方法的方式
测试代码（配置文件不变）：

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

在这里插入图片描述
最终还是调用的这个方法，这个方法执行的流程跟@Bean的流程一样，这里就不重复了。

到这里，其实我们把createBeanInstance()这个方法过了一遍，但是只是简单的过了一遍，里面还有很多逻辑需要去深挖，就比如spring是如何推断构造函数的？因为我们上面验证的都是无参的构造函数，并且只提供了一个构造函数，这里spring做的很复杂，这里还和spring中的自动装配和手动装配有关系，如果装配模型不一样，这里又会产生不一样的结果，因此这个留着后面来说。
还有就是spring是如何推断构造方法的？不管是静态工厂方法，还是实例工厂方法的方式，我们都只在类中提供了一个跟配置匹配的方法名，假设我们对方法进行了重载呢，结果又是怎么样的呢。这个也是留着后面来说.

实例化总结：
1.对象实例化，只是得到一个对象，还不是一个完全的Spring中的Bean，我们实例化后的这个对象还没有完成依赖注入，没有走完一系列的声明周期，这里需要大家注意。
2. Spring官网上指明了，在Spring中实例化一个对象有三种方式：
• 构造函数
• 实例工厂方法
• 静态工厂方法
3.自己总结如下：Spring通过解析我们的配置元数据，以及我们提供的类对象得到一个Beanfinition对象。通过这个对象可以实例化出一个java bean对象。

具体流程如下：在这里插入图片描述
这里大概说了spring官网的关于实例化bean的一些知识点以及一些扩展，下一节讲关于依赖注入的部分.

java_eehehe

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring容器及实例化

spring容器容器是什么？我们先看官网中的一句话：The org.springframework.context.ApplicationContext interface represents the Spring IoC container and is responsible for instantiating, configuring, and assembling the beans.翻译下来大概就是：Spring IOC容器就是一个org.springframework.cont
复制链接

扫一扫