-
单例还是多例
-
何时创建的对象(容器启动的时候创建还是方法调用的时候创建)
同样以spring工程为例,咱们来进行验证
【1】单例还是多例
这里使用applicationContext
来获取对象,按照id来获取,获取之后进行对比,看是否是同一个对象
// 启动类
public class MainTest {
@Test
public void TestMain(){
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
// 按照id获取bean
Object user = applicationContext.getBean(“user”);
Object user2 = applicationContext.getBean(“user”);
System.out.println(user == user2);
}
}
// 配置类
@Configuration
public class AppConfig {
// 默认是单例的
// @Scope(“prototype”):多实例,IOC容器启动的时候并不会创建对象放在容器中,每次获取的时候才会调用方法创建对象
// @Scope(“singleton”):单实例,IOC容器启动的时候就会调用方法创建对象放到容器中,以后每次获取都是从容器map中拿同一个对象
// @Scope(“request”):同一次请求创建一个实例
// @Scope(“session”):同一个session创建一个实例
@Scope(“singleton”)
@Bean
// @Lazy
public User user(){
return new User();
}
}
// User的bean
public class User {
public User() {
System.out.println(“User对象”);
}
}
运行启动类,可以看到user == suer2
是true,也就是同一个对象,这是@Scope("singleton")
注解的作用,当然,默认情况也是这样
接下来,咱们改为@Scope("prototype")
注解,也就是多实例模式,运行启动类,可以看到,返回值是false,也就是说两次创建的对象不是同一个,是多例的(其实这里也可以看到,两次打印,上面只创建了一个User对象,而这里创建了两个User对象,这里就已经能说明单例和多例模式下何时创建对象的了,下面还会进行发分析)
【2】对象何时创建
上面我们提到,单例模式是下容器启动的时候创建的对象,而多例模式是在方法调用的时候创建的对象,所以第一次创建一个,第二次创建两个,这也证实了上面的结论。为了更直观的查看,我们对案例进行如下修改
@Scope注解
我们先将启动类的获取Bean方法注释掉,只留下容器启动的方法,然后运行,
单例模式下(@Scope("singleton")
):可以看到,创建了User对象
多例子模式下(@Scope("prototype")
):可以看到,没有创建对象
因为没有了方法调用,所以只有在容器启动的时候才能创建对象,所以单例模式是在容器启动的时候创建对象的。
@Lazy注解
单例模式下,是可以在容器启动的时候创建对象的,而使用了@Lazy
懒加载注解后,可以改变这一特性,让对象在方法调用的时候再创建
加上@Lazy
注解,打印结果如下,可以看到并没有创建对象:
放开启动类的获取Bean方法注释,咱们再次运行,可以看到创建了一个对象:
这也证明了:通过加上@Lazy注解,让容器启动不创建对象,第一次使用的时候再创建Bean对象。
三、源码追踪
这里对单例和多例实例化过程底层原理进行源码追踪
咱们直接来到BeanFactoryPostProcessor
接口,找到和Scope注解相关的实现类,进入源码查看:
在这里,调用registerScope
方法,继续跟踪
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
if (this.scopes != null) {
this.scopes.forEach((scopeKey, value) -> {
if (value instanceof Scope) {
beanFactory.registerScope(scopeKey, (Scope)value);
} else {
Class scopeClass;
if (value instanceof Class) {
scopeClass = (Class)value;
Assert.isAssignable(Scope.class, scopeClass, “Invalid scope class”);
beanFactory.registerScope(scopeKey, (Scope)BeanUtils.instantiateClass(scopeClass));
} else {
if (!(value instanceof String)) {
throw new IllegalArgumentException(“Mapped value [” + value + “] for scope key [” + scopeKey + “] is not an instance of required type [” + Scope.class.getName() + “] or a corresponding Class or String value indicating a Scope implementation”);
}
scopeClass = ClassUtils.resolveClassName((String)value, this.beanClassLoader);
Assert.isAssignable(Scope.class, scopeClass, “Invalid scope class”);
beanFactory.registerScope(scopeKey, (Scope)BeanUtils.instantiateClass(scopeClass));
}
}
});
}
}
这里是进行注册Scope,在该类中,有个doGetBean
方法,所有的bean的创建都会去调用该方法,咱们继续跟踪源码,看Scope是如何创建的:
public void registerScope(String scopeName, Scope scope) {
Assert.notNull(scopeName, “Scope identifier must not be null”);
Assert.notNull(scope, “Scope must not be null”);
if (!“singleton”.equals(scopeName) && !“prototype”.equals(scopeName)) {
Scope previous = (Scope)this.scopes.put(scopeName, scope);
if (previous != null && previous != scope) {
if (this.logger.isDebugEnabled()) {
this.logger.debug(“Replacing scope '” + scopeName + “’ from [” + previous + “] to [” + scope + “]”);
}
} else if (this.logger.isTraceEnabled()) {
this.logger.trace(“Registering scope '” + scopeName + “’ with implementation [” + scope + “]”);
}
} else {
throw new IllegalArgumentException(“Cannot replace existing scopes ‘singleton’ and ‘prototype’”);
}
}
AbstractBeanFactory
类中doGetBean
方法:
protected T doGetBean(String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
// 转化传入的Bean,如果是别名转真名,如果是&开头,去掉&。&代表取factoryBean
String beanName = this.transformedBeanName(name);
// 1、这里为了解决Singleton循环依赖,如果允许早期暴露,会在这里取到其早期暴露,后面会介绍
// 2、如果是工厂模式,在获取bean的时候,在这里会先获取到factoryBean
Object sharedInstance = this.getSingleton(beanName);
Object bean;
// 如果 sharedInstance 不为空,说明当前singleton是依赖者在注入属性时创建的。则打印相关日志
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace(“Returning eagerly cached instance of singleton bean '” + beanName + “’ that is not fully initialized yet - a consequence of a circular reference”);
} else {
this.logger.trace(“Returning cached instance of singleton bean '” + beanName + “'”);
}
}
// 这里会将name和beanName同时传进来, 因为一开始我们的name可能是带&符号的,代表这里需要获取factoryBean而不是bean
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 判断是否有父容器,如果有父容器,优先用父容器调用其getBean
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return parentBeanFactory.getBean(nameToLookup);
}
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start(“spring.beans.instantiate”).tag(“beanName”, name);
try {
if (requiredType != null) {
beanCreation.tag(“beanType”, requiredType::toString);
}
// 获取目标bean的definition
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
// 实例化依赖bean
String[] dependsOn = mbd.getDependsOn();
String[] var12;
if (dependsOn != null) {
var12 = dependsOn;
int var13 = dependsOn.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dep = var12[var14];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, “Circular depends-on relationship between '” + beanName + “’ and '” + dep + “'”);
}
this.registerDependentBean(dep, beanName);
try {
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var33) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, “'” + beanName + “’ depends on missing bean '” + dep + “'”, var33);
}
}
}
// 这里就是和单例相关的,开始创建Singleton
if (mbd.isSingleton()) {
// 这里用了一个实现ObjectFactory接口 的 lambda表达式。getSingleton会有对这个createBean,有个前置操作和后置操作,中间调用lambda进行创建
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 多例相关,创建Prototype
else if (mbd.isPrototype()) {
var12 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException(“No scope name defined for bean ��” + beanName + “'”);
}
Scope scope = (Scope)this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException(“No Scope registered for scope name '” + scopeName + “'”);
}
try {
// scope创建和single差不多, 也是调用get by beanName + lambda表达式, 这个scope会对scopeBean生命进行管理
Object scopedInstance = scope.get(beanName, () -> {
// 也有before, 只是和singleton有点不一样, 它的before和after封装在lambda中
this.beforePrototypeCreation(beanName);
Object var4;
try {
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var32) {
throw new ScopeNotActiveException(beanName, scopeName, var32);
}
}
} catch (BeansException var35) {
beanCreation.tag(“exception”, var35.getClass().toString());
beanCreation.tag(“message”, String.valueOf(var35.getMessage()));
this.cleanupAfterBeanCreationFailure(beanName);
throw var35;
} finally {
beanCreation.end();
}
}
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
} else {
return convertedBean;
}
} catch (TypeMismatchException var34) {
if (this.logger.isTraceEnabled()) {
this.logger.trace(“Failed to convert bean '” + name + “’ to required type '” + ClassUtils.getQualifiedName(requiredType) + “'”, var34);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
} else {
return bean;
}
}
这个方法比较长,内容比较多,咱们挑重要的分开来进行讲解:
【1】获取单例对象
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace(“Returning eagerly cached instance of singleton bean '” + beanName + “’ that is not fully initialized yet - a consequence of a circular reference”);
} else {
this.logger.trace(“Returning cached instance of singleton bean '” + beanName + “'”);
}
}
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
// 创建对象
}
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
name, beanName, (RootBeanDefinition)null);
} else {
// 创建对象
}
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-wvMIoGo7-1715277512989)]
[外链图片转存中…(img-rEL2UAeo-1715277512990)]
[外链图片转存中…(img-YyQHwvDz-1715277512990)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!