SSM常见核心面试问题深度解析

在Java后端开发领域，Spring全家桶（Spring、SpringMVC、SpringBoot）与MyBatis是主流技术栈的核心组成部分。本文针对开发者高频关注的核心问题，从基础概念、实现原理、应用场景到执行流程进行系统化解析，既是面试复习的精华总结，也是夯实技术基础的实用指南。

一、Spring核心：IOC与AOP深度剖析

1.1 什么是Spring IOC和AOP？

Spring的核心优势在于其两大核心特性------控制反转（IOC）和面向切面编程（AOP），二者共同支撑起Spring的轻量级、可扩展架构。

Spring IOC（Inversion of Control，控制反转）：核心是"将对象的创建权交给Spring容器"，而非由开发者在代码中直接通过new关键字创建。通过IOC容器，我们可以专注于对象的业务逻辑，而非对象的依赖管理，实现了组件间的解耦。
Spring AOP（Aspect-Oriented Programming，面向切面编程）：是OOP（面向对象编程）的补充，核心是"将通用的横切逻辑（如日志、事务、权限校验）与业务逻辑分离"，通过动态代理的方式在不修改业务代码的前提下，为业务方法增强功能。

1.2 IOC和AOP的实现机制

IOC的实现机制：核心依赖「工厂模式」+「反射机制」。Spring通过BeanFactory（基础工厂）或ApplicationContext（高级工厂，包含BeanFactory的所有功能）作为IOC容器，读取配置文件（XML/注解）中的Bean定义，利用反射机制动态创建Bean对象，并管理Bean的依赖关系和生命周期。
AOP的实现机制：核心依赖「动态代理」。Spring AOP默认采用两种动态代理方式：① 当目标类实现接口时，使用JDK动态代理（基于接口的代理，生成目标类的接口实现类）；② 当目标类未实现接口时，使用CGLIB动态代理（基于子类的代理，生成目标类的子类）。通过代理类包裹目标类，在目标方法执行前后插入横切逻辑。

1.3 如何理解Spring IOC？

从本质上看，IOC是一种"设计思想"，核心是反转了"对象的创建和依赖注入的控制权"：

传统开发模式：开发者主动创建对象（new UserService()），并手动维护对象间的依赖（userService.setUserDao(new UserDaoImpl())），控制权在开发者手中。
IOC模式：开发者仅需在配置文件（或通过注解）中声明Bean的信息，Spring容器主动创建Bean对象，并自动将依赖的Bean注入到目标对象中，控制权转移到Spring容器。

IOC的核心价值是解耦------组件间不再直接依赖，而是依赖于Spring容器，降低了组件的耦合度，提高了代码的可维护性和可扩展性。

1.4 依赖注入（DI）：IOC的具体实现方式

依赖注入（Dependency Injection，DI）是IOC的具体实现形式，指Spring容器在创建Bean时，自动将其依赖的其他Bean注入到当前Bean中。

1.4.1 依赖注入的实现方式

构造方法注入：通过Bean的构造方法传入依赖的Bean。优势是强制依赖注入（创建Bean时必须传入依赖，避免空指针），且不允许修改依赖对象（无setter方法），符合"不可变对象"设计思想。示例：

java 复制代码

// 目标类
public class UserService {
    private UserDao userDao;
    // 构造方法注入
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}

XML 复制代码

// XML配置
<bean id="userService" class="com.example.UserService">
    <constructor-arg ref="userDao"/>
</bean>
<bean id="userDao" class="com.example.UserDaoImpl"/>

setter方法注入：通过Bean的setter方法注入依赖的Bean。优势是灵活性高（可在Bean创建后动态修改依赖），适用于非强制依赖。示例：

java 复制代码

// 目标类
public class UserService {
    private UserDao userDao;
    // setter方法注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

XML 复制代码

// XML配置
<bean id="userService" class="com.example.UserService">
    <property name="userDao" ref="userDao"/>
</bean>

注解注入：通过@Autowired（Spring原生注解）或@Resource（JDK注解）直接标注在字段或方法上，简化配置。示例：

java 复制代码

@Service
public class UserService {
    // 字段注入（最简洁，推荐使用）
    @Autowired
    private UserDao userDao;
}

// 或setter方法注解注入
@Service
public class UserService {
    private UserDao userDao;
    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

1.5 Spring AOP的核心目标与应用场景

1.5.1 AOP要解决的核心问题

在OOP开发中，横切逻辑（如日志记录、事务管理、权限校验）会分散在各个业务方法中，导致代码冗余（重复编写横切逻辑）、维护困难（修改横切逻辑需修改所有相关业务代码）。AOP的核心目标是「分离横切逻辑与业务逻辑」，实现横切逻辑的复用和集中管理。

1.5.2 Spring AOP的典型应用场景

日志记录：在方法执行前后记录请求参数、返回结果、执行时间等。
事务管理：在业务方法执行前开启事务，执行后提交/回滚事务。
权限校验：在方法执行前校验用户是否有权限执行该操作。
异常处理：统一捕获业务方法抛出的异常并处理。
缓存增强：在方法执行前查询缓存，执行后更新缓存。

1.6 反射：IOC/AOP的底层支撑

1.6.1 什么是反射？

反射（Reflection）是Java的核心特性，指程序在运行时可以获取类的所有信息（类名、属性、方法、构造方法等），并可以动态操作类的属性和方法（如创建对象、调用方法、修改属性值）。简单来说，反射让程序在运行时拥有"自检查"和"动态操作"的能力。

1.6.2 反射的使用场景

框架开发：Spring IOC通过反射创建Bean对象、注入依赖；MyBatis通过反射将数据库查询结果映射为Java对象；Spring AOP通过反射生成动态代理。
动态代理：JDK动态代理通过反射获取目标类的接口和方法，生成代理类。
注解解析：通过反射获取类/方法/字段上的注解信息，执行相应的逻辑（如Spring的@Service、@Autowired注解）。
通用工具类开发：如Bean拷贝工具（BeanUtils），通过反射获取两个Bean的属性并赋值。
动态配置：在运行时根据配置动态调用不同的类和方法。

二、Spring Bean生命周期全解析

Spring Bean的生命周期是指Bean从被Spring容器创建、初始化、使用到销毁的完整过程。理解Bean的生命周期，有助于我们在不同阶段对Bean进行自定义增强。

2.1 Bean的完整生命周期流程

「实例化」：Spring容器通过反射创建Bean的实例（调用无参构造方法）。
「属性赋值」：Spring容器将依赖的Bean注入到当前Bean的属性中（执行setter方法或字段注入）。
「初始化前」：如果Bean实现了BeanNameAware接口，调用setBeanName()方法，传入Bean的id；如果实现了BeanFactoryAware接口，调用setBeanFactory()方法，传入BeanFactory容器；如果实现了ApplicationContextAware接口，调用setApplicationContext()方法，传入ApplicationContext容器。
「初始化前置处理」：BeanPostProcessor的postProcessBeforeInitialization()方法（所有Bean初始化前都会执行，用于全局增强）。
「初始化」：如果Bean实现了InitializingBean接口，调用afterPropertiesSet()方法；如果在配置中指定了init-method属性（或@PostConstruct注解），执行自定义的初始化方法。
「初始化后置处理」：BeanPostProcessor的postProcessAfterInitialization()方法（所有Bean初始化后都会执行，Spring AOP的动态代理就在此阶段生成）。
「Bean就绪」：Bean进入容器，供开发者使用。
「销毁前」：如果Bean实现了DisposableBean接口，调用destroy()方法；如果在配置中指定了destroy-method属性（或@PreDestroy注解），执行自定义的销毁方法。
「Bean销毁」：Spring容器关闭时，Bean被销毁，释放资源。

2.2 Bean的作用域：单例与非单例

Spring Bean的作用域定义了Bean在容器中的创建方式和存活范围，默认是单例。

2.2.1 Spring Bean的核心作用域

singleton（单例）：默认作用域。Spring容器中只存在一个Bean实例，所有对该Bean的请求都共享同一个实例（创建时间：容器启动时，除非设置lazy-init="true"，则第一次获取时创建）。适用于无状态组件（如Service、Dao层）。
prototype（多例）：每次从容器中获取Bean时，都会创建一个新的实例（创建时间：每次getBean()时）。适用于有状态组件（如Controller层的请求参数对象、Struts2的Action）。
request（请求域）：Web应用专属，每个HTTP请求对应一个Bean实例，请求结束后Bean销毁。
session（会话域）：Web应用专属，每个用户会话对应一个Bean实例，会话结束后Bean销毁。
application（应用域）：Web应用专属，整个Web应用共享一个Bean实例，应用停止后Bean销毁。

2.2.2 单例与非单例Bean的生命周期差异

「创建时机」：单例Bean默认在容器启动时创建（懒加载除外）；多例Bean在每次获取时创建。
「销毁时机」：单例Bean在容器关闭时销毁；多例Bean由开发者手动管理销毁（Spring容器不负责多例Bean的销毁，因为无法跟踪多例Bean的使用范围）。
「生命周期完整性」：单例Bean的生命周期完整（从容器启动到关闭）；多例Bean的生命周期不完整（创建、初始化后即交给开发者，容器不管理销毁）。

2.3 Bean加载/销毁前后的自定义逻辑实现

在Bean的加载（初始化）和销毁前后，我们可以通过以下4种方式实现自定义逻辑：

实现InitializingBean（初始化）和DisposableBean（销毁）接口：重写afterPropertiesSet()和destroy()方法。示例：

java 复制代码

public class UserService implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Bean初始化：执行自定义初始化逻辑");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("Bean销毁：执行自定义销毁逻辑");
    }
}

配置init-method和destroy-method属性：在XML配置或@Bean注解中指定自定义方法。示例（注解方式）：

java 复制代码

@Bean(initMethod = "init", destroyMethod = "destroy")
public UserService userService() {
    return new UserService();
}
public class UserService {
    public void init() {
        System.out.println("Bean初始化：执行init方法");
    }
    public void destroy() {
        System.out.println("Bean销毁：执行destroy方法");
    }
}

使用@PostConstruct（初始化）和@PreDestroy（销毁）注解：标注在自定义方法上（JDK注解，无需实现接口）。示例：

java 复制代码

public class UserService {
    @PostConstruct
    public void init() {
        System.out.println("Bean初始化：执行@PostConstruct标注的方法");
    }
    @PreDestroy
    public void destroy() {
        System.out.println("Bean销毁：执行@PreDestroy标注的方法");
    }
}

实现BeanPostProcessor接口（全局增强）：重写postProcessBeforeInitialization()（初始化前）和postProcessAfterInitialization()（初始化后）方法，对所有Bean生效。示例：

java 复制代码

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化前：" + beanName);
        return bean; // 必须返回bean，否则后续无法获取
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化后：" + beanName);
        return bean;
    }
}

三、Spring事务：核心特性与使用方式

3.1 事务的四大核心特性（ACID）

事务（Transaction）是数据库操作的基本单位，确保一组操作要么全部执行成功，要么全部执行失败，核心是ACID四大特性：

原子性（Atomicity）：事务中的所有操作是一个不可分割的整体，要么全部执行成功，要么全部回滚（如转账操作：扣款和到账必须同时成功或同时失败）。
一致性（Consistency）：事务执行前后，数据库的完整性约束不被破坏（如转账前A和B的总金额为1000，转账后总金额仍为1000）。
隔离性（Isolation）：多个事务并发执行时，一个事务的执行结果不会被其他事务干扰（避免脏读、不可重复读、幻读等并发问题）。
持久性（Durability）：事务执行成功后，对数据库的修改是永久性的，即使数据库崩溃，修改也不会丢失（数据会写入磁盘）。

3.2 Spring事务的使用方式：XML配置 vs 注解配置

Spring事务管理的核心是「声明式事务」（通过配置声明事务规则，无需手动编写事务控制代码），支持XML和注解两种配置方式，其中注解方式更简洁，是当前主流。

3.2.1 XML配置方式

通过aop:config配置事务切面，指定哪些方法需要事务增强，以及事务属性（传播行为、隔离级别等）。

XML 复制代码

<!-- 1. 配置事务管理器（核心，负责事务的开启、提交、回滚） -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!-- 2. 配置事务通知（定义事务属性） -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!-- 所有以save、update、delete开头的方法需要事务，发生异常回滚 -->
        <tx:method name="save*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="update*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="delete*" propagation="REQUIRED" rollback-for="Exception"/>
        <!-- 查询方法无需事务 -->
        <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
    </tx:attributes>
</tx:advice>

<!-- 3. 配置AOP切面，将事务通知织入目标方法 -->
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* com.example.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>

3.2.2 注解配置方式

通过@EnableTransactionManagement开启事务管理，在需要事务的方法或类上标注@Transactional注解。

java 复制代码

// 1. 配置类中开启事务管理
@Configuration
@EnableTransactionManagement
public class SpringConfig {
    // 配置事务管理器
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

// 2. 在Service方法上标注@Transactional
@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    // 声明式事务：该方法需要事务支持
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void transferMoney(Long fromId, Long toId, BigDecimal amount) {
        // 扣款
        userDao.deductMoney(fromId, amount);
        // 到账
        userDao.addMoney(toId, amount);
    }
}

@Transactional注解的核心属性：

propagation：事务传播行为（如REQUIRED：如果当前没有事务，创建新事务；如果有，加入当前事务）。
isolation：事务隔离级别（如READ_COMMITTED：避免脏读，默认级别）。
rollbackFor：需要回滚的异常类型（默认只回滚RuntimeException）。
readOnly：是否为只读事务（查询方法设为true，提高性能）。

四、MVC分层与SpringMVC核心解析

4.1 MVC分层设计：职责清晰的架构模式

MVC（Model-View-Controller）是一种软件架构模式，通过分层设计实现业务逻辑、数据展示和用户交互的分离，提高代码的可维护性和可扩展性。

Model（模型）：负责封装数据和业务逻辑，是应用程序的核心。分为两类：① 数据模型（如User、Order实体类）：封装业务数据；② 业务模型（如Service层）：实现业务逻辑（如用户登录、订单创建）。
View（视图）：负责数据展示，与用户交互。如JSP、Thymeleaf、Vue模板等，接收Model传递的数据并渲染页面。
Controller（控制器）：负责接收用户请求，协调Model和View。核心职责：① 接收请求参数；② 调用Model层处理业务逻辑；③ 将处理结果传递给View，控制视图渲染。

MVC的核心价值：职责分离------不同层专注于自身职责，开发者可并行开发（前端开发View，后端开发Model和Controller），便于团队协作。

4.2 SpringMVC的核心处理流程

SpringMVC是Spring基于MVC模式的Web框架，核心是"DispatcherServlet"（前端控制器），负责统一接收请求、分发请求、处理响应。完整处理流程如下：

用户发送HTTP请求，请求被DispatcherServlet接收（DispatcherServlet是SpringMVC的入口，配置在web.xml中）。
DispatcherServlet调用HandlerMapping（处理器映射器），根据请求URL查找对应的Handler（控制器方法）。
HandlerMapping返回HandlerExecutionChain（包含Handler和拦截器）给DispatcherServlet。
DispatcherServlet调用HandlerAdapter（处理器适配器），适配不同类型的Handler（如注解式Controller、XML配置的Controller）。
HandlerAdapter调用Handler（控制器方法），执行业务逻辑，返回ModelAndView（包含模型数据和视图名称）。
DispatcherServlet调用ViewResolver（视图解析器），根据视图名称解析出具体的View（如JSP、Thymeleaf）。
ViewResolver返回View给DispatcherServlet。
DispatcherServlet渲染View（将Model中的数据填充到View中）。
DispatcherServlet将渲染后的页面响应给用户。

4.3 HandlerMapping与HandlerAdapter：SpringMVC的核心组件

HandlerMapping和HandlerAdapter是SpringMVC中连接DispatcherServlet和Handler的关键组件，实现了"请求-Handler"的映射和适配，是SpringMVC灵活性的核心体现。

4.3.1 HandlerMapping（处理器映射器）

核心职责：根据请求URL查找对应的Handler（控制器方法）。SpringMVC提供了多种HandlerMapping实现，默认使用RequestMappingHandlerMapping（支持@RequestMaping注解的Handler映射）。

工作原理：

SpringMVC启动时，HandlerMapping会扫描所有被@Controller注解的类，解析其中@RequestMaping注解的URL和方法信息，生成"URL-Handler"的映射表。
当请求到来时，HandlerMapping根据请求URL查询映射表，找到对应的Handler（控制器方法），并封装成HandlerExecutionChain（包含Handler和拦截器）返回给DispatcherServlet。

4.3.2 HandlerAdapter（处理器适配器）

核心职责：适配不同类型的Handler，执行Handler并返回ModelAndView。由于SpringMVC支持多种Handler类型（如注解式、XML配置式、实现Controller接口式），DispatcherServlet无法直接调用所有类型的Handler，因此需要HandlerAdapter进行适配。

工作原理：

DispatcherServlet获取到Handler后，会根据Handler的类型选择对应的HandlerAdapter（如注解式Handler对应RequestMappingHandlerAdapter）。
HandlerAdapter负责解析请求参数，将请求参数绑定到Handler的方法参数上，调用Handler的方法执行业务逻辑。
Handler执行完成后，HandlerAdapter将返回结果封装成ModelAndView，返回给DispatcherServlet。

HandlerAdapter的核心价值：解耦DispatcherServlet与Handler，DispatcherServlet无需关心Handler的具体类型，只需通过HandlerAdapter即可完成调用，符合"开闭原则"（新增Handler类型时，只需新增对应的HandlerAdapter，无需修改DispatcherServlet）。

五、MyBatis核心问题解析

5.1 #{}与${}的区别：参数注入的核心差异

MyBatis中，#{}和${}都是用于接收参数的占位符，但核心差异在于参数注入方式和安全性，是面试高频考点。

对比维度	#{}	${}
注入方式	预编译SQL（PreparedStatement），将参数作为占位符？传入，SQL执行前会对参数进行编译	字符串拼接，直接将参数值拼接到SQL语句中，再执行SQL
安全性	安全，可防止SQL注入攻击（如参数为单引号时，会自动转义）	不安全，无法防止SQL注入（如参数为"' or 1=1 --"，会拼接成恶意SQL）
参数类型	支持任意类型（基本类型、字符串、实体类等），自动进行类型转换	仅支持字符串类型，需要手动进行类型转换
适用场景	大多数场景（如查询条件、插入数据的参数）	动态SQL片段（如表名、列名、排序方式，如order by ${columnName}）
示例	SQL：select * from user where id=?；参数为1时，执行SQL：select * from user where id=1	SQL：select * from user where id=${id}；参数为1时，拼接为：select * from user where id=1

核心结论：优先使用#{}，仅在需要动态拼接SQL片段（如表名、排序字段）时使用 ${}，且使用$ {}时需严格校验参数（如白名单校验），避免SQL注入。

5.2 MyBatis的完整执行流程

MyBatis的执行流程围绕"SqlSessionFactory"和"SqlSession"展开，核心是将SQL配置解析为可执行的SQL语句，执行后将结果映射为Java对象。完整流程如下：

「加载配置文件」：加载MyBatis的核心配置文件（mybatis-config.xml）和Mapper映射文件（如UserMapper.xml），或读取注解式SQL（@Select、@Insert等）。
「创建SqlSessionFactory」：通过SqlSessionFactoryBuilder解析配置文件，创建SqlSessionFactory（会话工厂）。SqlSessionFactory是单例的，全局只需要一个。
「创建SqlSession」：通过SqlSessionFactory.openSession()创建SqlSession（会话）。SqlSession是非线程安全的，每次请求需创建新的SqlSession，使用后关闭。
「获取Mapper接口代理对象」：通过SqlSession.getMapper(Mapper接口.class)获取Mapper接口的动态代理对象（MyBatis通过JDK动态代理生成Mapper的实现类）。
「执行SQL语句」：调用Mapper代理对象的方法，MyBatis根据方法名匹配Mapper映射文件中的SQL语句，通过Executor（执行器）执行SQL：① 简单执行器（SimpleExecutor）：默认执行器，每次执行SQL都创建新的PreparedStatement；② 重用执行器（ReuseExecutor）：重用PreparedStatement；③ 批量执行器（BatchExecutor）：批量执行SQL。
「结果映射」：将SQL执行结果通过ResultSetHandler映射为Java对象（如实体类、List集合）。
「事务处理」：如果是增删改操作，需要调用SqlSession.commit()提交事务；如果发生异常，调用SqlSession.rollback()回滚事务。
「关闭资源」：关闭SqlSession，释放数据库连接。

六、SpringBoot核心：自动装配原理

SpringBoot的核心优势是"自动装配"（AutoConfiguration），通过"约定大于配置"的思想，消除了Spring繁琐的XML配置，实现了"开箱即用"。自动装配的核心是"根据类路径下的依赖，自动配置相关Bean到Spring容器中"。

6.1 自动装配的核心注解

SpringBoot自动装配的核心依赖@SpringBootApplication注解，该注解是一个复合注解，包含三个关键注解：

@SpringBootConfiguration：本质是@Configuration，标识当前类是配置类，可定义Bean。
@ComponentScan：扫描当前包及其子包下的@Component、@Service、@Controller、@Repository等注解，将其注册为Bean。
@EnableAutoConfiguration：开启自动装配，是自动装配的核心注解。

6.2 自动装配的核心原理

@EnableAutoConfiguration注解通过@Import(AutoConfigurationImportSelector.class)导入AutoConfigurationImportSelector类，该类是自动装配的核心逻辑实现类，核心流程如下：

「加载自动配置类清单」：AutoConfigurationImportSelector通过SpringFactoriesLoader.loadFactoryNames()方法，读取META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件（SpringBoot 2.7+版本，之前是META-INF/spring.factories），该文件中包含了所有自动配置类的全类名（如DataSourceAutoConfiguration、WebMvcAutoConfiguration等）。
「筛选自动配置类」：SpringFactoriesLoader加载所有自动配置类后，会根据类路径下的依赖（Starter）进行筛选。例如：如果类路径下存在spring-boot-starter-web依赖，则WebMvcAutoConfiguration会被筛选出来；如果存在spring-boot-starter-jdbc依赖，则DataSourceAutoConfiguration会被筛选出来。
「条件注解校验」：筛选后的自动配置类会通过@Conditional系列注解（如@ConditionalOnClass、@ConditionalOnMissingBean）进行校验，只有满足条件的自动配置类才会被注册到Spring容器中。例如：@ConditionalOnClass(DataSource.class)表示只有类路径下存在DataSource类时，该自动配置类才生效；@ConditionalOnMissingBean表示只有当容器中不存在该Bean时，才会自动配置该Bean。
「自动配置Bean」：通过的自动配置类会将相关的Bean（如DataSource、DispatcherServlet）注册到Spring容器中，实现"自动装配"。

核心总结：SpringBoot自动装配的本质是"通过SpringFactoriesLoader加载自动配置类清单，根据类路径依赖和条件注解筛选有效配置类，最终将相关Bean注册到容器中"，实现了"约定大于配置"，简化了开发流程。

七、总结

本文围绕Spring全家桶和MyBatis的核心问题，从IOC/AOP、Bean生命周期、事务管理、MVC分层、SpringMVC流程、MyBatis参数注入与执行流程、SpringBoot自动装配等维度进行了系统化解析。这些知识点不仅是面试的高频考点，也是实际开发中必须掌握的核心技能。

学习这些技术的关键是"理解原理+结合实践"：先搞懂底层实现逻辑（如反射、动态代理对IOC/AOP的支撑），再通过实际项目落地应用（如使用SpringBoot开发Web项目、用MyBatis操作数据库），才能真正夯实基础，提升开发能力。