-
单例还是多例
-
何时创建的对象(容器启动的时候创建还是方法调用的时候创建)
同样以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开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Java)
总结
我个人认为,如果你想靠着背面试题来获得心仪的offer,用癞蛤蟆想吃天鹅肉形容完全不过分。想必大家能感受到面试越来越难,想找到心仪的工作也是越来越难,高薪工作羡慕不来,却又对自己目前的薪资不太满意,工作几年甚至连一个应届生的薪资都比不上,终究是错付了,错付了自己没有去提升技术。
这些面试题分享给大家的目的,其实是希望大家通过大厂面试题分析自己的技术栈,给自己梳理一个更加明确的学习方向,当你准备好去面试大厂,你心里有底,大概知道面试官会问多广,多深,避免面试的时候一问三不知。
大家可以把Java基础,JVM,并发编程,MySQL,Redis,Spring,Spring cloud等等做一个知识总结以及延伸,再去进行操作,不然光记是学不会的,这里我也提供一些脑图分享给大家:
希望你看完这篇文章后,不要犹豫,抓紧学习,复习知识,准备在明年的金三银四拿到心仪的offer,加油,打工人!
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
:Java)**
[外链图片转存中…(img-rBLw8dWa-1713808031514)]
总结
我个人认为,如果你想靠着背面试题来获得心仪的offer,用癞蛤蟆想吃天鹅肉形容完全不过分。想必大家能感受到面试越来越难,想找到心仪的工作也是越来越难,高薪工作羡慕不来,却又对自己目前的薪资不太满意,工作几年甚至连一个应届生的薪资都比不上,终究是错付了,错付了自己没有去提升技术。
这些面试题分享给大家的目的,其实是希望大家通过大厂面试题分析自己的技术栈,给自己梳理一个更加明确的学习方向,当你准备好去面试大厂,你心里有底,大概知道面试官会问多广,多深,避免面试的时候一问三不知。
大家可以把Java基础,JVM,并发编程,MySQL,Redis,Spring,Spring cloud等等做一个知识总结以及延伸,再去进行操作,不然光记是学不会的,这里我也提供一些脑图分享给大家:
[外链图片转存中…(img-X0o4aweC-1713808031514)]
[外链图片转存中…(img-GtYp7zlW-1713808031515)]
[外链图片转存中…(img-Ium07dI0-1713808031515)]
希望你看完这篇文章后,不要犹豫,抓紧学习,复习知识,准备在明年的金三银四拿到心仪的offer,加油,打工人!
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!