Detaillierte Analyse der neuen Funktionen von Java Servlet3

In diesem Artikel werden hauptsächlich relevante Informationen zu den neuen Funktionen von Servlet3 im Detail vorgestellt, die einen gewissen Referenzwert haben.

Übersicht über die neuen Funktionen von Servlet 3.0

Servlet 3.0 ist Mitglied des Java EE 6-Spezifikationssystems und wurde zusammen mit der Java EE 6-Spezifikation veröffentlicht. Diese Version bietet mehrere neue Funktionen basierend auf der Vorgängerversion (Servlet 2.5), um die Entwicklung und Bereitstellung von Webanwendungen zu vereinfachen. Die Einführung mehrerer Funktionen hat die Entwickler sehr begeistert und auch von der Java-Community gelobt:

1. Unterstützung für asynchrone Verarbeitung: Mit dieser Funktion müssen Servlet-Threads nicht mehr blockiert werden bis die Geschäftsverarbeitung abgeschlossen ist, bevor die Antwort ausgegeben werden kann, und schließlich der Servlet-Thread beendet wird. Nach Erhalt der Anforderung kann der Servlet-Thread den zeitaufwändigen Vorgang an einen anderen Thread delegieren, um ihn abzuschließen und zum Container zurückzukehren, ohne eine Antwort zu generieren. In Situationen, in denen die Geschäftsverarbeitung zeitaufwändig ist, wird dadurch die Belegung der Serverressourcen erheblich reduziert und die Geschwindigkeit der gleichzeitigen Verarbeitung erhöht.
2. Neue Annotationsunterstützung: Diese Version fügt mehrere neue Annotationen hinzu, um die Deklaration von Servlets, Filtern (Filter) und Listenern (Listener) zu vereinfachen, wodurch die Bereitstellungsbeschreibungsdatei web.xml ab dieser Version nicht mehr erforderlich ist .
3. Plugability-Unterstützung: Entwickler, die mit Struts2 vertraut sind, werden sich definitiv an die Integrationsfunktionen mit verschiedenen häufig verwendeten Frameworks, einschließlich Spring, über Plug-Ins erinnern. Kapseln Sie die entsprechenden Plug-Ins in JAR-Pakete und platzieren Sie sie im Klassenpfad. Struts2 kann diese Plug-Ins beim Ausführen automatisch laden. Jetzt bietet Servlet 3.0 ähnliche Funktionen. Entwickler können die Funktionen vorhandener Webanwendungen problemlos durch Plug-Ins erweitern, ohne die ursprüngliche Anwendung zu ändern.
Im Folgenden werden wir diese neuen Funktionen einzeln erläutern. Durch die folgende Studie werden die Leser in der Lage sein, die Änderungen in Servlet 3.0 klar zu verstehen und es reibungslos für die tägliche Entwicklungsarbeit zu nutzen.

Asynchrone Verarbeitung unterstützt

Vor Servlet 3.0 war der Hauptworkflow eines gewöhnlichen Servlets ungefähr wie folgt: Erstens, nachdem das Servlet die empfangen hat Bei einer Anfrage ist möglicherweise eine gewisse Vorverarbeitung der von der Anfrage übertragenen Daten erforderlich. Anschließend werden bestimmte Methoden der Geschäftsschnittstelle aufgerufen, um die Geschäftsverarbeitung abzuschließen. Anschließend wird die Antwort basierend auf den Verarbeitungsergebnissen übermittelt und der Servlet-Thread beendet. Der zweite Schritt der Geschäftsverarbeitung ist normalerweise der zeitaufwändigste, was sich hauptsächlich in Datenbankoperationen und anderen netzwerkübergreifenden Aufrufen widerspiegelt. Während dieses Prozesses bleibt der Servlet-Thread blockiert, bis die Geschäftsmethode ausgeführt wird. Während der Geschäftsverarbeitung sind Servlet-Ressourcen immer belegt und können nicht freigegeben werden. Bei Anwendungen mit großer Parallelität kann dies zu Leistungsengpässen führen. In diesem Zusammenhang wurden in der Vergangenheit normalerweise private Lösungen verwendet, um den Servlet-Thread vorzeitig zu beenden und Ressourcen rechtzeitig freizugeben.
Servlet 3.0 hat bahnbrechende Arbeit an diesem Problem geleistet. Durch die Verwendung der asynchronen Verarbeitungsunterstützung von Servlet 3.0 kann der bisherige Servlet-Verarbeitungsablauf an den folgenden Prozess angepasst werden: Erstens, nachdem das Servlet die Anfrage empfangen hat, benötigt es möglicherweise zuerst Um die Anfrage zu verarbeiten, werden die übertragenen Daten einer gewissen Vorverarbeitung unterzogen. Anschließend überträgt der Servlet-Thread die Anfrage an einen asynchronen Thread, um die Geschäftsverarbeitung durchzuführen. Zu diesem Zeitpunkt hat das Servlet noch keine Antwortdaten generiert Nachdem der asynchrone Thread das Geschäft verarbeitet hat, kann er direkt Antwortdaten generieren (der asynchrone Thread verfügt über Verweise auf die Objekte ServletRequest und ServletResponse) oder die Anforderung wird weiterhin an andere Servlets weitergeleitet. Auf diese Weise ist der Servlet-Thread nicht länger blockiert und wartet auf die Verarbeitung der Geschäftslogik, sondern kann sofort nach dem Start des asynchronen Threads zurückkehren.

Die asynchrone Verarbeitungsfunktion kann sowohl auf Servlet- als auch auf Filterkomponenten angewendet werden, da es einen wesentlichen Unterschied in der Implementierung zwischen dem Arbeitsmodus der asynchronen Verarbeitung und dem normalen Arbeitsmodus, standardmäßig Servlet und Filter, gibt Die asynchrone Verarbeitungsfunktion ist nicht aktiviert. Wenn Sie diese Funktion verwenden möchten, müssen Sie sie wie folgt aktivieren:

1. Zum Konfigurieren von Servlets und Filtern mithilfe herkömmlicher Bereitstellungsdeskriptoren (web.xml). In diesem Fall fügt Servlet 3.0 den Untertag 46309ed845064fdb06e746051efff9e0 hinzu. Um die Unterstützung für die asynchrone Verarbeitung zu aktivieren, setzen Sie ihn auf „true“. Am Beispiel von Servlet lautet die Konfiguration

wie folgt:

<servlet> 
 <servlet-name>DemoServlet</servlet-name> 
 <servlet-class>footmark.servlet.Demo Servlet</servlet-class> 
 <async-supported>true</async-supported> 
</servlet>

Zur Verwendung von @WebServlet und @WebFilter, bereitgestellt von Servlet 3.0 Im Falle einer Servlet- oder Filterkonfiguration stellen beide Annotationen das Attribut asyncSupported bereit. Der Standardwert dieses Attributs ist false. Um die Unterstützung der asynchronen Verarbeitung zu aktivieren, setzen Sie dieses Attribut einfach auf true. Am Beispiel von @WebFilter lautet die Konfiguration wie folgt:

@WebFilter(urlPatterns = "/demo",asyncSupported = true) 
public class DemoFilter implements Filter{...}

Ein einfaches Servlet-Beispiel, das asynchrone Verarbeitung simuliert, lautet wie folgt:

@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();
 }
 }
}

Darüber hinaus stellt Servlet 3.0 auch einen Listener für die asynchrone Verarbeitung bereit, dargestellt durch die AsyncListener-Schnittstelle. Es kann die folgenden vier Ereignisse überwachen:

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 的顶层标签 8459cedd22f378aa35db2cd2b63decac 有一个 metadata-complete 属性，该属性指定当前的部署描述文件是否是完全的。如果设置为 true，则容器在部署时将只依赖部署描述文件，忽略所有的注解（同时也会跳过 web-fragment.xml 的扫描，亦即禁用可插性支持）；如果不配置该属性，或者将其设置为 false，则表示启用注解支持（和可插性支持）。

@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 中配置相应的 46309ed845064fdb06e746051efff9e0 和 870ae7edaa11700bcea972d006efb06e 元素了，容器会在部署时根据指定的属性将该类发布为 Servlet。它的等价的 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 中 46309ed845064fdb06e746051efff9e0 和 1d24e586ca31f4bd05eca427459d98c7 的 380fae52cc7d04565d26dd4bbf4b5460 子标签。@WebInitParam 具有下表给出的一些常用属性：

表 2. @WebInitParam 的常用属性

@WebFilter

@WebFilter 用于将一个类声明为过滤器，该注解将会在部署时被容器处理，容器将根据具体的属性配置将相应的类部署为过滤器。该注解具有下表给出的一些常用属性 ( 以下所有属性均为可选属性，但是 value、urlPatterns、servletNames 三者必需至少包含一个，且 value 和 urlPatterns 不能共存，如果同时指定，通常忽略 value 的取值 )：

表 3. @WebFilter 的常用属性

下面是一个简单的示例：

@WebFilter(servletNames = {"SimpleServlet"},filterName="SimpleFilter") 
public class LessThanSixFilter implements Filter{...}

如此配置之后，就可以不必在 web.xml 中配置相应的 1d24e586ca31f4bd05eca427459d98c7 和 dd0dfb26ea66647667f179a739921d33 元素了，容器会在部署时根据指定的属性将该类发布为过滤器。它等价的 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 中配置 eae7f28921fa176b20e23abb843be090 标签了。它等价的 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 包含了两个可选的顶层标签，8a11bc632ea32a57b3e3693c7987c420 和 792ac9b21a68bcc1f9ef5893f6dde014，如果希望为当前的文件指定明确的加载顺序，通常需要使用这两个标签，8a11bc632ea32a57b3e3693c7987c420 主要用于标识当前的文件，而 792ac9b21a68bcc1f9ef5893f6dde014 则用于指定先后顺序。一个简单的示例如下：

<web-fragment...>
 <name>FragmentA</name>
 <ordering>
  <after>
   <name>FragmentB</name>
   <name>FragmentC</name>
  </after>
 <before>
  <others/>
 </before>
 </ordering>
 ...
</web-fragment>

如上所示， 8a11bc632ea32a57b3e3693c7987c420 标签的取值通常是被其它 web-fragment.xml 文件在定义先后顺序时引用的，在当前文件中一般用不着，它起着标识当前文件的作用。

在 792ac9b21a68bcc1f9ef5893f6dde014 标签内部，我们可以定义当前 web-fragment.xml 文件与其他文件的相对位置关系，这主要通过 792ac9b21a68bcc1f9ef5893f6dde014 的 cbc918db1beed770b0e53b074ad87b15 和 963388cc8d4734180f4322c2b988d8a2 子标签来实现的。在这两个子标签内部可以通过 8a11bc632ea32a57b3e3693c7987c420 标签来指定相对应的文件。比如：

<after> 
 <name>FragmentB</name> 
 <name>FragmentC</name> 
</after>

以上片段则表示当前文件必须在 FragmentB 和 FragmentC 之后解析。963388cc8d4734180f4322c2b988d8a2 的使用于此相同，它所表示的是当前文件必须早于 963388cc8d4734180f4322c2b988d8a2 标签里所列出的 web-fragment.xml 文件。
除了将所比较的文件通过 8a11bc632ea32a57b3e3693c7987c420 在 cbc918db1beed770b0e53b074ad87b15 和 c15bac5f29418fadf3ed61a82491f55a 中列出之外，Servlet 还提供了一个简化的标签 97a887bdc94bec64e0472c45c3e63cd4。它表示除了当前文件之外的其他所有的 web-fragment.xml 文件。该标签的优先级要低于使用 8a11bc632ea32a57b3e3693c7987c420 明确指定的相对位置关系。

ServletContext 的性能增强

除了以上的新特性之外，ServletContext 对象的功能在新版本中也得到了增强。现在，该对象支持在运行时动态部署 Servlet、过滤器、监听器，以及为 Servlet 和过滤器增加 URL 映射等。以 Servlet 为例，过滤器与监听器与之类似。ServletContext 为动态配置 Servlet 增加了如下方法：

ServletRegistration.Dynamic addServlet(String servletName,Class67a2363d32a9733943a65b9e6b37ecfb servletClass)
ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet)
ServletRegistration.Dynamic addServlet(String servletName, String className)
fd2e4e87782626871a925874e70a40e2 T createServlet(Class8742468051c85b06f0a0af9e3e506b5c clazz)
ServletRegistration getServletRegistration(String servletName)
Map5701e386b66809fdf022d23cec5ee5b2 getServletRegistrations()

其中前三个方法的作用是相同的，只是参数类型不同而已；通过 createServlet() 方法创建的 Servlet，通常需要做一些自定义的配置，然后使用 addServlet() 方法来将其动态注册为一个可以用于服务的 Servlet。两个 getServletRegistration() 方法主要用于动态为 Servlet 增加映射信息，这等价于在 web.xml( 抑或 web-fragment.xml) 中使用 870ae7edaa11700bcea972d006efb06e 标签为存在的 Servlet 增加映射信息。

以上 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，则不能使用上面的两个方法，否则将抛异常。

Das obige ist der detaillierte Inhalt vonDetaillierte Analyse der neuen Funktionen von Java Servlet3. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!