WEB-过滤器

最新推荐文章于 2021-10-04 23:23:43 发布
最新推荐文章于 2021-10-04 23:23:43 发布
阅读量209 收藏
点赞数
分类专栏： WEB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45156610/article/details/95006991
版权

过滤器

学习目标

-[ ] 能够说出过滤器的作用
-[ ] 能够编写过滤器
-[ ] 能够说出过滤器生命周期相关的方法
-[ ] 能够根据过滤器判断指定的过滤是否起作用
-[ ] 能够说出什么是过滤器链
-[ ] 能够编写过滤器对非法字符进行过滤

第一章 过滤器简介

1、过滤器是什么

在这里插入图片描述

​ 过滤器（filter）本质是Java中预先定义好了不同的接口，和servlet类似。可以过滤不同的内容，具体怎么过滤，需要使用者定义一个实现类，然后实现接口中的过滤方法，在方法中书写过滤的条件。filter是对客户端访问资源的过滤，符合条件放行，不符合条件不放行。

​ 简而言之，是在servlet之前执行，拦截请求，将servlet中一些共同的业务代码抽取出来，这就是过滤器作用。比如：请求乱码处理。

​

第二章 过滤器开发入门

1、过滤器API介绍

Filter是由Tomcat启动时创建，是javax.servlet包下面的一个接口，这个接口中定义了3个方法。

package javax.servlet;
import java.io.IOException;
public interface Filter {
    void init(FilterConfig var1) throws ServletException;
    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;
    void destroy();
}
方法说明
void init(FilterConfig filterConfig)过滤器对象创建的时候调用的方法
void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)执行过滤的方法
void destory()过滤器销毁的时候调用的方法

说明：

​ 1.tomcat服务器一启动就会调用过滤器中的无参构造方法创建过滤器类的对象，然后立刻调用初始化init方法。

​ 2.每次访问拦截的资源都会执行一次执行过滤的方法doFilter

​ 3.正常关闭tomcat服务器，执行销毁过滤器的方法destory

2、过滤器开发步骤

​ 项目中如果需要使用到过滤器，使用Servlet3.0的注解方式进行创建。创建步骤如下：

在这里插入图片描述

  • 第一步：新建一个普通java类，实现Filter接口；
  • 第二步：根据提示重写Filter接口的3个方法；
  • 第三步：在这个类上面通过注解的方式配置这个Filter；
    • 注解@WebFilter：配置Filter的注解，这个注解有两个参数；
      • filterName：设置过滤器的名称；
      • urlPatterns：配置这个过滤器要拦截的资源的路径；
  • 第四步：在doFilter（）方法中，书写过滤的业务逻辑；
    • chain.doFilter()方法放行；

过滤器是在请求资源之前执行，这点非常重要

在这里插入图片描述

【参考代码】

filter的web.xml版本

package cn.itheima.filter01;

import javax.servlet.*;
import java.io.IOException;

public class FilterOne implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //doFilter 每一次请求都会执行  进行过滤业务逻辑处理
        //如果想放行
//        filterChain.doFilter(servletRequest,servletResponse);
    }
    @Override
    public void destroy() {
    }
}

说明：filterChain.doFilter(servletRequest,servletResponse);方法被执行，相当于放行的功能。

XML配置 和servlet一样，需要在web.xml中进行配置

	 <filter>
        <filter-name>one</filter-name>
        <filter-class>cn.itheima.filter01.FilterOne</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>one</filter-name>
        <url-pattern>/filter01.html</url-pattern>
    </filter-mapping>

filter01.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>来拦截我啊！</h1>
</body>
</html>

效果：访问http://localhost:8080/filter01.html

浏览器没有得到html资源。

在这里插入图片描述

Filter的注解版本

在这里插入图片描述

注解代码参考

package cn.itheima.filter01;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter("/filter02.html")
public class FilterTwo implements Filter {
    public void destroy() {
    }

    /*
    每一次请求，只要路径匹配，都会执行
     */
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //code...
        //放行
        System.out.println("执行过滤方法。。。");
        chain.doFilter(request, response);  //放行，没有拦截，准许用户访问资源
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

filter02.html页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>请不要拦截我</h1>
</body>
</html>

效果：

访问链接：http://localhost:8080/filter02.html

在这里插入图片描述

说明:可以修改idea中的配置过滤器的模板：

#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "")package ${PACKAGE_NAME};#end
#parse("File Header.java")
@javax.servlet.annotation.WebFilter("/${Entity_Name}")
public class ${Class_Name} implements javax.servlet.Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(javax.servlet.ServletRequest req, javax.servlet.ServletResponse resp, javax.servlet.FilterChain chain) throws javax.servlet.ServletException, java.io.IOException {
        javax.servlet.http.HttpServletRequest request = (javax.servlet.http.HttpServletRequest)req;
        javax.servlet.http.HttpServletResponse response = (javax.servlet.http.HttpServletResponse)resp;
        //your  code.... 
        chain.doFilter(request, response);
    }
    @Override
    public void init(javax.servlet.FilterConfig config) throws javax.servlet.ServletException {
    }
}

总结:

1)**chain.doFilter(request, response)**方法的作用:

​ 当不写**chain.doFilter(request, response)**方法时候，html文件访问不到，被拦截；

​ 当有了**chain.doFilter(request, response)**方法时候，html文件可以访问，被放行；所以：**chain.doFilter(request, response)**具有放行的作用。

3、过滤器应用练习

需求：实现横刀夺爱案例来应用过滤器：

案例描述：新建表单，用input标签提交数据，如果表单提交数据中含有"love me"，不让servlet接收。

案例步骤：

​ a:新建servlet，接收表单提交数据，含有"love me",就输出"我们结婚吧"。

​ b:新建filter，在doFilter()之前判断表单提交的数据是否含有"love me"，有的话，拦截，并输出，“抢走新娘”

1）前端页面：

marry.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/marryServlet" method="post">
    女神：<input type="text" name="word"><br>
    <input type="submit" value="发短信">
</form>
</body>
</html>

2）后台servlet：

MarryServlet.java

@WebServlet("/marryServlet")
public class MarryServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //解决响应乱码问题
        response.setContentType("text/html;charset=utf-8");
        String word = request.getParameter("word");
        if (word.contains("loveme")){
            response.getWriter().print("我们结婚吧");
        }
        System.out.println("我和女神聊天");
    }
}

3）过滤器：

MarryFilter.java

//这里路径书写拦截的servlet
@WebFilter("/marryServlet")
public class MarryFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        String word = request.getParameter("word");
        if (word.contains("loveme")){
            //不放行
            System.out.println("抢走新娘！哈哈");
            return;
        }else {
            //放行
            chain.doFilter(request, response);
        }
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

效果：

访问链接：http://localhost:8080/marry.html 输入带有loveme的信息，点击发短信按钮

在这里插入图片描述

过滤器拦截到，进行横刀夺爱了

在这里插入图片描述

第三章 过滤器的执行流程

1、过滤器中代码执行顺序

ProcessFilter.java

@WebFilter("/process")
public class ProcessFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("doFilter()之前执行。。。");
        chain.doFilter(request, response);
        System.out.println("doFilter()之后执行。。。");
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
    }
}

ProcessServlet.java

@WebServlet("/process")
public class ProcessServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("Servlet执行了。。。");
    }
}

执行效果图：

在这里插入图片描述

运行原理图

在这里插入图片描述

说明：servlet响应给浏览器的内容，过滤器也对其进行了拦截过滤。

2、过滤器中请求和响应对象

过滤器的doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)方法中的request对象和response对象与servlet中请求对象和响应对象相同。

过滤器的执行流程如下：

  1. 客户端（浏览器）的HttpRequest到达Servlet之前，被Filter的doFilter()方法拦截；
  2. 根据需要，我们可以获取或者修改HttpRequest对象中的数据；
  3. 在这个请求响应给浏览器之前，Filter拦截了HttpResponse对象；
  4. 根据需要，我们可以获取或者修改HttpReponse对象中的数据；
  5. 最后，由doFilter中的chain决定是否让这个请求通过；

代码：ProcessServlet.java

@WebServlet("/processServlet")
public class ProcessServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //代码肯定被执行
        System.out.println(request);
        System.out.println(response);
        System.out.println("servlet被执行了。。。");
    }
}

ProcessFilter.java

@WebFilter("/processServlet")
public class ProcessFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //code...
        System.out.println("在doFilter()之前执行。。。");
        System.out.println(request);
        System.out.println(response);
        chain.doFilter(request, response);
        System.out.println("在doFilter()之后执行。。。");
        // 拦截请求对象和响应对象就是servlet请求对象和响应对象
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

控制台运行效果图

在这里插入图片描述

3、多个Filter执行顺序

问题：如果多个过滤器都对相同路径进行匹配，执行顺序该是什么？

Filter默认是按照字母顺序执行的，如果过滤器名字第一个字母相同，再看过滤器名字的第二个字母，以此类推。从而形成一个执行链条。

代码AFilter.java

@WebFilter("/apple")
public class AFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("这是在AFilter之前执行。。。");
        chain.doFilter(request, response);
        System.out.println("这是在AFilter之后执行。。。");
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
    }
}

代码：BFilter.java

@WebFilter("/apple")
public class BFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("这是在BFilter之前执行。。。");
        chain.doFilter(request, response);
        System.out.println("这是在BFilter之后执行。。。");
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
    }
}

代码：CFilter.java

@WebFilter("/apple")
public class CFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("这是在CFilter之前执行。。。");
        chain.doFilter(request, response);
        System.out.println("这是在CFilter之后执行。。。");
    }
    @Override
    public void init(FilterConfig config) throws ServletException {
    }
}

代码：AppleServlet.java

@WebServlet("/apple")
public class AppleServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("AppleServlet");
    }
}

上述代码执行效果图：

在这里插入图片描述

执行流程图：

在这里插入图片描述

第四章 Filter的生命周期

我们之前学习过servlet生命周期，并且上面，我们分析了Filter的执行流程。我们有没有想过，我们并没有向Filter发送请求，请求是怎么进入到doFilter()中的呢？Filter类的对象是在什么时候创建的呢?创建之后又是怎么工作的呢？最后是在什么时候销毁的呢？这些问题就是Filter的生命周期问题。接下来我们要学习过滤器filter的生命周期，和servlet的生命周期差不多。
在这里插入图片描述

1.filter生命周期代码

接下来我们可以通过以下代码对Filter的生命周期问题进行验证：

【验证Filter的生命周期】LifecycleFilter.java

@WebFilter("/lifecycle")
public class LifecycleFilter implements Filter {
    @Override
    public void destroy() {
        System.out.println("被销毁了。。。");
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //your  code....
        System.out.println("doFilter()被执行了。。。");
        chain.doFilter(request, response);
    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        System.out.println("初始化了。。。");
    }

    public LifecycleFilter() {
        System.out.println("构造方法被执行了。。。");
    }
}

重启服务器：在浏览器输入访问过滤器地址，并查看控制台。

http://localhost:8080/lifecycle

在这里插入图片描述

【结论】

  1. Filter类的对象是在服务器启动的时候创建的；
  2. Filter类对象创建完成后会调用init()方法；
  3. 每当一个请求的路径是满足过滤器的配置路径，那么就会执行一次过滤器的doFilter方法 (类似于service方法)
  4. 当服务器停止的时候，销毁过滤器，执行过滤器的destory方法

2.doFilter()方法

​ doFilter()方法是拦截请求的方法，只要一个请求符合Filter拦截路径，都会被doFilter()方法拦截。doFilter()方法有3个参数，这3个参数的作用分别如下：

参数说明
ServletRequest reqServletRequest是HttpServletRequest类的父类，其中包含了被拦截的请求的信息
ServletResponse respServletResponse是HttpServletResponse类的父类，其中包含了被拦截的响应的信息
FilterChain chainFilterChain给Filter提供了放行的方法。chain.doFilter();

FilterChain 是一个接口，里面有doFilter(req，resp)方法，作用是将浏览器提交请求对象和响应对象传到过滤器的资源里面去，所以doFilter()方法具有放行的作用。

3.destory()方法

​ 过滤器的销毁方法。服务器停止的时候，销毁过滤器，调用一次destory方法。

【测试】在destory()方法中输出一句话，如下：

    @Override
    public void destroy() {
      System.out.println("服务器关闭");
        System.out.println("LifecycleFilter的destory方法执行了.......................");
    }

【关闭tomcat】查看结果

在这里插入图片描述

【结论】

  1. 过滤器是在服务器停止时销毁的；
  2. 过滤器销毁后会调用destory()方法；

【小结】Filter生命周期小结

  1. 当服务器启动的时候，过滤器就被初始化了，执行过滤器的init方法
  2. 每当一个请求的路径是满足过滤器的配置路径，那么就会执行一次过滤器的doFilter方法
  3. 当服务器停止的时候，销毁过滤器，执行过滤器的destory方法

第五章 Filter的映射路径

​ 映射路径指的是当前这个Filter需要拦截的路径。这个路径的配置方式有3种：

  1. 精确匹配：匹配指定的urlpattern；
  2. 模糊匹配：匹配复合条件的一类路径；
  3. 多路径匹配：一个filter匹配多个资源；

1、精确匹配

​ 精确匹配，要求访问的资源路径必须与Filter的urlPatterns中的配置一致。如下：

精确匹配说明
urlPatterns = “/index.jsp”拦截对index.jsp页面的请求
urlPatterns = “/loginServlet”拦截对loginServlet的请求
urlPatterns = “/a.jsp”拦截对a.jsp的请求

2、模糊匹配

​ 有时候，我们需要对这个服务器中的所有请求都有所特殊处理，比如处理post请求的乱码问题。我们就需要对所有的请求都设置乱码处理。这时候，就需要对所有的请求进行拦截。如果通过上面的精确匹配模式，需要配置很多的请求，这样就比较麻烦了。如果通过urlPatterns的模糊匹配，就能够对这些请求进行统一处理。

​ 模糊匹配主要有以下3种写法：

模糊匹配使用示例说明
urlPatterns = “/*”urlPatterns = “/*”对所有的请求都进行拦截
urlPatterns = “/xxx/*”urlPatterns = “/user/*”对映射路径中/user下的所有资源进行拦截
urlPatterns = “*.xxx”urlPatterns = “*.jsp”对指定后缀的请求进行拦截

使用场景

在这里插入图片描述

今天电商狂欢日，产品经理要求对所有购买的电脑进行打9折

http://localhost:8080/computer/dell

http://localhost:8080/computer/xiaomi

http://localhost:8080/computer/thinkpad

效果：我们只要过滤器中路径设置为：/computer/*，那么任何电脑的请求都会被过滤器拦截。

使用场景

网站有很多种请求：浏览商品，购买商品，删除商品；用户登录，修改用户信息，注册用户信息。

我们可以将请求分为两类：xxx.action和xxx.do

这样可以分清楚网站请求的类别。

效果：我们只要在过滤器中设置路径为：*.action，那么，所有以.action结尾的请求都会被过滤器拦截。

代码演示如下：

对所有的请求都进行拦截:

@WebFilter("/*")
public class OneFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("OneFilter执行了。。。");
//        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

对映射路径中/user下的所有资源进行拦截:

@WebFilter("/user/*")
public class TwoFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("TwoFilter执行了。。。。。");
//        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

对指定后缀的请求进行拦截:

@WebFilter("*.action")
public class ThrFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        System.out.println("ThrFilter执行了。。。。");
//        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

3、多个路径匹配

一个过滤器可以匹配多个路径

xml实现方式：

在这里插入图片描述

注解实现方式：

在这里插入图片描述

温馨提示：路径没有/，Tomcat会报错！

在这里插入图片描述

第六章 Filter应用案例

1、Filter统一解决post请求乱码问题

​ 8.0版本以上的tomcat为我们解决了get请求的乱码问题。我们需要自己处理post请求的乱码问题，因为我们的一个项目中可能有很多的请求。当然，我们可以在每一个Servlet中都对post的乱码进行处理。但是，Filter给我们提供了一个更加便捷的方式。我们自定义一个Filter类，拦截所有的请求，然后对这些请求进行post乱码处理即可。

【参考代码】：

1）页面：register.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>form</title>
</head>
<body>
<form action="/registerServlet" method="post">
    用户名：<input type="text" name="name"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit" value="提交">
</form>
</body>
</html>

2）后台 servlet代码：

RegisterServlet.java

@WebServlet("/registerServlet")
public class RegisterServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //处理请求乱码
        //request.setCharacterEncoding("utf-8");
        //处理响应乱码
        //response.setContentType("text/html;charset=utf-8");
        /*
            在这里我们需要处理post请求乱码和响应乱码，如果多个servlet，那么我们就会每个servlet
            中都会进行处理，这样代码会冗余，我们可以考虑使用过滤器来解决处理乱码问题
         */
        //获取用户数据
        String name = request.getParameter("name");
        String password = request.getParameter("password");
        System.out.println("name = " + name);
        response.getWriter().println("哈哈，乱码解决楼！");
    }
}

说明：上述代码中我们需要处理post请求乱码和响应乱码，如果多个servlet，那么我们就会每个servlet中都会进行处理，这样代码会冗余，我们可以考虑使用过滤器来解决处理乱码问题。即将处理乱码的代码放到过滤器中来处理。

3）过滤器EncodingFilter中的代码：

@WebFilter("/*")
public class EncodingFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //统一处理post请求乱码
        request.setCharacterEncoding("utf-8");
        //统一处理响应乱码
        response.setContentType("text/html;charset=utf-8");
        //放行
        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

2、过滤器案例–登录权限校验

【需求】

  1. 登录之后：能够访问hack.html，然后下载黑客视频资源，成为NB黑客；
  2. 未登录：跳转到登录页面，并提示"请先登录"；
  3. 我们对hack.html页面进行过滤，

下载资源页面：hack.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>黑客。。</h1>
<a href="javascript:;">下载黑客资源</a>
</body>
</html>

页面login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
 <form action="/loginServlet" method="post">
     用户名：<input type="text" name="name"><br>
     密码：<input type="password" name="password"><br>
     <input type="submit" value="登录">
 </form>
</body>
</html>

javabean，User类：

public class User {
    private String name;
    private String password;

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

    public User() {
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

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

LoginServlet代码：

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取用户名和密码
        String name = request.getParameter("name");
        String password = request.getParameter("password");
        User user = new User(name,password);
        System.out.println("user = " + user);
        //将用户信息保存session中
        request.getSession().setAttribute("user",user);
        response.sendRedirect("/hack.html");
    }
}

LoginFilter代码：

@WebFilter("/hack.html")
public class LoginFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //获取用户信息
        User user = (User) request.getSession().getAttribute("user");
        if (user == null) {
            //没有登陆
            response.sendRedirect("/login.html");
            return;
        } else {
            //放行。。
            chain.doFilter(request, response);
        }
    }
    public void init(FilterConfig config) throws ServletException {
    }
}
阿扎姆王子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java过滤器过滤非法字符_Spring Filter过滤表单中的非法字符
weixin_29734123的博客
02-19 641
1 packagetest.filter;23 importjava.io.IOException;4 importjava.util.Iterator;5 importjava.util.Map;67 importjavax.servlet.FilterChain;8 importjavax.servlet.ServletException;9 importjavax.servlet.http....
使用Filter过滤非法内容
diejiankuai3444的博客
12-16 185
1、首先，需要编写一个响应的封装器ResponseReplaceWrapper,用它来缓存response中的内容，代码如下： ResponseReplaceWrapper.java package com.comp.common; import java.io.CharArrayWriter; import java.io.IOException; import ja...
filter过滤器实现过滤非法文字
panxianming_it的专栏
05-31 1706
1.首先创建一个java web工程,目录如下:   说明:   WorldFilter.java -> 过滤非法字符的过滤器 IllegalText.properties - >需要过滤的非法字符2.  WorldFilter.java 代码       package com;import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream;
#04.Java Web中：使用Filter过滤器过滤评论中的非法字符并替换为*号
Hyper_Qi的博客
07-21 826
旨在: 判断用户发送的评论是否包含一些非法词汇，替换成*号, 屏蔽词库由配置文件提供. 1.解决中文乱码的filter @WebFilter("/*") public class CharEncodingFilter implements Filter { @Override public void destroy() { } @Override public void doFilter(ServletRequest req, ServletResponse res
用过滤器过滤全站非法字符
雪飘雪融的博客
08-10 1880
package cn.lfd.web.filter; import java.io.IOException; import java.util.Arrays; import java.util.List; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfi
java-web -- servlet 拦截器 过滤器使用
02-24
在Java Web开发中，Servlet、拦截器（Interceptor）和过滤器（Filter）是三个非常重要的概念，它们在处理HTTP请求和响应时起到了关键作用。理解并熟练运用这三者能够帮助开发者实现更高效、更安全的Web应用。 首先...
Java Web过滤器详解
08-29
Java Web过滤器详解 Java Web过滤器是一种服务端组件，用于截取用户端的请求与响应信息。过滤器的应用场景非常广泛，以下是其中的一些： 一、统一认证 过滤器可以对用户请求进行统一认证，保证不会出现用户账户...
2021-05-28-WebAPI高级应用三--过滤器Filter.rar
12-28
【标题】"2021-05-28-WebAPI高级应用三--过滤器Filter.rar" 提供的主题是关于Web API的高级应用，特别是过滤器（Filter）的使用。在Web API开发中，过滤器是一种强大的工具，用于执行跨多个操作的逻辑，如日志记录、...
somepjs-迭代器-fndcl-fnexpr-过滤器-实验室-dc-web-102819
03-01
迭代器钻头：过滤器学习目标定义filter()方法的工作方式展示filter() 使用filter()返回匹配结果介绍我们可能都有过在线过滤选择项的经验。 购物服装时，我们可能选择了一个尺寸，以便仅考虑所需的搜索结果。 或者，...
springboot-Servlet3.0过滤器
05-21
- 过滤器在Web应用程序中扮演着中间人角色，它可以在请求到达目标资源（如Servlet或JSP页面）之前以及响应返回给客户端之后进行拦截操作。 - 过滤器通过实现`javax.servlet.Filter`接口并覆盖其`doFilter()`方法来...
过滤器实现统一编码以及过滤非法文字
哈哈哈
05-27 594
一、新建过滤器 首先要新建一个过滤器，通过注解完成Filter配置 // 通过注解完成Filter配置，/*表示过滤所有请求 ​ @WebFilter("/*") 现在所有的页面都被过滤掉了，全部不能进行正常的请求，我们只需在doFilter()方法中写上 @Override ​ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, S
Filter实战——实现非法字符的过滤
qq_45169180的博客
10-04 1431
使用Filter实现非法字符过滤 需求：用户在评论页面输入非法字符以后，需要将非法字符替换为* 需要考虑的问题 1.用户输入的非法字符可能会有很多种，如果想要校验用户输入的字符是否是非法字符，首先需要将非法字符存储起来，而不是写死，那么存储非法字符的存储位置 文件如果文件的内容有变更，需要重启服务器才生效， 数据库（开发项目的时候）如果数据库有变更，不需要重启服务器，因为是实时查询数据库看到的都是最新的数据，Ctrip Apollo。 将非法字符存储到文件中，服务器启动之后就应该读取文件中的内容并且存储
Filter非法字符过滤器
itTanshenghua的专栏
05-08 458
package com.my.web.filter; import java.io.IOException; import java.util.Enumeration; import java.util.Iterator; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax....
过滤器案例一过滤非法字符
寨板p45黑苹果10.12.6
02-16 490
涉及到的过滤器知识 什么是过滤器？ filter是java预先定义好的接口，客户端访问服务器资源时都先经过filter filter是对访问服务器资源的客户端的过滤，只有当客户端满足filter的条件才会放行，继续访问服务器端的资源，否则会被拦截，访问不到服务器资源 生命周期 创建： ​ 服务器启动时创建，执行的是init方法 执行： ​ 访问的路径能匹配上@WebFilter(url)，执行d...
利用filter(过滤器)拦截非法字符
系阿升呀的博客
03-22 3592
一、需求 当用户发出非法言论的时候，提示用户言论非法。 二、分析 创建一个表单用于发表言论。 创建一个txt文件，其中存入非法字符。 创建一个Filter，拦截请求。在init方法中将txt文件中的非法字符读取到内存中。 获取请求中的参数，对请求的参数进行非法字符的校验。 如果言论中没有含有非法字符，就放行。 如果言论中含有非法字符，就拦截，并且提示用户非法言论。 三、实现过程 整个案例的结构...
Spring Boot中使用过滤器和拦截器
CarrotZsy的博客
09-10 430
过滤器（Filter）和拦截器（Interceptor）是Web项目中常用的两个功能，本文将简单介绍在Spring Boot中使用过滤器和拦截器。 Filter 过滤器可以用于过滤一些非法字符、权限检查等操作 在Spring Boot中可以通过注解@WebFilter或者使用配置类来实现过滤器 1.通过注解 @WebFilter("/*") public class MyFilter implements Filter { @Override public void init(Filte.
java 过滤非法字符_javaweb开发之Filter实现过滤非法文字
weixin_35982453的博客
02-16 715
一、概述在论坛或者网站中，我们会发现一些用户发表一些不文明或者非法的文字。这样可能导致论坛的不文明和谐，甚至还可能带来一些法律上的纠纷。我们可以使用过滤器来帮助我们过滤掉这些不文明的文字。二、思路统一维护非法文字，为了提高程序运行效率，可以将其缓存到内存中。当用户提交请求后，利用过滤器对指定程序(如发表言论)请求的内容进行过滤。发现有非法字符后替换成合法字符(如“*”)。三、具体实现​keywor...
关于web.xml中同一个过滤器filter映射多个路径
热门推荐
baidu_36720706的博客
04-24 1万+
习惯了使用框架，对基础内容生疏，这里再作一些记录，以备空余时间复习查看。 以下url-pattern的配置形式是错误的,部署时项目并不会对配置的路径有过滤作用: CROSFilter CROSFilter com.mrkj.bsns.filter.CROSFilter CROSFilter /h5test/sendEmail,/bazi/getOr
ELK6.0以上版本----------filebeat多路径日志，通过redis发送logstash解析多索引模式
打卤的博客
02-13 2896
一、前言 本篇环境 Elasticsearch6.0 , Logstash6.0 , Kibana6.0 , filebeat6.0 流程filebeat ⇒ redis ==&amp;gt;Logstash 流程图 请参考：https://blog.csdn.net/liyyzz33/article/details/86701949 二、目的 filebeat多日志传输，经Logstash过滤后输出多索...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值