9.过滤器监听器-过滤器

已于 2024-01-02 17:57:41 修改
阅读量1.3k 收藏 35
点赞数 35
分类专栏： Java后端 文章标签： java-ee
于 2023-12-12 23:38:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43303296/article/details/134960574
版权

文章目录

1.过滤器监听器概念引入

过滤器：
过滤器
Filter也称为过滤器，它是Servlet中最实用的技术，Web开发人员通过Filter技术，对web服务器管理所有的web资源：例如jsp,servlet,静态图片文件或静态html文件等进行拦截，从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。
过滤器主要用于对用户请求进行预处理，也可以对HttpServletResponse进行后处理。使用Filter的完整流程：Filter对用户请求进行预处理，接着将请求交给Servlet进行处理并生成响应，最后Filter再对服务器响应进行后处理。
过滤器是如何实现功能的：
1.在HttpServletRequest到达Servlet之前，拦截客户的HttpServletRequest，根据需要检查HttpServletRequest，也可以修改HttpServletRequest的请求头和数据。
2.在HttpServletResponse到达客户端之前，拦截HttpServletResponse。根据需要检查HttpServletResponse，也可以修改HttpServletResponse的响应头和响应体中的数据。
3.Filter接口中有一个doFilter方法，当开发人员编写好Filter，并配置对哪个web资源进行拦截后，web服务器每次在调用web资源的service方法之前，都会先调用一下filter的doFilter方法，doFilter方法中有一个filterChain对象，用于继续传递给下一个filter。在传递之前我们可以定义过滤请求的功能，在传递之后我们可以定义过滤响应的功能。
总结：来时过滤请求，去时过滤响应。我们可以通过过滤器实现比如权限控制等功能，根据用户的不同权限开放不同的页面

2.过滤器的编写和配置

采用三步走的策略使用filter：
1.开发后台资源（静态资源 如html,css或者动态资源 如Servlet,jsp）
2.开发Filter，实现javax.servlet.Filter接口，重写抽象方法（init,destroy,doFilter）
3.在web.xml中配置Filter拦截哪些资源

1.Servlet

package com.example.filter;/**
 * @Author:zhoayu
 * @Date:2023/12/12 23:07
 * @Description:com.example.filter
 * @version:1.0
 */

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @ClassName MyServlet
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2023/12/12
 */
public class MyServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("myservlet 执行了");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=UTF-8");
        resp.getWriter().print("myservlet响应了");
    }
}

2.Filter

package com.example.filter;/**
 * @Author:zhoayu
 * @Date:2023/12/12 23:12
 * @Description:com.example.filter
 * @version:1.0
 */

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

/**
 * @ClassName MyFilter
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2023/12/12
 */
public class MyFilter implements Filter {
    //过滤器初始化方法
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器对象创建了");
    }

    //过滤器销毁方法
    @Override
    public void destroy() {
        System.out.println("过滤器对象销毁了");
    }

    //过滤动作
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("过滤器开始过滤");
    }
}

3.在web.xml中进行配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
         
    <servlet>
        <servlet-name>myservlet1</servlet-name>
        <servlet-class>com.example.filter.MyServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>myservlet1</servlet-name>
        <url-pattern>/myservlet1.do</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>filter1</filter-name>
        <filter-class>com.example.filter.MyFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>filter1</filter-name>
        <!--对哪个web资源的请求和响应进行过滤-->
        <!--当请求url的请求路径是/myservlet1.do时，过滤器拦截请求/响应进行过滤。
        如果这里的url-pattern是/，则过滤所有请求（不包含jsp）,如果是/*,则过滤所有请求（包含jsp）-->
        <url-pattern>/myservlet1.do</url-pattern>
        <!--还可以直接指定servlet名称来指定对哪些servlet进行过滤,可以同时配置对多个servlet进行过滤-->
        <servlet-name>myservlet1</servlet-name>
    </filter-mapping>

</web-app>

请求servlet：
发现没有响应
请求servlet
后台日志
通过看后台日志可以发现：1.过滤器对象在服务器启动时被创建 2.过滤器拦截了我们的请求，并且我们的servlet中的逻辑没有执行（我们需要在doFilter中手动放行请求才可以）
后台日志
过滤器放行请求
对Filter做一些修改，在执行完对请求的过滤逻辑后，放行请求，并在目标资源做出响应后，再次对响应进行过滤：

package com.example.filter;/**
 * @Author:zhoayu
 * @Date:2023/12/12 23:12
 * @Description:com.example.filter
 * @version:1.0
 */

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

/**
 * @ClassName MyFilter
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2023/12/12
 */
public class MyFilter implements Filter {
    //过滤器初始化方法
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器对象创建了");
    }

    //过滤器销毁方法
    @Override
    public void destroy() {
        System.out.println("过滤器对象销毁了");
    }

    //过滤动作
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("过滤器对请求做出过滤");

        //放行请求，交给过滤器链继续进行过滤（过滤器1->过滤器2->过滤器3...->资源），目前我们只有一个过滤器，所以一旦放行 直接到达目标资源
        chain.doFilter(request,response);

        /*..目标资源逻辑..*/

        //对响应做出过滤
        System.out.println("过滤器对响应做出过滤");
    }
}

此时再次请求可以看到，目标资源顺利返回了：
请求资源
通过后台日志可以总结出过滤器-资源的执行顺序：
服务器启动->过滤器创建->请求->过滤器1对请求作出过滤->过滤器2对请求作出过滤->过滤器3对请求作出过滤->…->目标资源执行逻辑，做出响应->…->过滤器3对响应作出过滤->过滤器2对响应作出过滤->过滤器1对响应作出过滤->响应
过滤器-资源执行顺序

3.过滤器的生命周期

同Servlet对象一样，Filter对象的创建也是交给web服务器完成的，在web服务器创建和使用及最后销毁filter时，会调用filter对应的方法。
filter的初始化方法：

default public void init(FilterConfig filterConfig) throws ServletException {}

和我们编写的Servlet程序一样，Filter的创建和销毁由WEB服务器负责。web应用程序启动时，web服务器将创建Filter的实例对象，并调用其init方法，读取web.xml中的配置，完成对象的初始化功能，从而为后续的用户请求做好拦截的准备工作（Filter对象只会创建一次，init方法也只会执行一次）。开发人员通过init方法的参数，可获得代表当前filter配置信息的FilterConfig对象。
filter的拦截请求方法：

   public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain)
            throws IOException, ServletException;

doFilter方法完成实际的过滤操作。当客户请求访问与过滤器关联的URL或者Servlet时，过滤器将先执行doFilter方法。FilterChain参数用于将请求放行，让其访问后续资源（如果有过滤器，就到下一个过滤器，如果没有 就放行到目标资源）。
filter的销毁方法：

default public void destroy() {}

Filter对象创建后会驻留在内存，当web应用被移除或者服务器停止时才销毁。destroy方法在Web容器销毁Filter对象之前被调用，该方法在Filter的生命周期中仅执行一次，我们可以在这个方法中执行一些释放过滤器使用的资源等操作。

总结
1.Web容器启动时，会创建Filter对象并执行init()方法，这个Filter对象是单例（重复的请求不会重复创建Filter对象）
2.当请求Filter拦截的资源时，Filter对象执行doFilter()方法，doFilter()方法对请求&响应进行过滤
3.Web容器关闭时，销毁Filter对象，执行destroy()方法

4.过滤器链的使用

在一个Web应用中，我们可以针对一个Web资源写多个Filter，并把它们组合起来成为一个过滤器链。
过滤器链
Web服务器根据Filter在web.xml文件中的注册顺序，决定先调用哪个Filter。当第一个Filter对象的doFilter()方法被调用时，web服务器会创建一个代表Filter链的FilterChain对象作为入参传递给doFilter()方法。在doFilter()方法中，开发人员如果调用了FilterChain对象的doFilter方法，web服务器会检查FilterChain对象中是否还有Filter，如果有，则调用第二个Filter，如果没有，则调用目标资源。
使用过滤器链的好处是我们可以将不同的过滤逻辑分散到多个过滤器中，分工明确，避免出现一个过滤器做太多的业务处理，降低了代码的耦合度。这体现了单一职责的设计原则，应用了责任链的代码设计模式
ps：过滤器的执行顺序是由filter-mapping标签决定的

Filter1：

package com.example.filter;/**
 * @Author:zhoayu
 * @Date:2023/12/13 22:32
 * @Description:com.example.filter
 * @version:1.0
 */

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

/**
 * @ClassName Filter1
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2023/12/13
 */
public class Filter1 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("过滤器1执行了过滤请求动作");
        chain.doFilter(request,response);
        System.out.println("过滤器1执行了过滤响应动作");
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

Filter2：

package com.example.filter;/**
 * @Author:zhoayu
 * @Date:2023/12/13 22:33
 * @Description:com.example.filter
 * @version:1.0
 */

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

/**
 * @ClassName Filter2
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2023/12/13
 */
public class Filter2 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("过滤器2执行了过滤请求动作");
        chain.doFilter(request,response);
        System.out.println("过滤器2执行了过滤响应动作");
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

web.xml：

   <filter>
        <filter-name>f1</filter-name>
        <filter-class>com.example.filter.Filter1</filter-class>
    </filter>

    <filter>
        <filter-name>f2</filter-name>
        <filter-class>com.example.filter.Filter2</filter-class>
    </filter>
    
    <!--注意这里定义filter-mapping的顺序决定了一个filterchain中filter的顺序-->
    <filter-mapping>
        <filter-name>f1</filter-name>
        <servlet-name>myservlet1</servlet-name>
    </filter-mapping>

    <filter-mapping>
        <filter-name>f2</filter-name>
        <servlet-name>myservlet1</servlet-name>
    </filter-mapping>

请求目标资源：
请求目标资源
从后台日志分析Filter过滤请求和过滤响应时的执行顺序：
后台日志
Web容器启动->Filter对象创建->Filter对象的init()方法执行->请求目标资源->Filter1过滤请求->Filter2过滤请求->目标资源执行逻辑作出响应->Filter2过滤响应->Filter1过滤响应->…->Web容器停止->Filter对象销毁
这里Filter在FilterChain中的顺序是通过Filter的filter-mapping标签在web.xml中的定义顺序来决定的。
过滤器可以修改请求，放行请求，甚至拦截请求不放行

5.过滤器初始化参数配置

同servlet一样（ServletConfig），filter也可以通过web.xml进行初始化配置，在初始化时，将参数封装进FilterConfig并在调用init方法时将FilterConfig对象作为实参传入。我们可以在init方法中获取参数。FilterConfig接口为我们提供了以下功能：

    //过滤器初始化方法
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器对象创建了");
    }

//获得Filter的名称
public String getFilterName();

//返回指定名称的初始化参数的值，如果不存在对应参数则返回null
public String getInitParameter(String name);

//返回所有初始化参数的名字的枚举集合
public Enumeration<String> getInitParameterNames();

//返回ServletContext对象
public ServletContext getServletContext();

我们可以在web.xml中对Filter对象的初始化参数进行配置，这些key-value会在web容器启动时被设置到FilterConfig对象中，接着会把FilterConfig对象传入Filter实现类的init方法中

    <filter>
        <filter-name>f1</filter-name>
        <filter-class>com.example.filter.Filter1</filter-class>
        <init-param>
            <param-name>name</param-name>
            <param-value>zy</param-value>
        </init-param>

        <init-param>
            <param-name>gender</param-name>
            <param-value>nan</param-value>
        </init-param>

        <init-param>
            <param-name>age</param-name>
            <param-value>20</param-value>
        </init-param>

        <init-param>
            <param-name>charset</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>

接着我们在上述的Filter实现类中重写init方法：

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //获取Filter名称
        System.out.println(filterConfig.getFilterName());
        //获取参数
        System.out.println(filterConfig.getInitParameter("name"));

        //获取所有参数名
        Enumeration<String> initParameterNames = filterConfig.getInitParameterNames();
        while(initParameterNames.hasMoreElements()){
            String pname = initParameterNames.nextElement();
            System.out.println(filterConfig.getInitParameter(pname));
        }
    }

FilterConfig

6.过滤器中使用注解

使用注解来开发过滤器，通过使用注解来简化web.xml的配置：
过滤器中使用注解
使用注解模式开发Filter：

package com.example.filter;/**
 * @Author:zhoayu
 * @Date:2024/1/2 15:58
 * @Description:com.example.filter
 * @version:1.0
 */

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import java.io.IOException;

/**
 * @ClassName FilterWithAnnotation
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2024/1/2
 */
@WebFilter(filterName = "filterwithannotation",
            urlPatterns = {"/myservlet1.do","/myservlet2.do"},
            servletNames = {"myservlet","myservlet2"},
            initParams = {@WebInitParam(name = "name",value = "zy"),@WebInitParam(name = "charset",value = "utf-8")}
            )
public class FilterWithAnnotation implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("FilterWithAnnotation执行了");
        chain.doFilter(request,response);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

在web.xml配置filter时，可以通过在中的filter1和filter2的顺序来制定过滤器的顺序。但是使用注解模式时，怎么指定过滤器在过滤器链中的顺序呢?
使用注解模式开发Filter时，Filter的顺序是根据过滤器名称 即filterName=xxx 的字典序来确定的。
所以我们可以使用规范的命名方式来定义filter的顺序，eg:Filter0_myfilter1，Filter1_myfilter2…

7.过滤器处理POST乱码

login.jsp：提交账号密码

<%--
  Created by IntelliJ IDEA.
  User: zhaoyu
  Date: 2024/1/2
  Time: 16:16
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
please login ... ... <br/>
<form action="${pageContext.request.contextPath}/loginController.do" method="post">
    用户名：<input type="text" name="user"> <br/>
    密码：<input type="text" name="pwd"> <br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

package com.example.test;/**
 * @Author:zhoayu
 * @Date:2024/1/2 16:18
 * @Description:com.example.test
 * @version:1.0
 */

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

/**
 * @ClassName ServletLogin
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2024/1/2
 */
@WebServlet("/loginController.do")
public class loginController implements Servlet {
    @Override
    public void init(ServletConfig config) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        //获取用户名&密码
        String name = req.getParameter("user");
        String pwd = req.getParameter("pwd");
        System.out.println(name);
        System.out.println(pwd);
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

login.jsp
post请求乱码：
输出
我们可以设置字符集编码格式为UTF-8（将字符集编码格式的设置交给过滤器来做）：对所有请求，都将其字符集格式设置为UTF-8。这样做的好处是不用在所有Servlet的service方法中手动执行

req.setCharacterEncoding("UTF-8");

LoginFilter：

package com.example.test;/**
 * @Author:zhoayu
 * @Date:2024/1/2 16:33
 * @Description:com.example.test
 * @version:1.0
 */

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import java.io.IOException;

/**
 * @ClassName LoginFilter
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2024/1/2
 */
@WebFilter(filterName = "Filter0_loginFilter",
            urlPatterns = "/*",
            initParams = @WebInitParam(name="charset",value="UTF-8"))
public class LoginFilter implements Filter {
    String charset = null;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        charset = filterConfig.getInitParameter("charset");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //拦截所有请求，将其字符集格式设置为UTF-8
        //可以把UTF-8写到FilterConfig的初始参数中，不要在这里写死
        request.setCharacterEncoding(charset);
        System.out.println(charset); // UTF-8
        //放行
        chain.doFilter(request,response);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

通过这种方式解决了中文乱码的问题：
post请求中文乱码问题解决

8.过滤器控制登陆

需求：通过过滤器控制，只有登陆过之后可以反复进入welcome.jsp欢迎页，如果没有登陆，提示用户进入登陆页进行登录操作。（类似cookie-session小例子）
welcome.jsp：

<%--
  Created by IntelliJ IDEA.
  User: zhaoyu
  Date: 2024/1/2
  Time: 16:45
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<b>欢迎${sessionScope.user.username}登陆！！！</b>
</body>
</html>

User实体类：

package com.example.test2;/**
 * @Author:zhoayu
 * @Date:2024/1/2 16:47
 * @Description:com.example.test2
 * @version:1.0
 */

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @ClassName User
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2024/1/2
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class User implements Serializable {
    private String username;
    private String password;
}

login.jsp：

<%--
  Created by IntelliJ IDEA.
  User: zhaoyu
  Date: 2024/1/2
  Time: 16:16
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
please login ... ... <br/>
<form action="${pageContext.request.contextPath}/loginController.do" method="post">
    用户名：<input type="text" name="user"> <br/>
    密码：<input type="text" name="pwd"> <br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

因为我们还没有定义拦截器，所以现在是直接能够访问到welcome.jsp的，同时因为session域中没有User对象，所以此时${sessionScope.user.username}也是获取不到值的
访问welcome.jsp
我们现在要做的是：除了login.jsp外，只要没有登陆过 不允许用户访问任何资源。

拦截器Filter1_LoginFilter.java：

package com.example.test2;/**
 * @Author:zhoayu
 * @Date:2024/1/2 16:51
 * @Description:com.example.test2
 * @version:1.0
 */

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

/**
 * @ClassName Filter1_LoginFilter
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2024/1/2
 */
@WebFilter(filterName = "Filter1_loginFilter",urlPatterns = "/*") // 拦截访问任何资源的请求
public class Filter1_LoginFilter implements Filter {


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //不管登陆没登陆都要进行放行的:请求login.jsp的请求
        HttpServletRequest httpServletRequest = (HttpServletRequest)request;
        String uri = httpServletRequest.getRequestURI(); // /application_contest/资源路径
        System.out.println(uri); // /demo5_war_exploded/welcome.jsp

        //请求登陆页面or登陆servlet(提交用户密码)的请求直接放行
        //这里放行static目录下的资源是为了防止login.jsp上有static目录下资源的引用，让这些静态资源能够正常展示
        if(uri.endsWith("login.jsp") || uri.endsWith("loginController.do") || uri.contains("/static/")){
            chain.doFilter(httpServletRequest,response);
            return;
        }

        //需要登陆之后才能访问的资源，如果用户之前没登陆过，重定向到login.jsp上
        HttpSession session = httpServletRequest.getSession();
        Object user = session.getAttribute("user");

        if(user!=null){
            //如果登陆过，放行
            chain.doFilter(httpServletRequest,response);
        }else{
            //没有登陆过，跳转至登陆页
            //这里注意两点：
            // 1.session域的范围 不能跨用户请求 所以可以这样判断该用户是否登陆过。同时注意session的生命周期（cookie或session一方失效则失效,无法通过sessionid获得对应的session了）
            // 2.过滤器这里的参数req和resp其实是ServletRequest和ServletResponse的子类：HttpServletRequest和HttpServletResponse
            //   所以这里能这样强转以获得更多的api
            HttpServletResponse httpServletResponse = (HttpServletResponse)response;
            httpServletResponse.sendRedirect("/login.jsp");
        }
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

loginContoller.java：

package com.example.test;/**
 * @Author:zhoayu
 * @Date:2024/1/2 16:18
 * @Description:com.example.test
 * @version:1.0
 */


import com.example.test2.User;

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

/**
 * @ClassName ServletLogin
 * @Description //TODO 
 * @Author zhaoyu
 * @Date 2024/1/2
 */
@WebServlet("/loginController.do")
public class loginController extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取用户名&密码
        String name = req.getParameter("user");
        String pwd = req.getParameter("pwd");
        System.out.println(name);
        System.out.println(pwd);

        //连接数据库校验账号密码 这里省略

        //登陆成功，将用户信息放入session域
        User user = new User(name,pwd);
        req.getSession().setAttribute("user",user);

        //请求转发跳转到欢迎页
        RequestDispatcher requestDispatcher = req.getRequestDispatcher("/welcome.jsp");
        requestDispatcher.forward(req,resp);
    }
}
_laolao_
关注
  • 35
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot实现拦截器、过滤器、监听器过程解析
08-25
SpringBoot 实现拦截器、过滤器、监听器过程解析 SpringBoot 框架中提供了多种方式来拦截和过滤请求，包括拦截器、过滤器和监听器。以下是对这三种机制的详细解析： 一、拦截器 在 SpringBoot 中，拦截器是通过...
vue.js中过滤器的使用教程
10-19
`watch` 监听器用于在关键词改变时更新过滤后的用户列表。 在模板中，我们可以这样使用自定义过滤器： ```html <user-list :members="userList | customFilter key_word" :filter_key="key_word"></user-list> ```...
过滤器Filter,监听器Listener,拦截器Interceptor
hq091117的博客
08-15 5512
过滤器Filter 概念： Servlet过滤器是在java servlet规范2.3中定义的，他能够对servlet容器的请求和响应对象进行检查和修改。 Servlet过滤器本身并不产生请求和响应对象，他只能提供过滤作用，servlet过滤能够在servlet被调用之前检查request对象，修改request的header和request内容，在调用后检查response对象，修改res...
过滤器、监听器
yuer629
05-28 1812
一、过滤器(Filter)1.概述过滤器是JavaWeb三大组件之一，它与Servlet很相似！不过servlet是用来处理请求，而过滤器是用来过滤请求的。拥有对目标资源的请求和响应进行截取的功能。2.实现方式其实过滤器与Servlet很相似，具体如下: 1.实现Filter接口，重新里面抽象方法2.配置web.xml配置文件步骤一:创建类，实现Filter接口，重新里面的三个方法 public ...
过滤器&监听器
LY3054404567的博客
03-25 769
过滤器&监听器过滤器1、什么是过滤器?2、filter生命周期及其与生命周期相关的方法配置过滤器/代码演示监听器1、什么是监听器2、监听器的分类3、配置监听/代码演示 过滤器 1、什么是过滤器? Filter 过滤器它是 JavaWeb 的三大组件之一：三大组件分别是：Servlet 程序、Listener 监听器、Filter 过滤器 Filter 过滤器它是 JavaEE 的规范。也就是接口 Filter 过滤器它的作用是：拦截请求，过滤响应 过滤器实际上就是对web资源进行拦截，做一些处理
springBoot(6)---过滤器，监听器，拦截器
a8892117的博客
05-15 1681
过滤器，监听器，拦截器 一、理解它们 看里十几篇博客，总算有点小明白，总的来讲，两张图可以让我看明白点。 通过两幅图我们可以理解拦截器和过滤器的特点 1、过滤器 　　过滤器是在请求进入tomcat容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前。 理解上面这句话我们就可以知道...
过滤器、监听器 ---- 概念及使用
雁迟的博客
03-20 262
JavaWeb 一、课程目标 【理解】过滤器的概念 【掌握】过滤器的使用 【了解】监听器的概念 【理解】监听器的使用 二、过滤器 2.1 概念 当客户端发送请求至服务器端，服务器端可以配置过滤器对请求在执行前进行过滤操作，本质就是一个实现了过滤器接口的java类，通过doFilter方法进行请求的过滤与放行 2.2 工作流程 当客户端发送请求时，先由tomcat服务器处理请求，解析请求的地址路径，与web.xml中过滤器过滤地址进行匹配，如果匹配则执行对应过滤器doFilter方法，进行过滤操作，执行结
servlet过滤器与监听器
久绊A的博客
06-02 595
Servlet 过滤器和监听器是 Java Web 应用程序中常见的两种组件，它们提供了各种扩展 Web 应用程序功能的方式。总的来说，过滤器和监听器都可以通过 Java Web 应用程序的配置文件或注解进行使用，方便灵活，并可以很好地实现框架与业务逻辑的分离，提高代码可维护性和扩展性。
servlet过滤器和监听器PPT课件.ppt
06-04
servlet过滤器和监听器，servlet过滤器和监听器课件，servlet过滤器和监听器PPT
Java中的拦截器、过滤器、监听器用法详解
08-30
Java中的拦截器、过滤器、监听器用法详解 Java中的拦截器、过滤器、监听器是三个重要的概念，它们在Java Web开发中扮演着非常重要的角色。本文将详细介绍Java中的拦截器、过滤器、监听器的用法，包括它们的功能、...
JavaWeb13-过滤器与监听器.rar
03-29
JSP+servlet+javabean学习 里面有ＰＤＦ文件对该章节的详细讲解，培训老师才讲的到的，非常详细......资源内容如下： JavaWeb02-request与response.rar JavaWeb03-会话跟踪cookie与...JavaWeb13-过滤器与监听器.rar
【JavaEE】AOP实现原理
最新发布
m0_74105656的博客
07-13 508
Spring动态代理的具体实现细节,主要讲解AOP的实现原理
JavaEE: SpringBoot框架
cx不会编程的博客
07-13 151
SpringBoot框架安装以及简单介绍
初识JavaEE
Dxito_的博客
07-09 241
web（World Wide Web）即全球⼴域⽹，也称为万维⽹.简单来说,就是可以通过浏览器来和我们的程序进⾏交互。⽐如京东,淘宝,天猫,美团等⽹站项⽬。
【JavaEE】网络编程——TCP
HD_13的博客
07-11 815
网络编程的目的是为了跨主机通信，socket==》操作系统提供的网络编程的API就称为"socket"API。
【JavaEE】文件IO
HD_13的博客
07-10 810
算的，文件夹算目录文件，在我们计算机中有许多文件和目录，而且这些目录还有些嵌套的，为了将这些目录和文件给整理在一起，则计算机有个体系来整理这些文件与目录，可以看成一个N叉树。那我们怎么找到我需要的文件呢，那需要一个机制，可以帮我们迅速定位到目标文件，那么需要定位到目标文件，你肯定需要一个路径来实现吧。上述的write操作，都会覆盖之前的数据，为了不覆盖之前的数据，这个覆盖操作不是write造成的，而是打开文件这个操作造成的，在打开文件的构造方法中，加一个参数true，那么就不会覆盖之前的数据。
【JavaEE】Spring AOP详解
m0_74105656的博客
07-10 851
SpringAOP知识点的详细讲解
拦截器 过滤器 监听器区别
04-08
拦截器、过滤器和监听器是Java中常用的三种组件，用于处理请求和响应。它们有以下区别[^1][^2]： 1. 实现方式： - 拦截器是基于Java的反射机制实现的。 - 过滤器是基于函数回调实现的。 - 监听器是基于事件监听机制...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值