Spring面试题打卡(持续更新,可能=v=)

阳光穿透心脏的1/2处 2023-07-21 08:42 71阅读 0赞

### Spring的知识点太多了,先把自己觉得重要的背下来吧. ###

### 2020.4.3-2020.4.4 第1-20个,怎么看怎么重要,先记下了,下一个是SpringMVC. ###

√

√ 1.什么是Spring？  
Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。  
Spring为不同的层都提供的企业级解决方案：  
web层：spring mvc  
service层：spring  
dao层：JDBCTemplate  
Spring的核心思想是IoC(控制反转)和AOP(面向切面编程)

√ 2.为什么要用Spring？  
1.方便解耦，简化开发 （高内聚低耦合）  
Spring就是一个大工厂（容器），用于创建对象(bean)和维护对象间的依赖关系。  
2.AOP编程的支持  
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能.  
声明式事务的支持 ，只需要通过配置就可以完成对事务的管理，而无需手动编程  
3.方便程序的测试  
Spring对Junit4支持，可以通过注解方便的测试Spring程序  
4.方便集成各种优秀框架  
Spring支持各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）  
5.降低JavaEE API的使用难度  
Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低

√ 3.解释@Autowired和@Resource注解  
两个注解都可以完成依赖注入功能。  
1.@Autowired：  
@Autowired ： 默认是以byType按类型自动注入。  
@Autowired + @Qualifier(“名称”)：将按照名称自动注入  
2.@Resource：  
@Resource() 如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称注入，  
如果注解写在setter方法上默认取属性名进行注入。  
当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。  
@Resource(name="") 将按照名称自动注入

√ 4.Spring Bean有几种配置方式？  
1.基于XML配置  
在XML文件中通过元素定义Bean  
2.基于注解配置  
在Bean实现类处通过标注@Component或衍型类(@Repository、@Service及@Controller)定义Bean  
3.基于Java类配置  
在标注了@Configuration的Java类中，通过在类方法上标注@Bean定义一个Bean。方法必须提供Bean的实例化逻辑

√ 5.请解释Spring Bean的生命周期？  
  
Spring Bean生命周期共分10个步骤，简述如下：  
1.实例化：实例化一个Bean  
2.注入：按照Spring上下文对实例化的Bean进行依赖注入  
7.初始化：自动调用init-method初始化方法  
//此处就是项目中使用的bean  
10.销毁：当bean不再需要时，执行销毁方法destroy-method

专业解释，参考文档如下：（后处理bean）  
https://blog.csdn.net/fuzhongmin05/article/details/73389779  
https://www.jianshu.com/p/3944792a5fff

√ 6.Spring Bean的作用域之间有什么区别？  
1.singleton：单例，默认值，在Spring IoC容器只有一个Bean实例；  
2.prototype：多例，每次从容器中获得Bean时，都返回一个新的实例；  
3.request：一次请求，请求开始创建bean，请求结束销毁bean。只有在Web应用中使用Spring时，该作用域才有效  
4.session：一次会话，同一个会话共享一个Bean实例，在session过期后，bean会随之失效。同样只有在Web应用中使用Spring时，该作用域才有效  
5.global-session：全局会话，在不同的portlet间共享session。（Portal是一个基于Web的应用）

√ 7.Spring框架中的单例Bean是线程安全的吗？  
线程安全产生的原因是，多个线程对共享数据同时进行修改。  
该问题分以下俩种情况：  
1.有问题：如果类中存在成员变量（即共享数据），且成员变量中的数据在方法中会被修改，此时可能会产生线程安全问题；  
2.没有问题：如果Bean没有成员变量，或者成员变量数据在访问的时候不会被修改，则不会产生线程安全问题

√ 8.Spring和SpringBoot中的扫描机制  
1.Spring组件扫描：  
在spring的配置类中使用@ComponentScan(basePackages = “com.czxy”)可以扫描com.czxy包以及子包下添加了指定注解的类。  
常见的注解有： @Component、@Service、@Controller、@Repository

2.SpringBoot扫描机制  
1）默认扫描规则，SpringBoot中会自动扫描启动类所在包及其子包中的所有添加了指定注解类  
2）使用@ComponentScan注解可以覆盖默认扫描规则。

√ 9.Spring中如何使用注解来配置Bean？有哪些相关注解？  
1.在指定类中添加指定注解，配置类添加@ComponentScan注解进行包扫描，就可以完成bean的配置。  
2.相关注解  
@Component 通用组件类  
@Controller 用于配置web层的controller类  
@Service 用于配置service层的service类  
@Repository 用于配置dao层dao类  
@Bean 用于配置第三方实例，只能修饰方法。

√ 10.Spring不通过注入的方式怎么获取到对象？  
1.通过ApplicationContext手动获取：手动加载xml或配置类获得上下文对象，通过getBean()获得指定名称的bean。  
2.实现BeanFactoryAware接口：先获得BeanFactory，再getBean()获得指定名称的bean。  
3.实现ApplicationContextAware 接口 ：先获得ApplicationContext，再getBean()获得指定名称的bean。

参考：  
https://www.aliyun.com/jiaocheng/812869.html

√ 11.Spring什么情况下进行事务回滚？  
有异常就会回滚  
可以通过@Transactional(rollbackFor=Exception.class,notRollbackFor=RunTimeException.class)修改默认行为  
rollbackFor用于设置那些异常将发生回滚  
notRollbackFor用于设置那些异常不会发生回滚

√ 12.什么是控制反转(IoC)？  
IoC：Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。Ioc意味着将你设计好的对象交给容器控制，而不是new。  
IoC 控制反转，指将对象的创建权，反转到Spring容器

√ 13.什么是Spring IoC容器？  
IOC容器就是具有依赖注入功能的容器，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。应用程序无需直接在代码中new相关的对象，应用程序由IOC容器进行组装。在Spring中BeanFactory是IOC容器的实际代表者。

√ 14.IoC的优点是什么？  
1.减少代码的耦合，可以使应用更加模块化  
2.增加代码的复用率  
3.资源更加统一管理  
4.维护代码更加方便，一般只需要修改一下配置文件就ok了。  
5.提升了程序的测试性  
链接：https://www.imooc.com/article/35099

√ 15.什么是依赖注入(DI)？  
DI：Dependency Injection 依赖注入，在Spring框架创建Bean对象时，动态的将依赖对象注入到Bean组件

√ 16.DI是怎么实现的？  
1.实例化Bean对象：服务器启动时，初始化spring容器，创建由XML配置或添加了相应注解的类的实例，并将实例保存到Spring容器中；  
2.完成ID操作：通过XML描述或对应注解，完成对象之间的依赖关系，此过程称为依赖注入，spring支持3种注入实现：  
①注解注入：通过注解显示注入。常用注解@Resource。  
②XML注入：通过xml显示注入。  
③自动注入：隐式进行bean搜索并自动装配

√ 17.IoC和DI的关系  
IoC 控制反转，指将对象的创建权，反转到Spring容器 ，  
DI 依赖注入，指Spring创建对象的过程中，将对象依赖属性通过配置进行注入  
DI依赖注入不能单独存在，必须在IoC控制反转的基础上才能完成。

√ 18.什么是AOP？  
AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。在程序运行的时候，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

基于代理思想，对原来目标对象，创建代理对象，在不修改原对象代码情况下，对原有业务方法进行增强 ！

√ 19.AOP和代理模式  
代理模式：分为静态代理、JDK动态代理、cglib代理  
1.静态代理  
代理类和被代理类实现共同的接口（或继承），代理类中存有指向被代理类的引用，实际执行时通过调用代理类的方法、实际执行的是被代理类的方法。  
2.jdk动态代理：必须有接口和实现类（目标类），通过工具类Proxy生产接口对应的代理类，从而对目标类进行增强。  
3.Cglib代理：Cglib代理生成的代理类是目标类的子类，所以目标类不能使用final修饰。  
AOP  
Spring AOP通过代理的方式，对目标类进行增强。  
Spring aop底层默认使用JDK动态代理，通过配置可以修改成cglib代理。

√ 20.AOP的运用？  
1.事务  
2.日志处理  
3.缓存  
4.权限控制  
5.错误处理  
6.懒加载

链接：http://blog.sina.com.cn/s/blog\_7045cb9e01010a9r.html  
https://blog.csdn.net/qq513165077/article/details/78288999

21.你如何理解AOP中的连接点（Joinpoint）、切点（Pointcut）、增强（Advice）、引介（Introduction）、织入（Weaving）、切面（Aspect）这些概念？  
1.目标类（target）：需要被增强的类。  
2.连接点（Joinpoint）：可能被增强的点，目标类中的所有方法。  
3.切入点（Pointcut）：将会被增强的连接点，目标类中被增强的方法。  
4.通知/增强（Advice）：对切入点增强的内容。增强的内容通常以方法的形式体现的。增强执行的位置不同，称呼不同。  
（前置通知、后置通知、环绕通知、抛出异常通知、最终通知）  
通知方法所在的类，通常称为切面类。  
5.切面（Aspect）：通知和切入点的结合。一个通知对应一个切入点就形成一条线，多个通知对应多个切入点形成多条线，多条线形成了一个面，我们称为切面。  
6.织入（Weaving）： 生成切面并创建代理对象的过程。（将通知和切入点的结合，并创建代理对象的过程）  
7.引介（Introduction）：一种特殊的增强

参考：https://www.cnblogs.com/hongwz/p/5764917.html

22.你是如何理解“横切关注”这个概念的  
使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。  
业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。  
横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。  
AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

参考：https://www.cnblogs.com/hongwz/p/5764917.html

23.Spring AOP中什么是代理？  
AOP通过生成代理对象，对目标类进行增强。  
在spring aop中，代理对象，将通知和切入点连接在了一起，从而实现增强的过程。

24.Spring AOP中什么是目标对象？  
目标类：需要被增强的类。

25.Spring AOP中什么是切点？  
在说切入点前，需要先说连接点  
连接点：可能被增强的点，目标类中的所有方法。  
切入点：将会被增强的连接点，目标类中被增强的方法。

26.Spring AOP中什么是通知？  
通知：对切入点增强的内容。增强的内容通常以方法的形式体现的。  
在spring中根据增强执行位置的不同，将通知分成以下5种：  
1.前置通知（before）：在一个方法执行前被调用。  
2.后置通知（after-returning）：仅当方法成功完成后执行的通知。  
3.环绕通知（around）：在方法执行之前和之后调用的通知。  
4.抛出异常通知（after-throwing）：在方法抛出异常退出时执行的通知。  
5.最终通知（after）： 在方法执行之后调用的通知，无论方法执行是否成功。

实现细节，方便理解  
try\{  
//1 前置通知  
// 目标方法  
//2 后置通知  
\} catch()\{  
//4 抛出异常通知  
\} finally\{  
//5 最终通知  
\}

27.说说你对切面的理解？  
描述切面必须先了解以下几个概念：  
1.目标类：需要被增强的类。  
2.连接点：可能被增强的点，目标类中的所有方法。  
3.切入点：将会被增强的连接点，目标类中被增强的方法。  
4.通知/增强：对切入点增强的内容。增强的内容通常以方法的形式体现的。增强执行的位置不同，称呼不同。  
（前置通知、后置通知、环绕通知、抛出异常通知、最终通知）  
通知方法所在的类，通常称为切面类。  
5.切面：通知和切入点的结合。一个通知对应一个切入点就形成一条线，多个通知对应多个切入点形成多条线，多条线形成了一个面，我们称为切面。

以上在我看来是基础,必须掌握的.

--------------------

以下有时间再背吧.

28.Spring框架有哪些主要模块？  
1.Spring Core：Spring框架的核心容器，他提供了Spring框架的基本功能。这个模块中最主要的一个组件为BeanFactory,它使用工厂模式来创建所需的对象。同时BeanFactory使用IOC思想，通过读取XML文件的方式来实例化对象，可以说BeanFactory提供了组件生命周期的管理，组件的创建，装配以及销毁等功能;  
2.Spring AOP：采用了面向切面编程的思想，使Spring框架管理的对象支持AOP，同时这个模块也提供了事务管理，可以不依赖具体的EJB组件，就可以将事务管理集成到应用程序中;  
5.Spring Web：提供了Servlet监听器的Context和Web应用的上下文。同时还集成了一些现有的Web框架，例如Struts;  
6.Spring Context：扩展核心容器，提供了Spring上下文环境，给开发人员提供了很多非常有用的服务，例如国际化,Email和JNDI访问等；  
7.Spring Web MVC：提供了一个构建Web应用程序的MVC的实现  
3.Spring ORM：提供了对现有的ORM框架的支持，例如Hibernate等；  
4.Spring DAO：提供了对DAO（Data Access Object,数据访问对象）模式和JDBC的支持。DAO可以实现将业务逻辑与数据库访问的代码分离，从而降低代码的耦合度。通过对JDBC的抽象，简化了开发工作，同时简化了对异常的处理(可以很好的处理不同数据库厂商抛出的异常);

29.请解释Spring Bean的自动装配？  
自动装配，自动完成各个bean之间的依赖关系装配。  
Spring提供了5中自动装配模式：  
1.no：默认值，没有使用自动装配  
2.byName 按照属性名自动装配。  
3.byType 按照属性的数据类型自动装配。如果存在不止一个这样的bean，将抛出异常。  
4.constructor 按照构造函数参数类型自动装配。（常见于xml配置）  
5.autodetect 自动。先constructor自动装配，如果不执行，再按照 byType 自动装配

30.自动装配有哪些局限性？  
1. 显示的依赖注入（@Resource） 会重写自动装配  
2. 不能自动装配基本数据类型、字符串、数组等  
3. 自动装配不如显示依赖注入精确

31.Spring提供了几个关于事务处理的类？  
Spring事务管理高层抽象主要包括3个接口，Spring的事务主要是由他们共同完成的：  
PlatformTransactionManager：事务管理器—主要用于平台相关事务的管理  
TransactionDefinition： 事务定义信息(隔离、传播、超时、只读)—通过配置确定如何进行事务管理。  
TransactionStatus：事务具体运行状态—事务管理过程中，每个时间点事务的状态信息。

32.介绍一下Spring的事务管理？  
事务就是业务中的一组操作，要么全部成功，要么全部失败  
Spring通过平台事务管理器（PlatformTransactionManager）进行事务管理  
事务管理器通过事务定义（TransactionDefinition）进行具体的事务操作。  
事务定义通过4方面对事务进行详细描述  
1.readOnly：是否只读  
2.timeout：超时时间  
3.isolationLevel：事务隔离级别，隔离级别4种：读未提交、读已提交、可重复读、串行化  
4.propagationBehavior：传播行为，共7种，常见的有：必须有事务 PROPAGATION\_REQUIRED、每次必须新的 PROPAGATION\_REQUIRES\_NEW

33.谈谈Spring事务的隔离级别？  
DEFAULT(默认)：使用后端数据库默认的隔离级别(spring中的的选择项)  
READ\_UNCOMMITED(读未提交)：允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读  
READ\_COMMITTED(读已提交)：允许在并发事务已经提交后读取。可防止脏读，但幻读和 不可重复读仍可发生  
REPEATABLE\_READ(可重复读)：对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。  
SERIALIZABLE(串行化)：完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。

34.什么是事务的传播行为？ 有什么作用？  
事务传播行：多个事务方法相互调用时，事务如何在这些方法间传播  
作用：事务的传播行为就是一个个的事务策略，根据需求、设备等条件选择对应的策略，从而完成需求或优化程序。

35.Spring事务控制放在service层，在service方法中一个方法调用service中的另一个方法，默认开启几个事务？  
1.只开启了一个事务，Spring默认的传播行为是PROPAGATION\_REQUIRED，即如果当前存在事务，即加入该事务；如果当前没有事务，则新建一个新的事务。因此只开启了一个事务。

Spring事务的传播行为的7种类型  
TransactionDefinition.PROPAGATION\_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。  
TransactionDefinition.PROPAGATION\_REQUIRES\_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。  
TransactionDefinition.PROPAGATION\_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。  
TransactionDefinition.PROPAGATION\_NOT\_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。  
TransactionDefinition.PROPAGATION\_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。  
TransactionDefinition.PROPAGATION\_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。  
TransactionDefinition.PROPAGATION\_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION\_REQUIRED。

36.如何在Web项目中配置Spring IoC容器？  
在web项目中配置Spring的Ioc容器其实就是创建web应用的上下文(WebApplicationContext)  
1.如果使用Spring Boot，默认扫描启动类所在包以及子包，启动完成上下文对象创建完成。  
2.使用注解的普通web项目，需要在配置类中使用@ComponentScan确定扫描包位置，启动完成上下文对象创建完成。  
3.使用xml的普通web项目，需要在web.xml配置初始化参数确定xml文件位置，从而确定加载的内容，启动完成上下文对象创建完成。

参考：  
http://www.cnblogs.com/qf123/p/8488404.html

37.Spring框架中都用到了哪些设计模式？  
1.单例设计模式：spring 容器中 bean默认是单例的。  
2.工厂模式：BeanFactory，是spring管理bean的核。  
3.代理模式：AOP通过代理对目标类进行增强；  
4.适配器模式：将一个类的接口变换成客户所期待的另一种接口，从而使原本不匹配而无法一起工作的俩个类能够在一起工作；SpringMVC中的适配器HandlerAdatper，HandlerAdatper根据不同的handler规则执行不同的handler；  
5.模板方法模式：父类定义了骨架（调用哪些方法及顺序），某些特定方法由子类实现；在Spring的 JdbcTemplate，RestTemplate, JmsTemplate等地方使用了模板方法模式；

参考：https://blog.csdn.net/z69183787/article/details/65628166；

38.怎么不用Spring框架下实现IoC  
IoC控制反转：指将对象的创建权，反转到Spring容器  
方式1：创建工厂  
创建一个工厂，用于创建目标对象，就是最简单的IoC。但工厂和目标类耦合。  
方式2：工厂 + 配置文件  
1）配置文件中存放类的全限定名称  
2）编写工厂，用于读取配置文件中的内容，并通过反射创建对象。  
问题：工厂只能生产一个对象  
方式3：工厂 + properties文件  
1）properties配置文件存放一组，key是标识，value是全限定名称  
2）编写工厂类，读取配置文件  
3）提供getBean( name ) 用于生成实例：通过name获得对应的全限定名称，再通过反射创建对应的实例。