过滤器
过滤器JavaWeb三大组件之一，它与Servlet很相似！过滤器是用来拦截请求的，而不是处理请求的。
当用户请求某个Servlet时，会先执行部署在这个请求上的Filter，如果Filter“放行”，那么会继承执行用户请求的Servlet；如果Filter不“放行”，那么就不会执行用户请求的Servlet。
其实可以这样理解，当用户请求某个Servlet时，Tomcat会去执行注册在这个请求上的Filter，然后是否“放行”由Filter来决定。可以理解为，Filter来决定是否调用Servlet！当执行完成Servlet的代码后，还会执行Filter后面的代码。
过滤器的实现
其实过滤器与Servlet很相似，我们回忆一下如果写的第一个Servlet应用！写一个类，实现Servlet接口！没错，写过滤器就是写一个类，实现Filter接口。
public class HelloFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("Hello Filter");
}
public void destroy() {}
}
第二步也与Servlet一样，在web.xml文件中部署Filter：
<filter>
<filter-name>helloFilter</filter-name>
<filter-class>com.rl.filter.HelloFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>helloFilter</filter-name>
<url-pattern>/index.jsp</url-pattern>
</filter-mapping>
url-pattern和Servlet的url-pattern的匹配规则一模一样。
当用户访问index.jsp页面时，会执行HelloFilter的doFilter()方法！在我们的示例中，index.jsp页面是不会被执行的，如果想执行index.jsp页面，那么我们需要放行！
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("filter start...");
chain.doFilter(request, response);
System.out.println("filter end...");
}
过滤器的生命周期
- init(FilterConfig)：在服务器启动时会创建Filter实例，并且每个类型的Filter只创建一个实例，从此不再创建！在创建完Filter实例后，会马上调用init()方法完成初始化工作，这个方法只会被执行一次；
- doFilter(ServletRequest req,ServletResponse res,FilterChain chain)：这个方法会在用户每次访问“目标资源（pattern>index.jsp）”时执行，如果需要“放行”，那么需要调用FilterChain的doFilter(ServletRequest,ServletResponse)方法，如果不调用FilterChain的doFilter()方法，那么目标资源将无法执行；
- destroy()：服务器会在创建Filter对象之后，把Filter放到缓存中一直使用，通常不会销毁它。一般会在服务器关闭时销毁Filter对象，在销毁Filter对象之前，服务器会调用Filter对象的destory()方法。
FilterConfig
你已经看到了吧，Filter接口中的init()方法的参数类型为FilterConfig类型。它的功能与ServletConfig相似，与web.xml文件中的配置信息对应。下面是FilterConfig的功能介绍：
| 方法 | 描述 |
|---|---|
| ServletContext getServletContext() | 获取ServletContext的方法； |
| String getFilterName() | 获取Filter的配置名称；与元素对应； |
| String getInitParameter(String name) | 获取Filter的初始化配置，与元素对应； |
| Enumeration getInitParameterNames() | 获取所有初始化参数的名称。 |
doFilter
doFilter()方法的参数中有一个类型为FilterChain的参数，它只有一个方法：doFilter(ServletRequest,ServletResponse)。
前面我们说doFilter()方法的放行，让请求流访问目标资源！但这么说不严密，其实调用该方法的意思是，“我（当前Filter）”放行了，但不代表其他人（其他过滤器）也放行。
也就是说，一个目标资源上，可能部署了多个过滤器，就好比在你去北京的路上有多个打劫的匪人（过滤器），而其中第一伙匪人放行了，但不代表第二伙匪人也放行了，所以调用FilterChain类的doFilter()方法表示的是执行下一个过滤器的doFilter()方法，或者是执行目标资源！
如果当前过滤器是最后一个过滤器，那么调用chain.doFilter()方法表示执行目标资源，而不是最后一个过滤器，那么chain.doFilter()表示执行下一个过滤器的doFilter()方法。
多个过滤器执行顺序
一个目标资源可以指定多个过滤器，过滤器的执行顺序是在web.xml文件中的部署顺序：
<filter>
<filter-name>myFilter1</filter-name>
<filter-class>com.rl.filter.MyFilter1</filter-class>
</filter>
<filter-mapping>
<filter-name>myFilter1</filter-name>
<url-pattern>/index.jsp</url-pattern>
</filter-mapping>
<filter>
<filter-name>myFilter2</filter-name>
<filter-class>com.rl.filter.MyFilter2</filter-class>
</filter>
<filter-mapping>
<filter-name>myFilter2</filter-name>
<url-pattern>/index.jsp</url-pattern>
</filter-mapping>
public class MyFilter1 extends HttpFilter {
public void doFilter(HttpServletRequest request, HttpServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("filter1 start...");
chain.doFilter(request, response);//放行，执行MyFilter2的doFilter()方法
System.out.println("filter1 end...");
}
}
public class MyFilter2 extends HttpFilter {
public void doFilter(HttpServletRequest request, HttpServletResponse response,
FilterChain chain) throws IOException, ServletException {
System.out.println("filter2 start...");
chain.doFilter(request, response);//放行，执行目标资源
System.out.println("filter2 end...");
}
}
<body>
This is my JSP page. <br>
<h1>index.jsp</h1>
<%System.out.println("index.jsp"); %>
</body>
访问时输出的结果：
filter1 start...
filter2 start...
index.jsp
filter2 end...
filter1 end...
四种拦截方式
我们来做个测试，写一个过滤器，指定过滤的资源为b.jsp，然后我们在浏览器中直接访问b.jsp，你会发现过滤器执行了！
但是，当我们在a.jsp中request.getRequestDispathcer(“/b.jsp”).forward(request,response)时，就不会再执行过滤器了！也就是说，默认情况下，只能直接访问目标资源才会执行过滤器，而forward执行目标资源，不会执行过滤器！
public class MyFilter extends HttpFilter {
public void doFilter(HttpServletRequest request,
HttpServletResponse response, FilterChain chain)
throws IOException, ServletException {
System.out.println("myfilter...");
chain.doFilter(request, response);
}
}
<filter>
<filter-name>myfilter</filter-name>
<filter-class>com.rl.filter.MyFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>myfilter</filter-name>
<url-pattern>/b.jsp</url-pattern>
</filter-mapping>
<h1>a.jsp</h1>
<%
request.getRequestDispatcher("/b.jsp").forward(request, response);
%>
</body>
-
http://localhost:8080/filtertest/b.jsp -->直接访问b.jsp时，会执行过滤器内容；
-
http://localhost:8080/filtertest/a.jsp -->
访问a.jsp，但a.jsp会forward到b.jsp，这时就不会执行过滤器！
其实过滤器有四种拦截方式：
- REQUEST：直接访问目标资源时执行过滤器。包括：在地址栏中直接访问、表单提交、超链接、重定向，只要在地址栏中可以看到目标资源的路径，就是REQUEST；
- FORWARD：转发访问执行过滤器。包括RequestDispatcher#forward()方法、<jsp:forward>标签都是转发访问；
- INCLUDE：包含访问执行过滤器。包括RequestDispatcher#include()方法、<jsp:include>标签都是包含访问；
- ERROR：当目标资源在web.xml中配置为<error-page>中时，并且真的出现了异常，转发到目标资源时，会执行过滤器。
可以在中添加0~n个子元素，来说明当前访问的拦截方式
<filter-mapping>
<filter-name>myfilter</filter-name>
<url-pattern>/b.jsp</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>
其实最为常用的就是REQUEST和FORWARD两种拦截方式，而INCLUDE和ERROR都比较少用！其中INCLUDE比较好理解，我们这里不再给出代码，学员可以通过FORWARD方式修改，来自己测试。而ERROR方式不易理解，下面给出ERROR拦截方式的例子：
<filter-mapping>
<filter-name>myfilter</filter-name>
<url-pattern>/b.jsp</url-pattern>
<dispatcher>ERROR</dispatcher>
</filter-mapping>
<error-page>
<error-code>500</error-code>
<location>/b.jsp</location>
</error-page>
<body>
<h1>a.jsp</h1>
<%
if(true)
throw new RuntimeException("嘻嘻~");
%>
</body>
简单来说就是跳转到错误页面的拦截
过滤器的应用场景
- 执行目标资源之前做预处理工作，例如设置编码，这种试通常都会放行，只是在目标资源执行之前做一些准备工作；
- 通过条件判断是否放行，例如校验当前用户是否已经登录，或者用户IP是否已经被禁用；
- 在目标资源执行后，做一些后续的特殊处理工作，例如把目标资源输出的数据进行处理；
设置目标资源
在web.xml文件中部署Filter时，可以通过“*”来执行目标资源：
<filter-mapping>
<filter-name>myfilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
这点和servlet完全相同，除此之外还可以为指定目标资源为某个Servlet，例如：
<servlet>
<servlet-name>myservlet</servlet-name>
<servlet-class>com.rl.servlet.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>myservlet</servlet-name>
<url-pattern>/abc</url-pattern>
</servlet-mapping>
<filter>
<filter-name>myfilter</filter-name>
<filter-class>com.rl.filter.MyFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>myfilter</filter-name>
<servlet-name>myservlet</servlet-name>
</filter-mapping>
解决全站字符乱码（POST和GET中文编码问题）
其实全站乱码问题的难点就是处理GET请求参数的问题。
如果是POST请求，当执行目标Servlet时，Servlet中调用request.getParameter()方法时，就会根据request.setCharacterEncoding()设置的编码来转码！这说明在过滤器中调用request.setCharacterEncoding()方法会影响在目标Servlet中的request.getParameter()方法的行为！
但是如果是GET请求，我们又如何能影响request.getParameter()方法的行为呢？这是不好做到的！我们不可能先调用request.getParameter()方法获取参数，然后手动转码后，再施加在到request中,我们可以自定义请求包装器包装请求，将字符编码转换的工作添加到getParameter()方法中！
这里是通过继承了ServletRequest接口下的子类MyHttpServletRequestWrapper，重写了里面的getParameter方法，在拦截器中再返回回去，这样就可以解决get请求中文乱码问题。
我们自己的MyHttpServletRequestWrapper
public class MyHttpServletRequestWrapper extends HttpServletRequestWrapper {
//设置request装饰器的默认编码属性
private String encoder = "UTF-8";
public MyHttpServletRequestWrapper(HttpServletRequest request) {
super(request);
}
//定义有参构造器
public MyHttpServletRequestWrapper(HttpServletRequest request, String encoder) {
super(request);
this.encoder = encoder;
}
//重写getParameter
@Override
public String getParameter(String name) {
//调用父类实例的getParameter
String value = super.getParameter(name);
String targetVal = null;
try {
//转码
targetVal = value == null?null:new String(value.getBytes("ISO-8859-1"),encoder);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return targetVal;
}
}
再拦截器中将我们自己的HttpServletRequest返回回去
同时设置response的编码
public class CharEncoderFilter implements Filter {
/**
* 定义当前过滤器的属性
*/
private String encoder;
/**
* 过滤器的执行方法
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
//设置请求中编码
request.setCharacterEncoding(encoder);
//设置响应时的编码
response.setCharacterEncoding(encoder);
response.setContentType("text/html;char="+encoder);
//把ServletRequest强制转换成HttpServletRequest
HttpServletRequest req = (HttpServletRequest)request;
//获得请求方法
String method = req.getMethod();
if(method.equalsIgnoreCase("get")){
//创建request装饰实现类
req = new MyHttpServletRequestWrapper(req, encoder);
}
chain.doFilter(req, response);
}
public void init(FilterConfig filterConfig) throws ServletException {
String paramEncoder = filterConfig.getInitParameter("encoder").trim();
if(paramEncoder != null && !"".equals(paramEncoder)){
encoder = paramEncoder;
}
}
public void destroy() {
}
}
配置拦截器
<filter>
<filter-name>helloFilter</filter-name>
<filter-class>com.rl.filter.CharEncoderFilter</filter-class>
<init-param>
<param-name>encoder</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>helloFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
监听器
监听器从功能来看可以分为三种：
- 监听域对象“创建”与“销毁”的监听器
- 监听域对象“操作域属性”的监听器
- 监听HttpSession的监听器
创建与销毁监听器
创建与销毁监听器一共有三个：
- ServletContextListener：Tomcat启动和关闭时调用下面两个方法
| 方法 | 描述 |
|---|---|
| public void contextInitialized(ServletContextEvent evt) | ServletContext对象被创建后调用 |
| public void contextDestroyed(ServletContextEvent evt) | ServletContext对象被销毁前调用 |
- HttpSessionListener：开始会话和结束会话时调用下面两个方法
| 方法 | 描述 |
|---|---|
| public void sessionCreated(HttpSessionEvent evt) | HttpSession对象被创建后调用 |
| public void sessionDestroyed(HttpSessionEvent evt) | HttpSession对象被销毁前调用 |
- ServletRequestListener：开始请求和结束请求时调用下面两个方法
| 方法 | 描述 |
|---|---|
| public void requestInitiallized(ServletRequestEvent evt) | ServletRequest对象被创建后调用 |
| public void requestDestroyed(ServletRequestEvent evt) | ServletRequest对象被销毁前调用 |
ServletContextListener示例
/*
* ServletContextListener实现类
* contextDestroyed() -- 在ServletContext对象被销毁前调用
* contextInitialized() -- -- 在ServletContext对象被创建后调用
* ServletContextEvent -- 事件类对象
* 该类有getServletContext()，用来获取ServletContext对象，即获取事件源对象
*/
public class MyServletContextListener implements ServletContextListener {
public void contextDestroyed(ServletContextEvent evt) {
System.out.println("销毁ServletContext对象");
}
public void contextInitialized(ServletContextEvent evt) {
System.out.println("创建ServletContext对象");
}
}
HttpSessionListener示例
/*
* HttpSessionListener实现类
* sessionCreated() -- 在HttpSession对象被创建后被调用
* sessionDestroyed() -- -- 在HttpSession对象被销毁前调用
* HttpSessionEvent -- 事件类对象
* 该类有getSession()，用来获取当前HttpSession对象，即获取事件源对象
*/
public class MyHttpSessionListener implements HttpSessionListener {
public void sessionCreated(HttpSessionEvent evt) {
System.out.println("创建session对象");
}
public void sessionDestroyed(HttpSessionEvent evt) {
System.out.println("销毁session对象");
}
}
ServletRequestListener示例
/*
* ServletRequestListener实现类
* requestDestroyed() -- 在ServletRequest对象被销毁前调用
* requestInitialized() -- 在ServletRequest对象被创建后调用
* ServletRequestEvent -- 事件类对象
* 该类有getServletContext()，用来获取ServletContext对象
* 该类有getServletRequest()，用来获取当前ServletRequest对象，即事件源对象
*/
public class MyServletRequestListener implements ServletRequestListener {
public void requestDestroyed(ServletRequestEvent evt) {
System.out.println("销毁request对象");
}
public void requestInitialized(ServletRequestEvent evt) {
System.out.println("创建request对象");
}
}
listener配置
<listener>
<listener-class>com.rl.listener.MyServletContextListener</listener-class>
</listener>
<listener>
<listener-class>com.rl.listener.MyHttpSessionListener</listener-class>
</listener>
<listener>
<listener-class>com.rl.listener.MyServletRequestListener</listener-class>
</listener>
<session-config>
<session-timeout>1</session-timeout>
</session-config>
操作域属性的监听器
当对域属性进行增、删、改时，执行的监听器一共有三个：
- ServletContextAttributeListener：在ServletContext域进行增、删、改属性时调用下面方法
| 方法 |
|---|
| public void attributeAdded(ServletContextAttributeEvent evt) |
| public void attributeRemoved(ServletContextAttributeEvent evt) |
| public void attributeReplaced(ServletContextAttributeEvent evt) |
- HttpSessionAttributeListener：在HttpSession域进行增、删、改属性时调用下面方法
| 方法 |
|---|
| public void attributeAdded(ServletContextAttributeEvent evt) |
| public void attributeRemoved(ServletContextAttributeEvent evt) |
| public void attributeReplaced(ServletContextAttributeEvent evt) |
- ServletRequestAttributeListener：在ServletRequest域进行增、删、改属性时调用下面方法
| 方法 |
|---|
| public void attributeAdded(ServletContextAttributeEvent evt) |
| public void attributeRemoved(ServletContextAttributeEvent evt) |
| public void attributeReplaced(ServletContextAttributeEvent evt) |
下面对这三个监听器的事件对象功能进行介绍：
- ServletContextAttributeEvent
| 方法 | 描述 |
|---|---|
| String getName() | 获取当前操作的属性名 |
| Object getValue() | 获取当前操作的属性值 |
| ServletContext getServletContext() | 获取ServletContext对象 |
- HttpSessionBindingEvent
| 方法 | 描述 |
|---|---|
| String getName() | 获取当前操作的属性名 |
| Object getValue() | 获取当前操作的属性值 |
| ServletContext getSession() | 获取Session对象 |
- ServletRequestAttributeEvent
| 方法 | 描述 |
|---|---|
| String getName() | 获取当前操作的属性名 |
| Object getValue() | 获取当前操作的属性值 |
| ServletContext getServletContext() | 获取ServletContext对象 |
| ServletRequest getServletRequest() | 获取当前操作的ServletRequest对象 |
示例
public class MyListener implements ServletContextAttributeListener,
ServletRequestAttributeListener, HttpSessionAttributeListener {
public void attributeAdded(HttpSessionBindingEvent evt) {
System.out.println("向session中添加属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeRemoved(HttpSessionBindingEvent evt) {
System.out.println("从session中移除属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeReplaced(HttpSessionBindingEvent evt) {
System.out.println("修改session中的属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeAdded(ServletRequestAttributeEvent evt) {
System.out.println("向request中添加属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeRemoved(ServletRequestAttributeEvent evt) {
System.out.println("从request中移除属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeReplaced(ServletRequestAttributeEvent evt) {
System.out.println("修改request中的属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeAdded(ServletContextAttributeEvent evt) {
System.out.println("向context中添加属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeRemoved(ServletContextAttributeEvent evt) {
System.out.println("从context中移除属性：" + evt.getName() + "=" + evt.getValue());
}
public void attributeReplaced(ServletContextAttributeEvent evt) {
System.out.println("修改context中的属性：" + evt.getName() + "=" + evt.getValue());
}
}
public class ListenerServlet extends BaseServlet {
public String contextOperation(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ServletContext context = this.getServletContext();
context.setAttribute("a", "a");
context.setAttribute("a", "A");
context.removeAttribute("a");
return "/index.jsp";
}
///
public String sessionOperation(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession();
session.setAttribute("a", "a");
session.setAttribute("a", "A");
session.removeAttribute("a");
return "/index.jsp";
}
///
public String requestOperation(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setAttribute("a", "a");
request.setAttribute("a", "A");
request.removeAttribute("a");
return "/index.jsp";
}
}
<body>
<a href="<c:url value='/ListenerServlet?method=contextOperation'/>">SevletContext操作属性</a>
<br/>
<a href="<c:url value='/ListenerServlet?method=sessionOperation'/>">HttpSession操作属性</a>
<br/>
<a href="<c:url value='/ListenerServlet?method=requestOperation'/>">ServletRequest操作属性</a> |
</body>
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
