审核解析结果

返回队列

任务 ID: job_85553b781a9d4bd1afd2b04fccc99752
任务类型: 提取面经
状态: 已确认
尝试次数: 1

来源上下文

知识笔记来源已确认任务已确认

Java八股（框架）.md

src_1dc42134d1d14d9ab476cc2b2b7bacba

创建于 2026/03/29 15:40，最近更新时间 2026/04/07 12:16

公司岗位轮次标签

摘要原文

## Spring 基础概念
### 什么是IOC？
IOC就是控制反转，指的是将程序中创建新对象的权利转交给spring框架来管理。它的优点在于，能够降低对象间的耦合度，便于资源管理。

### IOC有几种配置方式？
1. xml配置<bean>
2. configuration类配置@Bean
3. 注解配置（@Component、@Controller...）

### 依赖注入有几种方式？
1. xml配置**setter注入**<property name="xxx" ref="xxx"/>
2. **构造函数**配置<constructor-arg name="xxx" ref="xxx"/>
3. **注解注入**@Autowired/@Resource

### 什么是Bean？
bean代指的就是那些被IOC交由spring管理的对象。通常可以使用@Component、@Repository、@Controller、@Service来声明。

### <font style="color:rgb(44, 62, 80);">@Component 和 @Bean 的区别是什么？</font>
@Component作用于类，旨在声明将该类添加到spring容器当中，可以通过@ComponentScan来配置扫描路径。而Bean相比于component具有更强的自定义性，它作用于方法，旨在声明该方法返回了一个需要添加到容器中的对象。相当于xml配置的注解形式

### <font style="color:rgb(44, 62, 80);">注入 Bean 的注解有哪些？</font>
Autowired、Resource、Inject

### <font style="color:rgb(44, 62, 80);">@Autowired 和 @Resource 的区别是什么？</font>
1. autowired是由spring提供的注解，而resource是java提供的
2. autowired是byType的形式进行匹配，resource是byName的形式，二者对具有多个实现类的接口进行注入的时候都需要利用name来匹配
3. autowired可以使用qualifier来定义名称，而resource则通过name属性定义

### <font style="color:rgb(44, 62, 80);">Bean 的作用域有哪些?</font>
1. singleton，单例模式，只会创建一个bean实例
2. prototype，每次getBean都会创建一个新的bean
3. request，每次http request创建一个新的bean，在该http request内有效
4. session，每次来此不同session的http请求创建一个新的bean，在该session内有效
5. application，每次启动一个web应用创建一个新的bean，在该应用启动时间内有效
6. websocket，每次一个新的websocket会话创建一个bean

### <font style="color:rgb(44, 62, 80);">单例 Bean 的线程安全问题了解吗？</font>
单例bean出现线程安全问题主要是由于，多线程对bean中可变成员变量的使用是资源竞争的。主要有两种解决方法：

1. 尽量不要在bean中定义可变的成员变量
2. 当要使用可变成员变量的时候，可以使用threadlocal

### Bean的生命周期？
bean的生命周期主要包含四个部分，加载，实例化，属性注入，初始化和销毁。

1. 在配置文件中寻找bean
2. 利用反射实例化bean对象
3. 设置相关属性
4. 检查Aware接口相关类并执行相应方法，如setBeanName，setBeanClassLoader
5. 执行BeanPostProcessor的前置方法（aop的实现）
6. 执行afterPropertiesSet方法(<font style="color:rgb(51, 51, 51);">这个方法可以用在一些特殊情况中，也就是某个对象的某个属性需要经过外界得到，比如说查询数据库等方式，这时候可以用到spring的该特性，</font>)
7. 执行init-method方法
8. 执行BeanPostProcessor的后置方法
9. 使用bean
10. 销毁bean，调用destroy方法
11. 执行destroy-method方法

### bean对象和java对象有什么区别？
区别主要体现在两个方面：

1. 创建上，java对象通过new进行创建，包括内存分配、初始化、返回指针几个步骤，而bean对象除了基本的java对象创建流程外，还会执行许多其他的方法，例如BeanPostProcessor的前置、后置方法，来实现aop
2. java对象需要手动的去new进行创建，而bean对象可以交由ioc容器管理，使用autowired/resource注解直接注入
3. bean对象在spring中可以享受到各种自定义注解的加成，而new的对象不行（因为本质上调用的是aop的代理对象去执行增强方法，而new的对象调用的是本身的方法）

### BeanFactory和ApplicationContext有什么区别？
两者都为我们提供了实例化bean和获取bean的能力。

ApplicationContext继承了BeanFactory，拥有更加丰富的功能，比如继承了MessageSource，支持国际化，能同时加载多个配置文件，提供了统一的资源访问。

此外，BeanFactory采用的是懒加载的方式，也就是当我们要使用这个bean了，才会去实例化创建，但这可能会导致我们要等到第一次调用getBean才会报错。而ApplicationContext则是在容器启动的时候，一次性创建了所有的bean，这样有助于检查是否有配置错误，并且需要用的时候也不需要等待。这样做的坏处是，可能会占用较大的空间，并且启动时较慢。

### 介绍一下Spring AOP？
AOP即面向切面编程，它旨在将业务模块中与业务无关，但相同的代码进行提取，（例如日志管理、事务处理）以减少代码冗余，降低模块间的耦合度，提高可扩展性。

AOP是基于动态代理的，当要代理的对象实现了接口时，可以直接使用JDK proxy生成代理对象，如果对象没有实现接口，则aop利用cglib，生成一个被代理对象的子类来进行代理。

### <font style="color:rgb(44, 62, 80);">Spring AOP 和 AspectJ AOP 有什么区别？</font>
spring aop是运行时增强，是基于代理的，而AspectJ是编译时增强，是基于字节码操作的。相对来说，AspectJ的性能要比spring aop好一点，功能更加强大，但spring aop比较简单易用

### AOP的配置？
配置切入点@PointCut("execute 返回类型 全类路径.方法名 (参数列表)")

配置相关通知@Around("切入点方法名")

获得连接点proceedingjoinpoint，调用proceed方法执行目标方法

### 如何实现自定义注解？
使用AOP+注解的形式实现。切入点配置为目标注解，使用@annotation

[AOP](https://so.csdn.net/so/search?q=AOP&spm=1001.2101.3001.7020)<font style="color:rgb(77, 77, 77);">中扫描指定注解相关说明</font>
<font style="color:rgb(77, 77, 77);">（1）</font>**<font style="color:rgb(51, 153, 234);">@annotation</font>**<font style="color:rgb(77, 77, 77);">：用来拦截所有被某个注解修饰的方法</font>
<font style="color:rgb(77, 77, 77);">（2）</font>**<font style="color:rgb(51, 153, 234);">@within</font>**<font style="color:rgb(77, 77, 77);">：用来拦截所有被某个注解修饰的类</font>
<font style="color:rgb(77, 77, 77);">（3）</font>**<font style="color:rgb(51, 153, 234);">within</font>**<font style="color:rgb(77, 77, 77);">：用来指定扫描的包的范围</font>

### <font style="color:rgb(44, 62, 80);">AspectJ 定义的通知类型有哪些？</font>
+ Before：目标方法被调用前
+ After：目标方法被调用后
+ AfterReturning：目标方法返回结果值之后
+ AfterThrowing：：目标方法抛出异常之后
+ Around：编程式控制目标对象的方法调用

### 通知类型顺序？
环绕前置->前置->执行方法体->环绕后置->后置->返回值/异常

### @Primary注解了解吗？
当一个接口有多个实现，且通过@Autowired注入属性，由于@Autowired是通过byType形式，用来给指定的字段或方法注入所需的外部资源。Spring无法确定具体注入的类（有多个实现，不知道选哪个）。<font style="color:rgb(64, 64, 64);">当给指定的组件添加@Primary是，默认会注入@Primary配置的组件。</font>

## Spring IOC
### Bean加载的过程？
首先会进行扫描或用ResourceReader读取xml配置文件，加载为Resource对象，再利用BeanDefinitionReader进行解析，封装成BeanDefinition对象，利用BeanDefinitionRegistry注册到ioc容器中的map当中进行存储，至此一个bean加载完成，然后调用getBean时进行具体的实例化。

### getBean的过程？
首先会根据beanName遍历map，获得相应的BeanDefinition对象，去一级至三级缓存中依次查找，如果不存在则开始进行创建。通过定义的class，利用反射获得构造方法并创建实例，将beanName标记为创建中。如果此bean为正在创建中，则将其ObjectFactory放入三级缓存。然后对实例进行初始化，移除创建中标记，把实例放入一级缓存，移除二三级缓存中的实例，最后返回实例。

### ioc如何解决循环依赖？
循环依赖出现的情况主要是，多个bean互相持有而导致的一种循环依赖，如果不经处理，在getBean时，初始化bean A，A中注入bean B，此时会再去初始化bean B，而bean B中也注入了bean A，但bean A还没有初始化完成，这就会导致循环依赖。在Spring中，解决循环依赖主要是靠三级缓存。一级缓存当中主要存放已经初始化完的完整bean实例，也叫成熟对象，二级缓存主要存放的已经实例化但还未初始化的bean对象，三级缓存主要用作单例工厂的缓存。在三级缓存下，我们在实例化A时，会将它的ObjectFactory放入第三级缓存，然后初始化时，发现要注入B，会对B进行实例化，并同样将他的ObjectFactory放入第三级缓存，然后在B中需要注入A，此时会在第三级缓存当中获取到A的ObjectFactory，并调用get方法获得A的实例，并将其放入二级缓存，删除三级缓存。然后B初始化完成，放入第一级缓存，删除二三级缓存，然后A也实例化完成，放入第一级缓存，删除二三。这种方法主要用来解决单例下的循环依赖。

<!-- 这是一张图片，ocr 内容为：创建A ABSTRACTBEANFACTORY.DOGETBEAN( A) DEFAULTSINGLETONBEANREGISTRY.GETSINGLETON( A,TRUE) 调用A的无参构造方法创建A ADDSINGLETONFACTORY(); ABSTRACTAUTOWIRECAPABLEBEANFACTORY.DOCREATEBEAN(A 把半成品A(BNULL)放入到三级缓存中 一级缓存 SINGLETONOBJECTS 为A的属性B赋值,即去创 POPULATEBEAN, 创建B 建B 二级缓存 EARLYSINGLETONOBJECTS 三级缓存 ABSTRACTBEANFACTORY.DOGETBEAN( SINGLETONFACTORIES DEFAULTSINGLETONBEANREGISTRY.GETSINGLETON( B,TRUE) ABSTRACTAUTOWIRECAPABLEBEANFACTORY.DOCREATEBEAN(B) 调用B的无参构造方法创建B 把半成品B(ANULL)放入到三级缓存中 POPULATEBEAN,为A的属性B赋值,即去创 建A ABSTRACTBEANFACTORY.DOGETBEAN( 此时从三级缓存SINGLETONFACTORIES中拿到半成品A(B-NULL)的地址,地址,地址,地址:此 时B已经拿到A了,B就可以创建完毕了,然后A也顺其自然的创建完毕了 DEFAULTSINGLETONBEANREGISTRY.GETSINGLETON( A) 创建B成功,并且返回到创建A的某一步继续创建A HITPSSIBTO3.CSTN.NE:@51CTO博客 -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1678610970801-9d0cfef3-f46e-436f-a7d5-397f37976316.png)

### 第三级缓存时做什么用的？
### <font style="color:rgb(44, 62, 80);">Spring为什么不能解决构造器的循环依赖？</font>
主要是由于在实例化A时，会先调用A的构造方法，在将其放入到三级缓存当中，而构造器注入的话，会在放入缓存之前去对B进行实例化，B同样调用构造方法去获取A，但A并不存在于缓存当中，这就会抛出异常，无法解决。

### <font style="color:rgb(44, 62, 80);">Spring为什么不能解决prototype作用域循环依赖？</font>
主要就是因为Spring不会缓存prototype的bean，而解决循环依赖主要就是由缓存来实现。

### <font style="color:rgb(24, 25, 28);">为什么要使用X的objectFacory对象而不是直接使用X对象？</font>
主要是利于拓展，程序员可以通过beanPostProcess接口操作objectFactory对象来获得自己想要的对象

### BeanFactory和FactoryBean有什么区别？
1. BeanFactory：<font style="color:rgb(18, 18, 18);">是所有Spring Bean的容器根接口，给Spring 的容器定义一套规范，给IOC容器提供了一套完整的规范，比如我们常用到的getBean方法等。</font>

**主要的实现类(包括抽象类)：**

+ <font style="color:rgb(18, 18, 18);">AbstractBeanFactory：抽象Bean工厂，绝大部分的实现类，都是继承于他</font>
+ <font style="color:rgb(18, 18, 18);">DefaultListableBeanFactory:Spring默认的工厂类</font>
+ <font style="color:rgb(18, 18, 18);">XmlBeanFactory：前期使用XML配置用的比较多的时候用的Bean工厂</font>
+ <font style="color:rgb(18, 18, 18);">AbstractXmlApplicationContext:抽象应用容器上下文对象</font>
+ <font style="color:rgb(18, 18, 18);">ClassPathXmlApplicationContext:XML解析上下文对象，用户创建Bean对象我们早期写Spring的时候用的就是他</font>
2. FactoryBean：该类是SpringIOC容器是创建Bean的一种形式，这种方式创建Bean会有加成方式，融合了简单的工厂设计模式与装饰器模式。在某些情况下，对于实例Bean对象比较复杂的情况下，使用传统方式创建bean会比较复杂，例如（使用xml配置），这样就出现了FactoryBean接口，可以让用户通过实现该接口来自定义该Bean接口的实例化过程。<font style="color:rgb(18, 18, 18);">
</font>

## Spring AOP
### Spring aop是如何实现的？
首先要进行切面的加载和配置， 将切面类的所有切面方法根据使用的注解生成对应的Advice，并将advice连同切入点匹配器、切面类等信息封装到advisor中。然后在bean生命周期的<font style="color:rgb(44, 62, 80);">postProcessAfterInitialization中，会根据beanName获取所有的advisor，若没有，则返回DO_NOT_PROXY，若获取到 了，则利用cglib或者jdkproxy创建代理。</font>

### <font style="color:rgb(44, 62, 80);">cglib和jdkproxy的区别？</font>
JDK Proxy要求代理类必须实现接口，而CGLIB是完全不受这个限制的。

JDK Proxy是java自带的功能，无需引入第三方类，通过拦截器加反射实现，使用比较简单。

而CGLIB是第三方提供的工具，基于ASM，性能较高，它通过给指定目标类生成一个子类，覆盖它的方法来实现增强，因此不能对final修饰的类进行代理。

## Spring MVC
### <font style="color:rgb(44, 62, 80);">说说自己对于 Spring MVC 了解?</font>
MVC即Model、View、Controller，其核心思想是将业务逻辑、数据和视图分离，进行解耦，是一种软件设计规范。而SpringMVC是一款MVC开发框架，原生集成了Spring。在Spring MVC下，我们通常将项目划分为Service层、Controller层、DAO层、Entity层。

### <font style="color:rgb(44, 62, 80);">Spring MVC 的核心组件有哪些？</font>
+ DispatchServlet
+ HandlerMapping
+ HandlerAdapter
+ Handler
+ ViewResolver

### <font style="color:rgb(44, 62, 80);">SpringMVC 工作原理了解吗?</font>
1. 客户端发送请求给DispatcherServlet
2. servlet调用HandlerMapping查找相应的Handler，并将其与拦截器封装为HandlerExecutionChain返回
3. servlet调用HandlerAdapter，根据具体的Handler进行真正的方法调用，返回ModelAndView给servlet
4. servlet调用ViewResolver，进行视图解析，解析为具体的view
5. 将ModelAndView传给View进行渲染
6. 将最后的结果响应给客户端

<!-- 这是一张图片，ocr 内容为： -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1690121071674-d480b838-b4b9-4ad9-95bf-f312f86fac0c.png)

### 为什么要有HandlerMapping和HandlerAdapter?
首先HandlerMapping的作用就是根据请求，查找到相应的Handler，并将其和拦截器封装成HandlerExecutionChain返回。而Handler有不同的实现类，对于不同的实现类，具体的执行不同，因此我们需要一个适配器，能够根据返回的Handler的类型，来具体执行该Handler，这就是HandlerAdapter做的事。

### 什么是DispatcherServlet？
在整个 Spring MVC 框架中，DispatcherServlet 处于核心位置，它负责协调和组织不同组件完成请求处理并返回响应工作。DispatcherServlet 是 SpringMVC统一的入口，所有的请求都通过它。DispatcherServlet 是前端控制器，配置在web.xml文件中，Servlet依自已定义的具体规则拦截匹配的请求，分发到目标Controller来处理。

### <font style="color:rgb(18, 18, 18);">HTTP请求流程</font>
<font style="color:rgb(18, 18, 18);">打开 tomcat/conf 目录下的 server.xml 文件来分析一个</font>[http://localhost:8080/docs/api](https://link.zhihu.com/?target=http%3A//localhost%3A8080/docs/api)<font style="color:rgb(18, 18, 18);"> </font><font style="color:rgb(18, 18, 18);">请求。</font>

<font style="color:rgb(18, 18, 18);">第一步：连接器监听的端口是8080。由于请求的端口和监听的端口一致，连接器接受了该请求。</font>

<font style="color:rgb(18, 18, 18);">第二步：因为引擎的默认虚拟主机是 localhost，并且虚拟主机的目录是webapps。所以请求找到了 tomcat/webapps 目录。</font>

<font style="color:rgb(18, 18, 18);">第三步：解析的 docs 是 web 程序的应用名，也就是 context。此时请求继续从 webapps 目录下找 docs 目录。有的时候我们也会把应用名省略。</font>

<font style="color:rgb(18, 18, 18);">第四步：解析的 api 是具体的业务逻辑地址。此时需要从 docs/WEB-INF/web.xml 中找映射关系，最后调用具体的函数。</font>

### <font style="color:rgb(44, 62, 80);">统一异常处理怎么做？</font>
可以使用@ControllerAdvice和@ExceptionHandler来处理。在这种模式下， 会给所有的controller织入异常处理逻辑，并根据controller抛出的异常找到相应@ExceptionHandler的处理方法。ExceptionHandlerMethodResolver中的getMappedHandler方法会根据异常类型找到相应的handler，并根据匹配程度返回最匹配的handler

```java
@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
	@ExceptionHandler(BaseException.class)
    public ResponseEntity<?> baseExceptionHandler(BaseException ex, HttpServletRequest request) {
        //处理逻辑
    }

    @ExceptionHandler(value = ResourceNotFoundException.class)
    public ResponseEntity<?> resourceNotFoundExceptionHandler(ResourceNotFoundException ex, HttpServletRequest request) {
        //处理逻辑
    }
}
```

## Spring 事务管理
### <font style="color:rgb(44, 62, 80);">Spring 管理事务的方式有几种？</font>
1. 编程式事务：通过`TransactionTemplate`和`TransactionManager`手动管理事务
2. 声明式事务：通过xml配置或注解声明事务，通过AOP实现

### <font style="color:rgb(44, 62, 80);">Spring 事务中哪几种事务传播行为?</font>
+ REQUIRED：外部有则用外部的，没有就新建一个事务
+ REQUIRED_NEW：外部有则将其挂起，新建一个
+ NESTED：外部有则开启一个事务嵌套在其内部进行执行（<font style="color:rgb(64, 64, 64);">嵌套事务出错回滚不会影响到主事务,主事务回滚会将嵌套事务一起回滚了</font>）
+ MANDATORY：有事务则加入，没有就抛出异常
+ SUPPORTS：有则加入，没有则以非事务方式运行
+ NOT-SUPPORTED：以非事务方式运行
+ NEVER：以非事务方式运行，如果存在事务，抛出异常

### REQUIRED_NEW和NESTED的区别是什么？
+ REQUIRES_NEW如果B（第二个事务）正常执行，则B中的数据在A（外部事务）提交之前已经完成提交，其他线程已经可见其修改，这就意味着可能有脏数据的产生；同时，如果接下来A的其他逻辑发生了异常，A回滚，但是B已经完成提交，不会回滚了。当然，如果A接下来的逻辑没有相关要求，那就无所谓了
+ NESTED如果B（内嵌事务）正常执行，此时B中的修改并不会立即提交，而是在A（外部事务）提交时一并提交，如果A下面的逻辑中发生异常，A回滚时，B中的修改也会回滚，就可以避免上述情况的发生

### <font style="color:rgb(44, 62, 80);">@Transactional 注解使用详解</font>
1. 方法：只能应用到public方法上
2. 类：应用到该类所有public方法上

### <font style="color:rgb(44, 62, 80);">@Transactional(rollbackFor = Exception.class)注解了解吗？</font>
异常分为运行时异常和非运行时异常，而当Transactional注解应用于类上时，意味着该类所有public方法都具有该类型的事务，而如果不配置rollbackFor，那么默认是当遇到运行时异常的时候回滚，如果配置了，则遇到非运行时异常也会滚。

### 声明式事务和编程式事务各有什么优缺点？
声明式事务：使用注解实现，更加方便，但整个方法会被加入事务，灵活性较差

编程式事务：需要每次都声明，但灵活性更强，可以只包括一个方法的一部分

### 事务失效有哪几种情况？
1. 访问权限问题，spring 要求被代理方法必须是public的，因此如果使用了不当的访问权限修饰符就会导致事务失效。
2. 事务方法被final修饰，spring使用aop来生成代理类实现事务功能，如果被final修饰则目标方法无法被重写，导致事务失效。
3. 调用内部方法，导致注解失效（声明式事务），具体失效原因是内部调用调用的是bean本身的方法，而外部调用注解方法调用的是代理类的方法。解决方法：将事务方法分离到其他类、在类中注入自身类（不会导致循环依赖）、使用 AopContext.currentProxy() 获取代理对象并调用方法等。
4. 数据库引擎不支持事务，例如myisam引擎不支持事务
5. 注解所在的类是否加载成bean
6. propagation配置是否正确
7. 异常被捕获处理，或者抛出的错误的异常。spring事务根据抛出异常来进行回滚，因此如果异常被try-catch了自然不会回滚，导致事务失效；且默认捕获runtimexception，如果要捕获其他的异常，需要进行配置。

[Spring事务失效的 8 大原因，这次可以吊打面试官了！ - Java技术栈 - 博客园](https://www.cnblogs.com/javastack/p/12160464.html)

## Spring Boot
### 什么是SpringBoot？
SpringBoot是Spring开源组织下的一个子项目，它主要就是简化了Spring开发，去繁化简，我们可以通过SpringBoot starter快速自动引入各种场景下需要的依赖，通过注解的方式进行开发，更加便捷，省去了Spring繁琐的配置

### <font style="color:rgb(44, 62, 80);">Spring、Spring MVC和SpringBoot有什么区别？</font>
spring是一个开发框架，他为我们提供了IOC和AOP功能，降低耦合度。

而Spring MVC是一个集成了Spring的mvc框架，主要用来进行web开发，它为我们提供了dispathcerservlet、handlermapping、handleradapter、viewresolver等组件，简化web开发。

SpringBoot则是简化了spring和springmvc开发，提供自动配置、注解来简化。

### <font style="color:rgb(44, 62, 80);">Spring Boot的核心注解是哪些？他主由哪几个注解组成的？</font>
核心注解是标注在启动类上的@SpringBootApplication，它可以看作是@Configuration、@EnableAutoConfiguration、@ComponentScan的组合。

常用注解:

<font style="color:rgb(44, 62, 80);">@RestController</font>

<font style="color:rgb(44, 62, 80);">@GetMapping("users")/@PostMapping("users")</font>

<font style="color:rgb(44, 62, 80);">@PathVariable：获取路径参数</font>

<font style="color:rgb(44, 62, 80);">@RequestParam：获取查询参数，?xxx=xxx</font>

<font style="color:rgb(44, 62, 80);">@RequestBody：用于读取 Request 请求</font>

@Valid

<font style="color:rgb(44, 62, 80);">@Value("${property}")</font>

### <font style="color:rgb(44, 62, 80);">SpringBoot的核心配置文件有哪几个？他们的区别是什么？</font>
bootstrap和application

bootstrap主要用来进行一些引导配置，比如配置项目的配置中心的一些信息，或者固定一些不能被覆盖的属性。它比application要先加载，且bootstrap的信息无法被application覆盖

而application一般就是用来做自动化配置，我们也可以把它放在配置中心中来统一管理。

springboot加载顺序：

1. <font style="color:rgb(51, 51, 51);">类路径下的配置文件</font>
2. <font style="color:rgb(51, 51, 51);">类路径内config子目录的配置文件</font>
3. <font style="color:rgb(51, 51, 51);">当前项目根目录下的配置文件</font>
4. <font style="color:rgb(51, 51, 51);">当前项目根目录下config子目录的配置文件</font>

此外，配置文件properties后加载，会覆盖yml

### SpringBoot如何实现自动装配？
SpringBoot实现自动装配的一个核心注解是@EnableAutoConfiguration，当我们用这个注解开启了自动装配后，springboot在启动的时候会读取jar包下的META-INF/spring.factories的所有配置类，但是并不是所有配置类都会生效，springboot通过@ConditionalXXX注解来进行筛选，只有满足了一定条件的配置类才会生效。如@ConditionalOnBean，当容器下有指定bean的时候生效。

## Mybatis
### Mybatis的优缺点是什么？
优点:

1. 基于sql语句编程，相当灵活，不会对现有的程序或数据库设计有任何影响，且将sql语句放在xml文件当中，实现了sql语句和代码的解耦，而且提供了动态sql标签来支持动态sql语句编写
2. 相比于jdbc，省去了更多的冗余代码，且不需要手动关闭连接
3. 很好的和各种数据库兼容
4. 提供映射标签，支持对象和数据库的ORM映射

缺点:

1. SQL语句的编写工作量大，尤其当字段多，关联表多的时候
2. SQL语句依赖数据库，因此数据库移植性较差

### <font style="color:rgb(44, 62, 80);">#{} 和 ${} 的区别是什么？</font>
${}：字符串替换，mybatis会对他进行直接的字符串替换

#{}：预编译处理，相当于一个占位符，mybatis会把sql中的#{}替换为？，在mysql执行前通过PreparedStatement进行赋值。<font style="color:rgb(44, 62, 80);"></font>

### <font style="color:rgb(44, 62, 80);">xml 映射文件中，除了常见的 select、insert、update、delete 标签之外，还有哪些标签？</font>
<resultMap> 设置查询结果到对象属性的映射关系

<sql> 用来封装sql语句，可以用<include>标签将它导入到其他语句当中

<selectKey> 获取自增主键，或者自定义主键

动态sql标签 where/if/when/foreach/trim/set/choose/otherwise/bind

### <font style="color:rgb(44, 62, 80);">Dao 接口的工作原理是什么？Dao 接口里的方法，参数不同时，方法能重载吗？</font>
一般来说，我们会在resource/mapper文件夹下创建与dao对应的xml文件，并将xml文件的namspace设置为dao接口的全类名，sql标签中的id设置为dao接口的方法名，从而建立dao和mapper文件的映射关系，接口方法的参数可以传入sql语句中，我们可以通过service调用dao来执行我们的具体业务。

DAO接口里的方法是可以重载的，但是mybatis里的id是不能重复的，我们可以通过动态sql标签来实现。<font style="color:rgb(44, 62, 80);"></font>

### <font style="color:rgb(44, 62, 80);">MyBatis 是如何进行分页的？分页插件的原理是什么？</font>
mybatis使用rowbunds对象进行分页，是针对resultset结果集进行内存分页，而非物理分页。可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件完成物理分页。

分页插件的基本原理就是使用mybatis提供的插件接口，实现自定义分页插件，在插件的拦截器方法内拦截待执行的sql语句，并进行重写，添加对应的语句和分页参数。

物理分页就是通过limit等sql语句，进行查询，数据库返回的结果就是分页结果

内存分页（逻辑分页）就是程序员利用代码进行分页，数据库返回全部数据，通过代码筛选获得分页数据。

### MyBatis和Hibernate有哪些不同？
Mybatis是一个半自动ORM框架，需要程序员自己编写sql语句，能够控制SQL执行性能，更加灵活，但无法做到数据库无关性。适用于对关系数据模型要求不高的软件开发。而hibernate对对象/关系映射能力更强，数据无关性更好。

### 动态sql执行原理
使用OGNL从SQL参数对象中计算表达式的值，并动态拼接到sql语句中

### Mybatis有哪些执行器?
1. SimpleExecutor：每次select或update都创建一个statement对象，用完立刻关闭
2. ReuseExecutor：执行update或select以sql为key，查找statement，有则使用，没有就创建一个，然后存在一个map当中重复使用
3. BatchExecutor：执行update，把所有的sql添加到批处理当中，等待统一执行。

候选题（51）

候选 1新建

什么是 IOC？

置信度 0.99

题目答案

分类标签

处理方式目标题目 ID

填写已有 canonical 题目 ID。当前正式题库 ID 也使用 q_ 前缀，不是临时占位。

候选 2新建

IOC 有几种配置方式？

置信度 0.98

分类: 后端框架标签: 0

候选 3新建

依赖注入有几种方式？

置信度 0.98

分类: 未设置标签: 0

候选 4新建

什么是 Bean？

置信度 0.98

分类: 后端框架标签: 1

候选 5新建

@Component 和 @Bean 的区别是什么？

置信度 0.99

分类: 后端框架标签: 1

候选 6新建

注入 Bean 的注解有哪些？

置信度 0.96

分类: 未设置标签: 1

候选 7新建

@Autowired 和 @Resource 的区别是什么？

置信度 0.99

分类: 后端框架标签: 1

候选 8新建

Bean 的作用域有哪些？

置信度 0.99

分类: 网络协议标签: 1

候选 9新建

单例 Bean 的线程安全问题了解吗？

置信度 0.98

分类: Java 并发标签: 4

候选 10新建

Bean 的生命周期是怎样的？

置信度 0.97

分类: 数据库标签: 2

候选 11新建

Bean 对象和 Java 对象有什么区别？

置信度 0.96

分类: 后端框架标签: 1

候选 12新建

BeanFactory 和 ApplicationContext 有什么区别？

置信度 0.98

分类: 未设置标签: 1

候选 13新建

介绍一下 Spring AOP？

置信度 0.99

分类: 数据库标签: 2

候选 14新建

Spring AOP 和 AspectJ AOP 有什么区别？

置信度 0.99

分类: Java JVM标签: 2

候选 15新建

AspectJ 定义的通知类型有哪些？

置信度 0.97

分类: 未设置标签: 1

候选 16新建

@Primary 注解了解吗？

置信度 0.97

分类: 后端框架标签: 1

候选 17新建

Bean 加载的过程是什么？

置信度 0.96

分类: 后端框架标签: 1

候选 18新建

getBean 的过程是什么？

置信度 0.94

分类: 分布式系统标签: 1

候选 19新建

IOC 如何解决循环依赖？

置信度 0.98

分类: 分布式系统标签: 1

候选 20新建

Spring 为什么不能解决构造器的循环依赖？

置信度 0.98

分类: 分布式系统标签: 1

候选 21新建

Spring 为什么不能解决 prototype 作用域循环依赖？

置信度 0.98

分类: 分布式系统标签: 1

候选 22新建

为什么要使用 ObjectFactory 而不是直接使用对象？

置信度 0.90

分类: 未设置标签: 2

候选 23新建

BeanFactory 和 FactoryBean 有什么区别？

置信度 0.97

分类: 后端框架标签: 2

候选 24新建

Spring AOP 是如何实现的？

置信度 0.97

分类: 后端框架标签: 2

候选 25新建

CGLIB 和 JDK Proxy 的区别？

置信度 0.99

分类: Java JVM标签: 2

候选 26新建

说说自己对于 Spring MVC 的了解？

置信度 0.97

分类: 后端框架标签: 2

候选 27新建

Spring MVC 的核心组件有哪些？

置信度 0.97

分类: 后端框架标签: 1

候选 28新建

Spring MVC 工作原理了解吗？

置信度 0.98

分类: 后端框架标签: 2

候选 29新建

为什么要有 HandlerMapping 和 HandlerAdapter？

置信度 0.97

分类: 未设置标签: 2

候选 30新建

什么是 DispatcherServlet？

置信度 0.98

分类: 后端框架标签: 2

候选 31新建

统一异常处理怎么做？

置信度 0.98

分类: 未设置标签: 2

候选 32新建

Spring 管理事务的方式有几种？

置信度 0.98

分类: 数据库标签: 1

候选 33新建

Spring 事务中有哪几种事务传播行为？

置信度 0.99

分类: 数据库标签: 1

候选 34新建

REQUIRES_NEW 和 NESTED 的区别是什么？

置信度 0.97

分类: 数据库标签: 2

候选 35新建

@Transactional 注解怎么用？

置信度 0.95

分类: 数据库标签: 1

候选 36新建

@Transactional(rollbackFor = Exception.class) 了解吗？

置信度 0.99

分类: 数据库标签: 1

候选 37新建

声明式事务和编程式事务各有什么优缺点？

置信度 0.97

分类: 数据库标签: 2

候选 38新建

事务失效有哪几种情况？

置信度 0.98

分类: 数据库标签: 2

候选 39新建

什么是 Spring Boot？

置信度 0.97

分类: 后端框架标签: 1

候选 40新建

Spring、Spring MVC 和 Spring Boot 有什么区别？

置信度 0.98

分类: 后端框架标签: 2

候选 41新建

Spring Boot 的核心注解是哪些？由哪几个注解组成？

置信度 0.99

分类: 后端框架标签: 1

候选 42新建

Spring Boot 的核心配置文件有哪几个？它们的区别是什么？

置信度 0.95

分类: 后端框架标签: 1

候选 43新建

Spring Boot 如何实现自动装配？

置信度 0.98

分类: 后端框架标签: 1

候选 44新建

MyBatis 的优缺点是什么？

置信度 0.97

分类: 数据库标签: 2

候选 45新建

#{} 和 ${} 的区别是什么？

置信度 0.99

分类: 数据库标签: 1

候选 46新建

XML 映射文件中除了 select、insert、update、delete，还有哪些标签？

置信度 0.97

分类: 数据库标签: 1

候选 47新建

Dao 接口的工作原理是什么？方法参数不同可以重载吗？

置信度 0.91

分类: 数据库标签: 1

候选 48新建

MyBatis 是如何进行分页的？分页插件的原理是什么？

置信度 0.97

分类: 数据库标签: 1

候选 49新建

MyBatis 和 Hibernate 有哪些不同？

置信度 0.96

分类: 数据库标签: 1

候选 50新建

动态 SQL 的执行原理是什么？

置信度 0.95

分类: 数据库标签: 1

候选 51新建

MyBatis 有哪些执行器？

置信度 0.98

分类: 数据库标签: 1

导入预览

新建预览

什么是 IOC？

分类: 后端框架

标签: Spring

答案预览

IOC就是控制反转，指的是将程序中创建新对象的权利转交给spring框架来管理。它的优点在于，能够降低对象间的耦合度，便于资源管理。

批量摘要

新建

合并

跳过

解析提示

源文本更像知识笔记而非真实面经，缺少公司、岗位、轮次等面试元信息。
部分内容为提纲式总结，个别表述不够严谨，例如 Bean 生命周期被概括为“四个部分”但后文列出更多阶段；已尽量规范化。
存在个别术语或拼写细节问题，如 DispatchServlet 应为 DispatcherServlet、REQUIRED_NEW 更常见写法为 REQUIRES_NEW、rowbunds 应为 RowBounds；canonical_answer 已做规范化。
“第三级缓存时做什么用的？”在原文仅以标题形式出现，答案已由上下文强推断提炼，属较强隐含证据。

这个任务已经确认过了，不会再次写入 canonical。

返回队列

创建时间: 2026/03/29 15:40

开始时间: 2026/03/29 15:40

完成时间: 2026/03/29 15:43