Cet article présente principalement en détail des informations pertinentes sur les nouvelles fonctionnalités de servlet3, qui ont une certaine valeur de référence. Les amis intéressés peuvent se référer à
Aperçu des nouvelles fonctionnalités de Servlet 3.0<.>
2. Nouveau support des annotations : Cette version ajoute plusieurs nouvelles annotations pour simplifier la déclaration des Servlets, des filtres (Filter) et des auditeurs (Listener), ce qui rend le fichier de description de déploiement web.xml à partir de cette version Ce n'est plus un incontournable .
3. Prise en charge de la pluggabilité : les développeurs familiers avec Struts2 se souviendront certainement de ses fonctionnalités d'intégration avec divers frameworks couramment utilisés, notamment Spring via des plug-ins. Encapsulez les plug-ins correspondants dans des packages JAR et placez-les sur le chemin de classe, et Struts2 peut charger automatiquement ces plug-ins lors de l'exécution. Désormais, Servlet 3.0 offre des fonctionnalités similaires. Les développeurs peuvent facilement étendre les fonctions des applications Web existantes via des plug-ins sans modifier l'application d'origine.
Ci-dessous, nous expliquerons ces nouvelles fonctionnalités une par une. Grâce à l'étude suivante, les lecteurs pourront clairement comprendre les changements apportés à Servlet 3.0 et pouvoir l'utiliser en douceur pour le travail de développement quotidien.
Prise en charge du traitement asynchrone
Servlet 3.0 a réalisé un travail révolutionnaire sur ce problème. Désormais, en utilisant la prise en charge du traitement asynchrone de Servlet 3.0, le flux de traitement précédent du servlet peut être ajusté au processus suivant : Premièrement, une fois que le servlet a reçu la requête, il peut d'abord en avoir besoin. pour traiter la demande. Les données transportées subissent un certain prétraitement ; ensuite, le thread Servlet transfère la demande à un thread asynchrone pour effectuer le traitement métier, et le thread lui-même retourne au conteneur. À ce stade, le Servlet n'a pas encore généré de données de réponse. . Une fois que le thread asynchrone a traité l'entreprise, il peut générer directement des données de réponse (le thread asynchrone a des références aux objets ServletRequest et ServletResponse), ou la demande continue d'être transmise à d'autres servlets. De cette façon, le thread Servlet n'est plus bloqué en attendant le traitement de la logique métier, mais peut revenir immédiatement après le démarrage du thread asynchrone.
<servlet> <servlet-name>DemoServlet</servlet-name> <servlet-class>footmark.servlet.Demo Servlet</servlet-class> <async-supported>true</async-supported> </servlet>
@WebFilter(urlPatterns = "/demo",asyncSupported = true)
public class DemoFilter implements Filter{...}@WebServlet(urlPatterns = "/demo", asyncSupported = true)
public class AsyncDemoServlet extends HttpServlet {
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp)
throws IOException, ServletException {
resp.setContentType("text/html;charset=UTF-8");
PrintWriter out = resp.getWriter();
out.println("进入Servlet的时间：" + new Date() + ".");
out.flush();
//在子线程中执行业务调用，并由其负责输出响应，主线程退出
AsyncContext ctx = req.startAsync();
new Thread(new Executor(ctx)).start();
out.println("结束Servlet的时间：" + new Date() + ".");
out.flush();
}
}
public class Executor implements Runnable {
private AsyncContext ctx = null;
public Executor(AsyncContext ctx){
this.ctx = ctx;
}
public void run(){
try {
//等待十秒钟，以模拟业务方法的执行
Thread.sleep(10000);
PrintWriter out = ctx.getResponse().getWriter();
out.println("业务处理完毕的时间：" + new Date() + ".");
out.flush();
ctx.complete();
} catch (Exception e) {
e.printStackTrace();
}
}
}1.异步线程开始时，调用 AsyncListener 的 onStartAsync(AsyncEvent event) 方法；
2.异步线程出错时，调用 AsyncListener 的 onError(AsyncEvent event) 方法；
3.异步线程执行超时，则调用 AsyncListener 的 onTimeout(AsyncEvent event) 方法；
4.异步执行完毕时，调用 AsyncListener 的 onComplete(AsyncEvent event) 方法；
要注册一个 AsyncListener，只需将准备好的 AsyncListener 对象传递给 AsyncContext 对象的 addListener() 方法即可，如下所示：
AsyncContext ctx = req.startAsync();
ctx.addListener(new AsyncListener() {
public void onComplete(AsyncEvent asyncEvent) throws IOException {
// 做一些清理工作或者其他
}
...
});新增的注解支持
Servlet 3.0 的部署描述文件 web.xml 的顶层标签
@WebServlet
@WebServlet 用于将一个类声明为 Servlet，该注解将会在部署时被容器处理，容器将根据具体的属性配置将相应的类部署为 Servlet。该注解具有下表给出的一些常用属性（以下所有属性均为可选属性，但是 vlaue 或者 urlPatterns 通常是必需的，且二者不能共存，如果同时指定，通常是忽略 value 的取值）：
表 1. @WebServlet 主要属性列表
下面是一个简单的示例：
@WebServlet(urlPatterns = {"/simple"}, asyncSupported = true,
loadOnStartup = -1, name = "SimpleServlet", displayName = "ss",
initParams = {@WebInitParam(name = "username", value = "tom")}
)
public class SimpleServlet extends HttpServlet{ … }如此配置之后，就可以不必在 web.xml 中配置相应的
<servlet> <display-name>ss</display-name> <servlet-name>SimpleServlet</servlet-name> <servlet-class>footmark.servlet.SimpleServlet</servlet-class> <load-on-startup>-1</load-on-startup> <async-supported>true</async-supported> <init-param> <param-name>username</param-name> <param-value>tom</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>SimpleServlet</servlet-name> <url-pattern>/simple</url-pattern> </servlet-mapping> @WebInitParam
该注解通常不单独使用，而是配合 @WebServlet 或者 @WebFilter 使用。它的作用是为 Servlet 或者过滤器指定初始化参数，这等价于 web.xml 中
表 2. @WebInitParam 的常用属性
@WebFilter
@WebFilter 用于将一个类声明为过滤器，该注解将会在部署时被容器处理，容器将根据具体的属性配置将相应的类部署为过滤器。该注解具有下表给出的一些常用属性 ( 以下所有属性均为可选属性，但是 value、urlPatterns、servletNames 三者必需至少包含一个，且 value 和 urlPatterns 不能共存，如果同时指定，通常忽略 value 的取值 )：
表 3. @WebFilter 的常用属性
下面是一个简单的示例：
@WebFilter(servletNames = {"SimpleServlet"},filterName="SimpleFilter")
public class LessThanSixFilter implements Filter{...}如此配置之后，就可以不必在 web.xml 中配置相应的
<filter> <filter-name>SimpleFilter</filter-name> <filter-class>xxx</filter-class> </filter> <filter-mapping> <filter-name>SimpleFilter</filter-name> <servlet-name>SimpleServlet</servlet-name> </filter-mapping>
@WebListener
该注解用于将类声明为监听器，被 @WebListener 标注的类必须实现以下至少一个接口：
ServletContextListener
ServletContextAttributeListener
ServletRequestListener
ServletRequestAttributeListener
HttpSessionListener
HttpSessionAttributeListener
该注解使用非常简单，其属性如下：
表 4. @WebListener 的常用属性
一个简单示例如下：
@WebListener("This is only a demo listener")
public class SimpleListener implements ServletContextListener{...}如此，则不需要在 web.xml 中配置
<listener> <listener-class>footmark.servlet.SimpleListener</listener-class> </listener>
@MultipartConfig
该注解主要是为了辅助 Servlet 3.0 中 HttpServletRequest 提供的对上传文件的支持。该注解标注在 Servlet 上面，以表示该 Servlet 希望处理的请求的 MIME 类型是 multipart/form-data。另外，它还提供了若干属性用于简化对上传文件的处理。具体如下：
表 5. @MultipartConfig 的常用属性
可插性支持
如果说 3.0 版本新增的注解支持是为了简化 Servlet/ 过滤器 / 监听器的声明，从而使得 web.xml 变为可选配置， 那么新增的可插性 (pluggability) 支持则将 Servlet 配置的灵活性提升到了新的高度。熟悉 Struts2 的开发者都知道，Struts2 通过插件的形式提供了对包括 Spring 在内的各种开发框架的支持，开发者甚至可以自己为 Struts2 开发插件，而 Servlet 的可插性支持正是基于这样的理念而产生的。使用该特性，现在我们可以在不修改已有 Web 应用的前提下，只需将按照一定格式打成的 JAR 包放到 WEB-INF/lib 目录下，即可实现新功能的扩充，不需要额外的配置。
Servlet 3.0 引入了称之为“Web 模块部署描述符片段”的 web-fragment.xml 部署描述文件，该文件必须存放在 JAR 文件的 META-INF 目录下，该部署描述文件可以包含一切可以在 web.xml 中定义的内容。JAR 包通常放在 WEB-INF/lib 目录下，除此之外，所有该模块使用的资源，包括 class 文件、配置文件等，只需要能够被容器的类加载器链加载的路径上，比如 classes 目录等。
现在，为一个 Web 应用增加一个 Servlet 配置有如下三种方式 ( 过滤器、监听器与 Servlet 三者的配置都是等价的，故在此以 Servlet 配置为例进行讲述，过滤器和监听器具有与之非常类似的特性 )：
编写一个类继承自 HttpServlet，将该类放在 classes 目录下的对应包结构中，修改 web.xml，在其中增加一个 Servlet 声明。这是最原始的方式；
编写一个类继承自 HttpServlet，并且在该类上使用 @WebServlet 注解将该类声明为 Servlet，将该类放在 classes 目录下的对应包结构中，无需修改 web.xml 文件。
编写一个类继承自 HttpServlet，将该类打成 JAR 包，并且在 JAR 包的 META-INF 目录下放置一个 web-fragment.xml 文件，该文件中声明了相应的 Servlet 配置。
web-fragment.xml 文件示例如下：
<?xml version="1.0" encoding="UTF-8"?> <web-fragment xmlns=http://java.sun.com/xml/ns/javaee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="3.0" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd" metadata-complete="true"> <servlet> <servlet-name>fragment</servlet-name> <servlet-class>footmark.servlet.FragmentServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>fragment</servlet-name> <url-pattern>/fragment</url-pattern> </servlet-mapping> </web-fragment>
从上面的示例可以看出，web-fragment.xml 与 web.xml 除了在头部声明的 XSD 引用不同之外，其主体配置与 web.xml 是完全一致的。
由于一个 Web 应用中可以出现多个 web-fragment.xml 声明文件，加上一个 web.xml 文件，加载顺序问题便成了不得不面对的问题。Servlet 规范的专家组在设计的时候已经考虑到了这个问题，并定义了加载顺序的规则。
web-fragment.xml 包含了两个可选的顶层标签，
<web-fragment...> <name>FragmentA</name> <ordering> <after> <name>FragmentB</name> <name>FragmentC</name> </after> <before> <others/> </before> </ordering> ... </web-fragment>
如上所示，
在
<after> <name>FragmentB</name> <name>FragmentC</name> </after>
以上片段则表示当前文件必须在 FragmentB 和 FragmentC 之后解析。
除了将所比较的文件通过
ServletContext 的性能增强
除了以上的新特性之外，ServletContext 对象的功能在新版本中也得到了增强。现在，该对象支持在运行时动态部署 Servlet、过滤器、监听器，以及为 Servlet 和过滤器增加 URL 映射等。以 Servlet 为例，过滤器与监听器与之类似。ServletContext 为动态配置 Servlet 增加了如下方法：
ServletRegistration.Dynamic addServlet(String servletName,Class servletClass)
ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet)
ServletRegistration.Dynamic addServlet(String servletName, String className)
ServletRegistration getServletRegistration(String servletName)
Map
其中前三个方法的作用是相同的，只是参数类型不同而已；通过 createServlet() 方法创建的 Servlet，通常需要做一些自定义的配置，然后使用 addServlet() 方法来将其动态注册为一个可以用于服务的 Servlet。两个 getServletRegistration() 方法主要用于动态为 Servlet 增加映射信息，这等价于在 web.xml( 抑或 web-fragment.xml) 中使用
以上 ServletContext 新增的方法要么是在 ServletContextListener 的 contexInitialized 方法中调用，要么是在 ServletContainerInitializer 的 onStartup() 方法中调用。
ServletContainerInitializer 也是 Servlet 3.0 新增的一个接口，容器在启动时使用 JAR 服务 API(JAR Service API) 来发现 ServletContainerInitializer 的实现类，并且容器将 WEB-INF/lib 目录下 JAR 包中的类都交给该类的 onStartup() 方法处理，我们通常需要在该实现类上使用 @HandlesTypes 注解来指定希望被处理的类，过滤掉不希望给 onStartup() 处理的类。
HttpServletRequest 对文件上传的支持
此前，对于处理上传文件的操作一直是让开发者头疼的问题，因为 Servlet 本身没有对此提供直接的支持，需要使用第三方框架来实现，而且使用起来也不够简单。如今这都成为了历史，Servlet 3.0 已经提供了这个功能，而且使用也非常简单。为此，HttpServletRequest 提供了两个方法用于从请求中解析出上传的文件：
Part getPart(String name) Collection<Part> getParts()
前者用于获取请求中给定 name 的文件，后者用于获取所有的文件。每一个文件用一个 javax.servlet.http.Part 对象来表示。该接口提供了处理文件的简易方法，比如 write()、delete() 等。至此，结合 HttpServletRequest 和 Part 来保存上传的文件变得非常简单，如下所示：
Part photo = request.getPart("photo");
photo.write("/tmp/photo.jpg");
// 可以将两行代码简化为 request.getPart("photo").write("/tmp/photo.jpg") 一行。另外，开发者可以配合前面提到的 @MultipartConfig 注解来对上传操作进行一些自定义的配置，比如限制上传文件的大小，以及保存文件的路径等。其用法非常简单，故不在此赘述了。
需要注意的是，如果请求的 MIME 类型不是 multipart/form-data，则不能使用上面的两个方法，否则将抛异常。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
