10-Spring支持Servlet3.0新特性

最新推荐文章于 2022-08-08 14:51:07 发布
最新推荐文章于 2022-08-08 14:51:07 发布
阅读量288 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizc_lizc/article/details/105161223
版权

Spring支持Servlet3.0

由上一节可以知道，利用Servlet3.0的新特性，我们在编写Servlet的时候可以不使用xml配置文件了，直接使用注解就可以了。本节将会介绍Spring是如何支持Servlet3.0。

首先导入SpringMVC的依赖

<dependencies>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.14.RELEASE</version>
    </dependency>
</dependencies>

查看spring-web-5.1.14.RELEASE依赖目录下的/META-INF/services/javax.servlet.ServletContainerInitializer文件，文件内容如下

org.springframework.web.SpringServletContainerInitializer

因此我们可以知道，容器在启动时将会调用这个类的#onStartup(...) 方法。

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
	@Override
	public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
			throws ServletException {
		List<WebApplicationInitializer> initializers = new LinkedList<>();
		if (webAppInitializerClasses != null) {
			for (Class<?> waiClass : webAppInitializerClasses) {
				// 如果waiClass不是一个接口、不是一个抽象类、并且是WebApplicationInitializer类的子类，则实例化并加到initializers
				if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
						WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
					try {
						initializers.add((WebApplicationInitializer)
								ReflectionUtils.accessibleConstructor(waiClass).newInstance());
					}
					catch (Throwable ex) {
						throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
					}
				}
			}
		}
        
		if (initializers.isEmpty()) {
			servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
			return;
		}
		servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
		AnnotationAwareOrderComparator.sort(initializers);
        // initializers 列表并执行onStartup方法
		for (WebApplicationInitializer initializer : initializers) {
			initializer.onStartup(servletContext);
		}
	}

}

代码比较简单，利用@HandlesTypes(WebApplicationInitializer.class)注解，收集所有不是接口、不是抽象类并且是WebApplicationInitializer接口的子类，最后调用#onStartup(ServletContext servletContext)方法。

WebApplicationInitializer有三个子类，分别是AbstractAnnotationConfigDispatcherServletInitializer、AbstractDispatcherServletInitializer、AbstractContextLoaderInitializer

这三个类的关键代码如下所示

AbstractAnnotationConfigDispatcherServletInitializer

// SpringMVC里面有两个容器, 
// 一个是父容器=》存储普通Bean，如Service、Component等
// 一个是子容器=》存储Controller相关Bean
// AbstractAnnotationConfigDispatcherServletInitializer.java
public abstract class AbstractAnnotationConfigDispatcherServletInitializer
		extends AbstractDispatcherServletInitializer {
    // 创建一个父容器, Root WebApplicationContext
	@Override
	@Nullable
	protected WebApplicationContext createRootApplicationContext() {
		Class<?>[] configClasses = getRootConfigClasses();
		if (!ObjectUtils.isEmpty(configClasses)) {
			AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
			context.register(configClasses);
			return context;
		}
		else {
			return null;
		}
	}
	// 创建一个子容器, Servlet WebApplicationContext
	@Override
	protected WebApplicationContext createServletApplicationContext() {
		AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
		Class<?>[] configClasses = getServletConfigClasses();
		if (!ObjectUtils.isEmpty(configClasses)) {
			context.register(configClasses);
		}
		return context;
	}
	// 指定父容器的配置类, 由子类实现
	@Nullable
	protected abstract Class<?>[] getRootConfigClasses();
	// 指定子容器的配置类, 由子类实现
	@Nullable
	protected abstract Class<?>[] getServletConfigClasses();

}

AbstractDispatcherServletInitializer

// AbstractDispatcherServletInitializer.java
public abstract class AbstractDispatcherServletInitializer extends AbstractContextLoaderInitializer {
	// 默认的Servlet名字
	public static final String DEFAULT_SERVLET_NAME = "dispatcher";
	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
		// 调用父类的onStartup方法, 这里会新建父容器, Root WebApplicationContext
        super.onStartup(servletContext);
        // 注册DispatcherServlet, 这里会新建子容器, Servlet WebApplicationContext
        // 子容器以 Root WebApplicationContext 作为父容器
		registerDispatcherServlet(servletContext);
	}
	// 注册DispatcherServlet
	protected void registerDispatcherServlet(ServletContext servletContext) {
		String servletName = getServletName();
		Assert.hasLength(servletName, "getServletName() must not return null or empty");
        // 创建一个Servlet WebApplicationContext
		WebApplicationContext servletAppContext = createServletApplicationContext();
		Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");
        // 创建 DispatcherServlet
		FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
		Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
		dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());
		// 向ServletContext中注册DispatcherServlet
		ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
		if (registration == null) {
			throw new IllegalStateException("Failed to register servlet with name '" + servletName + "'. " +
					"Check if there is another servlet registered under the same name.");
		}
		registration.setLoadOnStartup(1);
        // 获取Servlet拦截地址
		registration.addMapping(getServletMappings());
		registration.setAsyncSupported(isAsyncSupported());
        // 获取过滤器
		Filter[] filters = getServletFilters();
		if (!ObjectUtils.isEmpty(filters)) {
			for (Filter filter : filters) {
                // 往ServletContext中注册过滤器
				registerServletFilter(servletContext, filter);
			}
		}
		customizeRegistration(registration);
	}
	// 获取Servlet名字
	protected String getServletName() {
		return DEFAULT_SERVLET_NAME;
	}
	// 创建一个子容器Servlet WebApplicationContext, 由子类实现
	protected abstract WebApplicationContext createServletApplicationContext();
	// 创建 DispatcherServlet
	protected FrameworkServlet createDispatcherServlet(WebApplicationContext servletAppContext) {
        // 这里新建一个DispatcherServlet对象, 并且将 Servlet WebApplicationContext 传递进去
		return new DispatcherServlet(servletAppContext);
	}
	// 指定 DispatcherServlet 拦截规则, 由子类实现
	protected abstract String[] getServletMappings();
	// 省略代码......
}

AbstractContextLoaderInitializer

// AbstractContextLoaderInitializer.java
public abstract class AbstractContextLoaderInitializer implements WebApplicationInitializer {
	/** Logger available to subclasses. */
	protected final Log logger = LogFactory.getLog(getClass());
	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
		registerContextLoaderListener(servletContext);
	}
    // 往ServletContext中注册一个ContextLoaderListener
	protected void registerContextLoaderListener(ServletContext servletContext) {
        // 创建一个Root ApplicationContext
		WebApplicationContext rootAppContext = createRootApplicationContext();
		if (rootAppContext != null) {
            // ContextLoaderListener实现了ServletContextListener接口
            // 在 Servlet 容器启动时，例如 Tomcat、Jetty 启动
            // 则会被 ContextLoaderListener 监听到
            // 从而调用contextInitialized(ServletContextEvent event)方法
            // 初始化 Root WebApplicationContext 容器。 
            // 这里新建 ContextLoaderListener 对象并且将Root ApplicationContext传递过去
			ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
			listener.setContextInitializers(getRootApplicationContextInitializers());
            // 给ServletContext注册一个监听器
			servletContext.addListener(listener);
		}
		else {
			logger.debug("No ContextLoaderListener registered, as " +
					"createRootApplicationContext() did not return an application context");
		}
	}
	// 创建一个父容器, Root ApplicationContext, 由子类实现
	@Nullable
	protected abstract WebApplicationContext createRootApplicationContext();
    // 省略了部分代码......
}

前面提到了 org.springframework.web.context.ContextLoaderListener 与 org.springframework.web.servlet.DispatcherServlet 对象 。

ContextLoaderListener 对象。这是一个 javax.servlet.ServletContextListener 对象，会初始化一个Root Spring WebApplicationContext 容器。DispatcherServlet对象。这是一个 javax.servlet.http.HttpServlet 对象，它除了拦截我们制定的请求外，也会初始化一个属于它的 Spring WebApplicationContext 容器，并且它是以Root Spring WebApplicationContext 作为父容器的。

Root WebApplicationContext

我们已经看到，Root WebApplicationContext 容器的初始化，通过 ContextLoaderListener 来实现。在 Servlet 容器启动时，例如 Tomcat、Jetty 启动，则会被 ContextLoaderListener 监听到，从而调用 #contextInitialized(ServletContextEvent event) 方法，初始化 Root WebApplicationContext 容器。

ContextLoaderListener实现了ServletContextListener接口并且继承了ContextLoader类。

由前面的分析可以知道，创建ContextLoaderListener对象时传递了一个WebApplicationContext对象进去。

// ContextLoaderListener.java
public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
    // 无参构造方法
	public ContextLoaderListener() {
	}
    // 有参构造方法
	public ContextLoaderListener(WebApplicationContext context) {
		super(context);
	}
	@Override
	public void contextInitialized(ServletContextEvent event) {
        // 调用父类 ContextLoader 的 
        // #initWebApplicationContext(ServletContext servletContext) 方法，
        // 初始化 WebApplicationContext 对象
		initWebApplicationContext(event.getServletContext());
	}
    // 销毁 WebApplicationContext 容器的逻辑。
	@Override
	public void contextDestroyed(ServletContextEvent event) {
		closeWebApplicationContext(event.getServletContext());
		ContextCleanupListener.cleanupAttributes(event.getServletContext());
	}
}

接着看ContextLoader相关实现

public class ContextLoader {
    // 无参构造函数
	public ContextLoader() {
	}
    // 有参
	public ContextLoader(WebApplicationContext context) {
		this.context = context;
	}
    // 初始化 WebApplicationContext 对象
	public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
        // 若已经存在 ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE 对应的 WebApplicationContext 对象，则抛出 IllegalStateException 异常。
		if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
			throw new IllegalStateException(
					"Cannot initialize context because there is already a root application context present - " +
					"check whether you have multiple ContextLoader* definitions in your web.xml!");
		}
        // 记录开始时间
		long startTime = System.currentTimeMillis();
		try {
			if (this.context == null) {
				this.context = createWebApplicationContext(servletContext);
			}
			if (this.context instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
				if (!cwac.isActive()) {
					if (cwac.getParent() == null) {
						ApplicationContext parent = loadParentContext(servletContext);
						cwac.setParent(parent);
					}
                    // 配置 ConfigurableWebApplicationContext 对象，并刷新容器
					configureAndRefreshWebApplicationContext(cwac, servletContext);
				}
			}
             // 保存到 servletContext 中
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
            // 保存到 currentContext 或 currentContextPerThread 中
			ClassLoader ccl = Thread.currentThread().getContextClassLoader();
			if (ccl == ContextLoader.class.getClassLoader()) {
				currentContext = this.context;
			}
			else if (ccl != null) {
				currentContextPerThread.put(ccl, this.context);
			}

			if (logger.isInfoEnabled()) {
				long elapsedTime = System.currentTimeMillis() - startTime;
				logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
			}

			return this.context;
		}
		catch (RuntimeException | Error ex) {
			logger.error("Context initialization failed", ex);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
			throw ex;
		}
	}
    // 配置 ConfigurableWebApplicationContext 对象，并刷新容器
	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);
			}
			else {
				// Generate default id...
				wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
						ObjectUtils.getDisplayString(sc.getContextPath()));
			}
		}
		wac.setServletContext(sc);
		String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
		if (configLocationParam != null) {
			wac.setConfigLocation(configLocationParam);
		}
		ConfigurableEnvironment env = wac.getEnvironment();
		if (env instanceof ConfigurableWebEnvironment) {
			((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
		}
        // 执行一些自定义的初始化
		customizeContext(sc, wac);
        // 刷新 context ，执行初始化
		wac.refresh();
	}
}

Servlet WebApplicationContext

Servlet WebApplicationContext 容器的初始化，是在 DispatcherServlet 初始化的过程中执行。 由前面的分析可以知道，创建DispatcherServlet 对象时传递了一个WebApplicationContext对象进去。

DispatcherServlet继承了FrameworkServlet，FrameworkServlet继承了HttpServletBean，HttpServletBean继承了HttpServlet。

HttpServletBean实现了HttpServlet的init()方法

// HttpServletBean.java
public final void init() throws ServletException {
		// Set bean properties from init parameters.
    	// 将init parameters封装到 PropertyValues pvs 中
		PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
		if (!pvs.isEmpty()) {
			try {
                // 将当前的这个 Servlet 对象，转化成一个 BeanWrapper 对象。
                // 从而能够以 Spring 的方式来将 pvs 注入到该 BeanWrapper 对象。
                // BeanWrapper 是 Spring 提供的一个用来操作 Java Bean 属性的工具，使用它可以直接修改一个对象的属性。
				BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
				ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
                // 注册自定义属性编辑器，一旦碰到 Resource 类型的属性，
                // 将会使用 ResourceEditor 进行解析
				bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
                // 空实现，留给子类覆盖
				initBeanWrapper(bw);
                // 将 pvs 注入到该 BeanWrapper 对象中
				bw.setPropertyValues(pvs, true);
			}
			catch (BeansException ex) {
				if (logger.isErrorEnabled()) {
					logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
				}
				throw ex;
			}
		}
		// Let subclasses do whatever initialization they like.
    	// 子类来实现，实现自定义的初始化逻辑
    	// FrameworkServlet实现了这个方法
		initServletBean();
	}

FrameworkServlet#initServletBean()

// FrameworkServlet.java
protected final void initServletBean() throws ServletException {
    // 打日志
    getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'");
    if (logger.isInfoEnabled()) {
        logger.info("Initializing Servlet '" + getServletName() + "'");
    }
    // 记录开始时间
    long startTime = System.currentTimeMillis();
    try {
        // 初始化 Servlet WebApplicationContext 对象
        this.webApplicationContext = initWebApplicationContext();
        // 空实现。子类有需要，可以实现该方法，实现自定义逻辑
        initFrameworkServlet();
    }
    catch (ServletException | RuntimeException ex) {
        logger.error("Context initialization failed", ex);
        throw ex;
    }
    // 打日志
    if (logger.isDebugEnabled()) {
        String value = this.enableLoggingRequestDetails ?
            "shown which may lead to unsafe logging of potentially sensitive data" :
        "masked to prevent unsafe logging of potentially sensitive data";
        logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails +
                     "': request parameters and headers will be " + value);
    }
    // 打日志
    if (logger.isInfoEnabled()) {
        logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
    }
}

FrameworkServlet#initWebApplicationContext()

// FrameworkServlet.java
protected WebApplicationContext initWebApplicationContext() {
    // 获得Root WebApplicationContext 对象
    WebApplicationContext rootContext =
        WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    WebApplicationContext wac = null;
    // 第一种情况, 新建对象时就已经传入 webApplicationContext 属性，则直接使用
    // 从前面的分析可以知道, 创建DispatcherServlet对象时传递了一个WebApplicationContext对象进来
    if (this.webApplicationContext != null) {
        wac = this.webApplicationContext;
        if (wac instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
            // 未激活
            if (!cwac.isActive()) {
                if (cwac.getParent() == null) {
                    设置wac的父容器为rootContext对象
                    cwac.setParent(rootContext);
                }
                // 配置和初始化 wac
                configureAndRefreshWebApplicationContext(cwac);
            }
        }
    }
    if (wac == null) {
        
        wac = findWebApplicationContext();
    }
    if (wac == null) {
        // No context instance is defined for this servlet -> create a local one
        wac = createWebApplicationContext(rootContext);
    }
    if (!this.refreshEventReceived) {
        // 如果未触发刷新事件，则主动触发刷新事件
        synchronized (this.onRefreshMonitor) {
            // FrameworkServlet 中这是个空方法
            // 但是它的子类 DispatcherServlet实现了这个方法, 触发Spring MVC组件的初始化
            onRefresh(wac);
        }
    }
    if (this.publishContext) {
        // 将 wac 设置到 ServletContext 中
        String attrName = getServletContextAttributeName();
        getServletContext().setAttribute(attrName, wac);
    }
    return wac;
}

FrameworkServlet#configureAndRefreshWebApplicationContext()

// FrameworkServlet.java
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
    // 如果 wac 使用了默认编号，则重新设置 id 属性
    if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
        // 情况一，使用 contextId 属性
        if (this.contextId != null) {
            wac.setId(this.contextId);
        } else {
            // 情况二，自动生成
            wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
                      ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
        }
    }
    // 设置 wac 的 servletContext、servletConfig、namespace 属性
    wac.setServletContext(getServletContext());
    wac.setServletConfig(getServletConfig());
    wac.setNamespace(getNamespace());
    // 添加监听器 SourceFilteringListener 到 wac 中
    wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
    // 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(getServletContext(), getServletConfig());
    }
    // 执行处理完 WebApplicationContext 后的逻辑。目前是个空方法，暂无任何实现
    postProcessWebApplicationContext(wac);
    // 执行ApplicationContextInitializer的initialize方法
    applyInitializers(wac);
    // 刷新context, 执行初始化
    wac.refresh();
}
lizc_lizc
关注
专栏目录
Servlet 3.0 新特性-web-fragment（web片段）
weixin_45697842的博客
01-08 348
引用：https://www.cnblogs.com/learn-zy/p/10382302.html 可插性支持 如果说 3.0 版本新增的注解支持是为了简化 Servlet/ 过滤器 / 监听器的声明，从而使得 web.xml 变为可选配置， 那么新增的可插性 (pluggability) 支持则将 Servlet 配置的灵活性提升到了新的高度。熟悉 Struts2 的开发者都知道，Struts2 通过插件的形式提供了对包括 Spring 在内的各种开发框架的支持，开发者甚至可以自己为 Struts2
17-Javaweb-注解 & servlet3.0 & 类加载器 & 动态代理
qq_38247809的博客
07-22 584
目录 一、案例1-模拟junit测试 1-1 注解 1-1 java中3个注解(理解) 1-2 自定义注解(理解) 1-2-1 注解属性 1-2-2 注解属性类型 1-2-3 赋值的格式 1-2-4 元注解:(理解) 1-3 步骤分析:(了解) 1-3-1 定义一个注解 @MyTest 1-3-2 在一个测试类 MyTestTest 上的添加几个方法 1-3-3 在另一个有主方法的类上添加main方法 1-4 案例扩展 1-5 步骤分析 1-5-1 自定义一个注解JDBCInf
spring mvc3.2.7+servlet3.1(jetty)+maven3+eclipse
03-08
spring mvc3.2.7(基于注解配置)+servlet3.1(jetty)+maven3+eclipse
Spring 是如何支持 Servlet 3.0 的？
yingzi19911010的博客
10-11 381
写在前面： ServletContainerInitializer 也是 Servlet 3.0 新增的一个接口，容器在启动时使用 JAR 服务 API(JAR Service API) 来发现 ServletContainerInitializer 的实现类，并且容器将WEB-INF/lib目录下 JAR 包中的类都交给该类的#onStartup(...)方法处理，我们通常需要在该实现...
Servlet3.0新特性和Web容器如何整合SpringMVC
scorpio的博客
12-25 592
Servlet3.0新特性和如何启动SpringMVC
spring源码解读（二）基础篇之servlet3.1规范（二）
chuixue24的博客
12-20 209
目录 应用生命周期事件 事件监听器 监听器类配置 提供监听器类 部署声明 监听器注册 关闭时通知 分布式容器 映射请求到 Servlet 使用 URL 路径 映射规范 隐式映射 安全 介绍 部署描述文件 部署描述文件元素 应用生命周期事件 事件监听器 应用事件监听器是实现一个或多个 Servlet 事件监听器接口的类。它们是在部署 Web 应用时，实例化并注册...
spring源码解读（二）基础篇之servlet3.1规范（一）
chuixue24的博客
12-09 365
目录 servlet接口 request servletContext response filter filter生命周期 filter环境 在Web应用中配置filter filter和RequestDispatcher 会话 Cookies URL 重写 会话完整性 注解 @WebServlet @WebFilter @WebInitParam @WebL...
spring_servlet3:Spring MVC Servlet 3.0博客的源代码-mvc source code
03-24
Servlet 3.0 是 Java Servlet API 的一个重要版本，它引入了许多新特性，如异步处理、注解配置以及对 web.xml 配置的简化。`spring_servlet3` 项目提供了 Spring MVC 集成 Servlet 3.0 特性的示例源代码，这对于...
study-servlet3.0:学习servlet3.0
05-10
Servlet3.0是Java Web开发中的一个重要里程碑，它在Servlet2.5的基础上引入了许多新特性，极大地提高了开发效率和灵活性。在这个"study-servlet3.0"的学习资源中，我们将深入探讨Servlet3.0的核心改进和特性。 1. *...
基于servlet3.0手写springmvc
12-05
Servlet 3.0是Java Servlet API的一个重大更新，引入了许多新特性，如注解驱动的配置、异步Servlet处理、以及可插拔的部署描述符。这对于简化Web应用开发和提高其灵活性起到了关键作用。 Spring MVC 的核心是模型-...
springmvc基于servlet3.0特性记录
SchatzEclipse的博客
08-07 746
转自 http://13shu.iteye.com/blog/2021652 servlet3.0有一个新的特性，新增HTTP请求的异步处理，详细请参考。 由于项目采用的SpringMVC做的，所以查看了下SpringMVC的资料，发现3.2版本对于异步处理有良好的封装。  配置servlet3.0      web.xml中配置     
spring源码几个servlet功能的介绍
weixin_34354945的博客
04-10 131
DispatcherServlet继承 FrameworkServlet继承 HttpServletBean HttpServletBean中的重要的方法init FrameworkServlet中的重要的方法initWebApplicationContext DispatcherServlet中的重要的方法initStrategies覆写了FrameworkServle...
Spring3.1.1学习笔记05-servlet新特性-1
该页无法显示
04-10 96
既然使用到了Servlet3.0的东西，那就要学习一下Servlet3.0的新特性。Servlet3.0的新特性主要包括下面几个方面： 1、模块化web框架 类似于eclipse的插件技术，Servlet3.0就像一个花瓶（一个最底层的托盘），你可以在他的上面构建自己的应用，像springmvc，struts等mvc框架都构建在这个底层上，我们只需要加入一些声明，比如servlet、监听、过滤...
Spring版本特性---＞Spring各个版本引入了哪些新特性？-1
xiao-啸
08-08 1620
spring-java-javeee的持之版本和spring个版本之间的特性
第十章：配置SpringBoot支持自动装载Servlet
xs90xs的博客
07-18 709
Web 技术成为当今主流的互联网 Web 应用技术之一，而 Servlet 是 Java Web 技术的核心基础之一。 Servlet是Java编写服务器端的程序组件，主要功能在于交互式数据操作，动态生成WEB内容等。传统的Spring项目，配置Servlet比较繁琐，需要在web.xml内添加对应的标签以及映射路径规则。本章主要讲解在SpringBoot项目中如何创建Servlet以及自动装载到SpringBoot中，在SpringBoot项目中使用Servlet有两种配置方式，我们下面一一讲解。...
SpringMVC与Servlet3.0整合 - ServletContainerInitializer注解配置项目
小小默：进无止境
04-20 4407
【1】SpringServletContainerInitializer ServletContainerInitializer 该篇博文说明了ServletContainerInitializer是什么以及如何在项目中使用。 SpringMVC同样实现了该功能。 web容器在启动的时候，会扫描每个jar包下的META-INF/services/javax.servlet.ServletCo...
Spring全注解开发----Servlet 3.0
m0_53157173的博客
08-09 1843
Servlet 3.0servlet3.0-简介&测试使用前导入servlet相关的依赖@WebServlet : 注册servlet ,以及servlet 3.0相关的注解说明，链接在下面: 同样，要注册Filter用@WebFilter注解、注册Listener用@WebListener注解；如果在注册的时候，需要一些初始化参数，我们就可以用@WebInitParam注解；小细节回顾: 解决tomcat响应中文乱码问题，通知浏览器使用uft-8编码来对数据进行解码servlet3.0 ==&gt
SpringMVC——Servlet3.0
姜希成的博客
12-14 278
WEB三大组件：servlet、filter、listener。以前经常在web.xml配置使用。 servlet: @WebServlet ServletContainerInitializer——初始化web容器 在web容器启动时为提供给第三方组件机会做一些初始化的工作。每个框架要使用ServletContainerInitializer就必须在对应的jar包的META-INF/services目录创建一个名为javax.servlet.ServletContainerInitializer的文件，
springMVC+servlet3.0异步请求之AsyncContext
开心的专栏
03-14 8945
之前已经讲解过servlet3.0以下怎么实现异步请求，那就是使用jetty的continuation。下面来举例说明使用原生的servlet异步机制来进行异步请求。由于之前已经搭建了一个基于springmvc的框架，下面将会基于springmvc来讲解AsyncContext。先贴上代码，然后根据代码来体验异步流程package com.ds.test.asyncservlet;import ja
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值