Define Web. xml

1. Define the header and root element

The deployment descriptor file, like all XML files, must start with an XML header. This header declares the XML version that can be used and provides the character encoding of the file.
The DOCYTPE statement must appear immediately after this header. This Declaration tells the server the version of the applicable servlet specification (such as 2.2 or 2.3) and specifies the DTD (DocumentTypeDefinition, document type definition) that governs the syntax of the remaining part of the file ).
The top-level (Root) element of all deployment descriptor files is web-app. Please note that XML elements are case sensitive, Unlike HTML. Therefore, web-App and WEB-APP are invalid, web-app must be in lower case.

2. Deploy the element order in the descriptor File

XML elements are not only case sensitive, but also order sensitive to other elements. For example, the XML header must be the first item in the file, the DOCTYPE Declaration must be the second item, and the web-app element must be the third item. In web-app elements, the order of elements is also important. Servers do not necessarily require this order, but they promise (in fact some servers do this) to completely reject the execution of Web applications containing elements with incorrect order. This indicates that the web. xml file with non-standard element order cannot be transplanted.
The following list shows the order of all valid elements that can directly appear in the web-app element. For example, this list indicates that the servlet element must appear before all servlet-mapping elements. Note that all these elements are optional. Therefore, an element can be omitted, but it cannot be placed in an incorrect position.
The iconicon element specifies the location of one or two image files of a Web application using IDE and GUI tools.
The display-namedisplay-name element provides a GUI tool that may be used to mark the name of a specific Web application.
The descriptiondescription element provides descriptive text related to this.
The context-paramcontext-param element declares the initialization parameters within the application range.
The filter element associates a name with a class that implements the javax. servlet. Filter interface.
Once the filter-mapping name is a filter, use the filter-mapping element to associate it with one or more servlet or JSP pages.
The listenerservletAPI Version 2.3 adds support for the event listening program. The event listening program is notified when the session or servlet environment is created, modified, and deleted. The Listener element specifies the event Listener class.
When you specify initialization parameters or custom URLs for a servlet or JSP page, you must first name the servlet or JSP page. The Servlet element is used to complete this task.
The servlet-mapping server generally provides the servlet with a default URL: http: // host/webAppPrefix/servlet/ServletName. However, this URL is often changed so that the servlet can access initialization parameters or easily process relative URLs. When you change the default URL, use the servlet-mapping element.
Session-config if a session is not accessed for a certain period of time, the server can discard it to save memory. You can use the setMaxInactiveInterval method of HttpSession to explicitly set the timeout value for a single session object, or use the session-config element to specify the default timeout value.
Mime-mapping the MIME-mapping element provides this guarantee if a Web application wants to assign a specific mime type to an extraordinary file.
The welcom-file-listwelcome-file-list element indicates which file the server uses when it receives a URL that references a directory name rather than a file name.
The lerror-pageerror-page element allows you to specify the page to be displayed when a specific HTTP status code is returned or an exception of a specific type is thrown.
The taglibtaglib element specifies an alias for the taglibraryudescriptorfile. This feature allows you to change the location of TLD files without editing the JSP pages that use these files.
The resource-env-refresource-env-ref element declares a resource-related governance object.
The resource-refresource-ref element declares the external resources used by a resource factory.
The security-constraintsecurity-constraint element specifies the URL to be protected. It is used together with the login-config element.
Login-config uses the login-config element to specify how the server grants permissions to users attempting to access protected pages. It is used with the sercurity-constraint element.
The security-rolesecurity-role element provides a list of security roles that appear in the role-name sub-element of the security-role-ref element in the servlet element. Declaring roles separately makes it easier for advanced ide to process security information.
The env-entryenv-entry element declares the environment items of the Web application.
The EJB-refejb-ref element declares a reference to the main directory of an EJB.
The EJB-local-refejb-local-ref element declares the application of the local main directory of an EJB.

3. Name allocation and customized ul

One of the most common tasks completed in Web. XML is to give the servlet or JSP page names and custom URLs. Use the servlet element to assign a name, and use the servlet-mapping element to associate the custom URL with the name you just allocated.
3.1 allocation name
To provide initialization parameters, define a custom URL for the servlet or JSP page or assign a security role, you must first give the servlet or JSP page a name. You can assign a name through the servlet element. The most common formats include servlet-Name and servlet-class sub-elements (in the Web-app element), as shown below:
<Servlet>
<Servlet-Name> test </servlet-Name>
<Servlet-class> moreservlets. testservlet </servlet-class>
</Servlet>
This indicates that the servlet located in the WEB-INF/classes/moreservlets/testservlet has obtained the registration name test. A name for the servlet has two main meanings. First, initialize the parameter, customize the URL mode, and use this registration name instead of the class name to reference this servlet. Second, you can use this name in the URL rather than in the class name. Therefore, using the definition just given, urlhttp: // host/webappprefix/servlet/test can be used for http: // host/webappprefix/servlet/moreservlets. testservlet sites.
Remember: XML elements are not only case sensitive, but also important to define their order. For example, all servlet elements in the web-app element must be located before all servlet-mapping elements (described in the next section, it is also located before the elements (if any) related to filters or documents discussed in sections 5.6 and 5.11. Similarly, servlet-name sub-elements must appear before servlet-class. Section 5.2 "sequence of elements in the deployment descriptor file" describes the required sequence.
For example, the program listing 5-1 provides a simple servlet named TestServlet, which resides in the moreservlets package. Because this servlet is rooted in a part of the Web application in a directory named deployDemo, TestServlet. class is placed in deployDemo/WEB-INF/classes/moreservlets. The program listing 5-2 shows a part of the web. xml file that will be placed in deployDemo/WEB-INF. This web. xml file uses the servlet-name and servlet-class elements to associate the name Test with TestServlet. class. Figure 5-1 and figure 5-2 show the results when TestServlet is called using the default URL and Registration Name, respectively.

Program list 5-1TestServlet.java
Packagemoreservlets;

Importjava. io .*;
Importjavax. servlet .*;
Importjavax. servlet. http .*;

 

PublicclassTestServletextendsHttpServlet {
PublicvoiddoGet (HttpServletRequestrequest,
HttpServletResponseresponse)
ThrowsServletException, IOException {
Response. setContentType ("text/html ");
PrintWriterout = response. getWriter ();
Stringuri = request. getRequestURI ();
Out. println (ServletUtilities. headWithTitle ("TestServlet ")
"<BODYBGCOLOR =/" # FDF5E6/">/n"
"<H2> URI:" uri "</H2>/n"
"</BODY> </HTML> ");
}
}

Program list 5-2web.xml (excerpt from servlet name)
<? Xmlversion = "1.0" encoding = "ISO-8859-1"?>
<! DOCTYPEweb-app
PUBLIC "-// SunMicrosystems, Inc. // DTDWebApplication2.3 // EN"
Http://java.sun.com/dtd/web-app_2_3.dtd>

<Web-app>
<! --... -->
<Servlet>
<Servlet-name> Test </servlet-name>
<Servlet-class> moreservlets. testservlet </servlet-class>
</Servlet>
<! --... -->
</Web-app>

3.2 define custom URLs
Most servers have a default serlveturl:
Http: // host/webappprefix/servlet/packagename. servletname. Although it is convenient to use this URL during development, we often want another URL for deployment. For example, you may need a URL (such as http: // host/webappprefix/anyname) at the top layer of the Web application, and there is no servlet entry in the URL. The URL at the top layer simplifies the use of relative URLs. In addition, for many developers, the top-level URL seems to be shorter than the longer and more troublesome default URL.
In fact, you sometimes need to use custom URLs. For example, you may want to disable the default URL ing to better enforce security restrictions or prevent users from accidentally accessing servlets without initialization parameters. If you disable the default URL, how do you access the servlet? In this case, only custom URLs are used.
To assign a custom URL, you can use the servlet-mapping Element and Its servlet-Name and URL-pattern sub-elements. The servlet-name element provides an arbitrary name that can be used to reference the servlet. url-pattern describes the URL relative to the root directory of the Web application. The value of the URL-pattern element must start with a slash.
Below is a simple web. xml excerpt, which promises to use urlhttp: // host/webappprefix/urltest instead of http: // host/webappprefix/servlet/test or
Http: // host/webAppPrefix/servlet/moreservlets. TestServlet. Pay attention to the fact that XML headers, DOCTYPE declarations, and web-app closed elements are still required. In addition, we can recall that the order in which XML elements appear is not random. Specifically, all servlet elements need to be placed before all servlet-mapping elements.
<Servlet>
<Servlet-name> Test </servlet-name>
<Servlet-class> moreservlets. TestServlet </servlet-class>
</Servlet>
<! --... -->
<Servlet-mapping>
<Servlet-name> Test </servlet-name>
<Url-pattern>/UrlTest </url-pattern>
</Servlet-mapping>
The URL mode can also contain wildcards. For example, the following applet instructs the server to send all requests starting with the URL prefix of the Web application and ending with. asp to the servlet named BashMS.
<Servlet>
<Servlet-name> BashMS </servlet-name>
<Servlet-class> msUtils. ASPTranslator </servlet-class>
</Servlet>
<! --... -->
<Servlet-mapping>
<Servlet-name> BashMS </servlet-name>
<Url-pattern>

PublicclassSorryServletextendsHttpServlet {
PublicvoiddoGet (HttpServletRequestrequest,
HttpServletResponseresponse)
ThrowsServletException, IOException {
Response. setContentType ("text/html ");
PrintWriterout = response. getWriter ();
Stringtitle = "InvokerServletDisabled .";
Out. println (ServletUtilities. headWithTitle (title)
"<BODYBGCOLOR =/" # FDF5E6/">/n"
"<H2>" title "</H2>/n"
"Sorry, accesstoservletsbymeansof/n"
"URLsthatbeginwith/n"
"Http: // host/webAppPrefix/servlet // n"
"Hasbeendisabled./n"
"</BODY> </HTML> ");
}

Publicvoiddopost (httpservletrequestrequest,
Httpservletresponseresponse)
Throwsservletexception, ioexception {
Doget (request, response );
}
}

4.2 global inactivate: Tomcat
The method used to disable the default URL in Tomcat 4 is different from that used in Tomcat 3. The following two methods are described:
1. inactivate: tomcat4
Tomcat 4 closes the activator servlet in the same way as before, that is, it closes the servlet using the URL-mapping element in Web. xml. The difference is that Tomcat uses a server-specific global web in install_dir/CONF. XML file, which is previously used to store standard web in the WEB-INF directory of each web application. XML file.
Therefore, to disable the Enable servlet in Tomcat 4, you simply need to comment out the/servlet in install_dir/CONF/Web. xml.

Publicclassinitservletextendshttpservlet {
Privatestringfirstname, emailaddress;

Publicvoidinit (){
Servletconfigconfig = getservletconfig ();
Firstname = config. getinitparameter ("firstname ");
Emailaddress = config. getinitparameter ("emailaddress ");
}

PublicvoiddoGet (HttpServletRequestrequest,
HttpServletResponseresponse)
ThrowsServletException, IOException {
Response. setContentType ("text/html ");
PrintWriterout = response. getWriter ();
Stringuri = request. getRequestURI ();
Out. println (ServletUtilities. headWithTitle ("InitServlet ")
"<BODYBGCOLOR =/" # FDF5E6/">/n"
"<H2> InitParameters: </H2>/n"
"<UL>/n"
"<LI> Firstname:" firstName "/n"
"<LI> Emailaddress:" emailAddress "/n"
"</UL>/n"
"</BODY> </HTML> ");
}
}

Program list 5-8web.xml (excerpt from initialization parameters)
<? Xmlversion = "1.0" encoding = "ISO-8859-1"?>
<! DOCTYPEweb-app
PUBLIC "-// SunMicrosystems, Inc. // DTDWebApplication2.3 // EN"
Http://java.sun.com/dtd/web-app_2_3.dtd>

<Web-app>
<! --... -->
<Servlet>
<Servlet-name> InitTest </servlet-name>
<Servlet-class> moreservlets. InitServlet </servlet-class>
<Init-param>
<Param-name> firstName </param-name>
<Param-value> Larry </param-value>
</Init-param>
<Init-param>
<Param-name> emailAddress </param-name>
<Param-value> Ellison@Microsoft.com </param-value>
</Init-param>
</Servlet>
<! --... -->
</Web-app>

5.2 allocate JSP initialization parameters
Providing initialization parameters for the JSP page is different from providing initialization parameters for the servlet in three aspects.
1) use jsp-file instead of servlet-class. Therefore, the servlet elements in the WEB-INF/web. xml file are as follows:
<Servlet>
<Servlet-name> PageName </servlet-name>
<Jsp-file>/RealPage. jsp </jsp-file>
<Init-param>
<Param-name>... </param-name>
<Param-value>... </param-value>
</Init-param>
...
</Servlet>
2) almost always assign a clear URL pattern. For Servlets, the default URL starting with http: // host/webAppPrefix/servlet/is generally used. Remember to use the registration name instead of the original name. This is also technically legal for JSP pages. For example, in the preceding example, you can use URLhttp: // host/webAppPrefix/servlet/PageName to access the version of RealPage. jsp that has access to the initialization parameters. However, when using JSP pages, many users do not seem to like the general servlet URL. In this case, if the jsppage is stored in the directory (for example, the Directory of index. jsp file does not exist in index.html), the user may connect to the JSP page and click it to accidentally activate the uninitialized page. Therefore, the best way is to use url-pattern (section 5.3) to associate the original URL of the JSP page with the registered servlet name. In this way, the client can use the common name of the JSP page, but the custom version is still activated. For example, for a servlet definition from Project 1, you can use the following servlet-mapping definition:
<Servlet-mapping>
<Servlet-Name> pagename </servlet-Name>
<URL-pattern>/realpage. jsp </url-pattern>
</Servlet-mapping>
3) JSP pages use jspinit instead of init. The servlet automatically created from the JSP page may already use the Inti method. Therefore, using JSP Declaration to provide an init method is illegal and the jspinit method must be formulated.
To illustrate the process of initializing JSP pages, a JSP page named initpage. jsp is provided in listing 5-9. It contains a jspinit method and is placed on the top layer of the deploydemoweb application hierarchy. Generally, URLs in the form of http: // host/deploydemo/initpage. jsp will activate versions on this page that do not have access to initialization parameters, so as to display null for the firstname and emailaddress variables. However, a registration name is assigned to the Web. xml file (program list 5-10), and the registration name is associated with URL mode/initpage. jsp.

Program list 5-9initpage.jsp
<! Doctypehtmlpublic "-// W3C // dtdhtml4.0transitional // en">
<HTML>
<Head> <title> jspinittest </title> <Bodybgcolor = "# fdf5e6">
<H2> initparameters: </H2>
<Ul>
<LI> Firstname: <= firstName>
<LI> Emailaddress: <= emailAddress>
</UL>
</BODY> </HTML>
<!
PrivateStringfirstName, emailAddress;

PublicvoidjspInit (){
ServletConfigconfig = getServletConfig ();
FirstName = config. getInitParameter ("firstName ");
EmailAddress = config. getInitParameter ("emailAddress ");
}
>

Program list 5-10web.xml (excerpt from the init parameter on the JSP page)
<? Xmlversion = "1.0" encoding = "ISO-8859-1"?>
<! DOCTYPEweb-app
PUBLIC "-// SunMicrosystems, Inc. // DTDWebApplication2.3 // EN"
Http://java.sun.com/dtd/web-app_2_3.dtd>

<Web-app>
<! --... -->
<Servlet>
<Servlet-name> InitPage </servlet-name>
<Jsp-file>/InitPage. jsp </jsp-file>
<Init-param>
<Param-name> firstName </param-name>
<Param-value> Bill </param-value>
</Init-param>
<Init-param>
<Param-name> emailAddress </param-name>
<Param-value> gates@oracle.com </param-value>
</Init-param>
</Servlet>
<! --... -->
<Servlet-mapping>
<Servlet-name> InitPage </servlet-name>
<Url-pattern>/InitPage. jsp </url-pattern>
</Servlet-mapping>
<! --... -->
</Web-app>

5.3 provide initialization parameters within the scope of use
Generally, an initialization parameter is assigned to a single servlet or JSP page. The specified servlet or JSP page uses the getInitParameter method of ServletConfig to read these parameters. However, in some cases, you may want to provide system-wide initialization parameters that can be read by any servlet or JSP page using the getInitParameter method of ServletContext.
You can use the context-param element to declare the initialization values within these system ranges. The context-param element should contain param-name, param-value, and optional description sub-elements, as shown below:
<Context-param>
<Param-name> support-email </param-name>
<Param-value> blackhole@mycompany.com </param-value>
</Context-param>
You can recall that to ensure portability, elements in web. xml must be declared in the correct order. Note that the context-param element must appear after any document-related elements (icon, display-name, or description) and before the filter, filter-mapping, listener, or servlet elements.
5.4 load servlet at server startup
Assume that the servlet or JSP page has an init (servlet) or jspInit (JSP) method that takes a long time to execute. For example, if the init or jspInit method finds the output from a database or ResourceBundle. In this case, the default behavior of loading servlet at the first client request will cause a long delay for the first client. Therefore, you can use the servlet load-on-startup element to specify that the server will load the servlet at the first startup. The following is an example.
<Servlet>
<Servlet-name>... </Servlet-name>
<Servlet-class>... </Servlet-class> <! -- Orjsp-file -->
<Load-on-startup/>
</Servlet>
You can provide an integer for this element instead of an empty load-on-startup. The idea is that the server should load a few servlet or JSP pages before loading a large number of servlet or JSP pages. For example, the following servlet item (Web placed under the WEB-INF directory of the web application. the web-app element in the xml file) will instruct the server to first load and initialize the SearchServlet, and then load and initialize the index in the result directory of the Web application. the servlet generated by the jsp file.
<Servlet>
<Servlet-name> Search </servlet-name>
<Servlet-class> myPackage. SearchServlet </servlet-class> <! -- Orjsp-file -->
<Load-on-startup> 1 </load-on-startup>
</Servlet>
<Servlet>
<Servlet-name> Results </servlet-name>
<Servlet-class>/results/index. jsp </servlet-class> <! -- Orjsp-file -->
<Load-on-startup> 2 </load-on-startup>
</Servlet>

6. Declare a filter

Servlet Version 2.3 introduces the concept of filters. Although all servers that support servletAPI 2.3 Support filters, to use filter-related elements, you must use the DTD of Version 2.3 in web. xml.
Filters can intercept and modify requests that enter a servlet or JSP page or send requests from a servlet or JSP page. Before executing a servlet or JSP page, you must execute the doFilter method of the first related filter. When the filter calls doFilter for its FilterChain object, it executes the next filter in the chain. If no other filter exists, the servlet or JSP page is executed. Filters have full access to the ServletRequest object. Therefore, they can view the client name and find the cookie. To access the servlet or JSP page output, the filter can wrap the response object in a stand-inobject, for example, accumulating the output to a buffer. After calling the doFilter method of the FilterChain object, the filter can check the buffer. If necessary, modify the method and then transmit it to the client.
For example, a simple filter is difficult for the 5-11 empire, as long as you access the relevant servlet or JSP page, it intercepts requests and prints a Report on the standard output (most servers can use this filter when running on a desktop system during development ).

Program list 5-11ReportFilter.java
Packagemoreservlets;

Importjava. io .*;
Importjavax. servlet .*;
Importjavax. servlet. http .*;
Importjava. util .*;

 

PublicclassReportFilterimplementsFilter {
PublicvoiddoFilter (ServletRequestrequest,
ServletResponseresponse,
FilterChainchain)
ThrowsServletException, IOException {
HttpServletRequestreq = (HttpServletRequest) request;
System. out. println (req. getRemoteHost ()
"Triedtoaccess"
Req. getRequestURL ()
"On" newDate ()".");
Chain. doFilter (request, response );
}

Publicvoidinit (FilterConfigconfig)
ThrowsServletException {
}

Publicvoiddestroy (){}
}

Once a filter is created. in xml, use the filter element, filter-name (any name), file-class (fully qualified class name), and (optional) init-params sub-element to declare it. Please note that the elements are stored on the web. the order of the web-app elements in xml is not arbitrary; the Order required by the server (but not required) is required, and some servers actually do the same. Note that all filter elements must appear before any filter-mapping element, and the filter-mapping element must appear before all servlet or servlet-mapping elements.
For example, given the ReportFilter class, you can make the following filter declaration in web. xml. It associates the name Reporter with the actual class ReportFilter (located in the moreservlets package.
<Filter>
<Filter-name> Reporter </filter-name>
<Filter-class> moresevlets. ReportFilter </filter-class>
</Filter>
Once a filter is named, you can use the filter-mapping element to associate it with one or more servlet or JSP pages. There are two options for this job.
First, you can use the filter-name and servlet-name sub-elements to match this filter with a specific servlet name (this servlet name must be later in the same web. use the servlet element declaration in the xml file) for association. For example, the following program snippet indicates that the system runs a filter named Reporter as long as a custom URL is used to access the servlet or JSP page named SomeServletName.
<Filter-mapping>
<Filter-name> Reporter </filter-name>
<Servlet-name> SomeServletName </servlet-name>
</Filter-mapping>
Second, you can use the filter-name and url-pattern sub-elements to associate the filter with a set of servlet, JSP page, or static content. For example, the program fragment of the photo surface indicates that the system runs a filter named Reporter as long as it accesses any URL in the Web application.
<Filter-mapping>
<Filter-name> Reporter </filter-name>
<Url-pattern>

PublicclassContextReporterimplementsServletContextListener {
PublicvoidcontextInitialized (ServletContextEventevent ){
System. out. println ("Contextcreatedon"
NewDate ()".");
}

PublicvoidcontextDestroyed (ServletContextEventevent ){
System. out. println ("Contextdestroyedon"
NewDate ()".");
}
}

Program list 5-21web.xml (declare an excerpt from a listener)
<? Xmlversion = "1.0" encoding = "ISO-8859-1"?>
<! DOCTYPEweb-app
Public "-// sunmicrosystems, Inc. // dtdwebapplication2.3 // en"
Http://java.sun.com/dtd/web-app_2_3.dtd>

<Web-app>
<! --... -->
<Filter-mapping>... </Filter-mapping>
<Listener>
<Listener-class> package. listenerclass </listener-class>
</Listener>
<Servlet>... </servlet>
<! --... -->
</Web-app>

15j2ee Elements

This section describes the Web. XML elements used as part of the J2EE environment. A concise introduction is provided here. For details, refer.
Ldistributable
Distributable indicates that web applications are programmed in this way: servers supporting clusters can securely distribute web applications on multiple servers. For example, a distributed application must use only the serializable object as the attribute of its httpsession object and avoid using instance variables (fields) for continuity. The distributable element directly appears after the discription element and does not contain child elements or data. It is just a flag as follows.
<Distributable/>
Lresource-env-ref
The resource-env-ref element declares a resource-related governance object. This element is composed of an optional description element and a resource-env-ref-name element (a JNDI name relative to the java: comp/env Environment) and a resource-env-type element (specifying a fully qualified class of the resource type), as shown below:
<Resource-env-ref>
<Resource-env-ref-name>
Jms/StockQueue
</Resource-env-ref-name>
<Resource-env-ref-type>
Javax. jms. Queue
</Resource-env-ref-type>
</Resource-env-ref>
Lenv-entry
The env-entry element declares the environment items of the Web application. It consists of an optional description element, an env-entry-name element (a JNDI name relative to java: comp/env Environment), and an env-entry-value element (item value) and an env-entry-type element (java. A fully qualified class name of the type in the lang Package, java. lang. boolean, java. lang. string. The following is an example:
<Env-entry>
<Env-entry-name> minAmout </env-entry-name>
<Env-entry-value> 100.00 </env-entry-value>
<Env-entry-type> minAmout </env-entry-type>
</Env-entry>
Lejb-ref
The ejb-ref element declares the application to the main directory of an EJB. It consists of an optional description element, an ejb-ref-name element (compared to the java: comp/env EJB application), and an ejb-ref-type element (bean type, entity or Session), a home element (the fully qualified name of bean's main Directory Interface), and a remote element (the fully qualified name of bean's remote interface) and an optional ejb-link element (the name of another bean linked to the current bean.
Lejb-local-ref
The ejb-local-ref element declares a reference to the local directory of an EJB. Besides replacing home with local-home, this element has the same attributes as the ejb-ref element and is used in the same way.