死磕源码系列【springboot之ServletContextInitializerBeans如何将Filter、Servlet、EventListener注册到ServletContext中源码解

最新推荐文章于 2024-03-14 17:47:54 发布
最新推荐文章于 2024-03-14 17:47:54 发布
阅读量889 收藏 1
点赞数
分类专栏： 【spring系列】 文章标签： springboot Filter Servlet EventListener Initializer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaomingyang/article/details/111059405
版权

ServletContextInitializerBeans类表示从ListableBeanFactory容器中获取到的ServletContextInitializer实例集合，包括所有的ServletContextInitializer beans，并且也包含Servlet、Filter、EventListener beans集合。

这些beans会被排序，按照Servlet->Filter->EventListener->ServletContextInitializer的顺序排列。

springboot创建tomcat容器是在ServletWebServerApplicationContext#createWebServer方法中进行，通过调用getSelfInitializer方法来获取对应的ServletContextInitializer实例对象：

	private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
		return this::selfInitialize;
	}

	private void selfInitialize(ServletContext servletContext) throws ServletException {
    //使用给定的ServletContext准备WebApplicationContext
		prepareWebApplicationContext(servletContext);
		registerApplicationScope(servletContext);
		WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
    //getServletContextInitializerBeans方法获取ServletContextInitializer实例对象、Servlet、Filter、EventListener bean实例对象
		for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
      //调用ServletContextInitializer实例对象的onStartup方法
			beans.onStartup(servletContext);
		}
	}
  //获取ServletContextInitializer实例对象集合类ServletContextInitializerBeans
	protected Collection<ServletContextInitializer> getServletContextInitializerBeans() {
    //参数getBeanFactory()方法获取IOC容器工厂ConfigurableListableBeanFactory的实例对象
		return new ServletContextInitializerBeans(getBeanFactory());
	}

ServletContextInitializerBeans是一个从容器ListableBeanFactory中获取的ServletContextInitializer实例对象集合，包含所有的ServletContextInitializer beans对象，Servlet、Filter、EventListener监听器bean。

public class ServletContextInitializerBeans extends AbstractCollection<ServletContextInitializer> {

	private static final String DISPATCHER_SERVLET_NAME = "dispatcherServlet";

	private static final Log logger = LogFactory.getLog(ServletContextInitializerBeans.class);

	/**
	 * 将发下的bean实例及bean名称集合
	 */
	private final Set<Object> seen = new HashSet<>();
 //存储ServletContextInitializer实例对象
	private final MultiValueMap<Class<?>, ServletContextInitializer> initializers;
 //存储initializers集合中存储的数据类型
	private final List<Class<? extends ServletContextInitializer>> initializerTypes;
  //ServletContextInitializer的已排序不可以修改集合
	private List<ServletContextInitializer> sortedList;

	@SafeVarargs
	public ServletContextInitializerBeans(ListableBeanFactory beanFactory,
			Class<? extends ServletContextInitializer>... initializerTypes) {
    //存储ServletContextInitializer实例对象
		this.initializers = new LinkedMultiValueMap<>();
    //初始哈initializers集合中存储的数据类型，默认为：ServletContextInitializer类型
		this.initializerTypes = (initializerTypes.length != 0) ? Arrays.asList(initializerTypes)
				: Collections.singletonList(ServletContextInitializer.class);
    //将容器中的ServletContextInitializer实例对象按照类别加入到集合
		addServletContextInitializerBeans(beanFactory);
    //将容器中的Servlet、Filter、EventListenr实例对象加入集合
		addAdaptableBeans(beanFactory);
    //将ServletContextInitializer集合进行排序
		List<ServletContextInitializer> sortedInitializers = this.initializers.values().stream()
				.flatMap((value) -> value.stream().sorted(AnnotationAwareOrderComparator.INSTANCE))
				.collect(Collectors.toList());
    //将ServletContextInitializer集合转换为不可修改的已排序集合
		this.sortedList = Collections.unmodifiableList(sortedInitializers);
		logMappings(this.initializers);
	}

	private void addServletContextInitializerBeans(ListableBeanFactory beanFactory) {
		for (Class<? extends ServletContextInitializer> initializerType : this.initializerTypes) {
			//getOrderedBeansOfType方法获取bean实例对象集合
      for (Entry<String, ? extends ServletContextInitializer> initializerBean : getOrderedBeansOfType(beanFactory,
					initializerType)) {
        //将获取到的bean实例对象按照key为ServletContextInitializer.class class实例对象，value为ServletContextInitializer实例对象
				addServletContextInitializerBean(initializerBean.getKey(), initializerBean.getValue(), beanFactory);
			}
		}
	}
	//将ServletContextInitializer、Filter、Servlet、EventListener类的实例对象加入到集合中
	private void addServletContextInitializerBean(String beanName, ServletContextInitializer initializer,
			ListableBeanFactory beanFactory) {
		if (initializer instanceof ServletRegistrationBean) {
			Servlet source = ((ServletRegistrationBean<?>) initializer).getServlet();
      //将Servlet加入集合
			addServletContextInitializerBean(Servlet.class, beanName, initializer, beanFactory, source);
		}
		else if (initializer instanceof FilterRegistrationBean) {
			Filter source = ((FilterRegistrationBean<?>) initializer).getFilter();
      //将Filter加入集合
			addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);
		}
		else if (initializer instanceof DelegatingFilterProxyRegistrationBean) {
			String source = ((DelegatingFilterProxyRegistrationBean) initializer).getTargetBeanName();
      //将Servlet加入集合
			addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);
		}
		else if (initializer instanceof ServletListenerRegistrationBean) {
			EventListener source = ((ServletListenerRegistrationBean<?>) initializer).getListener();
      //将EventListener加入集合
			addServletContextInitializerBean(EventListener.class, beanName, initializer, beanFactory, source);
		}
		else {
      //将ServletContextInitializer加入集合
			addServletContextInitializerBean(ServletContextInitializer.class, beanName, initializer, beanFactory,
					initializer);
		}
	}
	/**
	* @param type Filter、Servlet、EventListener类class实例对象
	* @param beanName 是xxRegistrationBean的实例对象bean名称
	* @param initializer ServletContextInitializer实例对象
	**/
	private void addServletContextInitializerBean(Class<?> type, String beanName, ServletContextInitializer initializer,
			ListableBeanFactory beanFactory, Object source) {
    //将ServletContextInitializer实例对象加入集合，key为class类型
		this.initializers.add(type, initializer);
		if (source != null) {
			// 记录被标记为ServletContextInitializer实例对象的Filter、Servlet、EventListener bean实例对象
			this.seen.add(source);
		}
		if (logger.isTraceEnabled()) {
			String resourceDescription = getResourceDescription(beanName, beanFactory);
      //获取initializer实例化对象的order值
			int order = getOrder(initializer);
			logger.trace("Added existing " + type.getSimpleName() + " initializer bean '" + beanName + "'; order="
					+ order + ", resource=" + resourceDescription);
		}
	}

	private String getResourceDescription(String beanName, ListableBeanFactory beanFactory) {
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			return registry.getBeanDefinition(beanName).getResourceDescription();
		}
		return "unknown";
	}

	@SuppressWarnings("unchecked")
	protected void addAdaptableBeans(ListableBeanFactory beanFactory) {
		MultipartConfigElement multipartConfig = getMultipartConfig(beanFactory);
    //将容器中的Servlet实例对象转换为RegistrationBean实例对象加入ServletContextInitializer集合
		addAsRegistrationBean(beanFactory, Servlet.class, new ServletRegistrationBeanAdapter(multipartConfig));
    //将容器中的Filter实例对象转换为RegistrationBean实例对象加入ServletContextInitializer集合
		addAsRegistrationBean(beanFactory, Filter.class, new FilterRegistrationBeanAdapter());
		for (Class<?> listenerType : ServletListenerRegistrationBean.getSupportedTypes()) {
      //将容器中的EventListener实例对象转换为RegistrationBean实例对象加入ServletContextInitializer集合
			addAsRegistrationBean(beanFactory, EventListener.class, (Class<EventListener>) listenerType,
					new ServletListenerRegistrationBeanAdapter());
		}
	}

	private MultipartConfigElement getMultipartConfig(ListableBeanFactory beanFactory) {
		List<Entry<String, MultipartConfigElement>> beans = getOrderedBeansOfType(beanFactory,
				MultipartConfigElement.class);
		return beans.isEmpty() ? null : beans.get(0).getValue();
	}

	protected <T> void addAsRegistrationBean(ListableBeanFactory beanFactory, Class<T> type,
			RegistrationBeanAdapter<T> adapter) {
		addAsRegistrationBean(beanFactory, type, type, adapter);
	}

	private <T, B extends T> void addAsRegistrationBean(ListableBeanFactory beanFactory, Class<T> type,
			Class<B> beanType, RegistrationBeanAdapter<T> adapter) {
    //获取beanName及实例对象属性集合对象
		List<Map.Entry<String, B>> entries = getOrderedBeansOfType(beanFactory, beanType, this.seen);
		for (Entry<String, B> entry : entries) {
      //获取beanName
			String beanName = entry.getKey();
      //获取beanName对应的实例对象属性集合
			B bean = entry.getValue();
      //将对象加入seen集合
			if (this.seen.add(bean)) {
				// 根据适配器将bean转换为RegistrationBean对象
				RegistrationBean registration = adapter.createRegistrationBean(beanName, bean, entries.size());
        //获取排序顺序
				int order = getOrder(bean);
        //设置RegistrationBean的优先级顺序
				registration.setOrder(order);
        //将RegistrationBean加入到集合
				this.initializers.add(type, registration);
				if (logger.isTraceEnabled()) {
					logger.trace("Created " + type.getSimpleName() + " initializer for bean '" + beanName + "'; order="
							+ order + ", resource=" + getResourceDescription(beanName, beanFactory));
				}
			}
		}
	}
	//获取指定实例对象的order顺序值
	private int getOrder(Object value) {
		return new AnnotationAwareOrderComparator() {
			@Override
			public int getOrder(Object obj) {
				return super.getOrder(obj);
			}
		}.getOrder(value);
	}
	//根据class类型获取IOC容器中的bean实例对象，获取后对这些对象进行order排序
	private <T> List<Entry<String, T>> getOrderedBeansOfType(ListableBeanFactory beanFactory, Class<T> type) {
		return getOrderedBeansOfType(beanFactory, type, Collections.emptySet());
	}
	//获取指定IOC容器中指定class类型的bean集合
	private <T> List<Entry<String, T>> getOrderedBeansOfType(ListableBeanFactory beanFactory, Class<T> type,
			Set<?> excludes) {
    //获取指定的class类型的beanName集合
		String[] names = beanFactory.getBeanNamesForType(type, true, false);
		Map<String, T> map = new LinkedHashMap<>();
		for (String name : names) {
			if (!excludes.contains(name) && !ScopedProxyUtils.isScopedTarget(name)) {
        //获取指定beanName及类型的bean实例对象
				T bean = beanFactory.getBean(name, type);
				if (!excludes.contains(bean)) {
					map.put(name, bean);
				}
			}
		}
		List<Entry<String, T>> beans = new ArrayList<>(map.entrySet());
    //bean实例对象排序
		beans.sort((o1, o2) -> AnnotationAwareOrderComparator.INSTANCE.compare(o1.getValue(), o2.getValue()));
		return beans;
	}

	private void logMappings(MultiValueMap<Class<?>, ServletContextInitializer> initializers) {
		if (logger.isDebugEnabled()) {
			logMappings("filters", initializers, Filter.class, FilterRegistrationBean.class);
			logMappings("servlets", initializers, Servlet.class, ServletRegistrationBean.class);
		}
	}

	private void logMappings(String name, MultiValueMap<Class<?>, ServletContextInitializer> initializers,
			Class<?> type, Class<? extends RegistrationBean> registrationType) {
		List<ServletContextInitializer> registrations = new ArrayList<>();
		registrations.addAll(initializers.getOrDefault(registrationType, Collections.emptyList()));
		registrations.addAll(initializers.getOrDefault(type, Collections.emptyList()));
		String info = registrations.stream().map(Object::toString).collect(Collectors.joining(", "));
		logger.debug("Mapping " + name + ": " + info);
	}

	@Override
	public Iterator<ServletContextInitializer> iterator() {
		return this.sortedList.iterator();
	}
	//获取已排序的ServletContextInitializer集合大小
	@Override
	public int size() {
		return this.sortedList.size();
	}

	/**
	 * 讲一个bean转换为RegistrationBean适配器类型接口 (RegistrationBean是ServletContextInitializer的
	 * 的一个增强接口
	 */
	@FunctionalInterface
	protected interface RegistrationBeanAdapter<T> {

		RegistrationBean createRegistrationBean(String name, T source, int totalNumberOfSourceBeans);

	}

	/**
	 * Servlet的RegistrationBeanAdapter适配器接口
	 */
	private static class ServletRegistrationBeanAdapter implements RegistrationBeanAdapter<Servlet> {

		private final MultipartConfigElement multipartConfig;

		ServletRegistrationBeanAdapter(MultipartConfigElement multipartConfig) {
			this.multipartConfig = multipartConfig;
		}

		@Override
		public RegistrationBean createRegistrationBean(String name, Servlet source, int totalNumberOfSourceBeans) {
			String url = (totalNumberOfSourceBeans != 1) ? "/" + name + "/" : "/";
			if (name.equals(DISPATCHER_SERVLET_NAME)) {
				url = "/"; // always map the main dispatcherServlet to "/"
			}
			ServletRegistrationBean<Servlet> bean = new ServletRegistrationBean<>(source, url);
			bean.setName(name);
			bean.setMultipartConfig(this.multipartConfig);
			return bean;
		}

	}

	/**
	 * Filter适配类RegistrationBeanAdapter
	 */
	private static class FilterRegistrationBeanAdapter implements RegistrationBeanAdapter<Filter> {

		@Override
		public RegistrationBean createRegistrationBean(String name, Filter source, int totalNumberOfSourceBeans) {
			FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>(source);
			bean.setName(name);
			return bean;
		}

	}

	/**
	 * EventListener的RegistrationBeanAdapter适配接口
	 */
	private static class ServletListenerRegistrationBeanAdapter implements RegistrationBeanAdapter<EventListener> {

		@Override
		public RegistrationBean createRegistrationBean(String name, EventListener source,
				int totalNumberOfSourceBeans) {
			return new ServletListenerRegistrationBean<>(source);
		}

	}

}

GitHub地址：https://github.com/mingyang66/spring-parent

立小言先森
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringBoot如何注册Servlet、Filter、Listener的几种方式
08-26
在Servlet 3.0之前都是使用web.xml文件进行配置，这篇文章主要介绍了SpringBoot如何注册Servlet、Filter、Listener的几种方式,在Servlet 3.0之前都是使用web.xml文件进行配置，
SpringBoot - 浅析 ServletContextInitializer 如何注册 Servlet 组件
业精于勤荒于嬉
07-12 1364
SpringBoot 是如何通过 ServletContextInitializer 加载 Servlet 组件到 Servlet 容器的
从Servlet和Spring-web整合理解父子容器
daliucheng的博客
11-11 566
从Servlet和Spring-web整合理解父子容器 这篇文章主要分为两个部分， spring和servlet的融合。怎么Servlet容器启动起来，我就可以用Spring了。 从ServletContext和RootWebContext的关系理解Spring中的父子容器。 现在Springboot作为Java开发的主力军，开箱即用的特性，并且大多数的人在pom文件中写的都是直接写spring-boot-starter-web，然后在主启动类上在写@SpringbootApplication，在写一个
ServletContextInitializer的作用
最新发布
yangfengweiwsdn的博客
03-14 308
> StandardContext.startInternal() SpringApplication.run线程外的一个新线程。-> RegistrationBean.onStartup(ServletContext servletContext) 由于RegistrationBean implements。
Spring boot之ServletContextInitializer
bearboy80的专栏
12-14 2724
Spring Boot提供的在Servlet 3.0+环境中用于程序化配置ServletContext的接口。该接口 ServletContextInitializer主要被RegistrationBean实现用于往ServletContext容器中注册Servlet,Filter或者EventListener。这样设计的目的主要是旨在降低用于在war包中第三方库可能破坏spring boot 应用的风险，同时也方便spring容器管理这些beans。这些ServletContextInitializer实
ServletContainerInitializer、WebApplicationInitializer、ServletContextInitializer有什么区别
uhfun的博客
05-27 1937
版权声明：本文为博主原创文章，转载请附上原文出处链接和声明。 原文链接： http://uhfun.cn/tech/2020/05/22/傻傻分不清-ServletContainerInitializer-SpringServletContainerInitializer-WebApplicationInitializer-SpringBootServletInitializer-ServletContextInitializer都是些啥.html 这几个类乍一看有点像，仔细一看还是有点像，特别是Servl
ServletContextInitializer和WebApplicationInitializer的区别
wt_better的博客
11-10 1899
文章目录一、WebApplicationInitializer二、ServletContextInitializer三、反思 一、WebApplicationInitializer 实现原理： org.springframework.web.SpringServletContainerInitializer实现了javax.servlet.ServletContainerInitializer接口，在Servlet容器启动的时候，会自动探测WebApplicationInitializer的实现类，执行其o
Spring boot 的Web应用工具类ServletContextInitializerBeans
Details Inside Spring
11-28 3152
概述 该类位于包 : org.springframework.boot.web.servlet ServletContextInitializerBeans实例表示一个从ListableBeanFactory bean容器中获得的ServletContextInitializer实例的集合。这个集合中的每个元素来自容器中定义的每个如下类型的bean : ServletContext
【框架专题】——管理型容器——SpringBoot内置IOC容器/内置WEB容器原理
weixin_44275259的博客
07-31 360
SpringBoot源码——内置Tomcat原理 SpringBoot源码——自动配置原理
SpringBoot初始教程之Servlet、Filter、Listener配置详解
08-29
本篇文章主要介绍了SpringBoot初始教程之Servlet、Filter、Listener配置详解，具有一定的参考价值，有兴趣的可以了解一下
SpringBoot注册Servlet的三种方法详解
08-26
主要介绍了SpringBoot注册Servlet的三种方法详解，教你如何Spring Boot 注册 Servlet、Filter、Listener，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
C#,winform，Tcp通信源码 使用TcpListener和TcpClient 源码
04-29
C#,winform，Tcp通信源码 使用TcpListener和TcpClient 源码 Tcp通信源码TcpListener和TcpClient 源码
Filter、Servlet、Listener的学习_动力节点Java学院整理
08-29
主要为大家详细介绍了Filter、Servlet、Listener的学习资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
SpringBoot 官方文档示例：(62) ServletContextInitializer的用法
amadeus_liu2的博客
07-01 333
boot
Spring Boot Servlet : ServletContextInitializer
Details Inside Spring
05-22 5457
概述 功能介绍 Spring Boot提供的在Servlet 3.0+环境中用于程序化配置ServletContext的接口。该接口ServletContextInitializer主要被RegistrationBean实现用于往ServletContext容器中注册Servlet,Filter或者EventListener。这些ServletContextInitializer的设计目的主要是用...
内置容器源码解析：DispatcherServlet加载过程
m0_63437643的博客
02-22 487
DispatcherServlet的加载过程 DispatcherServlet 的获取 还 记 得 在 上 一 章 Web应 用 中 自 动 配 置 的 DispatcherServlet 和 DispatcherServletRegistra-tionBean 吗?当时只是将其实例化了，并未做其他处理。而在上节 WebServer 初始化的过程中又加载了它们。下面我们进行相关源码的解析。 在 ServletWebServerApplicationContext#createWebServer 方
SpringBoot是如何创建ServletContext
zhao_god的专栏
07-21 931
1处ServletContextInitializer封装进了tomcatStarter中，最后starter被添加到了tomcat的context中，在tomcat启动的时候会调用ServletContextInitializer的startUp方法。此处thisselfInitialize返回的是函数式方法实现，类似匿名内部类，而不是直接调用（注理解了很久，PS断点一直不进去，很奇怪），此处返回一个ServletContextInitialzer的实现。过程太长了，省略了一部分.............
Spring Boot如何在启动时取得servletContext
scruffybear的专栏
07-05 1058
Sping Boot在启动的时候尝试获取servletContext的时候会返回null空，进行了一些尝试，可以在Spring Boot启动后获取servletContext。
springboot如何控制filter、listener、servlet先后加载顺序
03-29
在Spring Boot中，可以通过实现`Ordered`接口或使用`@Order`注解来控制filter、listener、servlet的加载顺序。 1. 实现`Ordered`接口 可以让filter、listener、servlet实现`Ordered`接口，然后实现`getOrder()`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值