Shulou(Shulou.com)06/02 Report--

This article is to share with you the content of a sample analysis of Servlet 3.0 features in Web application development. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

Asynchronous processing support

Before Servlet 3.0, the main workflow of an ordinary Servlet is roughly as follows: first, after the Servlet receives the request, it may need to preprocess the data carried by the request; then, some methods of the business interface are called to complete the business processing; *, the response is submitted according to the result of the processing, and the Servlet thread ends.

The second step of the business process is usually the most time-consuming, which is mainly reflected in database operations and other cross-network calls, in which the Servlet thread is blocked until the business method is executed. In the process of processing business, Servlet resources have been occupied and can not be released, which may cause performance bottlenecks for applications with large concurrency. In the past, it was common to use a proprietary solution to terminate Servlet threads early and release resources in a timely manner.

Servlet 3.0 has done pioneering work on this problem. Now, by using the asynchronous processing support of Servlet 3.0, the previous Servlet processing flow can be adjusted to the following process: first, after Servlet receives the request, it may first need to preprocess the data carried by the request. Then, the Servlet thread transfers the request to an asynchronous thread to perform business processing, and the thread itself returns to the container. At this time, the Servlet has not yet generated the response data. After the asynchronous thread has finished processing the business, it can directly generate the response data (the asynchronous thread has references to ServletRequest and ServletResponse objects), or forward the request to other Servlet. In this way, the Servlet thread is no longer in a blocking state waiting for the business logic to process, but can return immediately after starting the asynchronous thread.

The asynchronous processing feature can be applied to both Servlet and filter components. Because the working mode of asynchronous processing is essentially different from the normal working mode, Servlet and filter do not enable the asynchronous processing feature by default. If you want to use this feature, you must enable it as follows:

For cases where Servlet and filters are configured using traditional deployment description files (web.xml), Servlet 3.0 adds a child tag to the and tag, which defaults to false. To enable asynchronous processing support, set it to true. Take Servlet as an example, its configuration is as follows:

DemoServlet footmark.servlet.DemoServlet true

For cases where @ WebServlet and @ WebFilter provided by Servlet 3.0 are used for Servlet or filter configuration, both annotations provide the asyncSupported attribute, which defaults to false. To enable asynchronous processing support, simply set this attribute to true. Take @ WebFilter as an example, the configuration is as follows:

@ WebFilter (urlPatterns= "/ demo", asyncSupported=true) publicclassDemoFilterimplementsFilter {...}

An example of a simple Servlet that simulates asynchronous processing is as follows:

@ WebServlet (urlPatterns= "/ demo", asyncSupported=true) publicclassAsyncDemoServletextendsHttpServlet {@ Override publicvoiddoGet (HttpServletRequestreq,HttpServletResponseresp) throwsIOException,ServletException {resp.setContentType ("text/html;charset=UTF-8"); PrintWriterout=resp.getWriter (); out.println ("time to enter Servlet:" + newDate () + "."); out.flush (); / / executes the business call in the child thread and is responsible for outputting the response, and the main thread exits AsyncContextctx=req.startAsync (); newThread (newExecutor (ctx)). Start () Out.println ("time to end Servlet:" + newDate () + ".); out.flush ();}} publicclassExecutorimplementsRunnable {privateAsyncContextctx=null; publicExecutor (AsyncContextctx) {this.ctx=ctx;} publicvoidrun () {try {/ / wait ten seconds to simulate the execution of a business method Thread.sleep (10000); PrintWriterout=ctx.getResponse (). GetWriter (); out.println (" time of business processing: "+ newDate () +".); out.flush () Ctx.complete ();} catch (Exceptione) {e.printStackTrace ();}

In addition, Servlet 3.0 provides a listener for asynchronous processing, which is represented by the AsyncListener interface. It can monitor the following four events:

1. When the asynchronous thread starts, call the onStartAsync (AsyncEventevent) method of AsyncListener

two。 When an asynchronous thread goes wrong, call the onError (AsyncEventevent) method of AsyncListener

3. If the asynchronous thread times out, the onTimeout (AsyncEventevent) method of AsyncListener is called.

4. When the asynchronous execution is complete, call the onComplete (AsyncEventevent) method of AsyncListener

To register an AsyncListener, simply pass the prepared AsyncListener object to the addListener () method of the AsyncContext object, as follows:

AsyncContextctx=req.startAsync (); ctx.addListener (newAsyncListener () {publicvoidonComplete (AsyncEventasyncEvent) throwsIOException {/ / do some cleaning or other}.})

New annotation support

The top-level tag of the deployment description file web.xml for Servlet 3.0 has a metadata-complete attribute that specifies whether the current deployment description file is complete. If set to true, the container will only rely on the deployment description file during deployment, ignoring all comments (also skip web-fragment.xml scanning, that is, disable pluggability support, see the following explanation on pluggability support); if you do not configure this attribute, or set it to false, it means that annotation support (and pluggability support) is enabled.

@ WebServlet

@ WebServlet is used to declare a class as Servlet, the annotation will be processed by the container at deployment time, and the container will deploy the corresponding class as Servlet according to the specific property configuration. This annotation has some of the common attributes given in the following table (all of the following properties are optional, but vlaue or urlPatterns are usually required and cannot co-exist, and if specified at the same time, the value of value is usually ignored):

Attribute name type description

1.nameString specifies the name property of Servlet, which is equivalent to. If not explicitly specified, the value of the Servlet is the fully qualified name of the class.

2.valueString [] this attribute is equivalent to the urlPatterns attribute. Two properties cannot be used at the same time.

3.urlPatternsString [] specifies a set of URL matching patterns for Servlet. Equivalent to a label.

4.loadOnStartupint specifies the loading order of the Servlet, which is equivalent to the label.

5.initParamsWebInitParam [] specifies a set of Servlet initialization parameters, which are equivalent to labels.

6.asyncSupportedboolean declares whether Servlet supports asynchronous operation mode, which is equivalent to tags.

7.descriptionString the description of the Servlet, which is equivalent to the tag.

8.displayNameString the display name of the Servlet, usually used with tools, is equivalent to a label.

Here is a simple example:

@ WebServlet (urlPatterns= {"/ simple"}, asyncSupported=true, loadOnStartup=-1,name= "SimpleServlet", displayName= "ss", initParams= {@ WebInitParam (name= "username", value= "tom")}) publicclassSimpleServletextendsHttpServlet {… }

After this configuration, there is no need to configure the corresponding and elements in web.xml, and the container publishes the class as Servlet based on the specified properties at deployment time. Its equivalent web.xml configuration is as follows:

Ss SimpleServlet footmark.servlet.SimpleServlet-1 true username tom SimpleServlet / simple

@ WebInitParam

This annotation is usually not used alone, but in conjunction with @ WebServlet or @ WebFilter. Its function is to specify initialization parameters for the Servlet or filter, which is equivalent to the child tags neutralized by web.xml. @ WebInitParam has some common properties given in the following table:

Whether the attribute name type has an optional description

◆ nameString does not specify the name of the parameter, which is equivalent to.

◆ valueString does not specify the value of the parameter, which is equivalent to.

◆ descriptionString is a description of parameters, which is equivalent to.

@ WebFilter

@ WebFilter is used to declare a class as a filter, the annotation will be processed by the container at deployment time, and the container will deploy the corresponding class as a filter according to the specific property configuration. This annotation has some common attributes given in the following table (all of the following attributes are optional, but value, urlPatterns, and servletNames must contain at least one, and value and urlPatterns cannot coexist. If specified at the same time, the value of value is usually ignored):

Attribute name type description

1.filterNameString specifies the name property of the filter, which is equivalent to.

2.valueString [] this attribute is equivalent to the urlPatterns attribute. But both should not be used at the same time.

3.urlPatternsString [] specifies the URL matching pattern for a set of filters. Equivalent to a label.

4.servletNamesString [] specifies which Servlet the filter will be applied to. The value is either the value of the name attribute in @ WebServlet or the value of web.xml.

5.dispatcherTypesDispatcherType specifies the forwarding mode of the filter. Specific values include:

◆ ASYNC 、 ERROR 、 FORWARD 、 INCLUDE 、 REQUEST .

◆ initParamsWebInitParam [] specifies a set of filter initialization parameters, which are equivalent to labels.

◆ asyncSupportedboolean declares whether the filter supports asynchronous operation mode, which is equivalent to the tag.

◆ descriptionString the description of the filter, equivalent to the label.

◆ displayNameString the display name of this filter, usually used with tools, is equivalent to a label.

Here is a simple example:

@ WebFilter (servletNames= {"SimpleServlet"}, filterName= "SimpleFilter") publicclassLessThanSixFilterimplementsFilter {...}

After this configuration, there is no need to configure the corresponding and elements in web.xml, and the container publishes the class as a filter based on the specified properties at deployment time. The configuration form in its equivalent web.xml is:

SimpleFilter xxx SimpleFilter SimpleServlet

@ WebListener

This annotation is used to declare a class as a listener, and the class annotated by @ WebListener must implement at least one of the following interfaces:

ServletContextListener ServletContextAttributeListener ServletRequestListener ServletRequestAttributeListener HttpSessionListener HttpSessionAttributeListener

This annotation is very easy to use and has the following properties:

Whether the attribute name type has an optional description

ValueString is the description of the listener.

A simple example is as follows:

@ WebListener ("Thisisonlyademolistener") publicclassSimpleListenerimplementsServletContextListener {...}

In this way, there is no need to configure tags in web.xml. The configuration form in its equivalent web.xml is as follows:

Footmark.servlet.SimpleListener

@ MultipartConfig

The main purpose of this note is to supplement the support for uploading files provided by HttpServletRequest in Servlet 3.0. This comment is annotated on the Servlet to indicate that the MIME type of the request that the Servlet wants to process is multipart/form-data. In addition, it provides several attributes to simplify the processing of uploaded files. The details are as follows:

Whether the attribute name type has an optional description

◆ fileSizeThresholdint is when the amount of data is greater than this value, the content will be written to the file.

◆ locationString is the address where the generated files are stored.

◆ maxFileSizelong is the file * * value allowed to be uploaded. The default value is-1, which means there is no limit.

◆ maxRequestSizelong is the number of * * requests for this multipart/form-data. The default value is-1, which means there is no limit.

Pluggable support

If the new annotation support in version 3.0 is to simplify the declaration of Servlet/ filters / listeners, thus making web.xml an optional configuration, the new pluggability support takes the flexibility of Servlet configuration to a new level. Developers familiar with Struts2 know that Struts2 provides support for various development frameworks, including Spring, in the form of plug-ins, and developers can even develop plug-ins for Struts2 themselves, and the plug-in support of Servlet is based on this idea. Using this feature, we can now expand the new functions without modifying the existing Web applications, as long as we put the JAR package in a certain format into the WEB-INF/lib directory, without additional configuration.

Servlet 3.0 introduces a web-fragment.xml deployment description file called "Web module deployment descriptor fragment", which must be stored in the META-INF directory of the JAR file, which can contain everything that can be defined in web.xml. The JAR package is usually placed in the WEB-INF/lib directory, but in addition, all the resources used by the module, including class files, configuration files, and so on, only need to be on a path that can be loaded by the container's classloader chain, such as the classes directory.

Now, there are three ways to add a Servlet configuration to a Web application (the configurations of filter, listener and Servlet are all equivalent, so take Servlet configuration as an example. Filters and listeners have very similar features):

1. Write a class that inherits from HttpServlet, place the class in the corresponding package structure under the classes directory, modify web.xml, and add a Servlet declaration to it. This is the most primitive way.

two。 Write a class that inherits from HttpServlet and declare the class as Servlet using the @ WebServlet annotation on it, placing it in the corresponding package structure under the classes directory without modifying the web.xml file.

3. Write a class that inherits from HttpServlet, package the class into a JAR package, and place a web-fragment.xml file in the META-INF directory of the JAR package that declares the corresponding Servlet configuration. Examples of web-fragment.xml files are as follows:

Fragment footmark.servlet.FragmentServlet fragment / fragment

As you can see from the above example, the body configuration of web-fragment.xml and web.xml is exactly the same as web.xml, except for the different XSD references declared in the header. Because multiple web-fragment.xml declaration files can appear in a Web application, plus a web.xml file, the problem of loading order has become a problem that has to be faced. The expert group on the Servlet specification has taken this issue into account when designing and defined the rules for the loading order.

Web-fragment.xml contains two optional top-level tags, and, if you want to specify a clear load order for the current file, you usually need to use these two tags, mainly to identify the current file, and to specify the order. A simple example is as follows:

FragmentA FragmentB FragmentC...

As shown above, the value of the tag is usually referenced by other web-fragment.xml files when defining the order, which is generally not needed in the current file, and serves to identify the current file. Inside the tag, we can define the relative location of the current web-fragment.xml file to other files, mainly through the and child tags. Within these two child tags, you can specify the corresponding files through tags. For example:

FragmentB FragmentC

The above fragment indicates that the current file must be parsed after FragmentB and FragmentC. It means that the current file must be earlier than the web-fragment.xml file listed in the tag. In addition to listing the compared files in and, Servlet provides a simplified tag. It represents all web-fragment.xml files except the current one. The label takes precedence over the use of explicitly specified relative position relationships.

Performance Enhancement of ServletContext

In addition to the above new features, the functionality of the ServletContext object has also been enhanced in the new version. The object now supports the dynamic deployment of Servlet, filters, listeners at run time, and the addition of URL mappings to Servlet and filters. In the case of Servlet, filters and listeners are similar. ServletContext adds the following methods to dynamically configure Servlet:

◆ ServletRegistration.DynamicaddServlet (StringservletName,Class

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.