面试题-Spring

最新推荐文章于 2024-08-29 09:11:22 发布

大Damon

最新推荐文章于 2024-08-29 09:11:22 发布

阅读量111

点赞数

分类专栏： java面试准备

本文链接：https://blog.csdn.net/qq_44006819/article/details/116198623

版权

java面试准备专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1. 什么事Spring？谈谈你对IOC和AOP的理解。

Spirng：是一个企业级Java应用框架，他的作用主要是简化软件的开发以及配置的过程，简化项目部署环境。

Spring的优点：

Spring低入侵设计，对业务代码的污染非常低。
Spirng的DI机制将对象之间的关系交由框架处理，减少组件的耦合。
Spring提供了AOP技术，支持将一些通用的功能进行集中式管理，从而提供更好的复用。
Spring对于主流框架提供了非常好的支持。

IOC就是控制反转，指创建对象的控制权转移给Spirng来进行管理。简单来说，就是应用不用去 new 对象了，而全部交由Spring自动生成。

IOC有三种注入方式：

构造器注入
setter 方法注入
根据注解注入

AOP面向切面。用于将那些与业务无关，但却对多个对象产生影响的公共行为，抽取并封装成一个可重用的模块。

AOP的核心就是动态代理：

JDK的动态代理
CGLIB的动态代理

2.Spring容器的启动流程是怎么样的

使用 AnnotationConfigApplicationContext 来跟踪一下启动流程：

this() 初始化 reader 和 scanner
this.scan(basePackages) 使用 scanner 组件扫描 basePackage 下的所有对象，将配置类的 BeanDefinition 注册到容器中。
this.refresh() 刷新容器：
1. prepareRefresh()：刷新前的预处理
2. obtainFreshBeanFactory()：获取在容器初始化时创建的 BeanFactory
3. prepareBeanFactory(beanFactory)：BeanFactory 的预处理工作，会向容器中添加一些组件
4. postProcessBeanFactory(beanFactory)：子类重写该方法，可以实现在 BeanFactory 创建并预处理完成后做进一步的设置
5. invokeBeanFactoryPostProcessors(beanFactory)：在 BeanFactory 初始化之后执行 BeanFactory 的后置处理器
6. registerBeanPostProcessors(beanFactory)：向容器中注册 Bean 的后置处理器，它的主要作用就是干预Spring初始化 Bean 的流程，完成代理、自动注入、依赖循环等功能
7. initMessageSource()：初始化 messagesource 组件，主要用于国际化
8. initApplicationEventMulticaster()：初始化事件分发器
9. onRefresh()：留给子容器，子类重写的方法，在容器刷新的时候可以自定义一些逻辑
10. registerListeners()：注册监听器
11. finishBeanFactoryInitialization(beanFactory)：完成 BeanFactory 的初始化，主要作用是初始化所有剩下的单例Bean
12. finishRefresh()：完成整个容器的初始化，发布 BeanFactory 容器刷新完成的事件

3、Spring框架中Bean的创建过程是怎样的？

首先简单来说，Spring框架中的Bean经过四个阶段：实例化 -> 属性赋值 -> 初始化 -> 销毁

然后具体来说，Spring中Bean经过了以下几个步骤：

实例化：new xxx(); 两个时机：
设置对象属性（依赖注入）：Spring通过 BeanDefinition 找到对象依赖的其他对象，并将这些对象赋予当前对象。
处理 Aware 接口：Spring会检测对象是否实现了 xxxAware 接口，如果实现了，就会调用对应的方法。
BeanNameAware、BeanClassLoaderAware、 BeanFactoryAware、ApplicationContextAware
BeanPostProcessor ：前置处理：调用 BeanPostProcessor 的 postProcessBeforeInitialization 方法
InitializingBean ：Spring检测对象如果实现了这个接口，就会执行他的 afterPropertiesSet() 方法，定制初始化逻辑。
init-method ：<bean init-method=xxx> 如果Spring发现Bean配置了这个属性，就会调用他的配置方法，执行初始化逻辑。
BeanPostProcessor 后置处理：调用 BeanPostProcessor 的 postProcessAfterInitialization 方法

到这里，这个Bean的创建过程就完成了，Bean就可以正常使用了

DisposableBean ：当Bean实现了这个接口，在对象销毁前就会调用 destory() 方法
destroy-method ：<bean destroy-method=xxx> @PreDestroy

4、Spring框架中的Bean是线程安全的吗？如果线程不安全，要如何处理？

Spring容器本身没有提供Bean的线程安全策略，因此也可以说Spring容器中的Bean不是线程安全的。

要如何处理线程安全问题，就要分情况来分析。

Spring中的作用域：

sington
prototype：为每个Bean请求创建一个实例。
request：为每个request请求创建一个实例，请求完成后失效
session：与request是类似的
golbal-session：全剧作用域

对于线程安全问题：

对于 prototype 作用域，每次都是生成一个新的对象，所以不存在线程安全问题
sington 作用域：默认就是线程不安全的。但是对于开发中的大部分Bean，其实是无状态的，不需要保证线程安全。所以在平常MVC开发中，是不会有线程安全问题的。

无状态表示这个实力没有属性对象，不能保存数据，是不变的类。比如：controller、service、dao
有状态表示实例是有属性对象的，可以保存数据，是线程不安全的，比如pojo

但是如果要保证线程安全，可以将Bean的作用域改为 prototype 比如 Model、View。

另外还可以采用 ThreadLocal 来解决线程安全问题。 ThreadLocal 为每个线程保存一个副本变量，每个线程指操作自己的副本变量

5、Spring如何处理依赖循环问题

依赖循环：多个对象之间存在循环的引用关系，在初始化过程中，就会出现“先有鸡还是先有蛋”的问题

使用 `@Lazy` 注解

解决构造方法造成的循环依赖问题

使用三级缓存

一级缓存：缓存最终的单例池对象

    private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);

二级缓存：缓存初始化的对象

    private final Map<String, Object> earlySingletonObjects = new HashMap(16);

三级缓存：缓存对象的 ObjectFactory

    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);

对于对象之间的普通引用关系，二级缓存会保存 new 出来的不完整对象，这样当单例池中找到不依赖的属性时，就可以先从二级缓存中获取到不完整的对象，完成对象创建，在后续的依赖注入过程中，将单例池中对象的引用关系调整完成。

如果引用的对象配置了 AOP ，那在单例池中最终就会需要注入动态代理对象，而不是原对象。而生成动态代理是要在对象初始化完成之后才开始的。于是Spring增加三级缓存，保存所有对象的动态代理配置信息。在发现有循环依赖时，将这个对象的动态代理信息获取出来，提前进行 AOP ，生成动态代理。

核心代码就带 DefaultSingletonBeanRegistry 的 getSingleton 方法当中。

    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            synchronized(this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }