java面试八股文--Spring

阿白别玩了

已于 2022-10-11 14:43:41 修改

阅读量518

点赞数

文章标签： spring java

于 2022-09-29 20:43:50 首次发布

原文链接：https://blog.csdn.net/uuqaz/article/details/125427897

版权

如何实现一个IOC容器

1.配置文件，配置包扫描路径

2.递归包，扫描获取.class文件

3.反射、确定需要交给IOC管理的类

4.对需要注入的类进行依赖注入

配置文件中指定需要扫描的包路径
配置一些注解，分别表示访问控制层、业务服务层、数据持久层、依赖注入注解
从配置文件中获取需要扫描的包路径，获取到当前路径下的文件信息及文件夹信息，我们将当前路径下所有以.class结尾的文件添加到一个Set集合中进行存储
遍历这个Set集合，获取在类上有指定注解的类，并将其交给IOC容器，定义一个安全的Map用来存储这些对象
遍历这个IOC容器,获取到每一个类的实例,判断里面是有否有依赖其它的类的实例,然后进行递归注入

Spring是什么?

轻量级的开源的2EE框架,它是一个容器框架,用来装javabean(java对象),中间层框架(万能胶)可以起到一个连接作用,比如说把struts和Hibernate粘合起来一起运用,可以让我们的企业开发开发得更快,更简洁

Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架

--从大小与开销两方面而言,Spring都是轻量级的

--通过控制反转(IOC)的技术达到松耦合的目的

--提供了面向切面变成的丰富支持,允许通过分离应用的业务逻辑与系统级服务进行内聚性的开发

--包含并管理应用对象(Bean)的配置和生命周期,这个意义上是一个容器

--将简单的组件配置、组合称为复杂的应用，这个意义上是一个框架

谈谈你对AOP的理解

系统是由许多不同的组件所组成的，每一个组件各负责一块特定功能。除了实现自身核心功能之外，这些组件还经常承担着额外的职责。例如日志，事务管理和信息安全这样的核心服务经常融入到自身具有核心业务逻辑的组件中去。这些系统服务经常被称为横切关注点，因为它们会跨越系统的多个组件。

当我们需要为分散的对象引入公共行为的时候，OOP显得无能为力。也就是说OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系，例如日志功能。

日志代码往往水平散布在所有对象层次中，而与它所散布到的随想的核心功能毫无关系。

在OOP设置中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP：将程序的交互业务逻辑（如安全、日志、事务），封装成一个切面，然后注入的到目标对象（具体业务逻辑）中去。AOP可以对某个对象或某些对象的功能进行增强，比如对象中的方法进行增强，可以在执行某个方法之前额外地做一些事情，在某个方法执行之后额外做一些事情。

谈谈你对IOC的理解

容器概念、控制反转、依赖注入

IOC容器：实际上就是一个map（key，value），里面存着各种对象（在xml里配置的bean节点、@repository、@Service、@controller、@component），在项目启动的时候回读取配置文件里面的bean节点，根据全限定类名使用反射创建对象放到map里、扫描到打上上述注解的类还是通过反射创建对象放到map里

这个时候map里面就有各种对象了，接下来我们在代码里需要用到里面的对象时，再通过DI注入（@autowired，@resource等注解，xml里bean结点内的ref属性，项目启动的时候就会读取xml节点ref属性，根据id注入，也会扫描这些注解，根据类型或id注入；id就是对象名）。

控制反转：

没有引入IOC容器之前，对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B，控制权都在自己手上。

引入IOC容器之后，对象A与对象B之间失去了失去了直接联系，当对象A运行到需要对象B的时候，IOC会主动创建一个对象B注入到对象A需要的地方。

通过前后的对比，不难看出：对象A获得依赖对象B的过程，由主动行为变成了被动行为，控制权颠倒过来了，这句是“控制反转”这个名称的由来

全部对象的控制权全部上缴给第三方“IOC”容器，所以，IOC容器成了整个系统的关键核心，它气到了一种类似粘合剂的所用，把系统中的所有对象粘合在一起发挥作用，如果没有这个粘合剂，对象与对象之间会彼此失去联系，这就是有人把IOC容器比喻成粘合剂的由来

依赖注入：

获得依赖对象的过程被反转了。控制被反转之后，获得依赖对象的过程由自身管理变成了由IOC容器主动注入。依赖注入是实现IOC的方法，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。

BeanFactory和ApplicationContext有什么区别？

ApplicationContext是BeanFactory的子接口

ApplicationContext提供了更完整的功能

继承MessageSource，因此支持国际化
统一的资源文件访问方式
提供在监听器中注册bean的时间
同时加载多个配置文件
载入多个（有继承关系）的上下文，使得每一个上下文都专注于一个特定的层次，比如应用的web层

BeanFactory采用的是延迟加载的形式来注入Bean的，即只有在使用到某个Bean（调用getBean（）），才会对Bean进行加载实例化。这样，我么就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFactory加载后，直至第一次使用代用getBean（）才会抛出异常
ApplicationContext,它在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。
ApplicationContext启动后预加载了所有的单实例Bean，通过预载入单实例Bean，确保你需要的时候，你就不用等待，因为它们已经创建好了
相对于基本的BeanFactory，ApplicationContext唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动缓慢。
BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。
BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryProcessor的使用，但二者的区别就：BeanFactory需要手动注册，而ApplicationContext则是自动注册。

描述一下Spring Bean的生命周期

1.解析类得到BeanDefinition

2.如果有多个构造方法，则要推断构造方法

3.确定好构造方法后，进行实例化得到一个对象

4.对对象中的加了Autowired注解的属性进行属性填充

5.回调Aware方法，比如BeanNameAware，BeanFactoryAware

6.调用BeanPostProcessor的初始化前的方法

7.调用初始化方法

8.调用BeanPostProcessor的初始化方法后的方法，在这里会进行AOP

9.如果当前创建的bean是单例的，则会把bean放入单例池

10.使用bean

11.spring容器关闭时调用DisposableBean中destory（）方法

解释下Spring支持的几种bean的作用域

singleton：默认，每个容器中只有一个bean的实例，单例的模式由BeanFactory自身来维护，该对象的生命周期与Spring IOC容器一致的（但在第一次被注入时才会创建）。
prototype：为每一个bean请求提供一个实例。在每次注入时都会创建一个新的对象
request：bean被定义在每个HTTP请求中创建一个单例对象，也就是说在单个请求中都会复用这一个单例对象
session：与request范围类似，确保每个session中有一个bean实例，在session过期后，bean会随之失效
application：bean被定义为在ServletContext的生命周期中复用的一个单例对象
websocket：bean被定义在websocket的生命周期中复用一个单例对象
global-session：全局作用域，global-session和Portlet应用相关。当你的应用部署在Protlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，你们让全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

Spring框架中的单例Bean是线程安全的吗？

Spring中的Bean默认是单例模式的，框架并没有对bean进行多线程的封装处理

如果Bean是有状态的，那就需要开发人员自己来进行线程安全的保证，最简单的办法就是改变bean的操作域，把singleton改为prototype，这样每次请求bean就相当于是new Bean（）这样就可以保证线程的安全例

有状态就是有数据存储功能
无状态就是不会保存数据 controller、service和dao层本身并不是安全的，如果只是调用里面的方法，而且多线程调用一个实例的方法，会在内存中赋值变量，这是自己的线程的工作内存，是安全的

Dao会操作数据库 Connection，Connection是带有状态的，比如说数据库事务，Spring的事务管理器使用ThreadLocal为不同线程维护了一套独立的Connection副本，保证线程之间不会互相影响（Spring是如何保证事务获取同一个Connection的）

不要再bean中声明任何有状态的实例变量或类变量，如果必须如此，那么就使用ThreadLocal把变量变为线程私有的，如果bean的实例变量或类变量无需要在多个线程之间共享，那么就只能使用synchronized、lock、CAS等这些实现线程同步的方法了。

Spring框架中都用到了哪些设计模式？

简单工厂：

由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类

Spring中BeanFactory就是简单工厂模式的提现，根据传入一个唯一的标识来获得Bean度效果，但是是在传入参数后穿件还是传入参数前创建这个要根据具体情况而定

工厂方法：

实现了FactoryBean接口的bean是一类叫做factory的bean。其特点是，spring会在使用getBean（）调用获得该bean时，会自动调用该bean的getObject（）方法没所以返回的不是factory这个bean而是bean.getObject（）方法的返回值

单例模式：

保证一个类仅有一个实例，并提供一个访问它的全局访问点

Spring对单例的实现：spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory，但没有从构造器级别去控制单例，这是因为spring管理的事任意的java对象。

适配器模式：

spring定义了一个适配接口，使得每一种controller有一种对应的适配器实现类，让适配器代替controller执行相应的方法。这样在扩展controller时，只需要增加一个适配器就完成了SpringMVC的拓展了。

装饰器模式：

动态地给一个对象增加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有wrapper，另一种是类名中含有Decorator

动态代理：

切面在应用运行的时刻被织入。一边情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。、SpringAOP就是以这种方式织入切面的

织入：吧前面应用到目标对象并创建新的代理对象的过程。

观察者模式：

spring的时间驱动模型使用的是观察者模式，spring中observe模式常用的地方是listener的实现

策略模式：

spring框架的资源访问Resource接口。该接口提供了更强的资源访问能力，spring框架本身大量使用了Resource接口来访问底层资源。

模板模式：

父类定义了骨架（调用哪些方法及顺序），某些特定方法由子类实现

最大的好处：代码复用，减少重复代码。除了子类要实现的特定方法，其他方法及方法调用顺序都在子类中预先写好了。如refresh方法

Spring事务的实现方式和原理以及隔离级别

在使用Spring框架时可以用两种使用事务的方式，一种是编程式的，一种是申明式的

@Transactional注解就是申明式的

首先，事务这个概念是数据库层面的，spring只是基于数据库中的事务进行了拓展，以及提供了一些能让程序员更加方便操作事务的方式

比如我们可以通过在某个方法上增加@Transactional注解，就可以开启事务，这个方法中所有的sql都会在同一个事务中执行，统一执行或失败

在一个方法上加了@Transactional注解后，Spring会基于这个类生成一个代理对象，会将这个代理对象作为bean，当在使用这个代理对象的方法时，如果这个方法上存在@Transactional注解，那么代理逻辑会事先把事务的自动提交设置为false，然后再去执行原本的业务逻辑方法，如果执行业务逻辑方法没有出现异常，那么代理逻辑中就会将事务进行提交，如果执行业务逻辑方法出现了异常，那么则会将业务进行回滚

当然，针对哪些异常回滚事务是可以配置的，可以利用@Transactional注解中的rollbackFor属性进行配置，默认情况下会对RuntimeException和Error进行回滚

spring事务隔离界别就是数据库的隔离界别，外加一个默认级别