关于Spring框架应用BeanPostProcessor和BeanFactoryPostProcessor接口导致的注入及事务失效问题

最新推荐文章于 2024-07-24 23:13:25 发布
原创 最新推荐文章于 2024-07-24 23:13:25 发布 · 1.5k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring #后端

本文通过示例展示了不当使用Spring框架的BeanPostProcessor和BeanFactoryPostProcessor可能导致的BEAN提前初始化问题，进而引发依赖注入失败及空指针异常。探讨了问题的原因，并提出了两种解决方案。
部署运行你感兴趣的模型镜像

前言：

Spring框架是一个以IOC和AOP为核心的业务框架，在使用它时，会因为技术和业务的不断迭代，业务框架本身越来越庞大，对应的技术融合也越来越多，原来可以成功执行的，后面加入一些组件就导致了无效问题发生。

例如：使用了BeanPostProcessor或者BeanFactoryPostProcessor的一些用法，导致了BEAN的提 前初始化，随后在一些场景中，导致BEAN的注入无效、Spring的事务不起作用。

思考：在解决这些问题时，其实当时造成这种问题时，只是为了解决功能，但没有在整体方案上思考一个良好的规范。从而经常碰到有新的问题或功能来临时，将一些挖的坑给释放出来，从来变得既要向前兼容，还要解决新的功能问题的两难局面。

下面，作者专门编写了一个最简单的例子展现给大家。

简单示例-准备：

这里使用简单的示例，提前让一些BEAN初始化，导致spring的bean ioc无效引发空指针异常

编写applicationContext.xml 内容非常简单，配置一个数据源，并声明一个dao，并给它注入datasource

@Override
       <context:component-scan base-package="com.riso.spring"/>

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/test"></property>
        <property name="username" value="test"></property>
        <property name="password" value="test"></property>
        <property name="initialSize" value="2"></property>
        <property name="maxActive" value="5"></property>
    </bean>

    <bean class="com.riso.spring.dao.Test1DaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>

编写对应的简单dao和简单service

public class BaseDaoImpl {

    private DataSource dataSource;

    private JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
        this.jdbcTemplate = new JdbcTemplate(this.dataSource);
    }

    public JdbcTemplate getJdbcTemplate() {
        if (jdbcTemplate == null) {
            throw new IllegalArgumentException("'dataSource' or 'jdbcTemplate' is required");
        }
        return jdbcTemplate;
    }

}

 public class Test1DaoImpl extends BaseDaoImpl {

    private static String INSERT_SQL = "insert into tr_test1(`test_name`) values(?)";
    
    public void insert(String testName) {
        int count = getJdbcTemplate().update(INSERT_SQL, testName);
        log.debug("insert count:{}", count);

    }

}

@Service
public class TestServiceImpl {

    @Autowired
    private Test1DaoImpl test1Dao;


    @Transactional
    public void insertSingleSourceTrsSuccess() {
        test1Dao.insert("testSuccess");
    }
}

编写对应的单元测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"/applicationContext.xml"}) //加载spring配置文件 启动入口
public class TestServiceImplTest {

    @Autowired
    TestServiceImpl testService;

    @Test
    public void insertSingleSourceTrsSuccess() {
        testService.insertSingleSourceTrsSuccess();
    }

}

然后我们跑一下单元测试，结果是成功的
在这里插入图片描述

简单示例-复盘（添加BeanPostProcessor或者BeanFactoryPostProcessor使用，使依赖注入无效）：

  1. 添加一个BeanPostProcessor的实现(仅仅实现接口，仅仅打印日志，实测，不打日志，也是一样）
@Slf4j
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
       log.info("postProcessBeforeInitialization beanName:{}", beanName);
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
       log.info("postProcessAfterInitialization beanName:{}", beanName);
        return null;
    }
}

然后跑一下单元测试，失败了
在这里插入图片描述
失败的异常见：

java.lang.IllegalStateException: Failed to load ApplicationContext

	at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:124)
	at org.springframework.test.context.support.DefaultTestContext.getApplicationContext(DefaultTestContext.java:83)
	at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.injectDependencies(DependencyInjectionTestExecutionListener.java:117)
	at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.prepareTestInstance(DependencyInjectionTestExecutionListener.java:83)
	at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:230)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:228)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:287)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:289)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:247)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:94)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
	at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:191)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)
Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'testMultiServiceImpl': Unsatisfied dependency expressed through field 'test1Dao'; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'com.riso.spring.dao.Test1DaoImpl#0' defined in class path resource [applicationContext.xml]: Error setting property values; nested exception is org.springframework.beans.PropertyBatchUpdateException; nested PropertyAccessExceptions (1) are:
PropertyAccessException 1: org.springframework.beans.MethodInvocationException: Property 'dataSource' threw exception; nested exception is java.lang.IllegalArgumentException: Property 'dataSource' is required
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:588)
	at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:88)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:366)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1264)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:553)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:483)
	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:306)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:302)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:761)
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:867)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:543)
	at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:128)
	at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:60)
	at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.delegateLoading(AbstractDelegatingSmartContextLoader.java:108)
	at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.loadContext(AbstractDelegatingSmartContextLoader.java:251)
	at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContextInternal(DefaultCacheAwareContextLoaderDelegate.java:98)
	at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:116)
	... 24 more
  1. 删除掉BeanPostProcessor的实现， 添加一个BeanFactoryPostProcessor的实现（特别注意：beanFactory.getBeansWithAnnotation）

@Slf4j
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        int beanDefinitionCount = beanFactory.getBeanDefinitionCount();
        log.info("beanDefinitionCount:{}", beanDefinitionCount);
        String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            log.info("beanDefinitionName:{}", beanDefinitionName);
        }
        
        //Service  上面的代码是没有问题下面的代码是导致问题的关键代码
        Map<String, Object> annotationMap = beanFactory.getBeansWithAnnotation(Service.class);


    }
}

然后跑一下单元测试，失败了
在这里插入图片描述
失败的异常见：（此次导致的问题 ，就是一个NullPointerException，还没有上面的错误的失败例子好分析。单看异常信息会莫名其妙

java.lang.NullPointerException
	at com.riso.spring.service.TestServiceImpl.insertSingleSourceTrsSuccess(TestServiceImpl.java:19)
	at com.riso.spring.service.TestServiceImplTest.insertSingleSourceTrsSuccess(TestServiceImplTest.java:21)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:75)
	at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:86)
	at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:84)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:252)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:94)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
	at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:191)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)

原因分析及解决方案：

原因分析： 在使用spring的BeanPostProcessor和BeanFactoryPostProcessor的时候，在spring的初始化过程中，提前将还不打算实例化的bean，实例化了，这些实例化的BEAN，其实还有依赖一些配置或者BEAN，从来引发问题

解决方案有二个方案：
1.在使用spring的BeanPostProcessor和BeanFactoryPostProcessor的时候，避免提前实例化bean的动作，这块引发的API可能有不少，作者本人也并没有枚举掉所有，需要实际项目人经过测试识别出来。

2.但作者本人认为根本的解决方案：
建立一个BEAN的良好规范、比如说所有的BEAN应用，应该是懒加载的，从硬的代码生成，或软的开发标准上，都偏向于懒加载，避免在Spring本身的组件初始化及依赖引发的初始化，造成失效问题。

查找问题中一些有参考意义的文章：

Spring 的类扫描器分析 - ClassPathBeanDefinitionScanner

浅谈BeanPostProcessor加载次序及其对Bean造成的影响分析

Spring 钩子之BeanFactoryPostProcessor和BeanPostProcessor的源码学习

最后附上我之前写的博文入口：

[1] https://blog.youkuaiyun.com/vipshop_fin_dev/article/details/89303458
[2] https://blog.youkuaiyun.com/vipshop_fin_dev/article/details/85323076
[3] https://blog.youkuaiyun.com/vipshop_fin_dev/article/details/85239099
[4] https://blog.youkuaiyun.com/vipshop_fin_dev/article/details/79618067
[5] https://blog.youkuaiyun.com/vipshop_fin_dev/article/details/79313432
[6] https://blog.youkuaiyun.com/vipshop_fin_dev/article/details/106862227

朱杰
2020-09-20

您可能感兴趣的与本文相关的镜像

Llama Factory

Llama Factory

模型微调
LLama-Factory

LLaMA Factory 是一个简单易用且高效的大型语言模型（Large Language Model）训练与微调平台。通过 LLaMA Factory，可以在无需编写任何代码的前提下，在本地完成上百种预训练模型的微调

Java中如何使用BeanFactoryPostProcessor注入Bean
CyberNerdX的博客
09-25 178
在Java应用程序中，BeanFactoryPostProcessor是一个Spring框架提供的接口，用于在Spring容器实例化和配置Bean之前修改Bean的定义和属性。你可以根据具体需求在BeanFactoryPostProcessor中实现自定义的逻辑，修改Bean的定义和属性，以满足应用程序的需求。在这个示例中，我们获取名为"myBean"的Bean定义，并向其添加一个名为"propertyName"的属性，并设置属性值为"propertyValue"。这个类将负责修改Bean的定义和属性。
Spring高频面试基础问题与知识点整理
热门推荐
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
04-07 173万+
高频Spring相关基本面试题和知识点整理
Spring 源码剖析 四、主要逻辑代码赏析之BeanFactoryPostProcessor对BeanFactory的拦截处理
HappyHeng的博客
05-17 363
在web开发中，我们经常会用到一些拦截器，比如Java Web中的filter，已经Spring MVC中的Interceptor，其能对一个请求进行前置与后置的处理。而在Spring中，可以使用BeanFactoryPostProcessor对BeanFactory进行拦截处理。 今天就来分析一下BeanFactoryPostProcessor对BeanFactory进行拦截处理的源码...
Spring扩展之BeanPostProcessor接口
weixiaohuai的博客
01-05 4009
目录 一、定义 二、自定义BeanPostProcessor的实现类 三、BeanPostProcessor的注册过程分析 四、BeanPostProcessor的执行过程分析 五、BeanPostProcessor的常用子类和实现类 六、总结 一、定义 BeanPostProcessor是Spring IOC容器给我们提供的一个扩展接口，它可以在spring容器实例化bean之后，在执行bean的初始化方法前后，允许我们自定义修改新的bean实例，如修改bean的属性，可以给bean生
聊一聊-不生效的 BeanPostProcessor
qq_48793913的博客
06-26 1739
问题描述 代码详见：extention-FactoryBean; clone 之后可以直接运行 DemoApplication 即可，可以观察到 控制台不输出 GlmapperBeanPostProcessor 里面 print out 的字符串。 运行代码，即可观察到具体的执行现场；代码里除了 BeanPostProcessor 之外，另外一个是 FactoryBean，也就是本篇所要聊的重点：FactoryBean getObjectType 为 null 时导致 bean 提前初始化，...
beanpostprocessor_聊一聊 BeanPostProcessor 不生效
weixin_39765209的博客
11-30 1694
关于 BeanPostProcessor 各位一定不陌生，在 SpringBoot 源码系列-Bean 的生命周期与扩展 (http://www.glmapper.com/2019/12/14/springboot-series-bean-life/) 这篇文章中，有介绍过 bean 的创建流程及相关扩展，也提到 BeanPostProcessor，包括它的作用时机及如何使用，这篇文章提...
2021面试准备-Spring 框架
a2522827931的博客
01-12 311
五．Spring 框架 5.1 Spring 是什么? Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基 础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需 要关心业务需求。常见的配置方式有三种：基于XML的配置.基于注解的配置. 基于Java的配置。 ​ 主要由以下几个模块组成： Spring Core：核心类库，提供IOC服务； ​ Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI. 定时任务等）； ​ Sprin
Spring知识点
YIYIYI
07-24 1485
Spring知识点
Spring框架核心原理面试题：从IoC到AOP的10个深度问题解析
![Spring框架核心原理面试题：从IoC到AOP的10个深度问题解析]...本文详细探讨了Spring框架的核心概念、原理及其在实际开发中的应用。首先，文章概述了Spring框架的IoC原理，并深入分析了IoC容
一篇文章讲透spring ioc (概念、原理、实例、应用场景、面试题)
zhouyunjian的博客
07-12 1万+
ioc概念 优势 原理 常见api 实例 应用场景 常见面试题 ioc概念、优势、原理、常见使用、实例、应用场景 ioc概念与定义：ioc翻译成中文为控制反转。意思可以理解为类与类之间的依赖通过容器来控制、配置实现；换一种方式可以这么理解 原来类与类之间在编译时即产生了依赖，即new 对象时，已建立好两者之间的依赖关系；ioc机制将两者之间的依赖关系通过容器进行...
springboot项目在BeanDefinitionRegistryPostProcessor中修改BeanDefinition不生效
qq_39610074的博客
12-10 956
springboot项目在BeanDefinitionRegistryPostProcessor中修改BeanDefinition不生效
Spring依赖注入Bean为空，注入失效场景
huangdi1309的博客
11-30 5705
场景介绍 使用spring往一个bean(BeanB)注入另一个bean(BeanA)，发现BeanA为null，注入失败了。 代码展示 /** * @author huangd * @date 2021-11-30 **/ @Component public class BBean { @Autowired private ABean aBean; public BBean() { System.out.println("BBean instantiatio
SpringBoot 实战：通过 BeanPostProcessor 动态注入 ID 生成器
沉潜飞动
04-25 1613
你好，我是看山。 在分布式系统中，我们会需要 ID 生成器的组件，这个组件可以实现帮助我们生成顺序的或者带业务含义的 ID。 目前有很多经典的 ID 生成方式，比如数据库自增列（自增主键或序列）、Snowflake 算法、美团 Leaf 算法等等，所以，会有一些公司级或者业务级的 ID 生成器组件的诞生。本文就是通过 BeanPostProcessor 实现动态注入 ID 生成器的实战。 在 Spring 中，实现注入的方式很多，比如 springboot 的 starter，在自定义的 Configu.
Spring Bean的生命周期、Java配置BeanFactoryPostProcessor失效与解决
qq_34922830的博客
10-03 3569
到底什么是 BeanFactory它是 ApplicationContext 的父接口它才是 Spring 的核心容器, 主要的 ApplicationContext 实现都【组合】了它的功能，【组合】是指 ApplicationContext 的一个重要成员变量就是 BeanFactoryBeanFactory 能干点啥表面上只有 getBean实际上控制反转、基本的依赖注入、直至 Bean 的生命周期的各种功能，都由它的实现类提供。
Spring各种PostProcessor : BeanFactoryPostProcessor
Details Inside Spring
01-11 1355
概述 顾名思义,BeanFactoryPostProcessor定义了关于 BeanFactory 的PostProcessor。这里的BeanFactory其实就是一般常说的Spring bean 容器，通常是一个DefaultListableBeanFactory,它实现了BeanDefinitionRegistry接口用于作为bean定义注册表,同时也实现了接口ConfigurableLis...
Spring @Autowired 失效 BeanFactoryPostProcessor 错误姿势
哲里哲里的博客
02-14 1620
工作中遇到一个@Autowired 自动注入失败的情况，经过一系列的探索之后发现是对spring 的 BeanFactoryPostProcessor 使用姿势错误导致的，下面我们来具体说明下 流程代码如下： 首先我们会在bean工厂的后置处理器中 运行如下代码 beanFactory.getBeansOfType(Man.class) 这个方法会返回与给定对象类型匹配的 bea...
spring复习：（23）DefaultListableBeanFactory BeanPostProcessor不起作用
amadeus_liu2的博客
07-13 790
这样写BeanPostProcessor的代码不执行。换成ApplicationContext的写法就可以。debug发现：用DefaultListableBeanFactory时，这个方法返回的list 的size为0。
Spring BeanPostProcessor 不生效的场景
wt_better的博客
06-12 810
Spring BeanPostProcessor不生效
为什么有时候Spring BeanPostProcessor接口事件不调用？
b306533659的博客
10-17 1740
spring BeanPostProcessor 动态注册Bean
Spring 面试高频问题解析
最新发布
04-28
<think>好的，我现在需要帮用户整理关于Spring框架面试的高频问题及详细解析。用户之前已经提供了一份面试总结，现在又补充了一些引用内容，我需要结合这些信息来优化回答。 首先，我要确认用户的需求。用户明确提到想要高频问题及其解析，可能是为了面试准备或深入学习Spring。之前的回答已经涵盖了核心概念、依赖注入、AOP、事务管理、Spring MVC、整合与扩展等内容，但用户提供的引用里提到了更多细节，比如Spring MVC的灵活性、设计模式、循环依赖的解决、Spring Cloud Config等。我需要确保这些新内容被适当整合进去。 接下来，我需要检查用户提供的引用内容。引用[1]提到Spring MVC的定制扩展能力和设计模式，引用[2]有关Spring Cloud的内容，但用户当前的问题集中在Spring框架本身，可能暂时不需要涉及Spring Cloud，所以可能暂时忽略引用[2]。引用[3]提到了SpringApplication的初始化过程，引用[4]详细说明了循环依赖的三级缓存机制。这些都需要被整合到相关的部分。 然后，我要回顾之前的回答结构，确保新增内容符合原有逻辑。例如，在核心概念部分，需要补充设计模式，如工厂模式、代理模式等，并引用[1]和之前的回答内容。在循环依赖的问题上，引用[4]提到的三级缓存机制需要详细说明，可能将其作为单独的问题或在IoC部分展开。 同时，用户可能希望问题更全面，所以需要检查是否有遗漏的高频问题，比如Bean的生命周期、Spring Boot的自动配置原理等，这些在之前的回答中可能没有详细说明，需要补充。 另外，用户提供的引用[3]关于SpringApplication的初始化流程，可以整合到Spring Boot相关的问题中，如果用户的问题扩展到Spring Boot的话，但当前问题主要围绕Spring框架，可能需要暂时搁置或简要提及。 最后，确保回答结构清晰，每个问题有解析和引用标记，语言简洁，符合中文习惯，并且正确使用LaTeX格式。需要避免重复，同时覆盖所有高频考点，如IoC、AOP、事务、MVC、设计模式、循环依赖、Bean作用域等。 总结步骤： 1. 整合用户提供的引用内容到现有问题中。 2. 补充遗漏的高频问题，如Bean生命周期、自动配置原理。 3. 确保每个问题解析准确，引用正确来源。 4. 结构清晰，使用适当的代码示例和公式。 5. 生成相关问题，覆盖用户可能感兴趣的扩展知识点。</think>### Spring 框架面试高频问题及详细解析 --- #### 一、核心机制与设计模式 1. **Spring 的核心功能与设计模式** - **核心功能**：IoC（控制反转）通过容器管理对象依赖，AOP（面向切面编程）实现横切关注点（如日志、事务）的模块化。 - **设计模式**： - **工厂模式**：`BeanFactory` 和 `ApplicationContext` 创建和管理 Bean。 - **代理模式**：AOP 使用 JDK 动态代理或 CGLIB 生成代理类。 - **模板方法模式**：`JdbcTemplate` 封装数据库操作流程。 - **观察者模式**：通过 `ApplicationEvent` 和 `ApplicationListener` 实现事件发布与监听[^1][^3]。 2. **Spring 如何解决循环依赖？** - **三级缓存机制**： 1. **一级缓存（单例池）**：存放完全初始化好的 Bean。 2. **二级缓存**：存放早期暴露的 Bean（未完成属性注入）。 3. **三级缓存**：存放 Bean 的工厂对象，用于生成半成品 Bean。 - **流程**：当 Bean A 依赖 Bean B 时，A 的工厂对象先存入三级缓存，B 创建时从三级缓存获取 A 的引用，避免死锁[^4]。 --- #### 二、IoC 与 Bean 管理 3. **Bean 的生命周期** - 主要阶段： 1. 实例化（通过构造器或工厂方法）。 2. 属性注入（依赖注入）。 3. 初始化（调用 `@PostConstruct` 或实现 `InitializingBean`）。 4. 销毁（调用 `@PreDestroy` 或实现 `DisposableBean`）。 - 扩展点：`BeanPostProcessor` 和 `BeanFactoryPostProcessor` 可在生命周期中插入自定义逻辑[^3][^4]。 4. **Bean 的作用域** - `singleton`（默认单例）、`prototype`（每次请求新实例）、`request`（HTTP 请求级别）、`session`（HTTP 会话级别）。 - **单例 Bean 的线程安全问题**：需避免共享可变状态，或用 `ThreadLocal` 隔离[^1][^3]。 --- #### 三、AOP 与事务管理 5. **AOP 的实现原理与使用场景** - **原理**：动态代理（JDK 基于接口，CGLIB 基于类继承）。 - **核心注解**： ```java @Aspect @Before("execution(* com.service.*.*(..))") public void logBefore(JoinPoint jp) { ... } ``` - **场景**：日志记录、事务管理、权限校验[^1][^3]。 6. **Spring 事务传播机制** - `PROPAGATION_REQUIRED`：加入当前事务，不存在则新建。 - `PROPAGATION_REQUIRES_NEW`：新建独立事务，挂起当前事务。 - `PROPAGATION_NESTED`：嵌套事务（依赖数据库保存点）[^1][^4]。 --- #### 四、Spring MVC 与扩展 7. **Spring MVC 工作流程** 1. 客户端请求 → `DispatcherServlet` 接收。 2. 通过 `HandlerMapping` 查找对应控制器。 3. 控制器处理请求 → 返回 `ModelAndView`。 4. `ViewResolver` 解析视图 → 渲染响应[^1]。 8. **如何自定义 Spring MVC 组件？** - **扩展点**： - 自定义 `HandlerInterceptor` 实现请求拦截。 - 配置 `ViewResolver` 支持多模板引擎（如 Thymeleaf）。 - 使用 `@ControllerAdvice` 统一异常处理： ```java @ExceptionHandler(NullPointerException.class) public ResponseEntity<String> handleNPE(NullPointerException e) { ... } ``` --- #### 五、高级特性与整合 9. **Spring Boot 自动配置原理** - **核心机制**：通过 `@EnableAutoConfiguration` 扫描 `META-INF/spring.factories` 中的配置类，条件注解（如 `@ConditionalOnClass`）决定是否加载。 10. **Spring 整合 MyBatis 的关键配置** - 配置 `SqlSessionFactoryBean` 指定数据源和映射文件路径。 - 使用 `@MapperScan` 扫描 DAO 接口： ```java @Configuration @MapperScan("com.example.mapper") public class MyBatisConfig { ... } ``` [^3]。 --- ### 相关问题 1. **BeanFactory 和 ApplicationContext 的区别？** - `BeanFactory` 提供基础 IoC 功能，`ApplicationContext` 扩展了国际化、事件传播等企业级特性[^3]。 2. **Spring 事务失效的常见原因？** - 方法非 `public`、同一类内方法调用（未通过代理）、异常未被捕获或未标记为回滚[^4]。 3. **如何基于 Spring 实现自定义注解？** - 定义注解 → 通过 AOP 或 `BeanPostProcessor` 实现注解逻辑： ```java @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface CustomLog { ... } ``` 4. **Spring MVC 中 `@RequestMapping` 和 `@RestController` 的区别？** - `@RestController` = `@Controller` + `@ResponseBody`，直接返回 JSON/XML 数据。 5. **Spring 如何管理多数据源？** - 配置多个 `DataSource` → 使用 `@Primary` 标记主数据源 → 在 DAO 层通过 `@Qualifier` 指定[^3]。 : Spring 官方文档与高频面试解析 [^2]: Spring Cloud 配置管理详解 : Spring 核心机制与初始化流程 [^4]: 循环依赖解决与事务机制深度剖析
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值