Java二阶段 Filter and Listener

Filter（过滤器）也是在服务器，负责检查过滤，也可以执行任何request,response的操作。

过滤器是在服务器开启时，就已经创建了。而servlet是可以改变创建时机的。，能过滤服务器的一切资源。切记，能执行request,response的一切操作和修改request,response的操作。还能转向。

配置Filter（web.xml）

在web.xml中

 <filter>
        <filter-name>MyFilter</filter-name>
        <filter-class>com.qf.servlet.MyFilter</filter-class>
    </filter>
    //决定了拦截的顺序。先写的那个mapping,那个mapping就先执行
    <filter-mapping>
        <filter-name>MyFilter</filter-name>
<!--        拦截的路径-->
        <url-pattern>/hello.jsp</url-pattern>
    </filter-mapping>

Filter在服务器启动时，Filter就创建好了。执行顺寻与创建顺序无关。

注解(@webfilter)

在web.xml的顶部需要配置 metadata-complete=“false”，默认为false,如果改为true,不会去扫描注解，只会查看配置文件
采用注解的形式，过滤器的执行顺序与全限定名有关。会根据全限定名进行比较。

过滤器链

Filter的优先级

过滤器配置参数

web.xml

<filter>
    <filter-name>MyFilter</filter-name>
    <filter-class>com.qf.servlet.MyFilter</filter-class>
    <init-param>
        <param-name>username</param-name>
        <param-value>xiaoxuan</param-value>
    </init-param>
</filter>

客户端第一次请求资源，服务端会把资源发送给服务端，并把ETag和Last-Modified发送给客户端，当客户端再次请求时，会带着这个去请求服务端，如果和服务端的信息没差别，服务端就发送304，告诉客户端上自己的缓存里去找。

过滤器的应用

浏览器缓存

cache-cotrol:缓存存活时间，单位是秒，如果没有缓存，no-cache
expires:过期时间，单位是毫秒，没有缓存，0
pargma:控制缓存，没有缓存 nocache
现在的大部分浏览器不会缓存动态页面，都会去请求服务端。

禁止缓存

现在浏览器已经没有问题了。

HttpServletResponse response = (HttpServletResponse)resp;
//设置无缓存
response.setHeader("cache-control", "no-cache");
//设置过期时间
response.setDateHeader("expires", 0);
response.setHeader("pragma", "no-cache");
chain.doFilter(req, resp);

允许缓存

HttpServletResponse response = (HttpServletResponse)resp;
//单位为秒，缓存的时间
response.setHeader("cache-control", "max-age=600");
//单位毫秒，记录过期的时间
response.setDateHeader("expires", System.currentTimeMillis()+600000);
chain.doFilter(req, resp);

这样就可以不需要访问服务器，浏览器自己去找自己的缓存。

自动登录

当成功登录之后，应该把自己的用户名和密码保存起来，下次能直接访问数据。
总的来说，就是在登录成功，检查是否选择自动登录按钮，如果选择了，就把账号和密码通过加密，存放到cookie,设置有效时间，当下次进入项目时，先检查当前用户是否在登录，如果没有，就把cookie中的数据解密，验证账号和密码是否正确，如果正确，就把数据存放到session中。

UserService userService = new UserServiceImpl();
HttpServletRequest request = (HttpServletRequest)req;
HttpServletResponse response = (HttpServletResponse)resp;
//判断当前是否登录
String username = (String) request.getSession().getAttribute("username");
if(username != null) {
    chain.doFilter(req,resp);
    return;
}
//获取cookie
Cookie[] cookies = request.getCookies();
if(cookies != null){
    for (Cookie cookie : cookies) {
        if(cookie.getName().equals("userInfo")){
            String value = cookie.getValue();
            //解密
            byte[] decode = Base64.getDecoder().decode(value);
            String info = new String(decode);
            String[] infos = info.split("#");
            User user = userService.queryByUserNameAndPassword(infos[0], infos[1]);
            if(user != null) {
                request.getSession().setAttribute("username", infos[0]);
            }else {
                Cookie cookie1 = new Cookie(infos[0],"");
                cookie1.setPath(request.getContextPath());
                cookie1.setMaxAge(0);
                response.addCookie(cookie1);
            }
        }
    }
}
chain.doFilter(req, resp);

过滤敏感词汇

一般我们都是将数据发送给服务器，服务器在响应回来，我们只要知道服务器用的什么方法，只要在过滤器中重载某些方法，并把自己创建的requset或者response传给目标资源，目标资源就调用的我们的重载的方法，依次达到不同的效果。
比如我们将评论提交给服务器，服务器需要把敏感词进行过滤。

这就是目标资源，它通过使用request.getParameter()方法得到数据。所以我们就在过滤器中把这个方法进行重载

@WebServlet(name = "CommentServlet", value = "/comment")
public class CommentServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        String comment = request.getParameter("comment");
        response.getWriter().write(comment);
    }

过滤器：

@WebFilter(filterName = "CleanDirtyFilter", value = "/comment")
public class CleanDirtyFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest realRequest = (HttpServletRequest)req;
        //把req中的getParameter()方法进行重载，把自己创建的request传给下一个链或者目标资源
        MyRequest request = new MyRequest(realRequest);
        chain.doFilter(request, resp);
    }

    public void init(FilterConfig config) throws ServletException {

    }
    //HttpServletRequestWrapper只是包装了request,里面存了request的引用,里面的方法都是和request相同的，方法里面是调用的request的方法
    class MyRequest extends HttpServletRequestWrapper {
        //需要把脏词保存起来
        private List<String> dirtyWords;
        public MyRequest(HttpServletRequest request) {
            super(request);
            dirtyWords = new ArrayList<>();
            dirtyWords.add("笨猪");
            dirtyWords.add("好兄弟");
            dirtyWords.add("好朋友");
            dirtyWords.add("铁子");
        }

        @Override
        public String getParameter(String name) {
             String comment = super.getParameter(name);
            for (String dirtyWord : dirtyWords) {
                comment = comment.replaceAll(dirtyWord, "***");
            }
             return comment;
        }
    }
}

结果：

压缩

一般都是压缩文本，比如我们去访问一个新闻

显示为4669字节，数据太大，影响效率。所以我们需要进行压缩。
我们是用jsp显示的这条内容。

@WebFilter(filterName = "NewsFilter",value = "/news.jsp")
public class NewsFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        //修改resp
        HttpServletResponse realResponse = (HttpServletResponse)resp;
        MyResponse response = new MyResponse(realResponse);
        chain.doFilter(req, response);
        //得到内存流
        ByteArrayOutputStream byteOut = response.getByteOut();
        //因为内存输出流的toByteArray(),toString就可以把缓冲区的数据给读出来，这个和普通的输出流是不一样的。
        //创建压缩流
        ByteArrayOutputStream newByteOut = new ByteArrayOutputStream();
        System.out.println("压缩之前的大小:"+byteOut.size());
        GZIPOutputStream gzip = new GZIPOutputStream(newByteOut);
        gzip.write(byteOut.toByteArray());
        gzip.finish();
        gzip.close();
        //告诉浏览器改内容已经被压缩
        response.setHeader("Content-Encoding", "gzip");
        System.out.println("压缩之后的内容："+newByteOut.size());
        response.getOutputStream().write(newByteOut.toByteArray()   );
    }
    public void init(FilterConfig config) throws ServletException {

    }
    static class MyResponse extends HttpServletResponseWrapper{
        //打印流
        private PrintWriter pw;
        //内存输出操作流
        private ByteArrayOutputStream byteOut;
        public MyResponse(HttpServletResponse response) {
            super(response);
            try {
                byteOut = new ByteArrayOutputStream();
                //将打印流写入内存
                pw = new PrintWriter(new OutputStreamWriter(byteOut,"utf-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        //重载方法，让目标资源用我创建的打印流
        @Override
        public PrintWriter getWriter() throws IOException {
            //返回的是我创建的流
            return pw;
        }
        //等响应回来我们还需要从内存流里读出数据。所以我们还需要获取内存流
        public ByteArrayOutputStream getByteOut(){
            //不为空，需要刷新缓冲区
            if(pw != null) {
                pw.flush();
            }
            return byteOut;
        }
    }
}

实现图片防盗链

只有本网站才能访问的资源（照片），如果别的网站访问这个照片，请求是别的网站的，这就是
盗取。这个也可以通过过滤器来过滤。

@WebFilter(filterName = "StealFilter", value = "*.png")
public class StealFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest)req;
        //请求服务器的客户端的地址
        String referer = request.getHeader("referer");
        System.out.println(referer);
        //图片的地址
        String path = "http://localhost:8080"+request.getContextPath();
        //refer何时为空，在浏览器上面写上该地址去访问，refer就为null
        if(referer != null && referer.startsWith(path)){
            HttpServletResponse response = (HttpServletResponse)resp;
            //相同说明是正常访问
            chain.doFilter(req, resp);
            return;
        }
        //如果是非正常访问
        request.getRequestDispatcher("/upload/steal.jpg").forward(request,resp);
        System.out.println(request.getRequestURI());
        chain.doFilter(req,resp);
    }
    public void init(FilterConfig config) throws ServletException {

    }
}

监听器

监听器的类型

监听某个的对象放入session中或者移出

是对象要实现这个接口
监听的是这个对象
不需要注解或者配置web.xml文件

public class User implements HttpSessionBindingListener {
    private String name;
    private String color;

    public User() {
    }

    public User(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

    @Override
    public void valueBound(HttpSessionBindingEvent event) {
        System.out.println("对象进入了session");
    }

    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {
        System.out.println("对象移出了session");
    }
}

<%
    User user = new User("小红","绿色");
    session.setAttribute("user", user);
%>

<body>
    ${pageContext.session.removeAttribute("user")}
</body>

对象的钝化与活化

钝化：内存到硬盘
活化：硬盘到内存
还需要实现序列化接口

配置文件：

管理session

因为在服务器中创建的session默认是30分钟清除，也就是失效，但是我们可以自己设置有效时间。这就用到了监听器。

@WebListener
public class SessionManager implements ServletContextListener, HttpSessionListener {
    //容器，存放session
    private ConcurrentHashMap<String, HttpSession/> map;
    //定时器
    private Timer timer;
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        //初始化
        map = new ConcurrentHashMap<>();
        timer = new Timer();
        //定时器开始
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                if(map.size()>0){
                    for (Map.Entry<String, HttpSession> entry : map.entrySet()) {
                        HttpSession value = entry.getValue();
                        //比较时间
                        if(System.currentTimeMillis()-value.getLastAccessedTime()>60000) {
                            //移出
                            map.remove(entry.getValue());
                            System.out.println("过期了"+value.hashCode());
                            //失效
                            value.invalidate();
                        }
                    }
                }
            }
        },0,10000);
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        map = null;
        timer.cancel();
    }

    @Override
    public void sessionCreated(HttpSessionEvent se) {
        System.out.println("创建了session"+se.getSource().hashCode());
        HttpSession session = (HttpSession)se.getSource();
        map.put(session.getId(),session);
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        System.out.println("session销毁了");
    }
}