《JavaWeb从入门到改行》过滤器学习笔记

>";
display: block;
height: 0;
clear: both;
visibility: hidden;
}
#sitemap, #sitemap ul{display:block;}
/* \*/
#sitemap, #sitemap ul{min-height:1%;}
* html #sitemap, * html #sitemap ul{height:1%;}
/* */
#sitemap ul{display:none;}
-->

目录:(点击红色方框展开子目录)

• Filter API
  • 无
• Filter详解
  • 过滤器配置
  • 四种拦截方式
• 经典案例
  • 分IP统计网站的访问次数
  • 粗粒度权限控制
  • 解决全站字符乱码
  • 页面静态化
• 使用@WebFilter注解取代web.xml进行对filter的配置
  • 无

---

Filter API

@过滤器( filter）是JavaWeb三大组件之一 ，作用是拦截请求，在访问指定目标资源（如Servlet、JSP、css、html）之前先执行过滤器中的操作 。

@过滤流程 是服务器启动后，自动创建Filter接口的实例对象，并进行初始化，我们编写一个filter类继承该实例对象，并且重写其doFilter方法，在此方法中添加过滤规则 。 当客户端每次要访问目标资源时，Servlet容器都会调用Filter接口的实例对象的doFilter方法，也就是会调用我们自己重写的doFilter方法，在此方法中，如果符合规则，则调用FilterChain对象的doFilter方法，表示这个过滤器对该请求进行放行，可以去执行下一个过滤器的生命周期方法中的doFilter方法。 如果下一个过滤器也放行的话，就再去执行下下个过滤器，知道通过了所有过滤器的考验，最终访问到目标资源

过滤器的详解

@过滤器的配置在Servet2.5及以前版本都需要在web.xml中进行配置 ，一个目标资源可以添加多个过滤器，也就是多个过滤规则 ，只有全部通过了，请求才能到达目标资源

   <filter>
     <filter-name>第一个过滤器类名字</filter-name>
     <filter-class>包.类</filter-class>
   </filter>
   <filter-mapping>
     <filter-name>第一个过滤器类名字</filter-name>
     <url-pattern>要过滤的目标资源A</url-pattern>
   </filter-mapping>
   <filter>
     <filter-name>第二个过滤器类名字</filter-name>
     <filter-class>包.类</filter-class>
   </filter>
   <filter-mapping>
     <filter-name>第二个过滤器类名字</filter-name>
     <url-pattern>要过滤的目标资源A</url-pattern>
   </filter-mapping>

@多个过滤器的执行顺序 是按照配置的先后顺序执行的

@四种拦截方式 ，假如： 我们编写一个过滤器用来过滤资源A，当我们直接访问该资源A时就会被过滤，但是当我们间接访问资源A（比如： 在其他页面用转发的形式间接访问资源A）时，过滤器不会执行。 所以有时候我们要定义我拦截方式。

拦截方式	说明
REQUEST	直接访问目标资源时执行过滤器 ，默认
FORWARD	转发访问执行过滤器
INCLUDE	包含访问执行过滤器
ERROR	当目标资源在web.xml中配置为<error-page>中时，并且真的出现了异常，转发到目标资源时，会执行过滤器。

在<filter-mapping>中添加0~n个<dispatcher>子元素，来说明当前访问的拦截方式。

<filter-mapping>
        <filter-name>过滤器名字</filter-name>
        <url-pattern>目标资源路径</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>
</filter-mapping>

经典案例_分IP统计网站的访问次数

@说明 网站的访问次数绝不可能随着浏览器的关闭而重置为0，因为和服务器的寿命是一样的，所以必须用Application域 。而访问次数与IP有关系，最好放在map中，即map<ip地址,访问次数>，而这个map又必须是在服务器启动时就需要创建并且要保存到Application域中以供使用，所以需要监听器

@注意 类名包名等路径随自己的项目更改

 package cn.kmust.web.demo1.filter;

 import java.io.IOException;
 import java.util.LinkedHashMap;
 import java.util.Map;

 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;

 /**
  * 过滤器  [分IP统计访问次数案例]
  * @功能 在访问a.jsp和b.jsp资源之前，进行分ip统计访问次数
  *    统计功能不需要拦截，所以放行，web.xml中为了不与其他demo项目冲突，
  *         所以拦截对象只是本例的demo1_show.jsp
  * @author ZHAOYUQIANG
  *
  */
 public class CountFilter implements Filter {
     private FilterConfig config ;

     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
         /*
          * 1. 得到application对象
          * 2. 获取application域中的Map
          * 3. 从request中获取当前客户端的IP地址
          * 4. 查看Map中是否存在这个IP对应的访问次数，
          *     如果存在，获取访问次数，+1
          * 5. 如果不存在ip，说明第一次访问，设置访问次数为1
          * 6. 操作完成后，再把map放回到application中
          * 7. 这个过滤器不需要拦截，所以放行
          */
         ServletContext app = config.getServletContext();
         Map<String,Integer> map = (Map<String , Integer>)app.getAttribute("map");
         String ip  = request.getRemoteAddr();
         if(map.containsKey(ip)){
             int cnt = map.get(ip);
             map.put(ip, cnt+1);
         }else{
             map.put(ip, 1);
         }
         app.setAttribute("map", map);
         chain.doFilter(request, response);
     }

     /**
      * 在服务器启动时执行
      *   保存config对象
      */
     public void init(FilterConfig fConfig) throws ServletException {
         this.config = fConfig ;

     }
     public void destroy() {
         // TODO Auto-generated method stub
     }

 }

CountFilter

 package cn.kmust.web.demo1.listerner;

 import java.util.LinkedHashMap;
 import java.util.Map;

 import javax.servlet.ServletContext;
 import javax.servlet.ServletContextEvent;
 import javax.servlet.ServletContextListener;

 /**
  * 监听器   [项目统计按IP分类为统计访问人数的辅助类]
  * @功能 创建Map,保存到application域中
  *     分IP查询，Map的类型为Map<IP地址,访问次数> ; 因为访问次数是项目整体范围，所以保存到application域中
  * @author ZHAOYUQIANG
  *
  */
 public class CountListerner implements ServletContextListener {
     /**
      * 在服务器启动时创建Map，保存到ServletContext中
      */
     public void contextInitialized(ServletContextEvent sce) {
         /*
          * 1. 创建Map<IP地址,访问次数>
          * 2. 通过ServletContextEvent对象获取ServletContext
          * 3. 把Map保存到application中
          */
         Map<String,Integer> map = new LinkedHashMap<String, Integer>();
         ServletContext application = sce.getServletContext();
         application.setAttribute("map", map);
     }

     public void contextDestroyed(ServletContextEvent arg0) {
         // TODO Auto-generated method stub
     }

 }

CountListerner

<body>
    <h1><center>显示结果</center></h1>
    <table align="center" width="60%" border="1">
        <tr>
           <th>IP</th>
           <th>次数</th>
        </tr>
<c:forEach items="${applicationScope.map }" var="entry">
        <tr>
           <td>${entry.key }</td>
           <td>${entry.value }</td>
        </tr>
</c:forEach>

    </table>
  </body>

测试页面

<filter>
    <display-name>CountFilter</display-name>
    <filter-name>CountFilter</filter-name>
    <filter-class>cn.kmust.web.demo1.filter.CountFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>CountFilter</filter-name>
    <url-pattern>/demo1_show.jsp</url-pattern>
  </filter-mapping>
  <listener>
    <listener-class>cn.kmust.web.demo1.listerner.CountListerner</listener-class>
  </listener>

配置

经典案例_粗粒度权限控制

@说明 防止为登陆的用户访问主页， /user/userindex.jsp是目标资源 ，如果为登陆的用户直接访问该资源，则打回到登陆页面

@注意 类名包名等路径随自己的项目更改

 package cn.kmust.webfilter.web.filter;

 import java.io.IOException;

 import javax.servlet.Filter;
 import javax.servlet.FilterChain;
 import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.http.HttpServletRequest;
 /**
  * 过滤器 用来 ，对/user/userindex.jsp进行过滤
  * @功能 当有请求访问userindex.jsp时，先检查session域中有没有用户名，如果有则放行，如果没有，则拦截，并且打回
  * @author ZHAOYUQIANG
  *
  */
 public class LoginFilter implements Filter {
     public void destroy() {
     }
     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
         //因为用的是Http协议的请求，所以需要把过滤器中的ServletRequest转换成Http协议的
         HttpServletRequest req = (HttpServletRequest) request;
         //从session域中获取用户名
         String name  = (String) req.getSession().getAttribute("session_user");
         if(name != null ){
             chain.doFilter(request, response);
         }else{
             req.getRequestDispatcher("/user/userlogin.jsp").forward(request, response);
         }
         chain.doFilter(request, response);
     }
     public void init(FilterConfig fConfig) throws ServletException {

     }
 }

filter

 package cn.kmust.webfilter.web.filter;

 import java.io.IOException;

 import javax.servlet.Filter;
 import javax.servlet.FilterChain;
 import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.http.HttpServletRequest;
 /**
  * 过滤器 用来 ，对/user/userindex.jsp进行过滤
  * @功能 当有请求访问userindex.jsp时，先检查session域中有没有用户名，如果有则放行，如果没有，则拦截，并且打回
  * @author ZHAOYUQIANG
  *
  */
 public class LoginFilter implements Filter {
     public void destroy() {
     }
     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
         //因为用的是Http协议的请求，所以需要把过滤器中的ServletRequest转换成Http协议的
         HttpServletRequest req = (HttpServletRequest) request;
         //从session域中获取用户名
         String name  = (String) req.getSession().getAttribute("session_user");
         if(name != null ){
             chain.doFilter(request, response);
         }else{
             req.getRequestDispatcher("/user/userlogin.jsp").forward(request, response);
         }
         chain.doFilter(request, response);
     }
     public void init(FilterConfig fConfig) throws ServletException {

     }
 }

servlet

 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <body>
   <h2>用户名字是user,密码是123</h2>
     <form action ="<c:url value="/LoginServlet"/>" method="post">
       <input type="text" name="username"/><br>
       <input type="password" name="password"/><br>
       <input type="submit" name="登陆"/>
     </form>
   </body>

login

<body>
   <h1><center>这是用户主页，没有登陆的用户是不能直接访问该页的</center></h1>
  </body>

userindex

<filter>
    <display-name>LoginFilter</display-name>
    <filter-name>LoginFilter</filter-name>
    <filter-class>cn.kmust.webfilter.web.filter.LoginFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>LoginFilter</filter-name>
    <url-pattern>/LoginFilter</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>LoginFilter</filter-name>
    <url-pattern>/user/userindex.jsp</url-pattern>
  </filter-mapping>

配置

经典案例_解决全站字符乱码

@说明 servlet处理post和get请求编码可以写在过滤器中，但是post和get编码的处理方式不是一样的，所以需要对request进行装饰，所以编写了EncodingRequest类来对request进行装饰，来帮助过滤器完成对get请求的编码 。

<%--get请求，传递过去method参数，指明调用TestServlet的fun2方法，并且传递一个参数param--%>
<a href="<c:url value='/GetServlet?param=哈哈'/>"> 这是get请求</a>
<%--post请求--%>
<form action="<c:url value='/PostServlet'/>" method="post">
   <input type="text" name="param" value="我是表单参数" />
   <input type="submit" name="提交"/>
</form>

提交页面

 package cn.kmust.webfilter.web.servlet;
 import java.io.IOException;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 /**
  *  post请求访问的Servlet，在过滤器中会进行编码的处理　
  *  获取参数，转发到显示页面
  * @author ZHAOYUQIANG
  *
  */
 public class PostServlet extends HttpServlet {

     public void doPost(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
          request.setAttribute("param", request.getParameter("param"));
          request.getRequestDispatcher("/show.jsp").forward(request, response);
     }
 }

PostServlet

package cn.kmust.webfilter.web.servlet;
import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 *  get请求访问的Servlet，在过滤器中会进行编码的处理　
 *  获取参数，转发到显示页面
 * @author ZHAOYUQIANG
 *
 */
public class GetServlet extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String  param = request.getParameter("param");
        request.setAttribute("param", param);
        request.getRequestDispatcher("/show.jsp").forward(request, response);
    }
}

GetServlet

package cn.kmust.webfilter.web.filter;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

import cn.kmust.webfilter.utils.EncodingRequest;

/**
 * 解决乱码的过滤器，servlet处理post和get乱码的操作，全都在这儿处理
 * @author ZHAOYUQIANG
 *
 */
public class EncodingFilter implements Filter {

    public void destroy() {
    }
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        /*
         * 处理post请求乱码问题
         */
        request.setCharacterEncoding("utf-8");
        /*
         * 处理GET请求编码问题
         *   String name1 =  request.getParameter("name");
         *   name2 = new String(name.getBytes("ISO-8859-1"),"utf-8");
         *    GET不一样，设置编码后，servlet中获取name，获取应该是name2,都是如果如上写的话，
         *     getParameter("name")获取的是name1 .
         * 掉包request
         *    1. 写一个request的装饰类
         *    2. 放行时，使用我们自己的request
         *    3. 但是POST方式依然使用request
         */
        HttpServletRequest req = (HttpServletRequest) request ;
        if(req.getMethod().equals("GET")){
            EncodingRequest er = new EncodingRequest(req);
            chain.doFilter(er, response);
        }else if(req.getMethod().equals("POST")){
            chain.doFilter(request, response);
        }
//        response.setContentType("text/html;charset=UTF-8");
    }

    public void init(FilterConfig fConfig) throws ServletException {
        // TODO Auto-generated method stub
    }
}

EncodingFilter

package cn.kmust.webfilter.utils;

import java.io.UnsupportedEncodingException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
/**
 * 辅助过滤器来处理GET编码问题
 * @author ZHAOYUQIANG
 *
 */
public class EncodingRequest extends HttpServletRequestWrapper{
private HttpServletRequest request ;

    public EncodingRequest(HttpServletRequest request) {
        super(request);
        this.request = request ;
    }
    /**
     * 处理编码问题
     */
    public String getParameter(String name) {
        String value = request.getParameter(name);
        /*
         * 处理编码问题
         */
        try {
            value = new String (value.getBytes("ISO-8859-1"),"utf-8");
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        return value;
    }

}

EncodingRequest

 ${requestScope.param }

显示页面

<filter>
    <display-name>EncodingFilter</display-name>
    <filter-name>EncodingFilter</filter-name>
    <filter-class>cn.kmust.webfilter.web.filter.EncodingFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>EncodingFilter</filter-name>
    <url-pattern>/EncodingFilter</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>EncodingFilter</filter-name>
    <url-pattern>/GetServlet</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>EncodingFilter</filter-name>
    <url-pattern>/PostServlet</url-pattern>
  </filter-mapping>

过滤器配置

经典案例_页面静态化

@说明 （页面静态化是什么请自行百度，这儿不做累述），我们做一个过滤器，让其访问servlet时判断是否符合静态化页面的要求 。如果是，则让其直接访问静态化的页面，如果不是，则继续访问资源。

CREATE TABLE `t_book` (
  `bid` char(32) NOT NULL,
  `bname` varchar(100) DEFAULT NULL,
  `price` decimal(10,2) DEFAULT NULL,
  `category` int(11) DEFAULT NULL,
  PRIMARY KEY (`bid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `t_book`(`bid`,`bname`,`price`,`category`) values ('b1','JavaSE_1','10.00',1),('b2','JavaSE_2','15.00',1),('b3','JavaSE_3','20.00',1),('b4','JavaSE_4','25.00',1),('b5','JavaEE_1','30.00',2),('b6','JavaEE_2','35.00',2),('b7','JavaEE_3','40.00',2),('b8','Java_framework_1','45.00',3),('b9','Java_framework_2','50.00',3);

数据库

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <default-config><!-- 这是默认的配置信息 -->
        <!-- 连接四大参数配置 -->
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/filtertest</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="user">root</property>
        <property name="password">123456</property>
        <!-- 池本身的参数配置 -->
        <property name="acquireIncrement">3</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">2</property>
        <property name="maxPoolSize">10</property>
    </default-config>

    <!-- 专门为oracle准备的配置信息 -->
    <!-- 这也是命名配置信息，在JDBC中创建连接池对象的时候要加 oracle-config这个参数-->
    <named-config name="oracle-config">
        <property name="jdbcUrl">  oracle的url   </property>
        <property name="driverClass">  oracle的驱动   </property>
        <property name="user">    oracle的用户 </property>
        <property name="password">    密码</property>
        <property name="acquireIncrement">3</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">2</property>
        <property name="maxPoolSize">10</property>
    </named-config>

</c3p0-config>

c3p0配置

 <h1>链接页面</h1>
 <%--Get方式，向页面传递method参数和方法中的参数 --%>
 <a href="<c:url value='/BookServlet?method=findAll'/>">查询所有</a><br/>
 <a href="<c:url value='/BookServlet?method=findByCategory&category=1'/>">查询SE</a><br/>
 <a href="<c:url value='/BookServlet?method=findByCategory&category=2'/>">查询EE</a><br/>
 <a href="<c:url value='/BookServlet?method=findByCategory&category=3'/>">查询Framework</a><br/>

提交页面

  <h1 align="center">图书列表</h1>
   <table border="1" align="center" width="50%">
     <tr>
         <th>书名</th>
         <th>单价</th>
         <th>分类</th>
     </tr>
 <c:forEach items="${bookList }" var="book">
     <tr>
         <td>${book.bname }</td>
         <td>${book.price }</td>
         <%--每个分类都是不同的颜色 --%>
         <c:choose>
           <c:when test="${book.category eq 1 }"><td style="color:red">JavaSE</td></c:when>
           <c:when test="${book.category eq 2 }"><td style="color:blue">JavaEE</td></c:when>
           <c:when test="${book.category eq 3 }"><td style="color:green">JaveFrameWork</td></c:when>
         </c:choose>
         <td>${book.category }</td>
     </tr>
 </c:forEach>
   </table>

显示页面

 package cn.kmust.book.web.servlet;

 import java.io.IOException;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import cn.itcast.servlet.BaseServlet;
 import cn.kmust.book.dao.BookDao;
 /**
  * servlet层
  * @功能 把查询到的图书放到request域中，转发到list.jsp中显示
  * @author ZHAOYUQIANG
  *
  */
 public class BookServlet extends BaseServlet {
     private BookDao bookDao = new BookDao();
     /**
      * 查询所有图书
      * @param request
      * @param response
      * @return
      * @throws ServletException
      * @throws IOException
      */
     public String findAll(HttpServletRequest request,HttpServletResponse response)
              throws ServletException,IOException{
         request.setAttribute("bookList", bookDao.findAll());
         return "/list.jsp" ;
     }
     /**
      * 按分类条件查询图书
      * @param request
      * @param response
      * @return
      * @throws ServletException
      * @throws IOException
      */
     public String findByCategory(HttpServletRequest request,HttpServletResponse response)
              throws ServletException,IOException{
         String value = request.getParameter("category");
         int category = Integer.parseInt(value);
         request.setAttribute("bookList", bookDao.findByCategorys(category));
         return "/list.jsp" ;
     }

 }

servlet

 package cn.kmust.book.web.filter;

 import java.io.File;
 import java.io.IOException;
 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;

 import cn.kmust.book.utils.StaticResponse;
 /**
  * 过滤器
  * @功能 /BookServlet， 访问Servlet之前，进行判断，如果静态化页面存在，过滤器直接拦截下来，直接让它访问该静态化页面，避免继续往下访问serlvet去查询数据库。
  *      如果静态化页面不存在（第一次访问），此时，生成新的静态化页面 ，过滤器放行， 放行之后，servlet会通过访问dao层查询数据库得到查询的数据，这个时候servlet会向list.jsp页面输出数据，但是
  *        我们不能让list.jsp输出，而是想办法让新的静态化页面做输出。
  * @解决问题 如何不能让list.jsp输出，而是让新的静态化页面做输出 ？
  *           jsp的输出实际上是out.write("<html>")，而这个out流底层就是response的getWriter()（注意，区分开Out内置对象）。
  *             就是因为这个out流，jsp中的out.write()才会输出在jsp页面中 。假如我们改变了out流，让这个流与我们指定静态页面绑定，那么
  *                jsp中的out流就会向定的静态页面中输出，这个过程就做调包response 。
  *                   毕竟response在一个请求中是不变的，用的同一个,所以我们用调包后的response来操作就完成了解决了这个问题
  * @解决问题  新的html页面会产生乱码问题 。 所以需要jsp页面中添加<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
  *
  * @author ZHAOYUQIANG
  *
  */
 public class StaticFilter implements Filter {
     private FilterConfig config ;
     public void destroy() {}
     public void init(FilterConfig fConfig) throws ServletException {
         this.config = fConfig ;
     }
     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
         /*
          * 把request和response转换成HttpServlet类型的
          */
         HttpServletRequest req = (HttpServletRequest) request ;
         HttpServletResponse res = (HttpServletResponse) response;
         /*
          * 1. 获取category参数，变成对应的文件名称
          *     category有四种值，分别对应四个静态化的页面
          *       null--> null.html
          *       1--> 1.html
          *       2--> 2.html
          *       3--> 3.html
          * 2. 获取文件所在目录路径
          *       FilterConfig对象的getServletContext()能够获取ServletContext对象
          * 3. 用路径和文件名称 创建一个新的文件
          * 4. 判断该新文件是否存在，如果文件存在，重定向到这个文件
          *
          */
         String category = request.getParameter("category");
         String htmlPage = category+".html" ;
         String htmlPath = config.getServletContext().getRealPath("/htmls");
         File destFile = new File(htmlPath,htmlPage);
         if(destFile.exists()){
             res.sendRedirect(req.getContextPath()+"/htmls/"+htmlPage);
             return ;
         }
         /*
          * 5. 如果该新文件不存在，调包response
          *      把新文件的路径传递过去，让out流与其路径绑定
          * 6. 放行
          *     在放行后，程序访问servlet，查询到数据，因为sr是调包后的response（response的getWriter()方法产生的out流与指定html绑定的），
          *        那么，数据都输出到指定的静态页面中了。这个时候浏览器是不显示这个页面的，用户也是看不到的
          * 7. 来一个重定向，让浏览器去显示这个静态页面
          */
         StaticResponse sr = new StaticResponse(res, destFile.getAbsolutePath());
         chain.doFilter(request, sr);
         res.sendRedirect(req.getContextPath()+"/htmls/"+htmlPage);

     }

 }

filter

package cn.kmust.book.utils;

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;

import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
/**
 * 调包response
 *    让getWriter()与传递过来的路径绑定
 * @author ZHAOYUQIANG
 *
 */
public class StaticResponse extends HttpServletResponseWrapper {
    private PrintWriter pw ;
    /**
     * 创建一个与html文件路径在一起的流对象
     * String path表示的是html文件路径
     *
     * @param response
     * @param path
     * @throws UnsupportedEncodingException
     * @throws FileNotFoundException
     */
    public StaticResponse(HttpServletResponse response,String path)
            throws FileNotFoundException, UnsupportedEncodingException {
        super(response);

        pw = new PrintWriter(path,"utf-8");
    }

    /**
     * 返回一个与html绑定在一起的printWriter对象
     *  jsp会使用它进行输出，这样数据都输出到了静态html页面中了
     */
    public PrintWriter getWriter(){

        return pw;
    }

}

调包response,辅助过滤器

关于dao层和servic层页面不再给出源码，大家可以直接下载完整项目源码：

@本项目源码使用说明 本代码第一次访问，查看各种分类 时，会访问数据库，获取资源，并且在htmls文件下建立静态化页面，可以去tomcat目录下的htmls下查看。 当再次访问该页面时候，直接重定向到该静态页面，不需要再去访问数据库了 。

@全部项目源码下载地址  https://files.cnblogs.com/files/zyuqiang/%E9%A1%B9%E7%9B%AE.zip

Servlet3.0新特性 之 使用@WebFilter注解取代web.xml进行对filter的配置

点击这里   请去Servlet3.0新特性中学习