Spring常见面试题

刺骨的言语ヽ痛彻心扉 2023-05-31 07:57 18阅读 0赞

**1.spring由那几个模块组成？**  
Spring Core：核心类库，提供IOC服务；  
Spring Context：提供框架式的Bean访问方式，以及企业级的功能；  
Spring AOP:提供AOP服务；  
Spring DAO :对JDBC的抽象，简化了数据访问异常的处理；  
Spring ORM:对象有ORM框架的支持；  
Spring Web:提供基本的面向Web的合特性，例如多方文件上传；  
Spring MVC:提供面向Web应用的Model-View-Controller实现

**2.spring中Bean的作用域**  
**singleton**：Spring IOC容器中只会存在一个共享的Bean实例，无论有多少个Bean引用它，始终指向同一个对象。单例的模式由BeanFactory自身来维护；  
**prototype**：每次通过spring容器获取prototype定义的Bean时，容器都将创建一个新的Bean的实例，每个Bean实例都有自己的属性和状态，而singleton全局只有一个对象；  
**request**：在一次http请求中，容器会返回该Bean的同一实例。而对不同的http请求，则会产生新的 Bean，而且该bean仅在当前Http Request内有效；  
**session**：与request范围类似，确保每个session都有一个Bean’实例，在session失效之后，Bean随之失效；  
**global-session**：全局作用域，global-session和portlet应用相关，当你的应用部署zaiportlet容器中工作时，它包含很多portlet，如果你想声明所有的portlet共用全局的储存变量的话，那么这个全局变量需要储存在global-session中，全局作用域与Servlet中的session作用域效果相同；

**3.Spring中Bean的声明周期**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RwZjM3MzUyMQ_size_16_color_FFFFFF_t_70]  
**（1）实例化Bean**  
对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取beanDefintion对象中的信息，实例化所有的bean。  
**（2）.依赖注入，设置对象属性**  
实例化后的对象封装在BeanWrapper对象中，紧接着，spring根据BeanDfinfintion中的信息以及通过BeanWrapper提供的设置的接口完成依赖注入；  
**（3）处理Aware接口：**  
spring会检测对象是否实现了 \*\*Aware接口，并将相关的 xxxAware实例注入给Bean  
a.如果这个bean已经实现了BeanNameAware接口，会调用他实现的setBeanName（BeanId）方法，此处传递的就是Spring配置文件中Bean的id值；  
b.如果这个bean已经实现了BeanFactoryAware接口，会调用它实现的  
setBeanFactory（），传递的是Spring工厂本身；  
c.如果这个bean已经实现了ApplicationContextAware接口，会调用它实现的  
setApplicationContext方法，传入spring上下文；  
**4）BeanPostProcessor**：  
如果相对bean进行一些自定义的处理，那么可以让bean实现了BeanPostProcessor接口，会调用postProcessorBeforeInitialization（Object obj，String s）方法；  
**（5）InitializingBean和init-method**：  
如果Bean在Spring配置文件中配置了init-method属性，则会自动调用其配置的初始化方法  
**（6）Bean关联BeanPostProcess接口**  
如果这个Bean实现了BeanPostProcess接口，就会调用postProcessAfterInitialization方法，这个方法是在Bean初始化结束时调用的（此时Bean已经被正确创建了）  
**（7）DisposableBean**  
当bean不在被需要时，会经历清理阶段，如果实现了DisposableBean这个接口，会调用其实现的destory()方法；  
**（8）destory-method**  
最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

**4.自动装配有哪些方式**  
在spring中，对象无需自己查找或创建与其关联的其他对象，由容器负责把需要相互协作的对象引用赋予各个对象，使用autowire来配置自动装载模式：  
\* no：默认的方式不进行自动装配，通过手动设置ref属性来进行装配bean  
\* byType：通过参数的类型进行自动装配  
\* byName：通过bean 的名称进行自动装配  
\* constructor：利用构造函数进行装配，并且构造函数的参数通过byType进行装配  
\* autodetect：自动探测，如果有构造方法，通过construtor方式自动装配，否则使用byType的方式自动装配

基于注解的方式：
    使用@autowired注解自动来装配制定的bean，在使用@Autowired注解之前需要在Spring配置文件
    进行配置，<context:annotation-config />。在启动spring IoC时，容器自动装载了一个
    AutowiredAnnotationBeanPostProcessor后置处理器，当容器扫描到@Autowied、
    @Resource或@Inject时，就会在IoC容器自动查找需要的bean，并装配给该对象的属性。在使用
    @Autowired时，首先在容器中查询对应类型的bean：
    	如果查询结果为一个，就将该bean装配给@autowired指定的数据
    	如果查询的结果不止一个，@autowiredautowired会根据名称来查找
    	若果上述的查找为空，那么会抛出异常，解决方法时；使用required=false
    @autowired可用于：构造函数，成员变量，Setter方法

**5.spring框架中都用到了哪些设计模式**  
**a.工厂模式**：BeanFactory就是简单的工厂模式，用来创建对象的实例；  
**b.单例模式**：Bean默认为单利模式  
**c代理模式**：Spring的AOP功能使用到的jdk的动态代理cglib动态代理  
**d.模板模式**：用来解决代码重复的问题。比如RestTemplate，JmsTemplate  
**e.观察者模式**：定义对象一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知自动更新，如spring中listener的实现（ApplicationListener）

**6.对Spring的AOP的理解**  
OOP：面向对象，允许开发者定义纵向的关系，但并适用于定义横向的关系，导致大量代码的重复，二不利于各个模块的重用；  
AOP：一般称为面向切面，用于将那些于业务无关，但是却能对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为**切面**（aspect），减少系统中的重复代码，降低模块间的耦合度，提高系统的可维护性。可用于权限认证，日志打印，事务代理  
AOP实现的关键在于代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为Aspect；动态代理则以Spring AOP为代表

Spring AOP中的动态代理主要有两种，JDK动态代理和CGLIB动态代理：
    	1.JDK动态代理只提供接口的代理，不支持类的代理。核心类是invocationHandler接口和
    	Proxy类invocationHandler通过invoke（）方法反射来调用目标类中的代码，动态的将
    	横切逻辑和业务编制在一起；接着，proxy利用invocationHandler动态创建一个符合某一
    	接口的实例，生成目标类的代理对象
    	2.如果代理类没有发现invocationHandler接口，那么Spring AOP会选择使用CGLIB来
    	动态代理目标类，CGLIB是一个代码生类库，可在运行时动态的生成指定类的一个子类对象
    	并覆盖其中特定方法，并添加增强代码，从而实现AOP，CGLIB通过继承的方式做的动态代理
    	因此如果某个类被标记为final，那么它是无法使用CGLIB
    	3.静态代理和动态代理区别在于AOP代理对象的时机不同，相对来说AspectJ的静态代理方式
    	具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编
    	译器处理。

InvocationHandler 的 invoke(Object proxy,Method method,Object\[\] args)：  
proxy是最终生成的代理实例;  
method 是被代理目标实例的某个具体方法; a  
rgs 是被代理目标实例某个方法的具体入参, 在方法反射调用时使用。

**7.对Spring的Ioc理解**  
1.IOC就是控制反转，是指创建对象的控制权的转移，以前创建对象的主动权是自己把控的，现在对象的创建权交给了spring容器，并由容器根据配置文件去创建实例和管理实例之间的依赖关系，对象与对象之间松散耦合，利于功能的复用。DI依赖注入，应用程序在运行依赖Ioc容器来动态注入对象需要的外部资源  
2.最直观的表达是：Ioc让对象的创建不用去new了，可以由spring自由生产，使用java的反射机制，根据配置文件在运行时动态的去创建对象以及管咯对象，并且调用对象的方法。  
3.spring IOC由三种注入方式：根据注解注入，构造器注入，setter方法注入  
4.Ioc让相互协作的组件保持松散的耦合，而AOP变成允许你把遍布于各个应用各层的功能分离出来形成可重用的功能组件

**8.BeanFactory和ApplicationContext有什么区别？**

**BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。**  
（1）BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载，初始化。实例化，管理bean的生命周期，维护bean之间的依赖关系。ApplicationContext接口作为BeanFactory的派生，除了提供BeanFactory所具有的的功能外，还维护了更完整的框架功能：  
1.集成MessageSource，因此支持国际化  
2. 统一的资源访问方式  
3.提供在监听器中注册bean的时间  
4.同时加载多个配置文件  
（2)1.BeanFactory采用的是延迟加载的形式来注入Bean的，只有在使用到某个Bean，才能对Bean进行实例化加载，这样，我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFactory加载后，直至第一次使用调用getBean方法才会抛出异常  
2.ApplicationContext，它在容器一起动的时候，一次性创建了所有的bean，这样，容器一启动时，就能发现spring中存在的配置错误，有利于检查所依赖的属性是否注入  
3.ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。  
（3）BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。

**9.spring事务的实现方式和实现原理**  
spring事务的本质其实就是数据库对事物的支持，没有数据库的事务支持，spring是无法提供事务的，真正的数据库层的事务提交和回滚通过binlog或者redo log实现的  
**spring事务的种类：**  
**1.编程时事务**： TransactionTemplate  
**2.声明式事务**：建立在AOP之上，本质是通过AOP功能，对方法前后进行拦截，将事务的功能便知道拦截的方法中，在目标方法开始之前加入一个事务，在目标方法执行完成之后进行提交或者回滚事务。

声明式事务最大的优点是不需要再业务逻辑代码中掺杂事务管理代码，只需要在配置文件中做相关的
    事务规则或通过@Transaction注解的方式，便可以将事务规则应用到业务逻辑中
    声明式事务福安里要优于编程式事务，这正是spring飞侵入式的开发方式，是业务代码不受污染，只
    要加上注解可获得完全的事务支持。只能应用到方法级别，不能像编程式事务一样作用到代码块级别

**10.spring的事务传播行为**  
传播行为说的是，当多个事务同时存在的时候，spring如何这个事务的行为？

① PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。
    
    ② PROPAGATION_SUPPORTS：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。‘
    
    ③ PROPAGATION_MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。
    
    ④ PROPAGATION_REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。
    
    ⑤ PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
    
    ⑥ PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
    
    ⑦ PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则按REQUIRED属性执行。

**12.spring的隔离级别**

① ISOLATION_DEFAULT：这是个 PlatfromTransactionManager 默认的隔离级别，使用数据库默认的事务隔离级别。
    
    ② ISOLATION_READ_UNCOMMITTED：读未提交，允许另外一个事务可以看到这个事务未提交的数据。
    
    ③ ISOLATION_READ_COMMITTED：读已提交，保证一个事务修改的数据提交后才能被另一事务读取，而且能看到该事务对已有记录的更新。
    
    ④ ISOLATION_REPEATABLE_READ：可重复读，保证一个事务修改的数据提交后才能被另一事务读取，但是不能看到该事务对已有记录的更新。
    
    ⑤ ISOLATION_SERIALIZABLE：一个事务在执行的过程中完全看不到其他事务对数据库所做的更新。

**13.spring AOP里面的名词解释**  
**切面**：被抽取的公共模块，可能会回横切多个对象在Spring AOP中，在AOP中切面就是与业务逻辑独立，但又垂直存在于业务逻辑的代码结构中的通用功能组合；  
**切点（join point）**：切面与业务逻辑相交的点就是切点；连接点就是把业务逻辑离散化后的关键节点；切点属于连接点，是连接点的子集，一个连接点代表一个方法的执行  
通知（advice）：在切面的某个特定的连接点上执行的操作，其中包括 “before”，“after”，“around”等通知  
**切入点（Pointcut**）：切入点是指我们要对哪些joint point进行拦截的定义，通过切入点表达式，指定拦截的方法，比如指定拦截add\*、search\*。  
目标对象： 被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做 被通知（adviced） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。  
**织入（Weaving**）：在切点上可以把要完成增强操作的目标对象（Target）连接到切面里，这个连接的方式就叫织入。

**13.spring的通知类型**

**前置通知**（Before advice）：在某连接点（join point）之前执行的通知，但这个通知不能阻止
    连接点前的执行
    返回后通知（After returning advice）：在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。 
    抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。 
    后通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异
    常退出）
    环绕通知（Around Advice）：包围一个连接点（join point）的通知，如方法调用。这是最强大
    的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点
    或直接返回它们自己的返回值或抛出异常来结束执行。 环绕通知是最常用的一种通知类型

**14.spring框架中单例Beans是线程安全的吗？**  
Spring框架并没有对单例bean进行任何多线程的封装处理，，大部分的Spring bean并没有可变的状态(比如Serview类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话（比如 View Model 对象），就需要自行保证线程安全。最浅显的解决办法就是将多态bean的作用域由“singleton”变更为“prototype”。

**15.spring如何解决线程并发问题？**  
在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大多数的Bean都可以声明为 singleton作用域，spring对一些bean中非线程安全状态采用Threadlocal进行处理，解决线程安全问题  
Threadlocal和线程同步机制都是为了解决线程中相同变量的访问冲突问题，同步机制采用“时间换空间”发方式，仅提供一份变量，不同线程访问前需要锁，没获得锁的需要排队。给每个线程提供独立的变量副本，隔离多个线程对数据的 访问冲突。Threadlocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进Threadlocal。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RwZjM3MzUyMQ_size_16_color_FFFFFF_t_70]: /images/20230531/5d19090c991c4065bb1c0d0b504a1643.png