Request介绍及演示样例 PART1

Request在ServletAPI的规范连接地址http://blog.csdn.net/zghwaicsdn/article/details/51035146

HTTP简介



URL是浏览器寻找信息时所须要的资源位置。通过URL。人类和应用程序才干找到、使用并共享因特网上大量的数据资源。

URL语法通过格式：

<scheme>://<user>:<password>@<host>:<port>/<path>;<params>?

<query>#<frag>

差点儿没有那个URL中包括了全部这些组件。

URL最重要的3个部分是方案(scheme)、主机(host)和路径(path).

经常使用介绍

方案 scheme：訪问server以获取资源时要使用那种协议

主机 host:资源宿主server的主机名或点分IP地址

port prot:资源宿主server正在监听的port号。非常多方案都有默认port号(HTTP的默认port号为80)

路径 path:server上资源的本定名，有一个斜杠将其与前面的URL组件分隔开来。

路径组件的语法是与server和方案有关的。

查询 query：某些方案会用这个组件传递參数以激活应用程序(如数据库、公告板、搜索引擎以及其它互联网网关)，查询组件的内容没有通用格式。

用字符？将其与URL的器与部分分隔开来。

片段 frag：一小片或一部分资源的名字，引用对象时，不会将frag字段传递给server，这个字段是在client内部使用的。通过字符“#”将其与URL的器与部分分隔开来。

1.方案--使用什么协议

方案实际上是规定怎样訪问制定资源的主要标识符，它会告诉负责解析URL的应用程序应该使用什么协议。

方案组件必须以一个字母符号開始。有第一个“：”符号将其与URL的其余部分分隔开来。方案名是大写和小写无关的。

2.主机与port号

要想在因特网上找到资源。应用程序要知道是那台即其装载了资源。以及在那台机器的什么地方能够找到能对目标资源进行訪问的server。

主机组件表示了因特网上可以訪问资源的宿主机器。可以使用主机名或IP地址来表示主机名。

port组件标识了server正在监听的网络port。对下层使用TCP协议的Http来说。默认port号为80。

3.路径

URL的路径组件说明了资源位于server的什么地方。

路径通常非常像一个分级的文件系统路径。

4.查询字符串

通过提问题或者查询来缩小所请求资源类型的范围。

查询字符串以一系列“名/值”对的形式出现。名值对之间用字符“&”分隔



http报文

http是因特网的信使，那么HTTP报文就是它用来搬东西的包裹。

HTTP报文是在HTTP应用程序之间发送的数据块。这些数据块以一些文本形式元信息开头。这些信息描写叙述了报文的内容及含义，后面跟着可选的数据部分。

这些报文在client、server和代理之间流动。

HTTP使用流入和流出来描写叙述是无处理的方向。



报文向下游流动

HTTP报文会像河水一样流动。无论是请求报文还是响应报文，全部报文都会向下游流动。全部报文的发送者都在接受者的上游。



报文的组成部分

HTTP报文是简单的格式化数据块。

每条报文都包括一条来自client的请求。或者一条来自server的响应。



三部分组成：

1.对报文进行描写叙述的起始行(start line)

2.包括属性的首部块(header)

3.可选的、包括数据的主题部分(body)

由一个回车符和一个换行符分隔



请求报文的格式

<method> <request-URL> <version>

<headers>



<entiry-body>



响应报文的格式

<version> <status> <reason-phrase>

<headers>



<entiry-body>

简要描写叙述：

方法(method)

  client希望server对资源运行的动作。

是一个单独的词，比方GET、HEAD或POST。

请求URL(request-URL)

  命名了所请求资源。或者URL路径组件的完整URL。假设直接与server进行对化，仅仅要URL的路径组件是资源的绝对路径。

  通常就不会有什么问题--server能够假定自己是URL的主机/port

版本号(version)

  报文所使用的HTTP版本号，其格式看起来是这种：

  HTTP/<major>.<minor>

  当中主要版本(major)和次要版本(minor)都是整数。

状态码(status-code)

  这三位数字描写叙述了请求过程中所发生的情况。每一个请求状态码的第一位数字都用于描写叙述状态的一般类别。

原因短语(reason-phrase)

  数字状态码的可读版本号。包括行终止序列之前的全部文本。

首部(header)

  能够有零个或多个首部。每一个首部都包括一个名字，后面跟着一个冒号(:),然后是一个可选的空格。接着是一个值。最后时一个CRLF。

  首部是由一个空行(CRLF)结束的，表示了首部列表的结束和实体主题部分的開始。

实体的主题部分(entity-body)

  实体的主题部分包括一个由随意数据组成的数据块。并非全部的报文都包括实体的主题部分。有时，报文仅仅是一个CRLF结束。



起始行

全部的HTTP报文都以一个起始行作为開始。

请求报文的起始行说明了要做些什么。响应报文的起始行说明发生了什么。

  请求行

    请求报文请求server对资源进行一些操作。请求报文的起始行，或称为请求行，包括了一个方法和一个请求URL，这种方法描写叙述了server应该运行的操作，

    请求URL描写叙述了要对那个资源运行这种方法。

请求行中还包括HTTP的版本号，用来告知server，client使用的是哪种HTTP。

请求首部

   请求首部仅仅在请求报文中有意义的首部。用于说明是谁或什么在发送请求、请求源来自何处，或者client的喜好及能力。

server能够依据请求首部给出的client信息。

试着为client提供更好的响应。



Request请求參数的编码问题

1.POST方法请求编码处理

  假设client没有在Content-type标头中设置字符编码信息(比如浏览器能够设置Content-Type:text/html;charset=UTF-8),此时使用HttpServletRequest的

  getCharachterEncoding()返回值是null。

在这个情况下，容器若使用的默认编码处理是ISO-8859-1，而client使用UTF-8发送非ASCII字符的请求參数。Servlet直接

  使用getParameter()等方法取得该请求參数值，就会是不对的结果也就是得到乱码。

  能够使用HttpServletRequest的setCharacterEncoding()方法指定取得POST请求參数时使用的编码。

  request.setCharacterEncoding("UTF-8");

  //解码

  相当于要求容器作这个操作：String text = java.net.URLDecoder.decode("要转码的參数","UTF-8");

  //编码

  String text = java.net.URLDecoder.decode("原始字符","ISO-8859-1");

一定要在取得不论什么请求參数前运行request.setCharacterEncoding("UTF-8")方法才有作用。

2.GET请求參数编码处理

setCharacterEncoding()方法仅仅对body中字符编码才有作用。也就是基本上这种方法值对POST产生作用，当请求是GET发送时，则未定义这种方法是否会影响容器处理

编码的方式(就其原因，是由于处理URL的是HTTPserver。而非Web容器)。

在Tomcat在GET时，使用setCharacterEncoding()方法设置编码就不会有作用，取得请求參数时仍会产生乱码。

原因是post请求和get请求存放參数位置是不同的：



post方式參数存放在请求数据包的消息体中。get方式參数存放在请求数据包的请求行的URI字段中，以？開始以param=value&parame2=value2的形式附加在URI字段之后。

而request.setCharacterEncoding(charset); 仅仅对消息体中的数据起作用。对于URI字段中的參数不起作用，我们通常通过以下的代码来完毕编码转换

   

    String paramValue = request.getParameter("paramName");  

    paramValue = new String(paramValue.trim().getBytes("ISO-8859-1"), charset);  



对于全局请求无论GET或者POST都须要在filter过滤器中doFilter方法中设置，比方：这里并不严格

    request.setCharacterEncoding("UTF-8");

        if(request.getMethod().equals("GET")){

            //设置GET方法參数编码为UTF-8,通过装饰类MyServletRequestWrapper来改变request对象的请求參数编码

            request=new MyServletRequestWrapper(request);

        }



servlet中的请求转发

        

servlet中的请求转发主要有三种方式：

1、  forward：是指转发，将当前request和response对象保存，交给指定的url处理。并没有表示页面的跳转，所以地址栏的地址不会发生改变。



2、  redirect：是指重定向,包括两次浏览器请求，浏览器依据url请求一个新的页面，全部的业务处理都转到下一个页面，地址栏的地址会变发生改变。



3、  include：意为包括，即包括url中的内容。进一步理解为。将url中的内容包括进当前的servlet其中来，并用当前servlet的request和respose来运行

url中的内容处理业务.所以不会发生页面的跳转，地址栏地址不会发生改变。



redirect与include、forward的差别在于是不是同一个Request，redirect会有两次交互。

include与forward的差别在于输出的内容，include包括本身servlet与跳转页面内容的结果，而forward不包括本身servlet的内容。



servlet请求转发与重定向的差别：

request.setAttribute("test","hello");

request.getRequestDispacther("/test.jsp").forword(request,response);

response.sendRedirect("test.jsp");

一、显示结果：

1、当用request.getRequestDispacther("/test.jsp").forword(request,response); 请求转发后，结果页面输出：hello

2、当用response.sendRedirect("test.jsp");重定向后。结果页面输出：null

二、底层分析：

1、请求转发（RequestDispatcher）的过程：

         客户首先发送一个请求到server端，server端发现匹配的servlet。并指定它去运行，当这个servlet运行完之后。它要调用getRequestDispacther()方法，

         把请求转发给指定的test.jsp,整个流程都是在server端完毕的，并且是在同一个请求里面完毕的，因此servlet和jsp共享的是同一个request，在servlet里面放的全部东西，在jsp中都能取出来，因此，jsp能把结果getAttribute()出来，getAttribute()出来后运行完把结果返回给client。

整个过程是一个请求，一个响应。

2、重定向（sendRedirect）的工作原理：

     客户发送一个请求到server。server匹配servlet。这都和请求转发一样，servlet处理完之后调用了sendRedirect()这种方法，这种方法是response的方法，所以。当这个servlet处理完之后，看到response.senRedirect()方法，马上向client返回这个响应。响应行告诉client你必需要再发送一个请求。去訪问test.jsp。

     紧接着client受到这个请求后，立马发出一个新的请求，去请求test.jsp,这里两个请求互不干扰，相互独立，在前面request里面setAttribute()的不论什么东西，在后面的request里面都获得不了。

可见，在sendRedirect()里面是两个请求，两个响应。

     

     这种方法会在响应中设置HTTP状态码301以及Location标头，浏览器接受到这个标头，会又一次使用GET方法请求指定的URL，因此地址栏上会反线URL的变更。

三、表面分析：

    1、当用RequestDispatcher请求转发后，地址栏为http://localhost:8080/test/TestServlet

这真好应正了上面的分析，我们起初请求的就一个servlet，至于你server端怎么转，流程怎么样的，我client根本就不知道，我发了请求后我就等

着响应，那你server那边愿意怎么转就怎么转。我client不关心也没法知道，所以当server端转发到jsp后，它把结果返回给client，client根本就

不知道你这个结果是我真正訪问的servlet产生的，还是由servlet转发后下一个组件产生的。

    2、当用sendRedirect重定向后，地址栏为http://localhost:8080/test/test.jsp

由于这个时候，client已经知道了他第二次请求的是test.jsp，server已经告诉client要去訪问test.jsp了。所以地址栏里会显示想要訪问的结果。

假设在处理请求的过程中发现一些错误。而你想要传送server默认的状态与错误信息。能够使用sendError()方法。

因为利用到HTTP状态码，要求浏览器重定向网页，因此。sendError()方法相同必须在未确认输出前运行，否则会抛出IllegalStateException



response.sendError(404);

package com.zghw.servlet.demo;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Date;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;

import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * Servlet implementation class MyRequestServlet
 */
@WebServlet("/myRequestServlet/*")
public class MyRequestServlet extends HttpServlet {
	static void f(Object obj) {
		System.out.println(obj);
	}
	private static final long serialVersionUID = 1L;
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		// http://localhost:8080/servlet-demo/myRequestServlet/test?

id=123&abc=222&abc=333
		// URL信息
		Request_URL(request);
		// request请求行
		RequestLine(request);
		// request请求header
		RequestHeader(request);
		// client和server端信息地址
		RequestLocalRemoteAddr(request);
		// 会话cookie和session
		RequestCookieSession(request);
		// request请求參数及属性
		RequestParameter(request);
		// 请求转发
		RequestDispatcher(request, response);
	}

	/**
	 * 请求转发
	 */
	private void RequestDispatcher(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		f("============ RequestDispatcher ==================");
		// 转发的类型FORWARD,INCLUDE,REQUEST,ASYNC,ERROR
		// REQUEST代表来自client的请求
		// INCLUDE代表了当前(servlet、jsp、html)是被包括在其它(servlet、jsp、html)里的
		// FORWARD代表了由其它Servlet、jsp或html转发过来的
		// ASYNC
		// ERROR
		DispatcherType dispathcerType = request.getDispatcherType();
		f(dispathcerType);
		// 能够使用？id=111能够使用像get方法一样传送字符串查询參数
		RequestDispatcher dispatcher = request
				.getRequestDispatcher("/ms1?

id=111");

		// 在include()或forward()时包括请求參数的作法，仅适用于传递字符串给还有一个Servlet。在调派请求的过程中，假设由必须共享的“对象”
		// 能够设置给请求对象成为属性，称为请求范围属性。
		// 在使用了include或forward后，包括或转发Servlet则能够从request.getAttribute中取出这个值
		// 而response.sendRedirect不能取出值。由于它是二次訪问
		request.setAttribute("nowDate", new Date());

		// include意为包括，即包括url中的内容，进一步理解为。将url中的内容包括进当前的servlet其中来，并用当前servlet的request和
		// respose来运行url中的内容处理业务.所以不会发生页面的跳转。地址栏地址不会发生改变。
		// 使用include()时。被包括的Servlet中不论什么对请求标头的设置都会被忽略。。被包括的Servlet中能够使用getSession()方法取得HttpSession对象
		// dispatcher.include(request, response);

		// forward是指转发，将当前request和response对象保存，交给指定的url处理。并没有表示页面的跳转，所以地址栏的地址不会发生改变。

dispatcher.forward(request, response);

		// response.sendRedirect是指重定向,包括两次浏览器请求，浏览器依据url请求一个新的页面。全部的业务处理都转到下一个页面，
		// 地址栏的地址会变发生改变。
		// response.sendRedirect(request.getContextPath()+"/ms");

		// 假设在处理请求的过程中发现一些错误，而你想要传送server默认的状态与错误信息，能够使用sendError()方法。
		// 由于利用到HTTP状态码，要求浏览器重定向网页，因此，sendError()方法相同必须在未确认输出前运行。否则会抛出IllegalStateException
		// 能够使用HttpServletResponse来查询状态码
		// response.sendError(HttpServletResponse.SC_NOT_FOUND);
		// 当然能够自己定义原因短语
		// response.sendError(HttpServletResponse.SC_NOT_FOUND, "找不到页面");
		f("分发后还运行我");
		f("============  RequestDispatcher end ==================");
	}

	/**
	 * 获取请求參数
	 *
	 * @param request
	 * @throws UnsupportedEncodingException
	 */
	private void RequestParameter(HttpServletRequest request)
			throws UnsupportedEncodingException {
		f("============request parameter==================");
		// 得到编码方式，这个body内容的编码方式，及POST方式提交的编码方式。
		String characterEncoding = request.getCharacterEncoding();
		f(characterEncoding);
		// 得到全部參数值
		Enumeration<String> paramterNames = request.getParameterNames();
		while (paramterNames.hasMoreElements()) {
			String name = paramterNames.nextElement();
			// 依据參数名称得到參数值
			f(name + "=" + request.getParameter(name));
		}
		// 得到全部參数值，以map的形式存储，
		Map<String, String[]> parameterMap = (Map<String, String[]>) request
				.getParameterMap();
		for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
			System.out.print(entry.getKey() + "=");
			if (entry.getValue() != null && entry.getValue().length > 0) {
				for (String value : entry.getValue()) {
					System.out.print(value + ",");
				}
			}
		}
		f("");
		// 得到參数的多个值，比方多选框
		String[] parameterValues = request.getParameterValues("abc");
		if (parameterValues != null) {
			for (String pv : parameterValues) {
				// 没实用
				// String p = URLDecoder.decode(pv, "UTF-8");
				// 直接设置编码方式
				// String p = new String(pv.getBytes("ISO-8859-1"),"UTF-8");
				System.out.print(pv + ",");
			}
		}
		// 依据參数名称得到參数值
		String parameter = request.getParameter("id");
		f("");
		f(parameter);
		f("============request parameter end==================");
	}

	/**
	 * 会话功能 cookie 和session
	 *
	 * @param request
	 */
	private void RequestCookieSession(HttpServletRequest request) {
		f("============cookies session ==================");
		// 取得全部Cookie
		Cookie[] cookies = request.getCookies();
		// 取得session
		HttpSession hs = request.getSession();
		// 假设当前session为空则创建一个，true为自己主动创建session
		HttpSession httpSession = request.getSession(true);
		// 当前的请求的sessionID。没有指定则返回null
		String sessionId = request.getRequestedSessionId();
		f("改变前的sessionId=" + sessionId);
		// request.changeSessionId();
		// sessionId = request.getRequestedSessionId();
		f("改变后的sessionId=" + sessionId);
		boolean sessionIdFromCookie = request.isRequestedSessionIdFromCookie();
		f("sessionID是从Cookie中来的？" + sessionIdFromCookie);
		boolean sessionIdFromURL = request.isRequestedSessionIdFromURL();
		f("sessionId是从URL来的？" + sessionIdFromURL);
		boolean sessionIdValid = request.isRequestedSessionIdValid();
		f("sessionId是有效的？" + sessionIdValid);
		f("============cookies session end==================");
	}

	/**
	 * client地址信息和server端地址信息
	 *
	 * @param request
	 */
	private void RequestLocalRemoteAddr(HttpServletRequest request) {
		f("============IP Local port==================");
		// server的IP地址
		String localAddr = request.getLocalAddr();
		f(localAddr);
		// serverIP地址相应的域名
		String localName = request.getLocalName();
		f(localName);
		// 本地使用的端口号
		int port = request.getLocalPort();
		f(port);
		// 假设client提供了Accept-Language 值，则使用client提供的语言，否则默认就是用server设置的国际化语言
		Locale locale = request.getLocale();
		f(locale);
		// 和上面的不同之处在于这个是多个server语言。默认是使用server设置的本地语言
		Enumeration<Locale> enumLocale = request.getLocales();
		while (enumLocale.hasMoreElements()) {
			Locale loc = enumLocale.nextElement();
			f(loc);
		}
		// clientIP地址
		String remoteAddr = request.getRemoteAddr();
		f(remoteAddr);
		// 获得client的主机名,假设没有就获取IP地址
		String remoteHost = request.getRemoteHost();
		f(remoteHost);
		// client端口号
		int remotePort = request.getRemotePort();
		f(remotePort);
		// client登录用户信息
		String user = request.getRemoteUser();
		f(remotePort);
		f("============IP Local port end ==================");
	}

	/**
	 *
	 * @param request
	 */
	private void RequestHeader(HttpServletRequest request) {
		// 得到请求中全部header的名称集合
		Enumeration<String> en = request.getHeaderNames();
		f("============Header==================");
		while (en.hasMoreElements()) {
			// 得到header名称
			String name = en.nextElement();
			// 取得header相应的值
			f(name + "=" + request.getHeader(name));
		}
		// 查询header中的时间戳，比方If-Modified-Since,，假设不存在返回-1
		long modified = request.getDateHeader("If-Modified-Since");
		f(modified);
		// 查询head中相应的App值
		Enumeration<String> getHeaders = request.getHeaders("App");
		while (getHeaders.hasMoreElements()) {
			// 得到header名称
			String name = getHeaders.nextElement();
			// 取得header相应的值
			f(name + "=" + request.getHeader(name));
		}
		// 查询Header头返回一个数值，假设不存在返回-1
		int intValue = request.getIntHeader("abc");
		f(intValue);
		f("============Header end==================");
	}

	/**
	 * reqeust请求行
	 * 请求报文请求server对资源进行一些操作。请求报文的起始行，或称为请求行，包括了一个方法和一个请求URL。这种方法描写叙述了server应该运行的操作，
	 * 请求URL描写叙述了要对那个资源运行这种方法。请求行中还包括HTTP的版本号，用来告知server。client使用的是哪种HTTP。
	 */
	private void RequestLine(HttpServletRequest request) {
		f("============request line==================");
		// 请求使用的协议及版本号
		String protocol = request.getProtocol();
		f(protocol);
		// 请求使用的方法比方GET POST
		String method = request.getMethod();
		f(method);
		f("============request line end==================");
	}

	/**
	 * 请求取得URL的全部信息
	 *
	 * @param request
	 * @throws UnsupportedEncodingException
	 */
	private void Request_URL(HttpServletRequest request)
			throws UnsupportedEncodingException {
		f("============request URL ==================");
		// 实例http://localhost:8080/servlet-demo/myRequestServlet/test?id=123&abc=222
		// 方案实际上是规定怎样訪问制定资源的主要标识符。它会告诉负责解析URL的应用程序应该使用什么协议。

// 方案组件必须以一个字母符号開始，有第一个“：”符号将其与URL的其余部分分隔开来。方案名是大写和小写无关的。
		String scheme = request.getScheme();
		// 输出：http
		f(scheme);
		// 主机组件表示了因特网上能够訪问资源的宿主机器
		String serverName = request.getServerName();
		// 输出：localhost
		f(serverName);
		// 端口组件标识了server正在监听的网络端口。
		int serverPort = request.getServerPort();
		// 输出：8080
		f(serverPort);
		// 项目在web容器中的根路径，环境路径。

假设应用程序环境路径和Webserver环境根路径相同。则应用程序环境路径为空字符串，
		// 假设不是。则应用程序环境路径以“/”开头。不包括“/”结尾。
		String contextPath = request.getContextPath();
		// 输出：/servlet-demo
		f(contextPath);
		// 资源位于server的什么地方。路径通常非常像一个分级的文件系统路径。

// Servlet中资源路径
		String servletPath = request.getServletPath();
		// 输出：/myRequestServlet/test
		f(servletPath);
		// 通过提问题或者查询来缩小所请求资源类型的范围。

// 查询字符串以一系列“名/值”对的形式出现，名值对之间用字符“&”分隔
		String queryString = request.getQueryString();
		// 输出：id=123&abc=222
		f(queryString);
		f(URLDecoder.decode(queryString, "UTF-8"));
		// 路径信息不包括请求參数，值的是不包括环境路径与Servlet路径部分的额外路径信息。

// 假设没有额外路径信息。则为null(扩展映射、预设Servlet、全然匹配的情况下，getPathInfo()就会取得null)
		// 假设有额外路径信息。则是一个以“/”开头的字符串。

String pathInfo = request.getPathInfo();
		f(pathInfo);
		// 请求的URI不包括方案主机名端口查询參数。仅包括地址
		String requestURI = request.getRequestURI();
		// 输出：/servlet-demo/myRequestServlet/test
		f(requestURI);
		// 请求的URL不包括查询參数
		String requestURL = request.getRequestURL().toString();
		// 输出：http://localhost:8080/servlet-demo/myRequestServlet/test
		f(requestURL);
		// server端真实绝对路径资源位置
		String pathTranslated = request.getPathTranslated();
		f(pathTranslated);
		f("============request URL end==================");
	}

	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}

}

package com.zghw.servlet.demo;

import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

/**
 * 包装request的请求參数编码的转换
 *
 * @author zghw
 *
 */
public class MyServletRequestWrapper extends HttpServletRequestWrapper {
	private static final String CHARSET = "UTF-8";

	public MyServletRequestWrapper(HttpServletRequest request) {
		super(request);
	}

	/**
	 * 重写get方法编码參数
	 */
	@Override
	public String getParameter(String name) {
		String paramter = super.getParameter(name);
		paramter = ("").equals(paramter) ?

null : convert(paramter);
		return paramter;
	}

	@Override
	public Map<String, String[]> getParameterMap() {
		Map<String, String[]> map = super.getParameterMap();
		Map<String,String[]> wapper=new HashMap<String,String[]>();
		if (map != null) {
			for (Map.Entry<String, String[]> m : map.entrySet()) {
				String[] orgin = m.getValue();
				String[] values = convertArray(orgin);
				wapper.put(m.getKey(), values);
			}
		}
		return wapper;
	}

	@Override
	public String[] getParameterValues(String name) {
		String[] strs = super.getParameterValues(name);
		if (strs != null) {
			for (int i = 0; i < strs.length; i++) {
				strs[i] = convert(strs[i]);
			}
		}
		return strs;
	}

	private String[] convertArray(String[] orgin) {
		String[] value = null;
		if (orgin != null) {
			value = new String[orgin.length];
			int i = 0;
			for (String val : orgin) {
				value[i] = convert(val);
				i++;
			}
		}
		return value;
	}

	private String convert(String paramter) {
		if (paramter != null) {
			try {
				//设置请求參数的默认编码方式ISO-8859-1变为UTF-8
				return new String(paramter.getBytes("ISO-8859-1"), CHARSET);
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

}

package com.zghw.servlet.demo;

import java.io.IOException;
import java.util.Date;
import java.util.Enumeration;

import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyServlet1 extends HttpServlet {
	private static final long serialVersionUID = 1L;
	public static void f(Object obj){
		System.out.println(obj);
	}
	public void init() throws ServletException {
		System.out.println("运行Servlet1 init()");
	}
	public void destroy() {
		System.out.println("运行Servlet1 destroy()");
    }
	public void doGet(HttpServletRequest request, HttpServletResponse respose)
			throws ServletException, IOException {
		System.out.println("运行Servlet1 service");
		DispatcherType dispathcerType = request.getDispatcherType();
		System.out.println("dispathcerType:"+dispathcerType);
		//取出上一个转发的全部request的属性名
		Enumeration<String> names = request.getAttributeNames();
		while(names.hasMoreElements()){
			String name = names.nextElement();
			//取出属性值
			f(name+":"+request.getAttribute(name));
		}
		String id = request.getParameter("id");
		f("paramter:id="+id);
		Date now=(Date)request.getAttribute("nowDate");
		f("得到上一个转发送来的值：nowDate = "+now);
		//FORWARD上一个servlet或JSP html的信息參数属性，对于FORWARD前一个请求须要做的事情。
		if(dispathcerType.equals(DispatcherType.FORWARD)){
			String contextPath=(String)request.getAttribute(RequestDispatcher.FORWARD_CONTEXT_PATH);
			f("FORWARD:"+contextPath);
			String pathInfo= (String)request.getAttribute(RequestDispatcher.FORWARD_PATH_INFO);
			f("FORWARD:"+pathInfo);
			String queryString= (String)request.getAttribute(RequestDispatcher.FORWARD_QUERY_STRING);
			f("FORWARD:"+queryString);
			String requestURI= (String)request.getAttribute(RequestDispatcher.FORWARD_REQUEST_URI);
			f("FORWARD:"+requestURI);
			String servletPath= (String)request.getAttribute(RequestDispatcher.FORWARD_SERVLET_PATH);
			f("FORWARD:"+servletPath);
		}
		//INCLUDE包括类型时。能够从參数中取得的类型
		if(dispathcerType.equals(DispatcherType.INCLUDE)){
			String contextPath= (String)request.getAttribute(RequestDispatcher.INCLUDE_CONTEXT_PATH);
			f("INCLUDE:"+contextPath);
			String pathInfo= (String)request.getAttribute(RequestDispatcher.INCLUDE_PATH_INFO);
			f("INCLUDE:"+pathInfo);
			String queryString= (String)request.getAttribute(RequestDispatcher.INCLUDE_QUERY_STRING);
			f("INCLUDE:"+queryString);
			String requestURI= (String)request.getAttribute(RequestDispatcher.INCLUDE_REQUEST_URI);
			f("INCLUDE:"+requestURI);
			String servletPath= (String)request.getAttribute(RequestDispatcher.INCLUDE_SERVLET_PATH);
			f("INCLUDE:"+servletPath);
		}
		//ERROR类型时，能够从request.getAttribute();中取得须要的參数值
		if(dispathcerType.equals(DispatcherType.ERROR)){
			String errorException= (String)request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);
			String exceptionType= (String)request.getAttribute(RequestDispatcher.ERROR_EXCEPTION_TYPE);
			String errorMessage= (String)request.getAttribute(RequestDispatcher.ERROR_MESSAGE);
			String requestURI= (String)request.getAttribute(RequestDispatcher.ERROR_REQUEST_URI);
			String servletName= (String)request.getAttribute(RequestDispatcher.ERROR_SERVLET_NAME);
			String statusCode= (String)request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
		}
	}
}

package com.zghw.servlet.demo;

import java.io.IOException;
import java.util.Enumeration;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyFilter implements Filter {

	// 取得过滤器配置參数供doFilter使用
	private FilterConfig filterConfig;

	/**
	 * FilterConfig包括了Filter配置的參数。能够得到ServletContext对象
	 */
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		System.out.println("运行MyFilter init");
		this.filterConfig = filterConfig;
		// 获取过滤器的配置參数
		Enumeration<String> paramNames = filterConfig.getInitParameterNames();
		while (paramNames.hasMoreElements()) {
			String name = paramNames.nextElement();
			System.out.println("过滤器配置的參数 name = " + name + " , value = "
					+ filterConfig.getInitParameter(name));
		}

		// 用来測试ServletContextAttributeListenter实现类作用。
		ServletContext servletContext = filterConfig.getServletContext();
		// 当加入属性值时，会通知监听器调用attributeAdded
		servletContext.setAttribute("test1",
				"test ServletContextAttributeListenter add in MyFilter ");
		// 当改变属性值时，会通知监听器调用attributeReplaced
		servletContext.setAttribute("test1",
				"test ServletContextAttributeListenter replace in MyFilter ");
		// 当改变属性值时，会通知监听器调用attributeRemoved
		servletContext.removeAttribute("test1");
	}

	/**
	 * 当请求来到容器，而容器发现调用Servlet的serivce方法前，能够应用某过滤器时。就会调用该过滤器的doFilter()方法，
	 * 能够在doFilter（）方法中进行service()方法的前置处理，而后决定是否调用FilterChain的doFilter()方法。

* 假设调用了FilterChain的doFilter
	 * ()方法，就会运行下一个过滤器，假设没有下一个过滤器了，就调用请求目标Servlet的service()方法。
	 * 假设由于某个情况(如用户没有通过验证
	 * )而没有调用FilterChain的doFilter()方法。则请求就不会继续交给接下来的过滤器或目标Servlet,
	 * 这时候就是所谓的拦截请求(从Servlet的观点来看。根本不知道浏览器有发出请求)。
	 * 在陆续调用完FIlter实例的doFilter()仍至Servlet的service
	 * ()之后，流程会以堆栈顺序返回，所以在FilterChain的doFilter()运行完成后。 就能够针对service()方法做兴许处理。
	 *
	 * 仅仅须要知道FilterChain运行后会以堆栈顺序返回就可以。

在实现Filter接口时，不用理会这个Filter前后是否有其它Filter，
	 * 应该将之作为一个独立的元件设计。 Servlet/JSP提供的过滤器机制，事实上是Java EE设计模式中Interceptor
	 * Filter模式的实现。假设希望能够弹性地抽换某功能地前置与后置处理元件 (比如Servlet/JSP
	 * 中Servlet的service()方法的前置与后置处理)。就能够应用Interceptor Filter模式。
	 */
	@Override
	public void doFilter(ServletRequest req, ServletResponse res,
			FilterChain chain) throws IOException, ServletException {
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
		// POST方法參数编码为UTF-8
		request.setCharacterEncoding("UTF-8");
		if (request.getMethod().equals("GET")) {
			// 设置GET方法參数编码为UTF-8,通过装饰类MyServletRequestWrapper来改变request对象的请求參数编码
			request = new MyServletRequestWrapper(request);
		}
		System.out.println("运行MyFilter doFilter");
		System.out.println("运行MyFilter doFilter before");
		chain.doFilter(request, response);
		response.setCharacterEncoding("UTF-8");
		System.out.println("运行MyFilter doFilter after");
	}

	@Override
	public void destroy() {
		System.out.println("运行MyFilter destroy");
	}

}