Spring源码揭秘：IOC容器详解与BeanFactory核心功能

spring

源码分析

需积分: 10 151 浏览量更新于2024-07-22 收藏 498KB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

本文档深入剖析了Spring框架中的依赖注入（Dependency Injection, DI）容器——尤其是BeanFactory的核心功能和实现原理。Spring框架由Rod Johnson开发，其核心思想是将控制反转（Inversion of Control, IoC）引入到Java应用中，简化组件之间的依赖管理。BeanFactory作为Spring的核心接口，扮演了至关重要的角色，它是一个抽象的工厂，负责根据配置信息动态创建和管理对象。首先，BeanFactory接口规定了所有IoC容器的基础行为。接口中包含几个关键方法： 1. `getBean(String name)`: 这是获取bean实例的主要入口，通过bean的名字查找并返回实例。如果bean是FactoryBean（一个可以生产其他bean的bean），需要使用前缀`&`来区别，即`getBean("&beanName")`能得到实际的工厂对象。 2. `getBean(String name, Class requiredType)`: 这个方法更进一步，允许指定预期的bean类型。如果实际获取的bean类型与所需不符，会抛出`BeansException`异常。 3. `containsBean(String name)`: 用于检查IoC容器中是否存在指定名称的bean。 4. `isSingleton(String name)`: 判断一个bean是否为单例模式，这对于理解和管理bean的生命周期管理至关重要。 Spring提供了多种IoC容器实现，如DefaultListableBeanFactory、XmlBeanFactory等，它们可以根据项目需求从不同角度和资源位置配置bean。这些容器不仅处理简单的bean实例化，还能处理更复杂的依赖关系，例如循环依赖的检测和处理、AOP（面向切面编程）的集成等。学习Spring源码有助于开发者深入了解其内部工作机制，比如BeanDefinition的解析、Autowire机制、以及如何通过各种配置元数据如XML配置文件、注解等方式动态构建bean实例。通过分析源码，我们可以优化应用性能，提高代码可维护性和扩展性。本文档旨在为想要深入了解Spring源码的开发者提供一个起点，鼓励大家一起参与讨论和研究。对于希望在Spring应用开发中更深入理解DI容器的读者来说，这是一份宝贵的参考资料。

资源详情

资源推荐

5. //这里使用 ContextLoader 对根上下文进行载入和初始化

6. this.contextLoader.initWebApplicationContext(event.getServletContext());

7. }

通过 ContextLoader 建立起根上下文的过程,我们可以在 ContextLoader 中看到：

Java 代码

1. public WebApplicationContext initWebApplicationContext(ServletContext servletContext)

2. throws IllegalStateException, BeansException {

3. //这里先看看是不是已经在 ServletContext 中存在上下文,如果有说明前面已经被载入过，或者是配置文件有错误。

4. if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) !

= null) {

5. //直接抛出异常

6. .........

7. }

9. ...............

10. try {

11. // 这里载入根上下文的父上下文

12. ApplicationContext parent = loadParentContext(servletContext);

13.

14. //这里创建根上下文作为整个应用的上下文同时把它存到 ServletContext 中去,注意这里使用的 ServletContex

t 的属性值是

15. //ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE，以后的应用都是根据这个属性值来取得根上下文的 - 往往作为

自己上下文的父上下文

16. this.context = createWebApplicationContext(servletContext, parent);

17. servletContext.setAttribute(

18. WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

19. ..........

20.

21. return this.context;

22. }

23. ............

24. }

建立根上下文的父上下文使用的是下面的代码，取决于在 web.xml 中定义的参数：locatorFactorySelector，这是一个可选参数：

Java 代码

1. protected ApplicationContext loadParentContext(ServletContext servletContext)

2. throws BeansException {

4. ApplicationContext parentContext = null;

6. String locatorFactorySelector = servletContext.getInitParameter(LOCATOR_FACTORY_SELECTOR_PARA

M);

7. String parentContextKey = servletContext.getInitParameter(LOCATOR_FACTORY_KEY_PARAM);

9. if (locatorFactorySelector != null) {

10. BeanFactoryLocator locator = ContextSingletonBeanFactoryLocator.getInstance(locatorFactoryS

elector);

11. ........

12. //得到根上下文的父上下文的引用

13. this.parentContextRef = locator.useBeanFactory(parentContextKey);

14. //这里建立得到根上下文的父上下文

15. parentContext = (ApplicationContext) this.parentContextRef.getFactory();

16. }

17.

18. return parentContext;

19. }

得到根上下文的父上下文以后，就是根上下文的创建过程：

Java 代码

1. protected WebApplicationContext createWebApplicationContext(

2. ServletContext servletContext, ApplicationContext parent) throws BeansException {

3. //这里需要确定我们载入的根 WebApplication 的类型，由在 web.xml 中配置的 contextClass 中配置的参数可以决定

我们需要载入什么样的 ApplicationContext,

4. //如果没有使用默认的。

5. Class contextClass = determineContextClass(servletContext);

6. .........

7. //这里就是上下文的创建过程

8. ConfigurableWebApplicationContext wac =

9. (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

10. //这里保持对父上下文和 ServletContext 的引用到根上下文中

11. wac.setParent(parent);

12. wac.setServletContext(servletContext);

13.

14. //这里从 web.xml 中取得相关的初始化参数

15. String configLocation = servletContext.getInitParameter(CONFIG_LOCATION_PARAM);

16. if (configLocation != null) {

17. wac.setConfigLocations(StringUtils.tokenizeToStringArray(configLocation,

18. ConfigurableWebApplicationContext.CONFIG_LOCATION_DELIMITERS));

19. }

20. //这里对 WebApplicationContext 进行初始化，我们又看到了熟悉的 refresh 调用。

21. wac.refresh();

22. return wac;

23. }

初始化根 ApplicationContext 后将其存储到 SevletContext 中去以后,这样就建立了一个全局的关于整个应用的上下文。这个根上下文会

被以后的 DispatcherServlet 初始化自己的时候作为自己 ApplicationContext 的父上下文。这个在对 DispatcherServlet 做分析的时候我

们可以看看到。

3.完成对 ContextLoaderListener 的初始化以后， Tomcat 开始初始化 DispatchServlet，- 还记得我们在 web.xml 中队载入次序进行了

定义。DispatcherServlet 会建立自己的 ApplicationContext,同时建立这个自己的上下文的时候会从 ServletContext 中得到根上下文作为

父上下文,然后再对自己的上下文进行初始化，并最后存到 ServletContext 中去供以后检索和使用。

可以从 DispatchServlet的父类 FrameworkServlet的代码中看到大致的初始化过程，整个 ApplicationContext的创建过程和 ContextLoder

创建的过程相类似：

Java 代码

1. protected final void initServletBean() throws ServletException, BeansException {

2. .........

3. try {

4. //这里是对上下文的初始化过程。

5. this.webApplicationContext = initWebApplicationContext();

6. //在完成对上下文的初始化过程结束后，根据 bean 配置信息建立 MVC 框架的各个主要元素

7. initFrameworkServlet();

8. }

9. ........

10. }

对 initWebApplicationContext()调用的代码如下：

Java 代码

1. protected WebApplicationContext initWebApplicationContext() throws BeansException {

2. //这里调用 WebApplicationContextUtils 静态类来得到根上下文

3. WebApplicationContext parent = WebApplicationContextUtils.getWebApplicationContext(getServletCo

ntext());

5. //创建当前 DispatcherServlet 的上下文，其上下文种类使用默认的在 FrameworkServlet 定义好的：DEFAULT_CON

TEXT_CLASS = XmlWebApplicationContext.class;

6. WebApplicationContext wac = createWebApplicationContext(parent);

7. ........

8. if (isPublishContext()) {

9. //把当前建立的上下文存到 ServletContext 中去，注意使用的属性名是和当前 Servlet 名相关的。

10. String attrName = getServletContextAttributeName();

11. getServletContext().setAttribute(attrName, wac);

12. }

13. return wac;

14. }

其中我们看到调用了 WebApplicationContextUtils 的静态方法得到根 ApplicationContext:

Java 代码

1. public static WebApplicationContext getWebApplicationContext(ServletContext sc) {

2. //很简单，直接从 ServletContext 中通过属性名得到根上下文

3. Object attr = sc.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUT

E);

4. .......

5. return (WebApplicationContext) attr;

6. }

7. 然后创建 DispatcherServlet 自己的 WebApplicationContext:

8. protected WebApplicationContext createWebApplicationContext(WebApplicationContext parent)

9. throws BeansException {

10. .......

11. //这里使用了 BeanUtils 直接得到 WebApplicationContext,ContextClass 是前面定义好的 DEFAULT_CONTEXT

_CLASS =

12. //XmlWebApplicationContext.class;

13. ConfigurableWebApplicationContext wac =

14. (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(getContextClass

());

15.

16. //这里配置父上下文，就是在 ContextLoader 中建立的根上下文

17. wac.setParent(parent);

18.

19. //保留 ServletContext 的引用和相关的配置信息。

20. wac.setServletContext(getServletContext());

21. wac.setServletConfig(getServletConfig());

22. wac.setNamespace(getNamespace());

23.

24. //这里得到 ApplicationContext 配置文件的位置

25. if (getContextConfigLocation() != null) {

26. wac.setConfigLocations(

27. StringUtils.tokenizeToStringArray(

28. getContextConfigLocation(), ConfigurableWebApplicationContext.CONFIG_LO

CATION_DELIMITERS));

29. }

30.

31. //这里调用 ApplicationContext 的初始化过程，同样需要使用 refresh()

32. wac.refresh();

33. return wac;

34. }

4. 然后就是 DispatchServlet 中对 Spring MVC 的配置过程，首先对配置文件中的定义元素进行配置 - 请注意这个时候我们的

WebApplicationContext 已经建立起来了，也意味着 DispatcherServlet 有自己的定义资源，可以需要从 web.xml 中读取 bean 的配置信

息，通常我们会使用单独的 xml 文件来配置 MVC 中各个要素定义，这里和 web 容器相关的加载过程实际上已经完成了，下面的处理和

普通的 Spring 应用程序的编写没有什么太大的差别，我们先看看 MVC 的初始化过程：

Java 代码

1. protected void initFrameworkServlet() throws ServletException, BeansException {

2. initMultipartResolver();

3. initLocaleResolver();

4. initThemeResolver();

5. initHandlerMappings();

6. initHandlerAdapters();

7. initHandlerExceptionResolvers();

8. initRequestToViewNameTranslator();

9. initViewResolvers();

10. }

5. 这样 MVC 的框架就建立起来了，DispatchServlet 对接受到的 HTTP Request 进行分发处理由 doService()完成，具体的 MVC 处理过

程我们在 doDispatch()中完成，其中包括使用 Command 模式建立执行链，显示模型数据等，这些处理我们都可以在 DispatcherServlet

的代码中看到：

Java 代码

1. protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exceptio

n {

2. ......

3. try {

4. doDispatch(request, response);

5. }

6. .......

7. }

实际的请求分发由 doDispatch(request,response)来完成：

Java 代码

1. protected void doDispatch(final HttpServletRequest request, HttpServletResponse response) throws Ex

ception {

2. .......

3. // 这是 Spring 定义的执行链，里面放了映射关系对应的 handler 和定义的相关拦截器。

4. HandlerExecutionChain mappedHandler = null;

6. ......

7. try {

8. //我们熟悉的 ModelAndView 在这里出现了。

9. ModelAndView mv = null;

10. try {

11. processedRequest = checkMultipart(request);

12.

13. //这里更具 request 中的参数和映射关系定义决定使用的 handler

14. mappedHandler = getHandler(processedRequest, false);

15.

16. ......

17. //这里是 handler 的调用过程，类似于 Command 模式中的 execute.

18. HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

19. mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

20.

21. .......

22. //这里将模型数据通过视图进行展现

23. if (mv != null && !mv.wasCleared()) {

24. render(mv, processedRequest, response);

25. }

26. ........

27. }

这样具体的 MVC 模型的实现就由 bean 配置文件里定义好的 view resolver,handler 这些类来实现用户代码的功能。

总结上面的过程，我们看到在 web 容器中，ServletContext 可以持有一系列的 web 上下文，而在整个 web 上下文中存在一个根上下文

来作为其它 Servlet 上下文的父上下文。这个根上下文是由 ContextLoader 载入并进行初始化的，对于我们的 web 应用，

剩余85页未读，继续阅读

qq_25816205

粉丝: 0
资源: 2

Spring源码揭秘：IOC容器详解与BeanFactory核心功能

Spring源码分析.docx

spring源码分析

Spring 源码分析文档----自用

spring源码分析环境搭建

spring 源码分析

Spring 源码分析

spring源码解析pdf

spring cloud stream源码分析

学习spring源码

springboot的源码分析

springboot项目文档源码

springboot logback 源码分析

springSecurity 学习

springboot源码分析

spring中文参考文献

springboot源码学习计划

springboot酒店管理系统【源码+数据库文件+一万字文档】

dynamic-datasource-spring-boot-starter详细使用

springboot 家教服务平台 源码

开源的java 管理系统源码

最新资源

springboot 家教服务平台源码