javax.servlet.Filter过滤器讲解

一 、javax.servlet.Filter过滤器
过滤器(Filter)位于客户端和web应用程序之间，用于检查和修改两者之间流过的请求和响应。
在请求到达Servlet/JSP之前，过滤器截获请求。 在响应送给客户端之前，过滤器截获响应。
多个过滤器形成一个过滤器链，过滤器链中不同过滤器的先后顺序由部署文件web.xml中过滤器映射<filter-mapping>的顺序决定。 最先截获客户端请求的过滤器将最后截获Servlet/JSP的响应信息。
可以为一个Web应用组件部署多个过滤器，这些过滤器组成一个过滤器链，每个过滤器只执行某个特定的操作或者检查。这样请求在到达被访问的目标之前，需要经过这个过滤器链。
Servlet API的2.3版本的一个新功能就是能够为servlet和JSP页面定义过滤器。过滤器提供了某些早期服务器所支持的非标准“servlet链接”的一 种功能强大且标准的替代品。过滤器是一个程序，它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或 JSP页面上，并且可以检查进入这些资源的请求信息。
1.过滤器可以作如下的选择：
以常规的方式调用资源（即，调用servlet或JSP页面）。

    利用修改过的请求信息调用资源。
    调用资源，但在发送响应到客户机前对其进行修改。
    阻止该资源调用，代之以转到其他的资源，返回一个特定的状态代码或生成替换输出。
    一般用途：

? Session 管理
? 权限验证
? 日志记录
? 字符编码转换

过滤器只在与servlet规范2.3版兼容的服务器上有作用。如果你的Web应用需要支持旧版服务器，就不能使用过滤器。
2． 建立基本过滤器
建立一个过滤器涉及下列五个步骤：

1） 建立一个实现Filter接口的类。这个类需要三个方法，分别是：doFilter、init和destroy。doFilter方法 包含主要的过滤代码（见第2步），init方法建立设置操作，而destroy方法进行销毁。

2） 在doFilter方法中放入过滤行为。doFilter方法的第一个参数为ServletRequest对象。此对象给过滤器提供了对进入的信息（包括 表单数据、cookie和HTTP请求头）的完全访问。第二个参数为ServletResponse，通常在简单的过滤器中忽略此参数。最后一个参数为 FilterChain，如下一步所述，此参数用来调用servlet或JSP页。

3） 调用FilterChain对象的doFilter方法。Filter接口的doFilter方法取一个FilterChain对象作为它的一个参数。在 调用此对象的doFilter方法时，激活下一个相关的过滤器。如果没有另一个过滤器与servlet或JSP页面关联，则servlet或JSP页面被 激活。

4） 对相应的servlet和JSP页面注册过滤器。在部署描述符文件（web.xml）中使用filter和filter-mapping元素。

5） 禁用激活器servlet。防止用户利用缺省servlet URL绕过过滤器设置。

3.例如：建立一个实现Filter接口的类
所有过滤器都必须实现javax.servlet.Filter。这个接口包含三个方法，分别为doFilter、init和destroy。
1）、public void doFilter(ServletRequset request, ServletResponse response,FilterChain chain)
thows ServletException, IOException

每当调用一个过滤器（即，每次请求与此过滤器相关的servlet或JSP页面）时，就执行其doFilter方法。正是这个方法包含了大部分过滤逻辑。

第一个参数为与传入请求有关的ServletRequest。对于简单的过滤器，大多数过滤逻辑是基于这个对象的。如果处理HTTP请求，并且需要 访问诸如getHeader或getCookies等在ServletRequest中无法得到的方法，就要把此对象构造成 HttpServletRequest。

第二个参数为ServletResponse。除了在两个情形下要使用它以外，通常忽略这个参数。首先，如果希望完全阻塞对相关 servlet或JSP页面的访问。可调用response.getWriter并直接发送一个响应到客户机。其次，如果希望修改相关的servlet或 JSP页面的输出，可把响应包含在一个收集所有发送到它的输出的对象中。然后，在调用serlvet或JSP页面后，过滤器可检查输出，如果合适就修改 它，之后发送到客户机。

DoFilter的最后一个参数为FilterChain对象。对此对象调用doFilter以激活与servlet或JSP页面相关的下一个过滤器。如果没有另一个相关的过滤器，则对doFilter的调用激活servlet或JSP本身。

2）、public void init(FilterConfig config)thows ServletExceptioninit 方法只在此过滤器第一次初始化时执行，不是每次调用过滤器都执行它。对于简单的过滤器，可提供此方法的一个空体，但有两个原因需要使用init。首 先，FilterConfig对象提供对servlet环境及web.xml文件中指派的过滤器名的访问。因此，普遍的办法是利用init将 FilterConfig对象存放在一个字段中，以便doFilter方法能够访问servlet环境或过滤器名。这种处理在第3节描述。其 次，FilterConfig对象具有一个getInitParameter方法，它能够访问部署描述符文件（web.xml）中分配的过滤器初始化参 数。初始化参数的使用在第5节中描述。


3）、public void destroy( )
此方法在利用一个给定的过滤器对象永久地终止服务器（如关闭服务器）时调用。大多数过滤器简单地为此方法提供一个空体，不过，可利用它来完成诸如关闭过滤器使用的文件或数据库连接池等清除任务。

4）、注册过滤器
部署描述符文件的2.3版本引入了两个用于过滤器的元素，分别是：filter和filter-mapping。filter元素向系统注册一个过滤对象，filter-mapping元素指定该过滤对象所应用的URL。

5）、

filter元素

filter元素位于部署描述符文件（web.xml）的前部，所有filter-mapping、servlet或servlet-mapping元素之前。filter元素具有如下六个可能的子元素：
icon 这是一个可选的元素，它声明IDE能够使用的一个图象文件。
filter-name 这是一个必需的元素，它给过滤器分配一个选定的名字。
display-name 这是一个可选的元素，它给出IDE使用的短名称。
description 这也是一个可选的元素，它给出IDE的信息，提供文本文档。
filter-class 这是一个必需的元素，它指定过滤器实现类的完全限定名。
init-param 这是一个可选的元素，它定义可利用FilterConfig的getInitParameter方法读取的初始化参数。单个过滤器元素可包含多个init-param元素。

filter-mapping元素

filter-mapping元素位于web.xml文件中filter元素之后serlvet元素之前。它包含如下三个可能的子元素：
@filter-name 这个必需的元素必须与用filter元素声明时给予过滤器的名称相匹配。
@url-pattern 此元素声明一个以斜杠（/）开始的模式，它指定过滤器应用的URL。所有filter-mapping元素中必须提供url-pattern或 servlet-name。但不能对单个filter-mapping元素提供多个url-pattern元素项。如果希望过滤器适用于多个模式，可重复 整个filter-mapping元素。
@servlet-name 此元素给出一个名称，此名称必须与利用servlet元素给予servlet或JSP页面的名称相匹配。不能给单个filter-mapping元素提供 多个servlet-name元素项。如果希望过滤器适合于多个servlet名，可重复这个filter-mapping元素。
4、Servlet和Filter的url匹配以及url-pattern详解

一，servlet容器对url的匹配过程：
当一个请求发送到servlet容器的时候，容器先会将请求的url减去当前应用上下文的路径作为servlet的映射url，比如我访问的是http://localhost/test/aaa.html，我的应用上下文是test，容器会将http://localhost/test去掉，剩下的/aaa.html部分拿来做servlet的映射匹配。这个映射匹配过程是有顺序的，而且当有一个servlet匹配成功以后，就不会去理会剩下的servlet了（filter不同，后文会提到）。其匹配规则和顺序如下：

1.      精确路径匹配。例子：比如servletA 的url-pattern为 /test，servletB的url-pattern为 /* ，这个时候，如果我访问的url为http://localhost/test ，这个时候容器就会先 进行精确路径匹配，发现/test正好被servletA精确匹配，那么就去调用servletA，也不会去理会其他的servlet了。
2.      最长路径匹配。例子：servletA的url-pattern为/test/*，而servletB的url-pattern为/test/a/*，此时访问http://localhost/test/a时，容器会选择路径最长的servlet来匹配，也就是这里的servletB。
3.      扩展匹配，如果url最后一段包含扩展，容器将会根据扩展选择合适的servlet。例子：servletA的url-pattern：*.action
4.      如果前面三条规则都没有找到一个servlet，容器会根据url选择对应的请求资源。如果应用定义了一个default servlet，则容器会将请求丢给default servlet（什么是default servlet？后面会讲）。

二，url-pattern详解

根据这个规则表，就能很清楚的知道servlet的匹配过程，所以定义servlet的时候也要考虑url-pattern的写法，以免出错。
对于filter，不会像servlet那样只匹配一个servlet，因为filter的集合是一个链，所以只会有处理的顺序不同，而不会出现只选择一 个filter。Filter的处理顺序和filter-mapping在web.xml中定义的顺序相同。

在web.xml文件中，以下语法用于定义映射：
1、以”/’开头和以”/*”结尾的是用来做路径映射的。
2、以前缀”*.”开头的是用来做扩展映射的。
3、“/” 是用来定义default servlet映射的。
4、剩下的都是用来定义详细映射的。比如： /aa/bb/cc.action
注意：所以，为什么定义”/*.action”这样一个看起来很正常的匹配会错？因为这个匹配即属于路径映射，也属于扩展映射，导致容器无法判断。

url-pattern配置技巧
   

配置Filter-mapping时，配置如下：

<filter-mapping>
<filter-name>aFilter</filter-name>
<url-pattern>/a/*</url-pattern>
</filter-mapping>
希望能过滤网站a地址下的所有请求。在实际的运行中，它确实能过滤a地址下的，不会过滤b地址下的。但是对于不在子目录下的请求（假如我的站点叫demo)，如：http://localhost:8080/demo/aDemo.do，这个请求地址竟然能和 <url-pattern>/a/*</url-pattern>匹配。这显然是错误的。我们仅希望能过滤http://localhost:8080/demo/a/*.do。

经查询资料，修改映射为：

<filter-mapping>
<filter-name>aFilter</filter-name>
<url-pattern>/a/*.*</url-pattern>
</filter-mapping>

Ok!成功！

配置servlet的<url-pattern>时，容器会首先查找完全匹配，如果找不到，再查找目录匹配，如果也找不到，就查找扩展名匹配。 如果一个请求匹配多个“目录匹配”，容器会选择最长的匹配。

①　完全匹配

1.        <!-- 必须以一个“/”开头，可以有扩展名，但不是必需的。 --> 

2.        <url-pattern>/test/list.do</url-pattern> 

② 目录匹配

1.        <!-- 必须以一个“/”开头，目录可以是虚拟或实际的，总是以一个“/*”结束 --> 

2.        <url-pattern>/test/*</url-pattern> 

③ 扩展名匹配

1.        <!-- 必须以“*”加“.”加扩展名的形式 --> 

2.        <url-pattern>*.do</url-pattern> 
--------------------------------------------------------------------------------------------------
二、代码示例

1、登录过滤
未登录无权访问系统相关内容（如：用户只有登陆之后才能浏览resource目录下的资源，而这些resource的地址都是静态地址，这时候就用到了过滤器）
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) req;
HttpServletResponse resp = (HttpServletResponse) res;
HttpSession session = req.getSession();
ServletContext application = session.getServletContext();
if (session.getAttribute("username") == null) {
response.sendRedirect("error/priv_error.jsp");
return;
} else {
chain.doFilter(request, response);
}
}
web.xml配置
<filter>
<filter-name>myFilter</filter-name>
<filter-class>cn.com.test.filter.myFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>myFilter</filter-name>
<url-pattern>/resource/*</url-pattern>

</filter-mapping>

<!--不能写多个url-pattern值，只能一个一个的写,如下:-->

<filter-mapping>
<filter-name>myFilter</filter-name>
<url-pattern>/meServlet</url-pattern>
</filter-mapping>

<filter>
<filter-name>myFilter</filter-name>
<filter-class>cn.com.test.filter.myFilter</filter-class>
</filter>

<filter-mapping>
<filter-name>myFilter</filter-name>
在过滤器程序中判断到resource目录下的请求的用户session是否为空，如果空的话就跳转至错误页面。
<url-pattern>/resource/*</url-pattern>
</filter-mapping>
2、操作记录
用户行为操作记录（如：需求要记录用户进入系统的最基本的增删改查操作，这时候就用到了过滤器）
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
String url = ((HttpServletRequest) request).getRequestURL().toString();
String param = ((HttpServletRequest) request).getQueryString();
System.out.println(" param= " + param);
chain.doFilter(request, response);
if (url.indexOf(".action") != -1) {
Map logMap = (Map) ((HttpServletRequest) request).getSession()
.getServletContext().getAttribute("logMap");
if (logMap == null) {
logMap = SystemLogManage.getLogMap();
((HttpServletRequest) request).getSession().getServletContext()
.setAttribute("logMap", logMap);
}
String actionName = url.substring(url.lastIndexOf("/") + 1, url.lastIndexOf("."));
SystemLogMap logmapInfo = (SystemLogMap) logMap.get(actionName);
if (logmapInfo != null) {
SystemLog systemLog = new SystemLog();
systemLog.setFunctionName(logmapInfo.getMapFunctionName());
User user = (User) ((HttpServletRequest) request).getSession().getAttribute("userInfo");
String loginName = "guest";
if (user == null) {
loginName = "guest";
} else {
loginName = user.getName();
}
systemLog.setUserName(loginName);
systemLog.setOperationTime(new Date());
String tableParam = logmapInfo.getMapFunctionPara();
System.out.println("tableParam=" + tableParam + " param="+ param);
if (tableParam != null && !"".equals(tableParam)) {
if (param != null && !"".equals(param)){
systemLog.setFunctionParaValue(param);
}
else {
String paramT = request.getParameter(tableParam);
systemLog.setFunctionParaValue(tableParam + "="
+ paramT);
}
} else {
systemLog.setFunctionParaValue("");
}
SystemLogManage.saveLog(systemLog);
}
}
}
web.xml中如下配置：
<!--系统操作日志 -->
<filter>
<filter-name>loggingFilter</filter-name>
<filter-class>
</filter>
<filter-mapping>
<filter-name>loggingFilter</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
<filter>
<filter-name>loggingFilter</filter-name>
<filter-class>cn.com.xinli.ump.webapp.action.systemlog.LoggingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>loggingFilter</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
另外像我们最常用的字符过滤器：（这里配置了Spring自身的过滤器）
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
3、页面编码
过滤编码器
/**
* 过滤编码器
* @author Administrator
*
*/
public class EncodeFilter implements Filter {
//编码格式
protected String encoding = null;
//读取filter节点中的参数(将FilterConfig的作用范围扩大)
protected FilterConfig filterConfig = null;
//是否编码
protected boolean ignore = true;
//过滤器销毁
public void destroy() {
this.encoding = null;
this.filterConfig = null;
}
//进行过滤
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
//编码为true或request对象属性CharacterEncoding为空时,
if (ignore || (request.getCharacterEncoding() == null)) {
//传参数request对象表示取request流的编码格式
String encoding = selectEncoding(request);
if (encoding != null)
request.setCharacterEncoding(encoding);
}
//交给下一个Filter
chain.doFilter(request, response);

}
//初始化Filter类
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
//读取web.xml文件编码格式参数
this.encoding = filterConfig.getInitParameter("encoding");
//读取web.xml文件是否编码参数(ignore为ture是进行编码)
String value = filterConfig.getInitParameter("ignore");
//3种情况进行编码
if (value == null) {
this.ignore = true;
} else if (value.equalsIgnoreCase("true")) {
this.ignore = true;
} else if (value.equalsIgnoreCase("yes")) {
this.ignore = true;
} else {
this.ignore = false;
}
}
//取值：编码格式
protected String selectEncoding(ServletRequest request) {
return (this.encoding);

}

}
<filter>
<filter-name>EncodeFilter</filter-name>
<filter-class>
org.com.moon.baolin.tools.EncodeFilter
</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>GB2312</param-value>
</init-param>
<init-param>
<param-name>ignore</param-name>
<param-value>true</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>EncodeFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

4、 在过滤器中实现权限控制类，用来检验用户是否有权限进入当前页面

public class FilterServlet extends HttpServlet implements Filter {
private static final long serialVersionUID = 5162189625393315379L;
private static Logger LOG = Logger.getLogger(FilterServlet.class);
/**
* 配置允许的角色
*/
private String allowRole = null;
/**
* 重定向的URL
*/
private String redirectURl = null;

public void init(FilterConfig filterConfig) throws ServletException {
// 得到允许的角色,这个参数是由web.xml里的allowRole所指定
this.allowRole = filterConfig.getInitParameter("allowRole");
// 指定要重定向的页面
this.redirectURl = "/login.html";
}

/**
* 在过滤器中实现权限控制
*/
public void doFilter(ServletRequest sRequest, ServletResponse sResponse,
FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) sRequest;
HttpServletResponse response = (HttpServletResponse) sResponse;
HttpSession session = request.getSession();

// 如果回话中的用户为空,页面重新定向到登陆页面
if (session.getAttribute("UserAction.CURRENT_USER") == null) {
response.sendRedirect(redirectURl);
}
// 会话中存在用户，则验证用户是否存在当前页面的权限
else {
User user = (User) session.getAttribute("UserAction.CURRENT_USER");
try {
// 如果用户没有当前页的权限,页面重新定向到登陆页面
if ("0".equals(allowRole) || user.hasPower(allowRole)) {
filterChain.doFilter(sRequest, sResponse);
} else {
// 过滤器经过过滤后，过滤链继续传递请求和响应
response.sendRedirect(redirectURl);
}
} catch (Throwable e) {
LOG.error("权限过滤时候出现错误", e);
throw new RuntimeException("权限过滤时候出现错误", e);
}
}
}

public void destroy() {
this.allowRole = null;
this.redirectURl = null;
}
}


在web.xml中配置 要过滤的页面和能进入当前页面的角色
xml 代码
<filter>
<filter-name>UserAdmin<filter-name>
<filter-class>com.emap.web.FilterServlet<filter-class>
<init-param>
<param-name>allowRole<param-name>
<param-value>1<param-value>
<init-param>
<filter>
<filter-mapping>
<filter-name>UserAdmin<filter-name>
<url-pattern>/jsp/security/*<url-pattern>
<filter-mapping>
上面配置的意思是说，当用户进入/jsp/security文件夹下的页面的时候，程序会进入FilterServlet 里的doFilter方法里，进行权限判断。
其他的页面权限控制：
1.你可以在filter里判断用户是否登录，然后需要特殊权限能访问的页面，在页面里进行判断。
2.推荐使用开源框架ACEGI来进行权限控制。