Servlet表单数据
当前位置：
>> Servlet表单数据
Servlet表单数据
Servlets表单数据代码例子 - 浏览器使用两种方法可将此信息传递到Web服务器，分别为GET方法和POST方法。
很多情况下，需要传递一些信息，从浏览器到Web服务器，最终到后台程序。浏览器使用两种方法可将此信息传递到Web服务器，分别为GET方法和POST方法。
GET方法发送编码的用户信息添加到页面请求。页面并已编码的信息中作用 ？分离字符如下：
/hello?key1=value1&key2=value2
GET方法是默认的方法来传递信息，从浏览器到Web服务器，它会产生一个很长的字符串出现在浏览器的位置：框中。不要使用GET方法，如果你有密码或其他敏感信息传递给服务器。GET方法有大小限制：能够在一个请求字符串，只有1024个字符。
这个信息被传递使用QUERY_STRING头，将可以通过QUERY_STRING环境变量的servlet处理这种类型的请求使用doGet()方法。
POST 方法:
将信息传递给后端的程序一般比较可靠的方法是POST方法。这些软件包中的信息完全相同的方式为GET方法，而是把它发送一个文本字符串在？后，在URL中，它发送它作为一个单独的消息。This 此消息的形式，可以处理分析和使用标准输入到后台程序。servlet处理这种类型的请求使用doPost()方法。
使用Servlet读取表单数据:
Servlet的处理表单数据解析自动根据不同的情况使用下列方法：
getParameter():&&可以调用request.getParameter()方法的获取表单参数的值。
getParameterValues():&&调用此方法，如果参数出现一次以上，并返回多个值，例如“复选框“。
getParameterNames():&如果你想在当前请求的所有参数的完整列表，调用此方法。
使用URL GET方法示例:
下面是一个简单的URL，将传递两个值HelloForm程序，使用GET方法。
http://localhost:8080/HelloForm?first_name=ZARA&last_name=ALI
下面的servlet程序来处理HelloForm.java通过Web浏览器的输入，我们将使用getParameter()方法，这使得它很容易访问传递的信息：
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class -by
public class HelloForm extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Using GET Method to Read Form Data";
String docType =
"&!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\"&\n";
out.println(docType +
"&html&\n" +
"&head&&title&" + title + "&/title&&/head&\n" +
"&body bgcolor=\"#f0f0f0\"&\n" +
"&h1 align=\"center\"&" + title + "&/h1&\n" +
"&ul&\n" +
&li&&b&First Name&/b&: "
+ request.getParameter("first_name") + "\n" +
&li&&b&Last Name&/b&: "
+ request.getParameter("last_name") + "\n" +
"&/ul&\n" +
"&/body&&/html&");
假设你的环境设置正确，编译HelloForm.java如下：
$ javac HelloForm.java
如果一切顺利，上述编译会产生HelloForm.class的文件。接下来，你就必须复制这个类文件到&Tomcat-installation-directory&/webapps/ ROOT/WEB-INF/classes，创建web.xml文件中的条目，位于&Tomcat-installation-directory&/webapps/ROOT/WEB-INF/目录
&servlet-name&HelloForm&/servlet-name&
&servlet-class&HelloForm&/servlet-class&
&/servlet&
&servlet-mapping&
&servlet-name&HelloForm&/servlet-name&
&url-pattern&/HelloForm&/url-pattern&
&/servlet-mapping&
现在在浏览器的位置：框中输入http://localhost:8080/HelloForm?first_name=ZARA&last_name=ALI，确保已经启动Tomcat服务器，在浏览器上面的命令请求前。这将产生以下结果：
Using GET Method to Read Form Data
First Name: ZARA
Last Name: ALI
GET方法使用表单的示例：
下面是一个简单的例子，通过两个值，使用HTML表单和提交按钮。我们将使用相同Servlet的HelloForm处理此输入。
&form action="HelloForm" method="GET"&
First Name: &input type="text" name="first_name"&
Last Name: &input type="text" name="last_name" /&
&input type="submit" value="Submit" /&
保存这个HTML的文件将hello.htm，并把它放在&Tomcat-installation-directory&/webapps /目录根目录。当你想访问http://localhost:8080/Hello.htm，这里是上述形式的实际输出。
First Name:&&
Last Name:&&
尝试输入First Name和Last名称，然后单击“提交”按钮，在Tomcat运行在本地计算机上看到的结果。基于所提供的输入的，它会产生类似的结果，如在上面的例子中提到的。
使用表单POST方法示例：
让我们在上面的servlet做小的修改，以便它可以处理GET和POST方法。下面的servlet程序来处理HelloForm.java通过Web浏览器输入使用GET或POST方法。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Using GET Method to Read Form Data";
String docType =
"&!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\"&\n";
out.println(docType +
"&html&\n" +
"&head&&title&" + title + "&/title&&/head&\n" +
"&body bgcolor=\"#f0f0f0\"&\n" +
"&h1 align=\"center\"&" + title + "&/h1&\n" +
"&ul&\n" +
&li&&b&First Name&/b&: "
+ request.getParameter("first_name") + "\n" +
&li&&b&Last Name&/b&: "
+ request.getParameter("last_name") + "\n" +
"&/ul&\n" +
"&/body&&/html&");
// Method to handle POST method request.
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
现在，编译，部署上述的Servlet和测试它的使用将hello.htm与POST方法如下：
&form action="HelloForm" method="POST"&
First Name: &input type="text" name="first_name"&
Last Name: &input type="text" name="last_name" /&
&input type="submit" value="Submit" /&
下面是实际的输出上面的形式，尝试进入第一个和最后一个名称，然后单击“提交”按钮，在Tomcat运行在本地计算机上看到的结果。
基于提供的输入，将产生类似的结果，如在上述例子中提到。
将复选框数据传递到Servlet程序
复选框被使用时，须选择一个以上的选项。
下面是一个例子HTML代码，CheckBox.htm两个复选框的形式，
&form action="CheckBox" method="POST" target="_blank"&
&input type="checkbox" name="maths" checked="checked" /& Maths
&input type="checkbox" name="physics"
/& Physics
&input type="checkbox" name="chemistry" checked="checked" /&
&input type="submit" value="Select Subject" /&
这段代码的结果是以下表格
&Maths&&Physics&&Chemistry&
下面的servlet程序来处理CheckBox.java输入的网页浏览器“复选框按钮“。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CheckBox extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading Checkbox Data";
String docType =
"&!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\"&\n";
out.println(docType +
"&html&\n" +
"&head&&title&" + title + "&/title&&/head&\n" +
"&body bgcolor=\"#f0f0f0\"&\n" +
"&h1 align=\"center\"&" + title + "&/h1&\n" +
"&ul&\n" +
&li&&b&Maths Flag : &/b&: "
+ request.getParameter("maths") + "\n" +
&li&&b&Physics Flag: &/b&: "
+ request.getParameter("physics") + "\n" +
&li&&b&Chemistry Flag: &/b&: "
+ request.getParameter("chemistry") + "\n" +
"&/ul&\n" +
"&/body&&/html&");
// Method to handle POST method request.
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
对于上面的例子中，它会显示以下结果：
Reading Checkbox Data
Maths Flag :&: on
Physics Flag:&: null
Chemistry Flag:&: on
读取一切形式参数：
以下是通用的示例，它使用HttpServletRequest的getParameterNames()方法读取所有可用的形式参数。此方法返回一个枚举，其中包含一个未指定的顺序中的参数名。
一旦我们有一个枚举，我们可以循环下来的枚举以标准方式，使用调用hasMoreElements()方法来确定何时停止，并用nextElement()方法得到每个参数的名称。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class ReadParams extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading All Form Parameters";
String docType =
"&!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\"&\n";
out.println(docType +
"&html&\n" +
"&head&&title&" + title + "&/title&&/head&\n" +
"&body bgcolor=\"#f0f0f0\"&\n" +
"&h1 align=\"center\"&" + title + "&/h1&\n" +
"&table width=\"100%\" border=\"1\" align=\"center\"&\n" +
"&tr bgcolor=\"#949494\"&\n" +
"&th&Param Name&/th&&th&Param Value(s)&/th&\n"+
"&/tr&\n");
Enumeration paramNames = request.getParameterNames();
while(paramNames.hasMoreElements()) {
String paramName = (String)paramNames.nextElement();
out.print("&tr&&td&" + paramName + "&/td&\n&td&");
String[] paramValues =
request.getParameterValues(paramName);
// Read single valued data
if (paramValues.length == 1) {
String paramValue = paramValues[0];
if (paramValue.length() == 0)
out.println("&i&No Value&/i&");
out.println(paramValue);
// Read multiple valued data
out.println("&ul&");
for(int i=0; i & paramValues. i++) {
out.println("&li&" + paramValues[i]);
out.println("&/ul&");
out.println("&/tr&\n&/table&\n&/body&&/html&");
// Method to handle POST method request.
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
现在，请尝试下面的表格上面的servlet：
&form action="ReadParams" method="POST" target="_blank"&
&input type="checkbox" name="maths" checked="checked" /& Maths
&input type="checkbox" name="physics"
/& Physics
&input type="checkbox" name="chemistry" checked="checked" /& Chem
&input type="submit" value="Select Subject" /&
现在调用servlet使用上述表单，将产生以下结果：
读取所有的表单参数
Param Name
Param Value(s)
你可以试试上面的servlet读取任何其他形式的数据等其他的对象，如文本框，单选按钮或下拉框等相关学习资料http://my.oschina.net/chape/blog/170247http:///cd/E13222_01/wls/docs81/webapp/web_xml.htmlhttp://blog.csdn.net/liaoxiaohua1981/article/details/6761053http://computer.c./blog/static//http://www.blogjava.net/w2gavin/articles/358641.htmlhttp:///note//http:///blog/1105522http://blog.csdn.net/li_jinjian2005/article/details/2915462http://210.44.193.6/JSP/07.htmhttp:///developerworks/cn/java/j-lo-servlet30/目录1. J2EE WEB应用文件目录结构2. web.xml基础语法3. JSP基础语法4. Servlet基础语法1. J2EE WEB应用文件目录结构Java Web应用由一组静态HTML页、Servlet、JSP和其他相关的class组成，它们一起构成一个大的工程项目。每种组件在Web应用中都有固定的存放目录。Web应用的配置信息存放在web.xml文件中。在发布某些组件(如Servlet)时，必须在web.xml文件中添加相应的配置信息Java Web应用程序必须使用规范的目录结构1. 应用程序根目录，可以取任意的名字，所有的HTML、JSP文件都放在这个目录下 1.1 WEB-INF目录: 必须目录
1.1.1 web.xml: Web应用部署描述文件，必须文件
1.1.2 classes目录:
1) 用于存放单个*.classes字节码文件，Servlet类文件也存放在这个目录下
1.1.3 lib目录:
1) 存放第三方类库文件，即打包后的JAR文件
1.1.4 TLD文件: 标签库描述文件
1.2 其他静态文件:
1.2.1 HTML
1.2.3 JavaScript
1.2.4 图片等 1.3 *.jsp: 存放任意多个JSP页面2. web.xml基础语法位于每个WEB应用的的WEB-INF路径下的web.xml文件被称为配置描述符，这个web.xml文件对于Java Web应用十分重要，总体来说，web.xml主要负责以下内容:1. JSP环境参数初始化2. 配置和管理Servlet3. 配置和管理Listener4. 配置和管理Filter5. 配置和管理JNDI6. Session配置7. MIME TYPE配置8. 错误处理9. 配置标签库10. 配置JSP属性11. 配置和管理JAAS授权认证12. 配置和管理资源引用13. WEB应用默认首页(welcome文件)的设置下面我尽量列出了一个完整的web.xml的结构，我使用了/**/注释符来说明某个项目的说明，要明白的是，在真实的web.xml中不允许使用/**/注释符的，只是我觉得直接在web.xml中插入解释说明能更好的说明问题/*&?xml version=&1.0& encoding=&GBK&?&是一个基本的XML文件的框架，不管是什么配置文件，只要是基于XML的，它的基本结构都是这样*/&?xml version=&1.0& encoding=&GBK&?&/*web.xml文件的根元素是&web-app.../&元素，整个web.xml只有这个根元素，每个web.xml必须以这个&web-app&根元素作为开头，在Servlet 3.0规范中，该元素新增了metadata-complete属性，当该属性值为true时，该web应用&不会&加载Annotation配置的WEB组件(如Servlet、Filter、Listener等)，反之则加载*/&web-app xmlns=&/xml/ns/javaee& xmlns:xsi=&http://www.w3.org/2001/XMLSchema-instance& xsi:schemaLocation=&/xml/ns/javaee /xml/ns/javaee/web-app_3_0.xsd& version=&3.0&& /* 1. icon信息: 用来指定web站点中小图标和大图标的路径
1) small-icon: 大小为16 X 16 pixel,但是图象文件必须为GIF或JPEG格式,扩展名必须为:.gif或.jpg.
2) large-icon: 大小为32 X 32 pixel,但是图象文件必须为GIF或JPEG的格式,扩展名必须为; gif或jpg.
*/ &small-icon&/路径/smallicon.gif&/small-icon& &large-icon&/路径/largeicon-jpg&/large-icon& /* 2. 描述信息 display-name: 定义站点的名称 description: 对站点的描述 */ &display-name&站点名称&/display-name& &description&站点描述&/discription& /* 3. distributable distributable元素为空标签,它的存在与否可以指定站台是否可分布式处理.如果web.xml中出现这个元素,则代表站台在开发时已经被设计为能在多个JSP Container之间分散执行 */
&distributable/&
/* 4. JSP环境参数: context-param context-param元素用来设定web站台的环境参数(context),它包含两个子元素:
1) param-name: 参数名称
2) param-value: 值
此所设定的参数,在JSP网页中可以使用下列方法来取得: ${initParam.param_name} 若在Servlet可以使用下列方法来获得: String param_name=getServletContext().getInitParamter(&param_name&); */
&context-param&
&param-name&param_name&/param-name&
&param-value&param_value&/param-value& &/context-param& /* 5. filter过滤器、filter-mapping 用于指定WEB容器的过滤器，在请求和响应对象在Servlet处理之前和之后，可以通过此过滤器对这两个对象进行处理 filter-class 中指定的过滤器类须继承 javax.servlet.Filter具有须有以下三种方法 init(FilterConfig filterConfig)：初始化;一般情况下时读取配置文件中的init-param参数值 如 filterConfig.getInitParameter(&encoding&) doFilter(...)：用于对request,response进行处理，并能过chain.doFilter(...) 交过下一个控制器 destroy()：资源销毁 filter-mapping则指示需要进行过滤器处理的URL访问模式，可以理解为当我们的URL匹配到指定的模式后，则对这个请求执行指定的&过滤处理流程&(可以把它理解为一种路由机制) */ &filter&
&small-icon&/路径/smallicon.gif&/small-icon&
&large-icon&/路径/largeicon-jpg&/large-icon&
&filter-name&encodingfilter&/filter-name&
&display-name&站点名称&/display-name&
&description&站点描述&/discription&
&filter-class&com.my.app.EncodingFilter&/filter-class&
&init-param&
&param-name&encoding&/param-name&
&param-value&UTF-8&/param-value&
&/init-param& &/filter& &filter-mapping&
&filter-name&encodingfilter&/filter-name&
&url-pattern&/*&/url-pattern& &/filter-mapping&
/* 6. servlet、servlet-mapping 和filter过滤器类似，servlet也是用来配置映射处理机制的 和filter-mapping的作用类似，servlet-mapping用来定义servlet所对应URL. */ &servlet&
&small-icon&/路径/smallicon.gif&/small-icon&
&large-icon&/路径/largeicon-jpg&/large-icon&
&servlet-name&MyServletName&/servlet-name&
&display-name&站点名称&/display-name&
&description&站点描述&/discription&
servlet-class、jsp-file有且只能出现一个
&servlet-class&com.Little.MyServlet&/servlet-class&
&jsp-file&/path/index.jsp&/jsp-file&
&init-param&
&param-name&name1&/param-name&
&param-value&value1&/param-value&
&/init-param&
指定当Web应用启动时，装载Servlet的次序
1) 当值为正数或零时: 容器在应用启动时就加载这个servlet，Servlet容器先加载数值小的servlet，再依次加载其他数值大的servlet
2) 当值为负或未定义: 容器在该servlet被选择时才加载，即Servlet容器将在Web客户首次访问这个servlet时加载它
&load-on-startup&&/load-on-startup&
设定运行时角色，可以使当前Servlet以一个特定的角色运行，有利于安全权限控制
&description&Security role for anonymous access&/description&
&role-name&tomcat&/role-name&
security-role-ref子元素提供出现在服务器专用口令文件中的安全角色名的一个别名。例如，假如编写了一个调用 request.isUserInRole(&boss&)的servlet，但后来该servlet被用在了一个其口令文件调用角色manager而不 是boss的服务器中。下面的程序段使该servlet能够使用这两个名称中的任何一个
&security-role-ref&
&role-name&boss&/role-name& &!-- New alias --&
&role-link&manager&/role-link& &!-- Real name --&
&/security-role-ref& &/servlet&
&servlet-mapping&
&servlet-name&LoginChecker&/servlet-name&
&url-pattern&/LoginChecker&/url-pattern&
&servlet-name&MyServletName&/&servlet-name& &/servlet-mapping& /* 7. security-role(虚拟安全用户) 给出安全角色的一个列表，这些角色将出现在servlet元素内的security-role-ref元素的role-name元素中。分别声明角色可使高级IDE处理安全信息更为容易。 */ &security-role&
&description&安全账户描述&/discription&
&role-name&admin&/role-name& &/security-role& /* 8. listener 监听器也叫Listener，是Servlet的监听器，它可以监听客户端的请求、服务端的操作等。通过监听器，可以自动激发一些操作，Servlet本身在一些特定的关键处理流程节点上增加Hook回调机制，使得我们可以在这些节点位置配置监听器 常见的监听器如下: Listener接口
1) ServletContextListener: ServletContextEvent 2) ServletContextAttributeListener: ServletContextAttributeEvent 3) HttpSessionListener: HttpSessionEvent 4) HttpSessionActivationListener: HttpSessionAttributeListener 5) HttpSessionBindingEvent: HttpSessionBindingListener 6) ServletRequestListener: ServletRequestEvent 7) ServletRequestAttributeListener: ServletRequestAttributeEvent
*/ &listener&
&listener-class&org.springframework.web.context.request.RequestContextListener&/listener-class& &/listener& /* 9. session配置 session-config包含一个子元素session-timeout.定义web站台中的session参数，定义这个web站台所有session的有效期限.单位为分钟 */ &session-config&
&session-timeout&20&/session-timeout& &/session-config& /* 10. mime-mapping mime-mapping包含两个子元素extension和mime-type.定义某一个扩展名和某一MIME Type做对映，和apache中的文件扩展处理器原理类似，对指定的扩展名指定相应的处理程序 */ &mime-mapping&
&extension&doc&/extension&
&mime-type&application/vnd.ms-word&/mime-type& &/mime-mapping&
&mime-mapping&
&extension&xls&/extension&
&mime-type&application/vnd.ms-excel&/mime-type& &/mime-mapping& /* 11. welcome-file-list welcome-file-list包含一个子元素welcome-file.用来定义首页列单，即当客户端的请求没有指定具体的页面时，服务区器默认指定的首页脚本 */ &welcome-file-list&
&welcome-file&index.jsp&/welcome-file&
&welcome-file&index.htm&/welcome-file& &/welcome-file-list& /* 12. error-page 错误处理机制，error-page元素包含三个子元素error-code,exception-type和location.将错误代码(Error Code)或异常(Exception)的种类对应到web站点资源路径。简单来说就是返回特定HTTP状态代码或者特定类型的异常被抛出时，制定响应将要显示的页面。 */ &error-page&
&error-code&404&/error-code&
&exception-type&java.lang.Exception&/exception-type&
&location&/error404.jsp&/location& &/error-page& &error-page&
&exception-type&java.lang.Exception&/exception-type&
&exception-type&java.lang.NullException&/exception-type&
&location&/except.jsp&/location& &/error-page& /* 13. jsp-config JSP相关配置
*/ &jsp-config&
taglib-uri定义TLD文件的URI,JSP网页的taglib指令可以经由这个URI存取到TLD文件
&taglib-uri&Taglib&/taglib-uri&
taglib-location定义TLD文件对应Web站台的存放位置
&taglib-location&/WEB-INF/tlds/MyTaglib.tld&/taglib-location&
&jsp-property-group&
&description&
Special property group for JSP Configuration JSP example.
&/description&
&display-name&JSPConfiguration&/display-name&
设定值所影响的范围,如:/CH2 或者/*.jsp
&uri-pattern&/*&/uri-pattern&
若为true,表示不支持EL语法
&el-ignored&true&/el-ignored&
设定JSP网页的编码
&page-encoding&GB2312&/page-encoding&
若为true表示不支持&%scription%&语法.
&scripting-inivalid&true&/scripting-inivalid&
设置JSP网页的结尾,扩展名为.jspf
&include-coda&.jspf&/include-coda&
设置JSP网页的抬头,扩展名为.jspf
&include-prelude&.jspf&/include-prelude&
&/jsp-property-group& &/jsp-config& /* 14. resource-ref、resource-env-ref resource-ref声明资源工厂使用的外部资源 resource-env-ref声明与资源相关的管理对象 */ &resource-ref&
&description&JNDI JDBC DataSource of JSPBook&/description& &!-- 资源说明 --&
&res-ref-name&jdbc/sample_db&/res-ref-name& &!-- 资源名称 --&
&res-type&javax.sql.DataSoruce&/res-type& &!-- 资源种类 --&
&res-auth&Container&/res-auth& &!-- 资源由Application或Container来许可 --&
&res-sharing-scope&Shareable|Unshareable&/res-sharing-scope& &!-- 资源是否可以共享.默认值为 Shareable --& &/resource-ref& &resource-env-ref&
&resource-env-ref-name&jms/StockQueue&/resource-env-ref-name&
&/resource-env-ref&
/* 15. EJB配置
ejb-ref用于声明一个EJB的主目录的引用 用于声明一个EJB的本地主目录的应用。 */ &ejb-ref&
&description&Example EJB reference&/decription&
&ejb-ref-name&ejb/Account&/ejb-ref-name&
&ejb-ref-type&Entity&/ejb-ref-type&
&home&com.mycompany.mypackage.AccountHome&/home&
&remote&com.mycompany.mypackage.Account&/remote&
&/ejb-ref&
&ejb-local-ref&
&description&Example Loacal EJB reference&/decription&
&ejb-ref-name&ejb/ProcessOrder&/ejb-ref-name&
&ejb-ref-type&Session&/ejb-ref-type&
&local-home&com.mycompany.mypackage.ProcessOrderHome&/local-home&
&local&com.mycompany.mypackage.ProcessOrder&/local&
&/ejb-local-ref&
/* 16. WEB应用环境参数配置 */ &env-entry&
&description&环境参数说明&/description&
&env-entry-name&minExemptions&/env-entry-name&
&env-entry-value&1&/env-entry-value&
&env-entry-type&java.lang.Integer&/env-entry-type&
&/env-entry&
/* 17. 安全配置、资源限制访问配置 在Web应用程序的web.xml中创建security-constraint、login-config和security-role元素 */ /* 配置对指定资源、指定角色的访问权限 */ &security-constraint&
&web-resource-collection&
&web-resource-name&HelloServlet&/web-resource-name&
&url-pattern&/HelloServlet&/url-pattern&
&http-method&GET&/http-method&
&http-method&POST&/http-method&
&/web-resource-collection&
&auth-constraint&
&description&This applies only to the &tomcat& security role&/description&
&role-name&admin&/role-name&
&/auth-constraint&
&user-data-constraint&
&transport-guarantee&NONE&/transport-guarantee&
&/user-data-constraint& &/security-constraint&
/* auth-method的方法有:
BASIC是一种常见的Web认证方式，浏览器给用户提示一个对话框，要求输入用户名和密码，随后Tomcat将给出的用户名和密码与tomcat-users.xml中的用户名和密码进行比较，然后使用前面的security-constraint配置来确定用户是否可访问受保护的servlet
3) CLIENT-CERT
4) DIGEST */ &login-config&
&realm-name&在HTTP验证返回包中的显示名称&/&realm-name&
&auth-method&BASIC&/auth-method&
&form-login-config&如果auth-method采用FORM，则这里填写form-login-config名称&/form-login-config&
&/login-config& /* 关于security-role，在前面的servlet已经说明过，这里要强调一下: web.xml中的HTTP认证方法实际上有两个步骤：
1) 检查提供的用户名和密码是否正确。
2) 判断用户是否映射到特定的安全角色。例如，用户可能提供了正确的用户名和密码，但没有映射到特定的安全角色，也将被禁止访问特定的Web资源。 */ &security-role&
&role-name&admin&/role-name& &/security-role&&/web-app&以上就是web.xml的完整结构，需要注意的是，web.xml中有一些环境参数的加载配置，它们之间存在优先级的关系，我们在编写配置的时候需要注意这一点web.xml 的加载顺序是：context-param -& listener -& filter -& servlet ，而相同类型节点之间的程序调用的顺序是根据对应的mapping的顺序进行调用的3. JSP基础语法JSP的本质是Servlet，当用户向指定Servlet发送请求时，Servlet利用输出流动态生成HTML页面，包括每一个静态的HTML标签和所有在HTML页面中出现的内容JSP页面由如下两部分组成1. 静态部分: 标准的HTML标签、静态的页面内容，也就是普通的HTML代码2. 动态部分: 受java程序控制的内容，这些内容由Java程序来动态生成/*1. JSP的编译指令 */&%@ page contentType=&text/ charset=GBK& language=&java& errorPage=&& %&&!DOCTYPE html PUBLIC &-//W3C//DTD XHTML 1.0 Transitional//EN& &http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd&&&html xmlns=&http://www.w3.org/1999/xhtml&&&head& &title&learn j2ee&/title&
/* 2. JSP注释
*/ &/head& /*3. JSP声明 */&body& /*4. JSP表达式*//*5. JSP脚本*/ /*6. JSP的动作指令*/ /*7. JSP脚本中的内置对象*/&/body&&/html&0x1: JSP的编译指令JSP的编译指令是通过JSP引擎的消息，它不直接生成输出。编译指令都有默认值，我们并不需要为每个指令设置值。它的格式如下&%@ 编译指令名 属性名=&属性值&...%&(不同属性名之间用空格分开) 1) page: Page指令为容器提供当前页面的使用说明。一个JSP页面可以包含多个page指令
1.1) buffer: 指定缓冲区的大小。缓冲区是JSP内部对象&out&，它用于缓存JSP页面对客户端浏览器的输出，默认值为8KB，可以设置为none，也可以设置为其他的值，单位为Kb
1.2) autoFlush: 当缓冲区即将满而溢出时，是否需要强制输出缓冲区的内容:
1.2.1) 如果设置为true则正常输出
1.2.2) 如果设置为false，则会在buffer溢出时产生一个异常
1.3) contentType: 用于设定生成网页的文件格式(MIME类型)、和编码字符集(页面字符集类型)(text/charSet=ISO-8859-1)
1.3.1) 默认的MIME类型是text/html
1.3.2) 默认的字符集类型为ISO-8859-1
1.4) errorPage: 指定错误处理页面，如果本页面产生了异常或错误，而该JSP页面没有对应的错误处理代码(没有用try、catch机制捕捉异常)，则会自动调用该属性所指定的JSP页面。值得注意的是，为页面指定错误发生时的错误提示页面是一种安全的做法，能够在一定程度上组织error-based-sql-injection的攻击
1.5) isErrorPage: 指定当前页面是否可以作为另一个JSP页面的错误处理页面
1.6) extends: JSP程序编译时所产生的Java类，需要继承的父类，或者需要实现的接口的全限定类名(即包含包名在内的完整路径)
1.7) import: 用来导入包。默认自动导入的包(参数之间用逗号分隔)(java.lang.*,javax.servlet.*)
1.7.1) java.lang.*
1.7.2) javax.servlet.*
1.7.3) javax.servlet.jsp.*
1.7.4) javax.servlet.http.*
1.8) info: 定义JSP页面的描述信息
1.9) isThreadSafe: 指定对JSP页面的访问是否为线程安全
1.10) language: 定义JSP页面所用的脚本语言，默认是Java
1.11) session: 指定JSP页面是否使用session
1.12) isELIgnored: 指定是否执行EL表达式
1.13) isScriptingEnabled: 确定脚本元素能否被使用 2) include: 用于指定包含另一个页面 &%@include file=&file.jsp&%& 可以将外部文件嵌入到当前JSP文件中，同时解析这个页面中的JSP语句(如果有的话)，也就是说，它既可以包含静态的文本，也可以包含动态的JSP页面。包含页面在编译时将完全包含了被包含页面的代码，融合成一个页面。作用和PHP中的inlcude、require类似。 需要注意的是，要指出的是，静态包含还会将被包含页面的编译指令也包含进来，如果两个页面的编译指令冲突，那么页面就会出错(即被包含的页面中不能重复定义page、include、taglib) 3) taglib: 用于定义和访问自定义标签 自定义标签库是一种非常优秀的表现层组件技术。通过使用自定义标签库，可以在简单的标签中封装复杂的功能，在JSP2中使用自定义标签需要以下步骤
1) 开发自定义标签处理类
在JSP页面使用一个标签时，底层实际上由标签处理类提供支持，从而可以通过简单的标签来封装复杂的功能，从而使团队更好地协作开发。自定义标签类应该继承一个父类: javax.servlet.jsp.tagext.SimpleTagSupport，除此之外，JSP自定义标签类还有如下要求(通过接口来强制性保证):
1) 如果标签包含属性，每个属性都有对应的getter、setter方法
2) 重写doTag()方法，这个方法负责生成页面内容
example1: 无属性、无标签体的最简单的标签处理类
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;
public class HelloWorldTag extends SimpleTagSupport
//重写doTag方法，该方法在标签结束生成页面内容
public void doTag()throws JspException, IOException
//获取页面输出流，并输出字符串
getJspContext().getOut().write(&Hello World & + new java.util.Date());
这个标签处理类继承了SimpleTagSupport父类，并重写了doTag()方法，doTag()负责输出页面内容(即标签代表的内容)
example2: 带属性的标签处理类
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;
import java.sql.*;
public class QueryTag extends SimpleTagSupport
//标签的属性
//driver属性的setter和getter方法
public void setDriver(String driver)
this.driver =
public String getDriver()
return this.
//url属性的setter和getter方法
public void setUrl(String url)
this.url =
public String getUrl()
return this.
//user属性的setter和getter方法
public void setUser(String user)
this.user =
public String getUser()
return this.
//pass属性的setter和getter方法
public void setPass(String pass)
this.pass =
public String getPass()
return this.
//sql属性的setter和getter方法
public void setSql(String sql)
this.sql =
public String getSql()
return this.
//conn属性的setter和getter方法
public void setConn(Connection conn)
this.conn =
public Connection getConn()
return this.
//stmt属性的setter和getter方法
public void setStmt(Statement stmt)
this.stmt =
public Statement getStmt()
return this.
//rs属性的setter和getter方法
public void setRs(ResultSet rs)
public ResultSet getRs()
return this.
//rsmd属性的setter和getter方法
public void setRsmd(ResultSetMetaData rsmd)
this.rsmd =
public ResultSetMetaData getRsmd()
return this.
//执行数据库访问的对象
private Connection conn = null;
private Statement stmt = null;
private ResultSet rs = null;
private ResultSetMetaData rsmd = null;
public void doTag()throws JspException,
IOException
//注册驱动
Class.forName(driver);
//获取数据库连接
conn = DriverManager.getConnection(url,user,pass);
//创建Statement对象
stmt = conn.createStatement();
//执行查询
rs = stmt.executeQuery(sql);
rsmd = rs.getMetaData();
//获取列数目
int columnCount = rsmd.getColumnCount();
//获取页面输出流
Writer out = getJspContext().getOut();
//在页面输出表格
out.write(&&table border='1' bgColor='#9999cc' width='400'&&);
//遍历结果集
while (rs.next())
out.write(&&tr&&);
//逐列输出查询到的数据
for (int i = 1 ; i &= columnC i++ )
out.write(&&td&&);
out.write(rs.getString(i));
out.write(&&/td&&);
out.write(&&/tr&&);
catch(ClassNotFoundException cnfe)
cnfe.printStackTrace();
throw new JspException(&自定义标签错误& + cnfe.getMessage());
catch (SQLException ex)
ex.printStackTrace();
throw new JspException(&自定义标签错误& + ex.getMessage());
//关闭结果集
if (rs != null)
rs.close();
if (stmt != null)
stmt.close();
if (conn != null)
conn.close();
catch (SQLException sqle)
sqle.printStackTrace();
example3: 带标签体的标签处理类
带标签体的标签可以在标签内嵌入其他内容(包括静态HTML、动态JSP内容)，通常用于完成一些逻辑运算
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;
import java.sql.*;
import java.util.*;
public class IteratorTag extends SimpleTagSupport
//标签属性，用于指定需要被迭代的集合
//标签属性，指定迭代集合元素，为集合元素指定的名称
//collection属性的setter和getter方法
public void setCollection(String collection)
this.collection =
public String getCollection()
return this.
//item属性的setter和getter方法
public void setItem(String item)
this.item =
public String getItem()
return this.
//标签的处理方法，简单标签处理类只需要重写doTag方法
public void doTag() throws JspException, IOException
//从page scope中获取属性名为collection的集合
Collection itemList = (Collection)getJspContext().getAttribute(collection);
//遍历集合
for (Object s : itemList)
//将集合的元素设置到page 范围
getJspContext().setAttribute(item, s);
//输出标签体
getJspBody().invoke(null);
example4: 以&页面片段&作为属性的标签处理类
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;
public class FragmentTag extends SimpleTagSupport
private JspF
//fragment属性的setter和getter方法
public void setFragment(JspFragment fragment)
this.fragment =
public JspFragment getFragment()
return this.
public void doTag() throws JspException, IOException
JspWriter out = getJspContext().getOut();
out.println(&&div style='padding:10border:1px solid black'&&);
out.println(&&h3&下面是动态传入的JSP片段&/h3&&);
//调用、输出“页面片段”
fragment.invoke( null );
out.println(&&/div&);
上面的程序定义了JspFragment类型的fragment属性，该属性代表了使用该标签时的&页面片段&
example5: 动态属性的标签处理类
在某些特殊情况下，我们需要传入自定义标签的属性个数是不确定的、属性名也是不确定的，这就需要使用到动态属性的标签
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;
import java.util.*;
public class DynaAttributesTag extends SimpleTagSupport implements DynamicAttributes
//保存每个属性名的集合
private ArrayList&String& keys = new ArrayList&String&();
//保存每个属性值的集合
private ArrayList&Object& values = new ArrayList&Object&();
public void doTag() throws JspException, IOException
JspWriter out = getJspContext().getOut();
//此处只是简单地输出每个属性
out.println(&&ol&&);
for( int i = 0; i & keys.size(); i++ )
String key = keys.get( i );
Object value = values.get( i );
out.println( &&li&& + key + & = & + value + &&/li&& );
out.println(&&/ol&&);
实现DynamicAttributes接口必须实现setDynamicAttribute，该方法用于为该标签处理类动态添加属性名、属性值
public void setDynamicAttribute( String uri, String localName, Object value) throws JspException
//添加属性名
keys.add( localName );
//添加属性值
values.add( value );
2) 建立一个*.tld文件，每个*.tld文件对应一个标签库，每个标签库可包含多个标签
TLD(Tag Library Definition 标签库定义)的根元素是taglib，它可以包含多个tag子元素，每个tag元素都定义一个标签
taglib结构如下
1) tlib-version: 指定该标签库实现的内部版本号
2) short-name: 该标签库的默认短名
3) uri: 指定该标签库的唯一标识URI，JSP页面中使用标签库就是根据该URI属性来定位标签库的
4) tag: 每个tag元素定义一个标签
4.1) name: 该标签的名字
4.2) tag-class: 该标签的处理类
4.3) body-content: 指定标签体内容
4.3.1) tagdependent: 标签处理类自己负责处理标签体
4.3.2) empty: 该标签只能作为空标签使用
4.3.3) scriptless: 该标签可以是静态HTML元素、表达式语言，但不允许JSP脚本
4.3.4) JSP: 该标签可以使用JSP脚本
4.3.5) dynamic-attributes: 该标签是否支持动态属性
JSP2规范的自定义标签还允许直接将一段&页面代码&作为属性，这种方式给自定义标签提供了更大的灵活性，它和普通标签的区别并不大，对于以&页面代码&作为属性的自定义标签来说，需要注意的是:
1) 标签处理类中定义类型为JspFragment的属性，该属性代表了&页面片段&
2) 使用标签库时，通过&jsp:attribute../&动作指令为标签库属性指定值
除此之外，还可以动态属性的标签
&?xml version=&1.0& encoding=&GBK&?&
&taglib xmlns=&/xml/ns/j2ee&
xmlns:xsi=&http://www.w3.org/2001/XMLSchema-instance&
xsi:schemaLocation=&/xml/ns/j2ee web-jsptaglibrary_2_0.xsd&
version=&2.0&&
&tlib-version&1.0&/tlib-version&
&short-name&mytaglib&/short-name&
&!-- 定义该标签库的URI --&
&uri&http:///mytaglib&/uri&
&!-- 定义第一个标签 --&
&!-- 定义标签名 --&
&name&helloWorld&/name&
&!-- 定义标签处理类 --&
&tag-class&lee.HelloWorldTag&/tag-class&
&!-- 定义标签体为空 --&
&body-content&empty&/body-content&
定义第二个标签，对于有属性的标签，需要为&tag../&元素增加&attribute../&子元素，每个attribute子元素定义一个标签元素。&attribute../&子元素通常还需要指定如下子元素
1) name: 属性名，子元素的值是字符串内容
2) required: 该属性是否为必须属性，true or false
3) fragment: 该属性是否支持JSP脚本、表达式等动态内容，true or false
&!-- 定义标签名 --&
&name&query&/name&
&!-- 定义标签处理类 --&
&tag-class&lee.QueryTag&/tag-class&
&!-- 定义标签体为空 --&
&body-content&empty&/body-content&
&!-- 配置标签属性:driver --&
&attribute&
&name&driver&/name&
&required&true&/required&
&fragment&true&/fragment&
&/attribute&
&!-- 配置标签属性:url --&
&attribute&
&name&url&/name&
&required&true&/required&
&fragment&true&/fragment&
&/attribute&
&!-- 配置标签属性:user --&
&attribute&
&name&user&/name&
&required&true&/required&
&fragment&true&/fragment&
&/attribute&
&!-- 配置标签属性:pass --&
&attribute&
&name&pass&/name&
&required&true&/required&
&fragment&true&/fragment&
&/attribute&
&!-- 配置标签属性:sql --&
&attribute&
&name&sql&/name&
&required&true&/required&
&fragment&true&/fragment&
&/attribute&
&!-- 定义第三个带标签体的标签 --&
&!-- 定义标签名 --&
&name&iterator&/name&
&!-- 定义标签处理类 --&
&tag-class&lee.IteratorTag&/tag-class&
&!-- 定义标签体不允许出现JSP脚本 --&
&body-content&scriptless&/body-content&
&!-- 配置标签属性:collection --&
&attribute&
&name&collection&/name&
&required&true&/required&
&fragment&true&/fragment&
&/attribute&
&!-- 配置标签属性:item --&
&attribute&
&name&item&/name&
&required&true&/required&
&fragment&true&/fragment&
&/attribute&
&!-- 定义以&页面片段&作为属性的标签名 --&
&name&fragment&/name&
&!-- 定义标签处理类 --&
&tag-class&lee.FragmentTag&/tag-class&
&!-- 指定该标签不支持标签体 --&
&body-content&empty&/body-content&
&!-- 定义标签属性：fragment --&
&attribute&
&name&fragment&/name&
&required&true&/required&
&fragment&true&/fragment&
&/attribute&
&!-- 定义接受动态属性的标签 --&
&name&dynaAttr&/name&
&tag-class&lee.DynaAttributesTag&/tag-class&
&body-content&empty&/body-content&
&!-- 指定支持动态属性 --&
&dynamic-attributes&true&/dynamic-attributes&
定义了上面的标签库定义文件之后，将标签库文件放在WEB应用的WEB-INF路径下，WEB容器会自动加载该文件，则该文件定义的标签库也将生效
3) 在JSP文件中使用自定义标签
在JSP页面中使用标签库步骤
1) 导入标签库: 使用taglib编译指令导入标签库，由URI唯一标识指定标签库，并将标签库和指定前缀关联起来(即所有使用该前缀的标签将由此标签库处理)
&%@ taglib uri=&tagliburi& prefix=&tagPrefix& %&
2) 使用标签: 在JSP页面中使用自定义标签
&tagPrefix:tagName tagAttribute=&tagValue& ..&
&tagBody/&
&/tagPrefix:tagName&
example1: helloWorld标签使用
&%@ taglib uri=&/mytaglib& prefix=&mytag&%&
&mytag:helloWorld&&/mytag:helloWorld&
example2: QueryTag标签使用
&%@ taglib uri=&/mytaglib& prefix=&mytag&%&
&mytag:query
driver=&com.mysql.jdbc.Driver&
url=&jdbc:mysql://localhost:3306/javaee&
user=&root&
pass=&32147&
sql=&select * from news_inf&/&
可以看出自定义标签库的作用，以简单的标签，隐藏复杂的逻辑
example3: IteratorTag标签使用
&%@ taglib uri=&/mytaglib& prefix=&mytag&%&
//创建一个List对象
List&String& a = new ArrayList&String&();
a.add(&疯狂Java&);
a.add(&www.crazyit.org&);
a.add(&java&);
//将List对象放入page范围内
pageContext.setAttribute(&a& , a);
&table border=&1& bgcolor=&#aaaadd& width=&300&&
&!-- 使用迭代器标签，对a集合进行迭代 --&
&mytag:iterator collection=&a& item=&item&&
&td&${pageScope.item}&/td&
&/mytag:iterator&
可以看到，使用iterator标签遍历集合元素比使用JSP脚本遍历集合元素要优雅，这也是自定义标签的优势
example4: fragment标签使用
&%@ taglib uri=&/mytaglib& prefix=&mytag&%&
&mytag:fragment&
&!-- 使用jsp:attribute标签传入fragment参数 --&
&jsp:attribute name=&fragment&&
&!-- 下面是动态的JSP页面片段 --&
&mytag:helloWorld/&
&/jsp:attribute&
&/mytag:fragment&
&mytag:fragment&
&jsp:attribute name=&fragment&&
&!-- 下面是动态的JSP页面片段 --&
${pageContext.request.remoteAddr}
&/jsp:attribute&
&/mytag:fragment&
example5: dynaAttr标签使用
&%@ taglib uri=&/mytaglib& prefix=&mytag&%&
&mytag:dynaAttr name=&crazyit& url=&crazyit.org&/&
&mytag:dynaAttr 书名=&疯狂Java讲义& 价格=&99.0& 出版时间=&2008年& 描述=&Java图书&/&
可以看到，不管传入多少属性，这个标签都可以处理
JSTL是Sun提供的一套标签库，DisplayTag是Apache组织下的一套开源标签库，主要用于生成页面并显示效果2. JSP注释&%-- 注释内容 --%&JSP注释用于标注在程序开发过程中的开发提示，&不会&输出到客户端，即客户端连注释符号都看不到3. JSP声明JSP声明用于声明变量和方法，值得注意的是，JSP声明将会转换成对应的Servlet(.java文件)的成员变量或成员方法(牢记这点，后因为我们还会看到在&%..%&中声明的是局部成员)，因此JSP声明依然符合java语法。&%! 声明部分 %&关于JSP的变量声明梳理一下，在JSP中声明变量总共有2中情况:1) 局部变量&% 在JSP(本质是java代码)中声明变量 %&，又因为JSP代码是会被Tomcat翻译成Servlet的面向对象的java代码，所以在&% %&中声明的变量全都是局部变量(即在代码块中声明的变量)，它们不能使用private、public、static等修饰2) 类变量&%! %&用这种方式声明的变量是在类的范围域中声明的，属于类变量，它们可以使用private、public、static等修饰使用的使用一定要注意example:&%!//声明一个整形变量public int//声明一个方法public String info(){return &hello&;}%&4. JSP表达式JSP提供了一种输出表达式值的简单方法&%=表达式%& example:&%!public int %&&%=count++%&5. JSP脚本所有可执行性java代码都可以通过JSP脚本嵌入HTML页面example:&%out.println(new java.util.Date());%&6. JSP的动作指令动作指令与编译指令不同: 1) 编译指令是通知Servlet引擎的处理消息，是在将JSP编译成Servlet时起作用 2) 动作指令只是运行时的动作，通常可替换成JSP脚本，它只是JSP脚本的标准化写法JSP的动作指令主要有如下7个:1) jsp:forward: 执行页面转向，将请求的处理转发到下一个页面，可以转发到: 1) 静态HTML页面 2) 动态的JSP页面 3) 容器中的Servlet语法1:&jsp:forward page=&{relativeURL|&%=expression%&}&/&语法2:&jsp:forward page=&{relativeURL|&%=expression%&}&& {&jsp:param.../&}&/jsp:forward&第二种语法用于在转发时增加额外的请求参数。增加的请求参数的值可以通过HttpServletRequest类的getParameter()方法获取request.getParameter(&&);从本质上来说，jsp:forward这个动作指令只是一个内部转发，即&jsp:forward../&并没有重新向新页面发送了请求，它只是完全采用了新页面来对用户生成响应(内部转发)，请求依然是一次请求，所以请求参数、请求属性都不会丢失2) jsp:include:动态引入一个JSP页面，它不会导入被include页面的编译指令，仅仅将被导入页面的body内容插入本页面中&jsp:include page=&{relativeURL|&%=expression%&}& flush=&true&/&或者&jsp:include page=&{relativeURL|&%=expression%&}& flush=&true&& &jsp:param name=&parameterName& value=&parameerValue&/&&/jsp:include&这里要注意和编译指令的inlcude进行区分1) 静态引入(编译指令)&%@include file=&file.jsp&%&可以将外部文件嵌入到当前JSP文件中，同时解析这个页面中的JSP语句(如果有的话)，也就是说，它既可以包含静态的文本，也可以包含动态的JSP页面。包含页面在编译时将完全包含了被包含页面的代码。需要指出的是，静态包含还会将被包含页面的编译指令也包含进来，如果两个页面的编译指令冲突，那么页面就会出错2) 动态引入(动作指令)&jsp:include&归纳起来，动态导入和静态导入的区别有1. 静态导入是将被导入页面的代码完全融入，两个页面融合成一个整体Servlet2. 动态导入则在Servlet中使用include方法来引入被导入页面的内容3. 静态导入时被导入页面的编译指令会起作用。4. 动态导入时被导入页面的编译指令则失去作用，只是插入被导入页面的body内容5. 动态导入可以增加额外的参数实际上，forward动作指令和include动作指令(动态引入)十分相似，它们都采用方法来引入目标页面forward指令使用_jspx_page_context.forward()方法来引入目标页面include指令使用org.apache.jasper.runtime.JspRuntimeLibrary.include()方法来引入目标页面区别在于，执行forward时，被forward的页面将完全代替原有的页面，而执行include时，被include的页面只是插入原有页面即forward拿目标页面代替原有页面，而include则拿目标页面插入原有页面3) JavaBean相关 3.1) jsp:useBean: 在JSP页面中初始化一个JavaBean的实例 &jsp:useBean id=&name& class=&Classname& scope=&page|request|session|application&/&
3.1.1) id: JavaBean的实例名
3.1.2) class: 确定JavaBean的实现类
3.1.3) scope: 指定JavaBean实例的作用范围
3.1.3.1) page: 该JavaBean实例仅在该页面有效
3.1.3.2) request: 在本次请求有效
3.1.3.3) session: 在本次session内有效
3.1.3.4) application: 在本应用中一直有效
3.2) jsp:setProperty: 设置JavaBean实例的属性值 &jsp:setProperty name=&BeanName& property=&propertyName& value=&value& /&
3.2.1) name: JavaBean的实例名
3.2.2) property: 确定需要设置的属性名
3.2.3) value: 确定需要设置的属性值 3.3) jsp:getProperty: 输出JavaBean实例的属性值 &jsp:getProperty name=&BeanName& property=&propertyName& /&
3.3.1) name: 确定需要输出的JavaBean实例名
3.3.2) property: 确定需要输出的属性名这三个指令都是与JavaBean相关的指令，如果多个JSP页面中需要重复使用某段代码，我们可以把这段代码定义成java类的方法，然后让多个JSP页面调用该方法即可，这样可以达到较好的代码复用在.jsp页面中我们可以这样编码&!-- 创建lee.Person的实例，该实例的实例名为p1 --&&jsp:useBean id=&p1& class=&lee.Person& scope=&page&/&&!-- 设置p1的name属性值 --&&jsp:setProperty name=&p1& property=&name& value=&wawa&/&&!-- 设置p1的age属性值 --&&jsp:setProperty name=&p1& property=&age& value=&23&/&&!-- 输出p1的name属性值 --&&jsp:getProperty name=&p1& property=&name&/&&br/&&!-- 输出p1的age属性值 --&&jsp:getProperty name=&p1& property=&age&/&从代码中可以看到，我们使用了useBean、setProperty、getProperty来操作JavaBean的方法，同时我们需要明白的是，对于property=&name&，在JavaBean中提供了setName()、getName()方法来操作，property=&age&也是同理代码中对应的JavaBean的Person类源代码如下public class Person{ private S private int
//无参数的构造器 public Person() { } //初始化全部属性的构造器 public Person(String name , int age) {
this.name =
this.age = }
//name属性的setter和getter方法 public void setName(String name) {
this.name = } public String getName() {
return this. }
//age属性的setter和getter方法 public void setAge(int age) {
this.age = } public int getAge() {
return this. }} 4) plugin指令plugin指令主要用于下载服务器端的JavaBean、或Applet到客户端执行。由于程序在客户端执行，因此客户端必须安装虚拟机5) param指令param指令用于设置参数值，这个指令本身不能单独使用，因为单独的param没有实际意义。param指令可以与以下三个指令结合使用 5.1) jsp:include 当与include指令结合使用时，param指令用于将参数值传入被导入的页面 5.2) jsp:forward 当与forward指令结合使用时，param指令用于将参数值传入被转向的页面 5.3) jsp:plugin 当与plugin指令结合使用时，用于将参数传入页面中的JavaBean实例或Applet实例&jsp:param name=&paramName& value=&paramValue&/&*/7. JSP脚本中的内置对象JSP脚本中包含内置对象，这些内置对象都是Servleet API接口的实例，JSP规范对它们进行了默认初始化(由JSP页面对应的Servlet的_jspService()方法来创建这些实例)。即它们已经是对象了，可以直接在JSP脚本中使用了内置对象依次如下: 1) application: javax.servlet.ServletContext的实例，该实例代表JSP所属的WEB应用本身，因此可以使用application来操作WEB相关的数据，application对象通常有如下两个作用:
1.1) 在整个WEB应用的多个JSP、Servlet之间共享数据
application通过setAttribute(String attrName, Object value)方法将一个值设置成application的attrName属性，该属性的值对整个WEB应用有效，因此该WEB应用的每个JSP页面或Servlet都可以访问该属性，访问属性的方法为getAttribute(String attrName)
1) put-application.jsp
&% application.setAttribute(&counter&,String.valueOf(++i)); %&
2) get-application.jsp
&%=application.getAttribute(&counter&)%&
3) GetApplication.java
ServletContext sc = getServletConfig().getServletContext();
out.println(sc.getAttribute(&counter&));
因为application代表的是整个WEB应用，因此可以在JSP、Servlet之间共享数据，由于在Servlet中并没有application内置对象，所以需要获取该web应用的ServletContext实例，每个web应用只有一个ServletContext实例，而在JSP中可以直接通过application内置对象访问该实例
1.2) 访问WEB应用的配置参数
除了共享数据，application还可用于从web.xml中获得WEB应用的配置参数
//从配置参数中获取驱动
String driver = application.getInitParameter(&driver&);
从以上的代码可以看到，可以使用application的getInitParameter(String paramName)来获取WEB应用的配置参数，这些参数应该在web.xml文件中使用context-param元素配置，每个&context-param../&元素配置一个参数
&context-param&
&param-name&driver&/param-name&
&param-value&com.mysql.jdbc.Driver&/param-value&
&/context-param& 2) config对象 javax.servlet.ServletConfig类的实例，config对象代表当前JSP配置信息 &%=config.getServletName()%& 因为所有的JSP页面都有相同的名字: jsp，所以这段JSP代码永远输出jsp 实际上，我们也可以在web.xml文件中配置JSP，这样就可以为JSP页面指定配置信息，并为JSP页面指定一个虚拟路径
1) configTest2.jsp
&!-- 输出该JSP名为name的配置参数 --&
name配置参数的值:&%=config.getInitParameter(&name&)%&&br/&
&!-- 输出该JSP名为age的配置参数 --&
age配置参数的值:&%=config.getInitParameter(&age&)%&
2) web.xml
&!-- 指定Servlet名字 --&
&servlet-name&config&/servlet-name&
&!-- 指定将哪个JSP页面配置成Servlet --&
&jsp-file&/configTest2.jsp&/jsp-file&
&!-- 配置名为name的参数，值为yeeku --&
&init-param&
&param-name&name&/param-name&
&param-value&yeeku&/param-value&
&/init-param&
&!-- 配置名为age的参数，值为30 --&
&init-param&
&param-name&age&/param-name&
&param-value&30&/param-value&
&/init-param&
&/servlet&
&servlet-mapping&
&!-- 指定将config Servlet配置到/config URL--&
&servlet-name&config&/servlet-name&
&url-pattern&/config&/url-pattern&
&/servlet-mapping& 3) exception对象 exception对象是Throwable的实例，代表JSP脚本中产生的错误和异常，是JSP异常机制的一部分。在JSP脚本中无须处理异常，即使该异常是checked异常，JSP脚本包含的异常都可以交给错误处理页面处理，exception对象也仅在异常处理页面中才有效。 打开普通的JSP页面所生成的Servlet类，可以看到如下代码段 public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
throws java.io.IOException, javax.servlet.ServletException
response.setContentType(&text/ charset=GBK&);
out.write(' ');
catch (java.lang.Throwable t)
if (_jspx_page_context != null)
_jspx_page_context.handlePageException(t);
throw new ServletException(t);
_jspxFactory.releasePageContext(_jspx_page_context);
} } 从以上代码可以看出，JSP脚本和静态HTML部分都已经转换成_jspService()方法里的执行型代码，这就是JSP脚本无须处理异常的原因，因为这些脚本都已经被包含在try块中了。一旦try块中捕捉到JSP脚本的异常，并且_jspx_page_context不为null，就会由该对象来处理异常。_jspx_page_context对异常的处理也非常简单: 如果该页面的page指令指定了errorPage属性，则将请求forward到errorPage属性指定的页面，否则使用系统页面来输出异常信息
4) out对象 out对象代表一个页面输出流，通常用于在页面删输出变量值、及常量。所有使用out的地方，都可以使用输出表达式来代替，而且输出表达式更加简洁。从底层原理来看，&%=..%&的本质就是out.write(..); 5) pageContext对象 pageContext对象代表页面上下文，该对象主要用于访问JSP之间的共享数据。使用pageContext可以访问page、request、session、application范围的变量。 pageContext是javax.servlet.jsp.PageContext类的实例，它提供了 getAttribute(String name, int scope)来取得指定范围内的name属性，其中scope可以是如下值:
1) PageContext.PAGE_SCOPE(对应于page范围，默认值)
2) PageContext.REQUEST_SCOPE(对应于requsst范围)
3) PageContext.SESSION_SCOPE(对应于session范围)
4) PageContext.APPLICATION_SCOPE(对应于application范围) 与getAttribute相对的，PageContext内置对象自然也有一个setAttribute()方法，用于将指定变量放入page、request、session、application范围内 &% //使用pageContext设置属性，该属性默认在page范围内 pageContext.setAttribute(&page&,&hello&);
//下面获取各属性所在的范围： out.println(&page变量所在范围：& + pageContext.getAttributesScope(&page&) + &&br/&&); %& 除此之外，pageContext还可用于获取其他内置对象，pageContext对象还包含如下方法
1) ServletRequest getRequest(): 获取request对象
2) ServletResponse getResponse(): 获取response对象
3) ServletConfig getServletConfig(): 获取config对象
4) ServletContext getServletContext(): 获取application对象
5) HttpSession getSession(): 获取session对象 因此，pageContext对象是一个很重要的对象，一旦在JSP、Servlet编程中获取了pageContext对象，就可以通过它提供的相应方法来获取其他内置对象 6) request对象 request对象是JSP中重要的对象，每个request对象封装着一次用户请求，并且所有的请求参数都被封装在request对象中，因此request对象是获取&请求参数&的重要途径。除此之外，request可代表本次请求的范围，所以还可用于操作request范围的属性 和request对象相关的功能有:
1) 获取请求头/请求参数
request是HttpServletRequest接口的实例，它提供了如下几个方法来获得&请求参数&(GET、POST、COOKIE)
1.1) String getParameter(String paramName): 获取paramName参数的值
1.2) Map getParameterMap(): 获取所有请求参数名和参数值所组成的Map对象
1.3) Enumeration getParameterNames(): 获取所有请求参数名和参数值所组成的Enumeration对象
1.4) String[] getParameterValues(String name): 获取参数name的值，如果有同名的多个，则返回数组
HttpServletRequest提供了如下方法来访问HTTP请求头
1.1) String getHeader(String name): 获取指定HTTP头的参数值
1.2) java.util.Enumeration&String& getHeaderNames(): 获取所有请求头的名称
1.3) java.util.Enumeration&String& getHeaders(String name): 获取指定请求头的所有值
1.4) int getIntHeader(String name): 获取指定请求头的值，并转化为整数值返回
2) 操作request范围的属性
HttpServletRequest还包含如下两个方法，用于设置和获取request范围的属性
2.1) setAttribute(String attName, Object attValue): 将attValue设置成request范围的属性(用于JSP页面间共享变量)
2.2) Object getAttribute(String attName): 获取request范围的属性
3) 执行forward、或include
request还有一个功能是执行forward和include，也就是代替JSP所提供的forward和include动作指令。
HttpServletRequest类提供了一个:
RequesDispatcher getRequestDispatcher(String path):
1) path为希望forward或include的目标路径
返回了一个RequesDispatcher对象，它提供如下两个方法：
1) forward(ServletRequest request, ServletResponse response): 执行forward
getRequestDispatcher(&/a.jsp&).forward(request, response);
2) include(ServletRequest request, ServletResponse response): 执行include
getRequestDispatcher(&/a.jsp&).include(request, response);
7) response对象 response代表服务器对客户端的响应。大部分时候，使用out(页面输出流)生成响应更简单。但out是JspWriter的实例，JspWriter是Writer的子类，而Writer是字符流，无法输出非字符数据。如果需要在JSP中生成一副位图、PDF文档，则必须使用response作为响应输出
7.1) response响应生成非字符响应
response是HttpServletResponse接口的实例，该接口提供了一个getOutputStream()方法，该方法返回响应输出&字节流&
&%-- 通过contentType属性指定响应数据是图片 --%&
&%@ page contentType=&image/jpeg& language=&java&%&
&%@ page import=&java.awt.image.*,javax.imageio.*,java.io.*,java.awt.*&%&
//创建BufferedImage对象
BufferedImage image = new BufferedImage(340, 160, BufferedImage.TYPE_INT_RGB);
//以Image对象获取Graphics对象
Graphics g = image.getGraphics();
//使用Graphics画图，所画的图像将会出现在image对象中
g.fillRect(0,0,400,400);
//设置颜色：红
g.setColor(new Color(255,0,0));
//画出一段弧
g.fillArc(20, 20, 100,100, 30, 120);
//设置颜色：绿
g.setColor(new Color(0 , 255, 0));
//画出一段弧
g.fillArc(20, 20, 100,100, 150, 120);
//设置颜色：蓝
g.setColor(new Color(0 , 0, 255));
//画出一段弧
g.fillArc(20, 20, 100,100, 270, 120);
//设置颜色：黑
g.setColor(new Color(0,0,0));
g.setFont(new Font(&Arial Black&, Font.PLAIN, 16));
//画出三个字符串
g.drawString(&red:climb& , 200 , 60);
g.drawString(&green:swim& , 200 , 100);
g.drawString(&blue:jump& , 200 , 140);
g.dispose();
//将图像输出到页面的响应
ImageIO.write(image , &jpg& , response.getOutputStream());
从代码中可以看到几个关键点:
1) 设置了服务器响应数据是image/jpeg，这表明服务器响应是一张JPG图片
2) 最后的响应输出流是一个图片的字节流
也可以在其他HTML页面中使用img标签来显示这张图片
&img src=&img.jsp&&
7.2) 重定向
重定向是response的另外一个用处，要注意的是，和forward这种内部转接&不同&的是，response的重定向会丢失所有的原始请求参数和request范围的属性，因为重定向将生成第二次请求，自然与前一次请求不在同一个request范围内。
HttpServletResponse提供了一个sendRedirect(String path)方法，该方法用于&重定向&到path资源，即&重新&向path资源发送请求
7.3) 增加Cookie
增加Cookie也是使用response内置对象完成的，增加Cookie的步骤如下
1) 创建Cookie实例，构造函数Cookie(String name, String value)
2) 设置Cookie的生命周期，即该Cookie在多长时间内有效
3) 向客户端写Cookie，void addCookie(Cookie cookie): 增加Cookie
//获取请求参数
String name = request.getParameter(&name&);
//以获取到的请求参数为值，创建一个Cookie对象
Cookie c = new Cookie(&username& , name);
//设置Cookie对象的生存期限
c.setMaxAge(24 * 3600);
//向客户端增加Cookie对象
response.addCookie(c);
获取客户端发送的Cookie的方法
//获取本站在客户端上保留的所有Cookie
Cookie[] cookies = request.getCookies();
//遍历客户端上的每个Cookie
for (Cookie c : cookies)
//如果Cookie的名为username，表明该Cookie是我们需要访问的Cookie
if(c.getName().equals(&username&))
out.println(c.getValue());
要注意的是:
1) 使用Cookie对象必须设置生存周期，否则Cookie将会随浏览器关闭而自动消失(session cookie)
2) 如果要存入中文Cookie，则需要使用java.net.URLEncoder进行编码，在获取时用java.net.URLDncoder进行解码 8) session对象
session对象代表一次用户会话，session范围内的属性可以在多个页面的跳转之间共享。session对象是HttpSession的实例，它有如下两个常用的方法:
8.1) setAttribute(String attName, Object attValue): 设置session范围内attName属性的值为attValue
8.2) getAttribute(String attName): 返回session范围内attName属性的值 使用session对象要注意的是: 考虑session本身的目的，通常只应该把与用户会话状态相关的信息放入session范围内。不要仅仅为两个页面之间交换信息，就将信息放入session范围内。如果仅仅是为了页面间交换信息，可以将信息放入request范围内，然后forward请求即可。 除此之外，session机制通常用于保存客户端的状态信息，这些状态信息需要保存到web服务器的硬盘上，所以要求session里的属性值必须是可序列化的，否则将引起&不可序列化异常&，即session的属性值可以是任何可序列化的java对象&4. Servlet基础语法我们知道，JSP的本质就是Servlet，开发者把编写好的JSP页面部署在WEB容器中之后，WEB容器会将JSP编译成对应的Servlet。Servlet和JSP的区别在于:1) Servlet中没有内置对象，原来在JSP中的内置对象都必须由程序显示创建。JSP是Servlet的一种简化，使用JSP只需要完成程序员需要输出到客户端的内容，至于JSP脚本如何嵌入一个类中，由JSP容器完成2) 对于静态HTML标签，Servlet都必须使用页面输出流逐行输出。而Servlet则是一个完整的java类，这个类的service()方法用于生成对客户端的响应0x1: Servlet的配置配置需要的准备条件如下:1. 编辑好的Servlet源代码文件并不能响应用户请求，还必须将其编译成class文件。将编译好的.class文件放在WEB-INF/classes路径下，如果Servlet有包，则还应该将class文件放在对应的包路径下2. 为了让Servlet能响应用户请求，还必须将Servlet配置在web应用中，配置Servlet有两种方式 1) 在Servlet类中使用@WebServlet Annotation进行配置 使用@WebServlet时可制定如下常用属性
1.1) asyncSupported: 声明Servlet是否支持异步操作模式，等价于&async-supported&标签
1.2) displayName: 该Servlet的显示名，通常配合工具使用，等价于&display-name&标签
1.3) initParams: 指定一组Servlet初始化参数，等价于&init-param&标签
1.4) loadOnStartup: 指定Servlet的加载顺序，等价于&load-on-startup&标签
1.5) name: 指定Servlet的name属性，等价于&servlet-name&，如果没有显式指定，则该Servlet的取值即为类的全限定名
1.6) urlPatterns: 指定一组Servlet的URL匹配模式(虚拟路径)。等价于&url-pattern&标签
1.7) value: 该属性等价于urlPatterns属性。两个属性不能同时使用 example: @WebServlet(name=&firstServlet&, urlPatterns={&/firstServlet&}) 需要注意的是，如果打算采用Annotation来配置Servlet，需要注意如下两点:
1) 不要在web.xml文件的根元素&web-app../&中指定metadata-complete=&true&，因为当该属性值为true时，该web应用不会加载Annotation配置的WEB组件(如Servlet、Filter、Listener等)
2) 不要在web.xml文件中配置该Servlet 2) 通过在web.xml文件中进行配置
2.1) 配置Servlet的名字: 对应web.xml文件中的&servlet/&元素
2.2) 配置Servlet的URL: 对应web.xml文件中的&servlet-mapping/&元素。这一步是可选的。但如果没有为Servlet配置URL(虚拟路径)，则该Servlet不能响应用户请求 example: &servlet&
&!-- 指定Servlet的名字，相当于指定@WebServlet的name属性 --&
&servlet-name&firstServlet&/servlet-name&
&!-- 指定Servlet的实现类 --&
&servlet-class&lee.FirstServlet&/servlet-class& &/servlet& &!-- 配置Servlet的URL --& &servlet-mapping&
&!-- 指定Servlet的名字 --&
&servlet-name&firstServlet&/servlet-name&
&!-- 指定Servlet映射的URL地址，相当于指定@WebServlet的urlPatterns属性--&
&url-pattern&/aa&/url-pattern& &/servlet-mapping&需要明白的，Annotation和web.xml配置，只要其中一种即可完成Servlet的配置0x2: JSP/Servlet的生命周期JSP的本质就是Servlet，当Servlet在容器中运行时，其实例的创建及销毁等都不是由程序员决定的，而是由WEB容器进行控制的。创建Servlet实例有两个时机1. 客户端第一次请求某个Servlet时，系统创建该Servlet的实例: 大部分的Servlet都是这种情况2. WEB应用启动时立即创建Servlet实例，即load-on-startup Servlet每个Servlet的运行都遵循如下生命周期1. 创建Servlet实例2. WEB容器调用Servlet的init方法，对Servlet进行初始化3. Servlet初始化之后，将一直存在于容器中，用于响应客户端请求:1) 如果客户端发送GET请求，容器调用Servlet的doGet方法处理并响应请求2) 如果客户端发送POST请求，容器调用Servlet的doPost方法处理并响应请求3) 或者统一用service()方法处理来响应用户请求4. WEB容器决定销毁Servlet时，先调用Servlet的destroy方法，通常在关闭web应用之前销毁Servlet0x3: Filter介绍Filter从本质上来说和Servlet很相似，它主要用于对用于请求(HttpServletRequest)进行预处理、以及对用户响应(HttpServletResponse)进行后处理，是一种典型的&处理链&机制。Filter完整运行的流程是:1) Filter对用于请求(HttpServletRequest)进行预处理2) 接着将请求交给Servlet进行处理并生成响应3) 最后Filter再对服务器响应(HttpServletResponse)进行后处理使用Filter编程的完成流程是:1. 创建Filter类创建Filter必须实现javax.servlet.Filter接口，在该接口中定义了如下3个方法 1) void init(FilterConfig config): Filter的初始化 2) void destroy(): 用于Filter销毁前，完成资源的回收等工作 3) void doFilter(ServletRequest request, ServletResponse response, FilterChain chain): 实现过滤功能，该方法负责对每个请求、及响应增加额外的处理example:import javax.servlet.*;import javax.servlet.http.*;import javax.servlet.annotation.*;import java.io.*;@WebFilter(filterName=&log&, urlPatterns={&/*&})public class LogFilter implements Filter { //FilterConfig可用于访问Filter的配置信息 private FilterC //实现初始化方法 public void init(FilterConfig config) {
this.config =
} //实现销毁方法 public void destroy() {
this.config = null;
} //执行过滤的核心方法 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,ServletException {
//---------下面代码用于对用户请求执行预处理---------
//获取ServletContext对象，用于记录日志
ServletContext context = this.config.getServletContext();
long before = System.currentTimeMillis();
System.out.println(&开始过滤...&);
//将请求转换成HttpServletRequest请求
HttpServletRequest hrequest = (HttpServletRequest)
//输出提示信息
System.out.println(&Filter已经截获到用户的请求的地址： & + hrequest.getServletPath());
//Filter只是链式处理，请求依然放行到目的地址
chain.doFilter(request, response);
//---------下面代码用于对服务器响应执行后处理---------
long after = System.currentTimeMillis();
//输出提示信息
System.out.println(&过滤结束&);
//输出提示信息
System.out.println(&请求被定位到& + hrequest.getRequestURI() + & 所花的时间为: & + (after - before));
} }从代码中可以看到，doFilter()方法中&请求预处理&和&响应后处理&的分界线是chain.doFilter()2. 配置Filter配置Filter和配置Servlet非常类似，需要配置如下两部分: 1) 配置Filter名 2) 配置Filter拦截URL模式: Servlet通常只配置一个URL，而Filter可以同时拦截多个请求的URL。因此在配置Filter的URL模式时通常会使用&模式字符串&(正则字符串)，使得Filter可以拦截多个请求
2.1) 在Filter类中通过Annotation进行配置
2.1.1) asyncSupported: 声明Filter是否支持异步操作模式
2.1.2) dispatcherTypes: 指定该Filter仅对哪种dispatcher模式的请求进行过滤
2.1.2.1) ASYNC
2.1.2.2) ERROR
2.1.2.3) FORWARD
2.1.2.4) INLCUDE
2.1.2.5) REQUEST
这5种组合可以以OR的形式进行组合，dispatcherTypes的默认值是&同时&过滤5种模式的请求
2.1.3) displayName: 该Filter的显示名
2.1.4) filterName: 指定该Filter的名称
2.1.5) initParams: 指定一组Filter配置参数
2.1.6) servletName: 指定多个Servlet的名称，用于指定该Filter仅对这几个Servlet执行过滤
2.1.7) urlPatterns: 指定一组Filter的URL匹配模式(虚拟路径)
2.1.8) value: 该属性等价于urlPatterns属性。两个属性不能同时使用
2.2) 在web.xml文件中通过配置文件进行配置
&!-- Filter的名字，相当于指定@WebFilter的filterName属性 --&
&filter-name&log&/filter-name&
&!-- Filter的实现类 --&
&filter-class&lee.LogFilter&/filter-class&
&!-- 定义Filter拦截的URL地址 --&
&filter-mapping&
&!-- Filter的名字 --&
&filter-name&log&/filter-name&
&!-- Filter负责拦截的URL，相当于指定@WebFilter的urlPatterns属性 --&
&url-pattern&/*&/url-pattern&
&/filter-mapping&3. 使用FilterFilter对应的.class文件被加载后，Filter就会根据设定的URL模式进行响应的预处理、后处理Filter和Servlet的异同从本质上来说，Filter和Servlet很相似，Filter里的doFilter()方法里的代码就是从多个Servlet的service()方法里抽取的通用代码，通过使用Filter可以实现更好的代码复用(类似PHP中的auto_prepend_file、auto_append_file)假设系统有包含多个Servlet，这些Servlet都需要进行一些通用处理，比如1) 权限控制: 在预处理中判断用户是否登录，从而决定是否重定向到初始登录页面2) 记录日志: 将用户的访问记录记录到日志中3) URL Rewrite实现网站伪静态所谓伪静态，是将*.jsp、*.php、这种动态URL伪装成静态HTML页面，目的是提供搜索引擎的收录率，我们可以通过Filter拦截所有发向*.html请求，然后按某种规则将请求forward到实际的*.jsp页面 3.1) 下载Url Rewrite: http://www.tuckey.org/urlrewrite/ 3.2) 将urlrewrite-3.2.0.jar放到WEB-INF/lib目录下 3.3) 配置WEB-INF/web.xml &filter&
&filter-name&UrlRewriteFilter&/filter-name&
&filter-class&org.tuckey.web.filters.urlrewrite.UrlRewriteFilter&/filter-class& &/filter& &!-- 配置Url Rewrite的Filter拦截所有请求 --& &filter-mapping&
&filter-name&UrlRewriteFilter&/filter-name&
&url-pattern&/*&/url-pattern& &/filter-mapping& 3.4) 配置WEB-INF/urlrewrite.xml &urlrewrite&
&!-- 所有配置如下正则表达式的请求 --&
&from&/userinf-(/w*).html&/from&
&!-- 将被forward到如下JSP页面，其中$1代表上面第一个正则表达式所匹配的字符串 --&
&to type=&forward&&/userinf.jsp?username=$1&/to&
&/rule& &/urlrewrite& 3.5) 访问伪静HTML页面: http://localhost:8080/urlrewrite/userinf-LittleHann.html0x4: Listener介绍当WEB应用在WEB容器中运行时，WEB应用内部会不断地发生各种事件:1) web应用被启动2) web应用被停止3) 用户session开始4) 用户session结束5) 用户请求到达通常来说，这些web事件对开发者是透明的实际上，Servlet API提供了大量监听器和监听WEB应用内部事件，从而允许当WEB内部事件发生时自动回调&事件监听器内的方法&使用Listener的步骤如下:1. 实现Listener类监听不同的WEB事件的监听器也不相同。WEB事件监听器接口如下 1) ServletContextListener: 用于监听WEB应用的启动和关闭
1.1) contextInitialized(ServletContextEvent sce)
1.2) contextDestroyed(ServletContextEvent sce) 2) ServletContextAttributeListener: 用于监听ServletContext范围(application)内属性的改变
2.1) attributeAdded(ServletContextAttributeEvent event)
2.2) attributeRemoved(ServletContextAttributeEvent event)
2.3) attributeReplaced(ServletContextAttributeEvent event) 3) ServletRequestListener: 用于监听用户请求
3.1) requestInitialized(ServletRequestEvent sre)
3.2) requestDestroyed(ServletRequestEvent sre)
由于实现了ServletRequestListener接口的监听器可以非常方便地监听到每次请求的创建、销毁，因此web应用可通过该接口的监听器来监听访问该应用的每个请求，从而实现系统日志 4) ServletRequestAttributeListener: 用于监听ServletRequest范围(request)内属性的改变
4.1) attributeAdded(ServletRequestAttributeEvent event)
4.2) attributeRemoved(ServletRequestAttributeEvent event)
4.3) attributeReplaced(ServletRequestAttributeEvent event)
5) HttpSessionListener: 用于监听用户session的开始和结束
5.1) sessionCreated(HttpSessionEvent se)
5.2) sessionDestroyed(HttpSessionEvent se) 实现HttpSessionListener接口的监听器可以监听每个用于会话的开始和断开，因此应用可以通过该监听器监听系统的在线用户 6) HttpSessionAttributeListener: 用于监听HttpSession范围(session)内属性的改变
6.1) attributeAdded(HttpSessionBindingEvent se)
6.2) attributeRemoved(HttpSessionBindingEvent se)
6.3) attributeReplaced(HttpSessionBindingEvent se) 2. 配置Listener配置Listener只要向web应用注册Listener实现类即可，无须配置参数，相对较简单 1) 使用@WebListener修饰Listener实现类 2) 在web.xml文档中使用&listener../&元素进行配置 &listener&
&!-- 指定Listener的实现类 --&
&listener-class&lee.GetConnListener&/listener-class& &/listener&3. 在指定事件发生时执行相应的函数，我们在实现相应的接口时就需要实现相应的函数Copyright (c) 2014 LittleHann All rights reserved