【spring 源碼】IOC 之 ClassPathXmlApplicationContext
先看下啓動 Spring 容器的一個例子：前端
public class App {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
// 從 context 中取出咱們的 Bean
MessageService messageService = context.getBean(MessageService.class);
System.out.println(messageService.getMessage());
}
}
複製代碼
ClassPathXmlApplicationContext 的源碼：
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
// 將配置文件做爲資源都存放到這個數組中
private Resource[] configResources;
// 若是已經有 ApplicationContext並須要配置成父子關係，那麼調用這個構造方法
public ClassPathXmlApplicationContext(ApplicationContext parent) {
super(parent);
}
...
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
super(parent);
// 解析配置文件列表，放置到上面說的那個 configResources 數組中
setConfigLocations(configLocations);
if (refresh) {
refresh(); // 核心方法 調用AbstractApplicationContext.refresh()
}
}
...
}
複製代碼
// AbstractApplicationContext.java L509java
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 準備工做，記錄下容器的啓動時間、標記「已啓動」狀態、處理配置文件中的佔位符
prepareRefresh();
// 這步比較關鍵，這步完成後，配置文件就會解析成一個個 Bean 定義，註冊到 BeanFactory 中，這裏的 Bean 尚未初始化，只是配置信息都提取出來了，
// 註冊也只是將這些信息都保存到了註冊中心(說到底核心是一個 beanName-> beanDefinition 的 map)
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 設置 BeanFactory 的類加載器，添加幾個 BeanPostProcessor，手動註冊幾個特殊的 bean
// 這塊待會會展開說
prepareBeanFactory(beanFactory);
try {
// 【這裏須要知道 BeanFactoryPostProcessor 這個知識點，Bean 若是實現了此接口，那麼在容器初始化之後，Spring 會負責調用裏面的 postProcessBeanFactory 方法。】
// 這裏是提供給子類的擴展點，到這裏的時候，全部的 Bean 都加載、註冊完成了，可是都尚未初始化
// 具體的子類能夠在這步的時候添加一些特殊的BeanFactoryPostProcessor 的實現類或作點什麼事
postProcessBeanFactory(beanFactory);
// 調用 BeanFactoryPostProcessor 各個實現類的 postProcessBeanFactory(factory) 方法
invokeBeanFactoryPostProcessors(beanFactory);
// 註冊 BeanPostProcessor 的實現類，注意看和 BeanFactoryPostProcessor 的區別
// 此接口兩個方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 兩個方法分別在 Bean 初始化以前和初始化以後獲得執行。注意，到這裏 Bean 還沒初始化
registerBeanPostProcessors(beanFactory);
// 初始化當前 ApplicationContext 的 MessageSource（國際化相關信息），國際化這裏就不展開說了
initMessageSource();
// 初始化當前 ApplicationContext 的事件廣播器，這裏也不展開了
initApplicationEventMulticaster();
// 從方法名就能夠知道，典型的模板方法(鉤子方法)，
// 具體的子類能夠在這裏初始化一些特殊的 Bean（在初始化 singleton beans 以前）
onRefresh();
// 註冊事件監聽器，監聽器須要實現 ApplicationListener 接口。這也不是咱們的重點，過
registerListeners();
// 重點，重點，重點
// 初始化全部的 singleton beans
//（lazy-init 的除外）
finishBeanFactoryInitialization(beanFactory);
// 最後，廣播事件，ApplicationContext 初始化完成
finishRefresh();
} catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
// 銷燬已經初始化的 singleton 的 Beans，以避免有些 bean 會一直佔用資源
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// 把異常往外拋
throw ex;
}finally {
// Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); } } } 複製代碼
接下來對refresh（）方法進行分析：web
1-0.prepareRefresh() 建立 Bean 容器前的準備工做
AbstractApplicationContext.java L557spring
protected void prepareRefresh() {
// 將 active 屬性設置爲 true，closed 屬性設置爲 false，它們都是 AtomicBoolean 類型
this.closed.set(false);
this.active.set(true);
// Initialize any placeholder property sources in the context environment
initPropertySources();
// 校驗 xml 配置文件
getEnvironment().validateRequiredProperties();
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}
複製代碼
1-1.obtainFreshBeanFactory() 建立 Bean 容器，加載並註冊 Bean
// AbstractApplicationContext.java L613後端
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 關閉舊的 BeanFactory (若是有)，建立新的 BeanFactory，加載 Bean 定義、註冊 Bean 等等
refreshBeanFactory();
// 返回剛剛建立的 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
複製代碼
refreshBeanFactory（）是建立bean的入口，並將bean實例放到bean工廠的入口（beanName爲key，bean實例爲value放入beanFactory裏的map中），在《【spring 源碼】IOC 之bean實例的建立》裏詳細介紹這個方法的實現。數組
1-2 prepareBeanFactory(beanFactory) 準備bean容器
AbstractApplicationContext.java L627bash
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 設置 BeanFactory 的類加載器，咱們知道 BeanFactory 須要加載類，也就須要類加載器，這裏設置爲當前線程的上下文類加載器
beanFactory.setBeanClassLoader(getClassLoader());
//設置spring 的Spel表達式相關解析器，不是主流程，不作拓展
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//設置PropertyEditorRegistrar,經過PropertyEditor將xml解析出來的bean屬性（字符串）和相應的java類型作轉換
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加一個 BeanPostProcessor，這個 processor 比較簡單，
// 實現了 Aware 接口的幾個特殊的 beans 在初始化的時候，這個 processor 負責回調
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 下面幾行的意思就是，若是某個 bean 依賴於如下幾個接口的實現類，在自動裝配的時候忽略它們，Spring 會經過其餘方式來處理這些依賴。
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
/**
* 下面幾行就是爲特殊的幾個 bean 賦值，若是有 bean 依賴瞭如下幾個，會注入這邊相應的值，
* 以前咱們說過，"當前 ApplicationContext 持有一個 BeanFactory"，這裏解釋了第一行
* ApplicationContext 繼承了 ResourceLoader、ApplicationEventPublisher、MessageSource
* 因此對於這幾個，能夠賦值爲 this，注意 this 是一個 ApplicationContext
*/
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// ，在 bean 實例化後，若是是 ApplicationListener 的子類，那麼將其添加到 listener 列表中，能夠理解成：註冊事件監聽器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 這裏涉及到特殊的 bean:loadTimeWeaver，織入的一種方式，此處這不是咱們的重點，忽略它
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
/**
* 從下面幾行代碼咱們能夠知道，Spring 每每很 "智能" 就是由於它會幫咱們默認註冊一些有用的 bean，
* 咱們也能夠選擇覆蓋
*/
//註冊一個默認的environment的bean
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
//註冊一個systemProperties的bean
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
//註冊一個systemEnvironment的bean
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
複製代碼
至此，準備bean容器結束了，主要就是初始化bean工廠的一些環境、類加載器等session
1-3 postProcessBeanFactory(beanFactory)
主要做用是：承接前文中的prepareBeanFactory()方法後，供子類在標準的基礎上再添加自定義的屬性性質，主要是註冊BeanPostProcessors //AbstractRefreshableWebApplicationContext.java L159mybatis
/**
* Register request/session scopes, a {@link ServletContextAwareProcessor}, etc.
*/
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//註冊ServletContextAwareProcessor
beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
//註冊web環境，包括request、session、golableSession、application
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
//註冊servletContext、contextParamters、contextAttributes、servletConfig單例bean
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}
複製代碼
1-4 invokeBeanFactoryPostProcessors(beanFactory)
主要是實例化和調用全部已註冊的BeanFactoryPostProcessors的postProcessBeanFactory(factory) 方法 //AbstractApplicationContext.java L686app
/**
* Instantiate and invoke all registered BeanFactoryPostProcessor beans,
* respecting explicit order if given.
* <p>Must be called before singleton instantiation.
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//經過一個委託類來處理實例化調用
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
複製代碼
1-4-0 invokeBeanFactoryPostProcessors(beanFactory,beanFactoryPostProcessors)
//PostProcessorRegistrationDelegate.java L52
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<String>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
//遍歷BeanFactoryPostProcessors
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
//BeanDefinitionRegistryPostProcessor這個類很重要，spring集成mybatis時會用到它。後面會有篇文章專門介紹它的做用
//BeanDefinitionRegistryPostProcessor容許在正常的BeanFactoryPostProcessor檢測開始以前註冊更多的自定義bean。常常用來自定義註解
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
複製代碼
咱們來總結一下，到目前爲止，應該說 BeanFactory 已經建立完成，而且全部的實現了 BeanFactoryPostProcessor 接口的 Bean 都已經初始化而且其中的 postProcessBeanFactory(factory) 方法已經獲得執行了。全部實現了 BeanPostProcessor 接口的 Bean 也都完成了初始化。
1-5 finishBeanFactoryInitialization（beanFactory）
初始化全部的 singleton beans
/**
* Finish the initialization of this context's bean factory, * initializing all remaining singleton beans. */ protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // 首先，初始化名字爲 conversionService 的 Bean // 注意了，初始化的動做包裝在 beanFactory.getBean(...) 中 //conversionService這個類相信用過的人不會陌生，它用來將前端傳過來的參數和後端的 controller 方法上的參數進行綁定的時候用。像前端傳過來的字符串、整數要轉換爲後端的 String、Integer 很容易，可是若是 controller 方法須要的是一個枚舉值，或者是 Date 這些非基礎類型（含基礎類型包裝類）值的時候，咱們就能夠考慮採用 ConversionService 來進行轉換 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( //beanFactory.getBean(),是bean真正初始化過程的關鍵入口 beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } // Register a default embedded value resolver if no bean post-processor // (such as a PropertyPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(new StringValueResolver() { @Override public String resolveStringValue(String strVal) { return getEnvironment().resolvePlaceholders(strVal); } }); } // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null); // Allow for caching all bean definition metadata, not expecting further changes. beanFactory.freezeConfiguration(); // 開始初始化剩下的 beanFactory.preInstantiateSingletons(); } 複製代碼
從上面最後一行往裏看，咱們又回到 DefaultListableBeanFactory#preInstantiateSingletons了 //DefaultListableBeanFactory.java L728
public void preInstantiateSingletons() throws BeansException {
...
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
for (String beanName : beanNames) {
//合併父bean中的配置
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// FactoryBean 的話，在 beanName 前面加上 ‘&’ 符號。再調用 getBean
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
// 判斷當前 FactoryBean 是不是 SmartFactoryBean 的實現，此處忽略，直接跳過
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
// 對於普通的 Bean，只要調用 getBean(beanName) 這個方法就能夠進行初始化了
getBean(beanName);
}
}
}
// 到這裏說明全部的非懶加載的 singleton beans 已經完成了初始化
// 若是咱們定義的 bean 是實現了 SmartInitializingSingleton 接口的，那麼在這裏獲得回調，忽略
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
複製代碼
上面代碼裏屢次出現getBean() 方法，這個方法咱們常常用來從 BeanFactory 中獲取一個 Bean，而初始化的過程也封裝到了這個方法裏，詳見 【spring 源碼】IOC 之 bean實例初始化。
（未完，待續）
相關文章
- 1. Spring源碼分析之ClassPathXmlApplicationContext
- 2. Spring ioc ClassPathXmlApplicationContext類介紹
- 3. Spring 源碼閱讀-ClassPathXmlApplicationContext
- 4. Spring源碼閱讀——ClassPathXmlApplicationContext（二）
- 5. Spring源碼閱讀——ClassPathXmlApplicationContext（三）
- 6. Spring源碼閱讀——ClassPathXmlApplicationContext（一）
- 7. Spring源碼閱讀——ClassPathXmlApplicationContext（四）
- 8. Spring源碼-Ioc
- 9. Spring源碼解析三 (IOC容器初始化方式二:ClassPathXmlApplicationContext)
- 10. ClassPathXmlApplicationContext 源碼解析
- 更多相關文章...
- • Spring IoC容器：BeanFactory和ApplicationContext - Spring教程
- • Java操作Neo4j數據庫（附帶源碼） - NoSQL教程
- • 互聯網組織的未來：剖析GitHub員工的任性之源
- • Java Agent入門實戰（二）-Instrumentation源碼概述
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Spring源碼分析之ClassPathXmlApplicationContext
- 2. Spring ioc ClassPathXmlApplicationContext類介紹
- 3. Spring 源碼閱讀-ClassPathXmlApplicationContext
- 4. Spring源碼閱讀——ClassPathXmlApplicationContext（二）
- 5. Spring源碼閱讀——ClassPathXmlApplicationContext（三）
- 6. Spring源碼閱讀——ClassPathXmlApplicationContext（一）
- 7. Spring源碼閱讀——ClassPathXmlApplicationContext（四）
- 8. Spring源碼-Ioc
- 9. Spring源碼解析三 (IOC容器初始化方式二:ClassPathXmlApplicationContext)
- 10. ClassPathXmlApplicationContext 源碼解析