spring4，2024年最新java跳槽面试题

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

// Propagate exception to caller.

throw ex;

}

}

}

接下来逐个分析吧：

prepareRefresh方法

prepareRefresh方法的源码如下：

protected void prepareRefresh() {

//记录初始化开始时间

this.startupDate = System.currentTimeMillis();

//context是否关闭的标志，设置为false

this.closed.set(false);

//context是否激活的标志，设置为true

this.active.set(true);

if (logger.isInfoEnabled()) {

logger.info("Refreshing " + this);

}

//留给子类实现的空方法

initPropertySources();

/**

AbstractPropertyResolver类的requiredProperties是个集合，

在下面的validateRequiredProperties方法中，都要拿requiredProperties中的元素作为key去检查是否存在对应的环境变量，

如果不存在就抛出异常

*/

getEnvironment().validateRequiredProperties();

}

上述代码中，注意以下两处：

1. initPropertySources是个空方法，是留给子类实现的，以AnnotationConfigWebApplicationContext类为例，就overwrite了initPropertySources方法：

@Override

protected void initPropertySources() {

ConfigurableEnvironment env = getEnvironment();

if (env instanceof ConfigurableWebEnvironment) {

((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, this.servletConfig);

}

}

跟踪上面的initPropertySources方法，最终找到了WebApplicationContextUtils.initServletPropertySources：

public static void initServletPropertySources(

MutablePropertySources propertySources, ServletContext servletContext, ServletConfig servletConfig) {

Assert.notNull(propertySources, “propertySources must not be null”);

if (servletContext != null && propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME) &&

propertySources.get(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME) instanceof StubPropertySource) {

propertySources.replace(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME,

new ServletContextPropertySource(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME, servletContext));

}

if (servletConfig != null && propertySources.contains(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME) &&

propertySources.get(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME) instanceof StubPropertySource) {

propertySources.replace(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME,

new ServletConfigPropertySource(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME, servletConfig));

}

}

上面的代码所做的事情，就是给context增加环境变量数据(数据来自servlet相关的配置信息)，这样spring环境就能从context中随时key取得对应的变量了；

1. getEnvironment().validateRequiredProperties()的作用是用来校验context中是否存在"某些"变量，何谓"某些"？来看validateRequiredProperties方法，追踪到多层调用，最终在AbstractPropertyResolver类的validateRequiredProperties方法中实现：

@Override

public void validateRequiredProperties() {

MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();

for (String key : this.requiredProperties) {

if (this.getProperty(key) == null) {

ex.addMissingRequiredProperty(key);

}

}

if (!ex.getMissingRequiredProperties().isEmpty()) {

throw ex;

}

}

上述代码显示，如果集合requiredProperties中的name在context中找不到对应的变量，就会抛出异常；

那么问题来了，requiredProperties集合是何时设置的呢？spring-framework中并没有调用，但是官方的单元测试源码给我们了启发，如下图：

如上图红框，如果业务需要确保某些变量在spring环境中必须存在，就可以调用setRequiredProperties方法将变量的name传递进去，这样validateRequiredProperties方法就会做检查了，我们可以基于现有的各种ApplicationContext实现自己定制一个Context类，确保在validateRequiredProperties方法调用之前调用setRequiredProperties方法将变量的name传递进去（例如重写initPropertySources），就能让spring帮我们完成检查了；

obtainFreshBeanFactory()

接下来看ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();得到临时变量beanFactory，先看看ConfigurableListableBeanFactory和BeanFactory的关系：

再看看obtainFreshBeanFactory方法：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

//由子类创建beanFactory

refreshBeanFactory();

//取得子类创建好的beanFactory，作为obtainFreshBeanFactory方法的返回值返回

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (logger.isDebugEnabled()) {

logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

}

return beanFactory;

}

上述代码中有的refreshBeanFactory需要细看；

refreshBeanFactory方法

refreshBeanFactory方法，在AbstractApplicationContext类中是抽象方法，具体实现在子类中，以其子类AbstractRefreshableApplicationContext为例，我们来看看refreshBeanFactory方法的实现：

@Override

protected final void refreshBeanFactory() throws BeansException {

//如果beanFactory已经存在，就销毁context管理的所有bean，并关闭beanFactory

if (hasBeanFactory()) {

//其实就是调用一些集合的clear方法，解除对一些实例的引用，参考DefaultSingletonBeanRegistry.destroySingletons方法

destroyBeans();

//关闭当前的beanFactory，其实就是将成员变量beanFactory设置为null

closeBeanFactory();

}

try {

DefaultListableBeanFactory beanFactory = createBeanFactory();

beanFactory.setSerializationId(getId());

customizeBeanFactory(beanFactory);

loadBeanDefinitions(beanFactory);

synchronized (this.beanFactoryMonitor) {

this.beanFactory = beanFactory;

}

}

catch (IOException ex) {

throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

}

}

1. createBeanFactory方法实际上返回的是一个DefaultListableBeanFactory实例：

protected DefaultListableBeanFactory createBeanFactory() {

return new DefaultListableBeanFactory(getInternalParentBeanFactory());

}

1. 接下来的customizeBeanFactory方法是留给子类OverWrite的，该方法的说明和源码如下，说明中推荐通过OverWrite的方式对现有beanFactory做特别的设置：

/**

• Customize the internal bean factory used by this context.

• Called for each {@link #refresh()} attempt.

• The default implementation applies this context's

• {@linkplain #setAllowBeanDefinitionOverriding “allowBeanDefinitionOverriding”}

• and {@linkplain #setAllowCircularReferences “allowCircularReferences”} settings,

• if specified. Can be overridden in subclasses to customize any of

• {@link DefaultListableBeanFactory}'s settings.

• @param beanFactory the newly created bean factory for this context

• @see DefaultListableBeanFactory#setAllowBeanDefinitionOverriding

• @see DefaultListableBeanFactory#setAllowCircularReferences

• @see DefaultListableBeanFactory#setAllowRawInjectionDespiteWrapping

• @see DefaultListableBeanFactory#setAllowEagerClassLoading

*/

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {

if (this.allowBeanDefinitionOverriding != null) {

//allowBeanDefinitionOverriding表示是否允许注册一个同名的类来覆盖原有类(注意是类，不是实例)

beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);

}

if (this.allowCircularReferences != null) {

//allowCircularReferences表示是否运行多个类之间的循环引用

beanFactory.setAllowCircularReferences(this.allowCircularReferences);

}

}

1. loadBeanDefinitions在AbstractRefreshableApplicationContext类中是个抽象方法，留给子类实现，作用是把所有bean的定义后保存在context中，以AbstractXmlApplicationContext为例，看看loadBeanDefinitions方法做了什么：

/**

• Loads the bean definitions via an XmlBeanDefinitionReader.

• @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader

• @see #initBeanDefinitionReader

• @see #loadBeanDefinitions

*/

@Override

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

// Create a new XmlBeanDefinitionReader for the given BeanFactory.

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

// Configure the bean definition reader with this context’s

// resource loading environment.

beanDefinitionReader.setEnvironment(this.getEnvironment());

beanDefinitionReader.setResourceLoader(this);

beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

// Allow a subclass to provide custom initialization of the reader,

// then proceed with actually loading the bean definitions.

initBeanDefinitionReader(beanDefinitionReader);

loadBeanDefinitions(beanDefinitionReader);

}

以上代码可见，加载bean的定义是通过XmlBeanDefinitionReader 来完成的，重点关注loadBeanDefinitions方法：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

Resource[] configResources = getConfigResources();

if (configResources != null) {

reader.loadBeanDefinitions(configResources);

}

String[] configLocations = getConfigLocations();

if (configLocations != null) {

reader.loadBeanDefinitions(configLocations);

}

}

上述代码中的getConfigResources()和getConfigLocations()，究竟哪个会返回值有效数据呢？这就要去看ClassPathXmlApplicationContext的构造方法了：

//这个方法设置的是configLocations

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

throws BeansException {

super(parent);

setConfigLocations(configLocations);

if (refresh) {

refresh();

}

}

//这个方法设置的是这个方法设置的是configResources

public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, ApplicationContext parent)

throws BeansException {

super(parent);

Assert.notNull(paths, “Path array must not be null”);

Assert.notNull(clazz, “Class argument must not be null”);

this.configResources = new Resource[paths.length];

for (int i = 0; i < paths.length; i++) {

this.configResources[i] = new ClassPathResource(paths[i], clazz);

}

refresh();

}

因此，到底是configLocations 还是configResources ，和我们使用哪个构造方法来实例化applicationContext对象有关；

1. 如果我们实例化applicationContext对象的方式是new ClassPathXmlApplicationContext(“applicationContext.xml”)，那么setConfigLocations方法就会被调用，因此loadBeanDefinitions方法内部，实际执行的代码如下：

String[] configLocations = getConfigLocations();

if (configLocations != null) {

reader.loadBeanDefinitions(configLocations);

}

1. 现在可以来看AbstractBeanDefinitionReader类的loadBeanDefinitions(String… locations)方法了：

public int loadBeanDefinitions(String… locations) throws BeanDefinitionStoreException {

Assert.notNull(locations, “Location array must not be null”);

int counter = 0;

for (String location : locations) {

counter += loadBeanDefinitions(location);

}

return counter;

}

展开上面for循环中调用的方法：

public int loadBeanDefinitions(String location, Set actualResources) throws BeanDefinitionStoreException {

ResourceLoader resourceLoader = getResourceLoader();

if (resourceLoader == null) {

throw new BeanDefinitionStoreException(

“Cannot import bean definitions from location [” + location + “]: no ResourceLoader available”);

}

if (resourceLoader instanceof ResourcePatternResolver) {

// Resource pattern matching available.

try {

Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

int loadCount = loadBeanDefinitions(resources);

if (actualResources != null) {

for (Resource resource : resources) {

actualResources.add(resource);

}

}

if (logger.isDebugEnabled()) {

logger.debug(“Loaded " + loadCount + " bean definitions from location pattern [” + location + “]”);

}

return loadCount;

}

catch (IOException ex) {

throw new BeanDefinitionStoreException(

“Could not resolve bean definition resource pattern [” + location + “]”, ex);

}

}

else {

// Can only load single resources by absolute URL.

Resource resource = resourceLoader.getResource(location);

int loadCount = loadBeanDefinitions(resource);

if (actualResources != null) {

actualResources.add(resource);

}

if (logger.isDebugEnabled()) {

logger.debug(“Loaded " + loadCount + " bean definitions from location [” + location + “]”);

}

return loadCount;

}

}

以上方法中，首先要记得resourceLoader是ClassPathXmlApplicationContext（beanDefinitionReader.setResourceLoader(this)这行代码），所有resourceLoader.getResource(location)这行代码最终会调用PathMatchingResourcePatternResolver类的getResources(String locationPattern)方法得到bean有关的Resource对象；得到Resource对象后，接着会调用loadBeanDefinitions(Resource… resources)方法来加载bean的定义了，最终是调用XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource)方法：

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {

Assert.notNull(encodedResource, “EncodedResource must not be null”);

if (logger.isInfoEnabled()) {

logger.info("Loading XML bean definitions from " + encodedResource.getResource());

}

Set currentResources = this.resourcesCurrentlyBeingLoaded.get();

if (currentResources == null) {

currentResources = new HashSet(4);

this.resourcesCurrentlyBeingLoaded.set(currentResources);

}

if (!currentResources.add(encodedResource)) {

throw new BeanDefinitionStoreException(

“Detected cyclic loading of " + encodedResource + " - check your import definitions!”);

}

try {

InputStream inputStream = encodedResource.getResource().getInputStream();

try {

InputSource inputSource = new InputSource(inputStream);

if (encodedResource.getEncoding() != null) {

inputSource.setEncoding(encodedResource.getEncoding());

}

return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

}

finally {

inputStream.close();

}

}

catch (IOException ex) {

throw new BeanDefinitionStoreException(

"IOException parsing XML document from " + encodedResource.getResource(), ex);

}

finally {

currentResources.remove(encodedResource);

if (currentResources.isEmpty()) {

this.resourcesCurrentlyBeingLoaded.remove();

}

}

}

上述代码可见，重要的是通过Resource对象得到InputStream，再调用doLoadBeanDefinitions方法：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

throws BeanDefinitionStoreException {

try {

Document doc = doLoadDocument(inputSource, resource);

return registerBeanDefinitions(doc, resource);

}

…

上面是加载bean定义的关键代码：先制作Document对象，再调用registerBeanDefinitions方法，最终会将每个bean的定义放入DefaultListableBeanFactory的beanDefinitionMap中，详细的堆栈如下图：

完成了bean定义的注册，可以回到AbstractRefreshableApplicationContext.refreshBeanFactory方法了，看看loadBeanDefinitions(beanFactory)之后的代码：

synchronized (this.beanFactoryMonitor) {

this.beanFactory = beanFactory;

}

至此，refreshBeanFactory方法分析完毕，该方法所做的事情：把xml文件中的bean定义被解析后，存放在DefaultListableBeanFactory的beanDefinitionMap中；

现在回到主线的AbstractApplicationContext.refresh()方法内，obtainFreshBeanFactory()我们已经分析完毕，所有bean定义都被存放在beanFactory这个临时变量对应的实例中；

prepareBeanFactory

接下来是prepareBeanFactory(beanFactory)，看一下此方法的源码：

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

//设置类加载器

beanFactory.setBeanClassLoader(getClassLoader());

//设置解析器，用于解析bean的定义中出现的Spel表达式表达式

beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

//设置一个注册接口，该接口只有一个方法registerCustomEditors，用来设置自定义的转换器

beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

// 部署一个bean的后置处理器ApplicationContextAwareProcessor，用于将spring的环境信息注入到实例化的bean之中

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

//bean在初始化的时候，如果有属性的类型为ResourceLoaderAware，则该属性不会被依赖注入

beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);

beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);

beanFactory.ignoreDependencyInterface(MessageSourceAware.class);

beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

// BeanFactory interface not registered as resolvable type in a plain factory.

// MessageSource registered (and found for autowiring) as a bean.

//bean如果有个属性的类型为BeanFactory.class，那么该属性会被设置为beanFactory

beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);

beanFactory.registerResolvableDependency(ResourceLoader.class, this);

beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);

beanFactory.registerResolvableDependency(ApplicationContext.class, this);

// Detect a LoadTimeWeaver and prepare for weaving, if found.

if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

// 部署一个bean的后置处理器ApplicationContextAwareProcessor，用于AOP静态代理相关的处理

beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

// Set a temporary ClassLoader for type matching.

beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

}

// Register default environment beans.

if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {

//注册一个bean

beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());

}

if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {

beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());

}

if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {

beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());

}

}

上述代码中有以下几点需要注意：

1. beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()))，此方法要配合AbstractBeanFactory.registerCustomEditors方法一起看更好理解：addPropertyEditorRegistrar方法向propertyEditorRegistrars属性中放入了一个registrar，之后调用registerCustomEditors方法的时候，会用到propertyEditorRegistrars中的registrar，调用这些registrar的registerCustomEditors方法，完成自定义的转换器的设置；

2. beanFactory.addBeanPostProcessor方法用来注入后置处理器，在bean实例被创建后，初始化方法被执行的前后，后置处理器的postProcessBeforeInitialization、postProcessAfterInitialization这两个方法会分别被调用；

3. beanFactory.ignoreDependencyInterface设置了依赖注入时要忽略的接口，例如bean有个属性类型是ResourceLoaderAware，那么该属性不会被注入ResourceLoaderAware类型的实例；

4. beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory)是特殊设置，如果一个bean有个属性的类型是BeanFactory，那么该属性会被设置为beanFactory这个实例；

总的来说prepareBeanFactory方法就是为beanFactory做一些设置工作，传入一些后面会用到的参数和工具类，再在spring容器中创建一些bean；

postProcessBeanFactory

postProcessBeanFactory方法是留给子类扩展的，可以在bean实例初始化之前注册后置处理器（类似prepareBeanFactory方法中的beanFactory.addBeanPostProcessor），以子类AbstractRefreshableWebApplicationContext为例，其postProcessBeanFactory方法如下：

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));

beanFactory.ignoreDependencyInterface(ServletContextAware.class);

beanFactory.ignoreDependencyInterface(ServletConfigAware.class);

WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);

WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);

}

可见除了WebApplicationContextUtils类的工作之外，其余的都是和prepareBeanFactory方法中类似的处理；

invokeBeanFactoryPostProcessors

invokeBeanFactoryPostProcessors方法用来执行BeanFactory实例的后置处理器BeanFactoryPostProcessor的postProcessBeanFactory方法，这个后置处理器除了原生的，我们也可以自己扩展，用来对Bean的定义做一些修改，由于此时bean还没有实例化，所以不要在自己扩展的BeanFactoryPostProcessor中调用那些会触发bean实例化的方法（例如BeanFactory的getBeanNamesForType方法），源码的文档中有相关说明，如下图红框所示，不要触发bean的实例化，如果要处理bean实例请在BeanPostProcessor中进行；：

registerBeanPostProcessors

registerBeanPostProcessors方法的代码略多，就不在此贴出来了，简单的说，就是找出所有的bean的后置处理器(注意，是bean的后置处理器，不是beanFactory的后置处理器，bean后置处理器处理的是bean实例，beanfactory后置处理器处理的是bean的定义)，然后将这些bean的后置处理器分为三类：

1. 实现了顺序接口Ordered.class的，先放入orderedPostProcessors集合，排序后顺序加入beanFactory的bean后处理集合中；

2. 既没有实现Ordered.class，也没有实现PriorityOrdered.class的后置处理器，也加入到beanFactory的bean后处理集合中；

3. 最后是实现了优先级接口PriorityOrdered.class的，排序后顺序加入beanFactory的bean后处理集合中；

registerBeanPostProcessors方法执行完毕后，beanFactory中已经保存了有序的bean后置处理器，在bean实例化之后，会依次使用这些后置处理器对bean实例来做对应的处理；

initMessageSource

initMessageSource方法用来准备国际化资源相关的，将实现了MessageSource接口的bean存放在ApplicationContext的成员变量中，先看是否有配置，如果有就实例化，否则就创建一个DelegatingMessageSource实例的bean；

initApplicationEventMulticaster

spring中有事件、事件广播器、事件监听器等组成事件体系，在initApplicationEventMulticaster方法中对事件广播器做初始化，如果找不到此bean的配置，就创建一个SimpleApplicationEventMulticaster实例作为事件广播器的bean，并且保存为applicationContext的成员变量applicationEventMulticaster；

onRefresh

onRefresh是个空方法，留给子类自己实现的，在实例化bean之前做一些ApplicationContext相关的操作，以子类AbstractRefreshableWebApplicationContext为例，看看它的onRefresh方法：

@Override

protected void onRefresh() {

this.themeSource = UiApplicationContextUtils.initThemeSource(this);

}

可见是做了主题相关的初始化，并保存在ApplicationContext的成员变量中；

registerListeners

方法名为registerListeners，看名字像是将监听器注册在事件广播器中，但实际情况并非如此，只有一些特殊的监听器被注册了，那些在bean配置文件中实现了ApplicationListener接口的类还没有实例化，所以此处只是将其name保存在广播器中，将这些监听器注册在广播器的操作是在bean的后置处理器中完成的，那时候bean已经实例化完成了，我们看代码：

protected void registerListeners() {

// 注册的都是特殊的事件监听器，而并非配置中的bean

for (ApplicationListener<?> listener : getApplicationListeners()) {

getApplicationEventMulticaster().addApplicationListener(listener);

}

// Do not initialize FactoryBeans here: We need to leave all regular beans

// uninitialized to let post-processors apply to them!

最后

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
tionContext相关的操作，以子类AbstractRefreshableWebApplicationContext为例，看看它的onRefresh方法：

@Override

protected void onRefresh() {

this.themeSource = UiApplicationContextUtils.initThemeSource(this);

}

可见是做了主题相关的初始化，并保存在ApplicationContext的成员变量中；

registerListeners

方法名为registerListeners，看名字像是将监听器注册在事件广播器中，但实际情况并非如此，只有一些特殊的监听器被注册了，那些在bean配置文件中实现了ApplicationListener接口的类还没有实例化，所以此处只是将其name保存在广播器中，将这些监听器注册在广播器的操作是在bean的后置处理器中完成的，那时候bean已经实例化完成了，我们看代码：

protected void registerListeners() {

// 注册的都是特殊的事件监听器，而并非配置中的bean

for (ApplicationListener<?> listener : getApplicationListeners()) {

getApplicationEventMulticaster().addApplicationListener(listener);

}

// Do not initialize FactoryBeans here: We need to leave all regular beans

// uninitialized to let post-processors apply to them!

最后

[外链图片转存中…(img-JnVMPCIh-1713426829780)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-RLIiRJjq-1713426829780)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！