Spring源码阅读入口web.xml

最新推荐文章于 2022-06-09 14:50:24 发布
最新推荐文章于 2022-06-09 14:50:24 发布
阅读量940 收藏 3
点赞数
分类专栏： 源码分析 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38094271/article/details/85081633
版权

Spring 源码阅读起始web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!---->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
      <!--加载spring配置-->
      classpath:config/spring/applicationContext-core.xml
    </param-value>
</context-param>
  <context-param>
    <param-name>webAppRootKey</param-name>
    <param-value>ServicePlatform.root</param-value>
  </context-param>

  <context-param>
    <param-name>globalInitializerClasses</param-name>
    <param-value>com.zhuguang.jack.applicationContextInitializer.MyApplicationContextInitializer</param-value>
  </context-param>
  <!--<context-param>
      <param-name>log4jRefreshInterval</param-name>
      <param-value>600000</param-value>
  </context-param>

  <context-param>
      <param-name>log4jConfigLocation</param-name>
      <param-value>classpath:config/log/log4j.properties</param-value>
  </context-param>
  <listener>
      <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
  </listener>-->
  <context-param>
    <param-name>allowBeanDefinitionOverriding</param-name>
    <param-value>true</param-value>
  </context-param>

  <listener>
  <!-- 当加载servlet 的时候此监听器执行-->
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--
  <filter>
    <filter-name>sessionFilter</filter-name>
    <filter-class>com.zhuguang.jack.filter.SessionFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>sessionFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>-->

  <servlet>
    <servlet-name>spring-dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <!--springmvc的配置文件-->
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:config/spring/spring-dispatcher.xml</param-value>
    </init-param>
    <init-param>
      <param-name>detectAllHandlerMappings</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>contextInitializerClasses</param-name>
      <param-value>com.zhuguang.jack.applicationContextInitializer.MyApplicationContextInitializer</param-value>
    </init-param>
    <init-param>
      <param-name>allowBeanDefinitionOverriding</param-name>
      <param-value>true</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>spring-dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

spring 与springmvc 的区别

spring

有时候不是web项目但是想用spring的 aop 和ioc 怎么办
new ClassPathXmlApplicationContext(“application.xml”);

springmvc

包括spring aop ioc的功能
mvc 表示 model view controller

可能有些读者就要问了，web.xml 里面即加载了spring的ioc 和aop ,springmvc 里面又加载了aop 和ioc 那么不重复了么？

重复也不重复。何解？ spring 容器将先加载，然后springmvc 的容器将拷贝一份放入自己的容器中，初始化容器的方法不在同一个类中。所以是没有冲突的

tomcat会先调用spring的Servlet 于是配置的监听器（ContextLoaderListener）将会执行

/**
	 * Initialize the root web application context.
	 * 这是spring 自己的注释 很明显的会调用这个方法初始化
	 */
	@Override
	public void contextInitialized(ServletContextEvent event) {
	 //参数是 servelt容器
		initWebApplicationContext(event.getServletContext());
	}

进入initWebApplicationContext方法
在这里插入图片描述
刚开始debug 发现context 一定为空所以会走createWebApplicationContext 方法

创建WebApplicationContext

/**
	 * Return the WebApplicationContext implementation class to use, either the
	 * default XmlWebApplicationContext or a custom context class if specified.
	 * @param servletContext current servlet context
	 * @return the WebApplicationContext implementation class to use
	 * @see #CONTEXT_CLASS_PARAM
	 * @see org.springframework.web.context.support.XmlWebApplicationContext
	 */
//注释上写着返回WebApplicationContext 类型为默认的xnlWebApplicationContext 或者配置的类
	protected Class<?> determineContextClass(ServletContext servletContext) {
	//CONTEXT_CLASS_PARAM很明显如果配置则取的这个值， 我进去看了一下
	//public static final String CONTEXT_CLASS_PARAM = "contextClass";
		String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
		if (contextClassName != null) {
			try {
				return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
			}
			catch (ClassNotFoundException ex) {
				throw new ApplicationContextException(
						"Failed to load custom context class [" + contextClassName + "]", ex);
			}
		}
		else {
		//很明显不配置为空走这里 ，contextClassName 和defaultStrategies有关
			contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
			try {
			//反射出类然后返回， 完美
				return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
			}
			catch (ClassNotFoundException ex) {
				throw new ApplicationContextException(
						"Failed to load default context class [" + contextClassName + "]", ex);
			}
		}
	}

// 寻找defaultStrategies 发现了这个静态代码块 defaultStrategies 是Properties类型
private static final String DEFAULT_STRATEGIES_PATH = "ContextLoader.properties";
private static final Properties defaultStrategies;
static {
		// Load default strategy implementations from properties file.
		// This is currently strictly internal and not meant to be customized
		// by application developers.
		try {
		//那么真相只有一个 这边 和DEFAULT_STRATEGIES_PATH 有关，所以去ClassPath下寻找ContextLoader.properties
			ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		}
		catch (IOException ex) {
			throw new IllegalStateException("Could not load 'ContextLoader.properties': " + ex.getMessage());
		}
	}

在这里插入图片描述
找到了 在这呢：
在这里插入图片描述
内容如上图，之所以默认是XmlWebApplicationContext 的原因也找到了
回到createWebApplicationContext()方法

if (this.context == null) {
//这边其实按照我的理解 就是xml 里面配置了就用xml 里面的 ，没有的话就用默认的
				this.context = createWebApplicationContext(servletContext);
			}
			if (this.context instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
				if (!cwac.isActive()) {
					// The context has not yet been refreshed -> provide services such as
					// setting the parent context, setting the application context id, etc
					//如果没有parent属性就去servlet 里面找找看
					if (cwac.getParent() == null) {
						// The context instance was injected without an explicit parent ->
						// determine parent for root web application context, if any.
						ApplicationContext parent = loadParentContext(servletContext);
						cwac.setParent(parent);
					}
					//这句代码里面做了很多事情
					configureAndRefreshWebApplicationContext(cwac, servletContext);
				}
			}
			//servlet 也放了一份spring的
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);



String APPLICATION_CONTEXT_ID_PREFIX = WebApplicationContext.class.getName() + ":";
	protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
		if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
			// The application context id is still set to its original default value
			// -> assign a more useful id based on available information
			String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
			if (idParam != null) {
				wac.setId(idParam);
			}
			//contextid没有设置所以设为默认的
			else {
				// Generate default id...
				//参数如上 类名加冒号+项目名称
				wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
						ObjectUtils.getDisplayString(sc.getContextPath()));
			}
		}
		//将servlet容器放入了spring容器中
		wac.setServletContext(sc);
		//查看web.xml里面有没有配置contextConfigLocation,有就放进来，很明显这个是spring 写死的名称
		String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
		if (configLocationParam != null) {
		//实际上调到AbstractRefreshableWebApplicationContext类的方法里面了
			wac.setConfigLocation(configLocationParam);
		}

		// The wac environment's #initPropertySources will be called in any case when the context
		// is refreshed; do it eagerly here to ensure servlet property sources are in place for
		// use in any post-processing or initialization that occurs below prior to #refresh
		ConfigurableEnvironment env = wac.getEnvironment();
		if (env instanceof ConfigurableWebEnvironment) {
			((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
		}
		//当我们需要对spring的容器做点事情的时候 有时会用到这里
		customizeContext(sc, wac);
		wac.refresh();
	}

如何在spring容器初始化之前做点事情呢？
首先调用了wac.refresh就是对容器初始化了

//传入sc 和spring容器

protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {
//重点在这个方法里面
		List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =
				determineContextInitializerClasses(sc);
		if (initializerClasses.isEmpty()) {
			// no ApplicationContextInitializers have been declared -> nothing to do
			return;
		}

		ArrayList<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerInstances =
				new ArrayList<ApplicationContextInitializer<ConfigurableApplicationContext>>();

		for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {
			Class<?> initializerContextClass =
					GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
			if (initializerContextClass != null) {
				Assert.isAssignable(initializerContextClass, wac.getClass(), String.format(
						"Could not add context initializer [%s] since its generic parameter [%s] " +
						"is not assignable from the type of application context used by this " +
						"context loader [%s]: ", initializerClass.getName(), initializerContextClass.getName(),
						wac.getClass().getName()));
			}
			initializerInstances.add(BeanUtils.instantiateClass(initializerClass));
		}
		//对所用继承ApplicationContextInitializer的类排序
		AnnotationAwareOrderComparator.sort(initializerInstances);
		for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : initializerInstances) {
		//循环调用initialize方法
			initializer.initialize(wac);
		}
	}

determineContextInitializerClasses（）方法

public static final String GLOBAL_INITIALIZER_CLASSES_PARAM = "globalInitializerClasses";
public static final String CONTEXT_INITIALIZER_CLASSES_PARAM = "contextInitializerClasses";
//只要在web.xml配置了globalInitializerClasses，contextInitializerClasses就会加载进来
	protected List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>>
			determineContextInitializerClasses(ServletContext servletContext) {

		List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> classes =
				new ArrayList<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>>();

		String globalClassNames = servletContext.getInitParameter(GLOBAL_INITIALIZER_CLASSES_PARAM);
		if (globalClassNames != null) {
			for (String className : StringUtils.tokenizeToStringArray(globalClassNames, INIT_PARAM_DELIMITERS)) {
				classes.add(loadInitializerClass(className));
			}
		}

		String localClassNames = servletContext.getInitParameter(CONTEXT_INITIALIZER_CLASSES_PARAM);
		if (localClassNames != null) {
			for (String className : StringUtils.tokenizeToStringArray(localClassNames, INIT_PARAM_DELIMITERS)) {
				classes.add(loadInitializerClass(className));
			}
		}

		return classes;
	}

至于如何排序则需要继承Ordered类

public class MyApplicationContextInitializer1 implements ApplicationContextInitializer,PriorityOrdered {
    //在spring容器初始化之前对spring的上下文做一些修改
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("===========MyApplicationContextInitializer");
    }

    @Override
    //返回值越大越先执行上面的方法
    public int getOrder() {
        return 1;
    }
}

我们再来看看springmvc 是如何做的，看springmvc 的话，根据web.xml 中的指示我们应该去看DispatcherServlet这个类

//DispatcherServlet 这个类继承了FrameworkServlet 
public class DispatcherServlet extends FrameworkServlet 
//FrameworkServlet 继承了HttpServletBean 和实现了ApplicationContextAware（ApplicationContextAware可以获取spring上下文）
public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware
//HttpServletBean 继承了HttpServlet 所以 DispatcherServlet 这东西就是一个servlet
public abstract class HttpServletBean extends HttpServlet
		implements EnvironmentCapable, EnvironmentAware

HttpServletBean 无脑看init 方法

	@Override
	public final void init() throws ServletException {
		if (logger.isDebugEnabled()) {
			logger.debug("Initializing servlet '" + getServletName() + "'");
		}

		// Set bean properties from init parameters.
		try {
			PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
			BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
			ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
			bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
			initBeanWrapper(bw);
			bw.setPropertyValues(pvs, true);
		}
		catch (BeansException ex) {
			logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
			throw ex;
		}

		// Let subclasses do whatever initialization they like.
		//初始化bean
		initServletBean();

		if (logger.isDebugEnabled()) {
			logger.debug("Servlet '" + getServletName() + "' configured successfully");
		}
	}

进入initServletBean（）方法 又看见如下代码

	@Override
	protected final void initServletBean() throws ServletException {
		getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");
		if (this.logger.isInfoEnabled()) {
			this.logger.info("FrameworkServlet '" + getServletName() + "': initialization started");
		}
		long startTime = System.currentTimeMillis();

		try {
		//这边也是初始化webApplicationContext 方法
			this.webApplicationContext = initWebApplicationContext();
			initFrameworkServlet();
		}
没有腹肌不改名
关注
专栏目录
阅读Spring源码第一步：源码编译与创建调试入口
如切如磋，如琢如磨
03-30 888
文章目录1 源码下载与编译2 创建学习入口 1 源码下载与编译   Spring开源框架经过很长时间的发展，各个模块均已成熟，一个常识就是一个可靠，可扩展的高性能框架，它的代码行数是相当可观的，我用static插件简略测算了一下，Spring的源码有100多万行，可以想象其中的调用逻辑是相当复杂的，所以将Spring源码下载到本地再编译的话，我们就可以通过IDE的debug来来到抽丝剥茧分析源码的目的，并且我们可以很方便的使用idea来查看调用栈，方法的调用关系也就比较明了了。 下载Spring源码：htt
spring-web项目不用配置web.xml的方式原理
chijianwei的博客
05-04 1544
springmvc时的入口 比较早之前使用springmvc的时候,都要配置个web.xml文件.并且在文件写个servlet的标签,如下: <!-- 配置Spring的前置控制器DispatcherServlet --> <servlet> <servlet-name>spring</servlet-name> ...
Spring源码调试入口
xharvard的专栏
06-09 303
推荐使用【ClassPathXmlApplicationContext】作为调试入口。
spring源码：入口
不会吃萝卜的兔子
02-08 2131
11.
Spring 源码（一）Spring 容器的入口
xiaolyuh的专栏
11-28 562
Spring 容器的初始化 ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class); 当我们完成一个ApplicationContext的实例化时就完成了Spring容器的初始化，而AnnotationConfigApplicationContext的构造方法也就是Spring容器的入...
Spring-web源代码阅读之入口程序
weixin_55543787的博客
02-24 217
使用的源码版本如下： spring-web-5.0.6 ，本次阅读的对象。 spring-framework-1.0，用做对照，看一下两者的不同。 Spring-web模块概要说明 spring-web模块是从spring3.x起独立打包，主要作用是集成了spring的bean管理以及依赖注入，并加入了Java Web的特征，例如对servletContext的封装，以及对请求参数的封装和统一外部资源的加载方式等等，核心是通过spring来管理Java Web中的各种bean组件。 Spring集成到
手把手搭建 零配置文件的spring项目（java Configuration 代替xml编写配置文件，并脱离web.xml启动web项目）
qq_38593205的博客
01-31 963
layout: post author: zjhChester header-img: img/post-bg-hacker.jpg catalog: true tags: - spring 手把手搭建 零配置文件的spring项目（java Configuration 代替xml编写配置文件，并脱离web.xml启动web项目） 前言： 要知道，在自我学习的过程中都有一个过渡...
快速搭建一个java config(无web.xml)的web工程（一）
05-01
Spring Boot是一个很好的选择，它简化了Spring应用的启动和配置过程，无需手动配置web.xml。在pom.xml中添加如下依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-parent ...
Spring高级源码学习笔记.zip
05-24
在阅读Spring源码笔记时，建议结合实际项目经验，逐步理解并实践源码中的关键概念。"查看密码，打开必看.txt"可能是提供解压文件的密码，确保正确解压并阅读PDF文档，以获得完整的知识体系。 总之，Spring源码学习...
Pro.Spring.MVC.With.Web.Flow.英文版+源码
11-10
在Web Flow中，开发者可以定义flow.xml文件来配置流程，包括入口状态、结束状态、决策状态和动作状态等。此外，Web Flow还提供了回退管理、异常处理和事务管理等功能，增强了应用的健壮性和用户体验。 结合这本书的...
Spring官方 源码
05-24
这是从Spring官方github 源码下载下来的，里面主要是SpringIO等核心技术的，应该Spring5的吧，不过改动不带，Spring一直是那个结构没有多大改变
spring 源码 官网资源
09-23
spring 源码 官网资源 spring 源码 官网资源
【spring源码分析（一）】IOC容器初始化---入口
欢迎来到【战羽】的博客
10-09 1194
一、什么是ioc容器 IoC容器指的Spring中BeanFactory，底层使用Map存储了Bean的实例（通过反射生成） 二、ioc核心组件 1、BeanFactory：是Spring框架早期创建Bean对象的工厂接口，定义了IOC容器的基本功能规范 2、ApplicationContext：是Spring框架最常用的接口，在BeanFactory IOC容器的基础上添加了许多对高级容器的支持...
Spring 源码分析(四) ——MVC（三）源码入口
孤云博客
08-16 778
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666)、博主微信（guyun297890152）、QQ技术交流群(183198395)。 from：https://my.oschina.net/kaywu123/blog/648743 测试代码 框架配置 现在就从 SpringMVC 的网站开发开始。当然，最先是...
Spring的代码入口ContextLoaderListener
蓝色忧郁
03-26 665
1.监听器 public class ContextLoaderListener extends ContextLoader implements ServletContextListener ContextLoaderListener 是spring-web中的类,实现了servlet-api中的接口ServletContextListener ,继承了 spring-web中ContextL...
Spring源码分析（一）：从哪里开始看spring源码（系列文章基于Spring5.0）
u013328649的博客
10-03 364
参考视频教程: **剑指Java自研框架，决胜Spring源码 ** 一、概述 对于大多数第一次看spring源码的人来说，都会感觉不知从哪开始看起，因为spring项目源码由多个子项目组成，如spring-beans，spring-context，spring-core，spring-aop，spring-web，spring-webmvc等，整个项目结构如图： 可能有人会觉得，既然spring是一个IOC容器或者说是一个bean的容器，那么应该从spring-beans看起，先了...
寻找spring框架的启动入口 ContextLoaderListener
solo.du
06-21 202
spring在web下的入口在配置文件web.xml的监听器中 &lt;listener&gt;         &lt;listener-class&gt;            org.springframework.web.context.ContextLoaderListener         &lt;/listener-class&gt; &lt;/listener&gt; ...
java Spring入口
u014551778的博客
03-22 758
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:META-INF/spring/application-context.bean.xml"); context.start();
01 Spring程序入口和XML解析
暗夜零星的博客
12-01 191
title: “Spring程序入口和XML解析” date: 2020-11-22T12:00:00+08:00 draft: false toc: true tags: [“spring源码”] categories: [“spring”] Spring源码的程序入口，和XML解析的源码流程。 1 前言 Spring源码Gitee传送门 （本人从 github 中下载，然后以自身理解对核心流程及主要节点做了详细的中文注释。建议下载、结合 Spring 系列文章阅读源码） spring源码系列文章，.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值