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> ```...
过滤器&监听器
LY3054404567的博客
03-25 773
过滤器&监听器过滤器1、什么是过滤器?2、filter生命周期及其与生命周期相关的方法配置过滤器/代码演示监听器1、什么是监听器2、监听器的分类3、配置监听/代码演示 过滤器 1、什么是过滤器? Filter 过滤器它是 JavaWeb 的三大组件之一：三大组件分别是：Servlet 程序、Listener 监听器、Filter 过滤器 Filter 过滤器它是 JavaEE 的规范。也就是接口 Filter 过滤器它的作用是：拦截请求，过滤响应 过滤器实际上就是对web资源进行拦截，做一些处理
监听器和过滤器
好好
12-10 1759
一、Listener 当服务器发生了某个事件(Event)时，调用事件处理程序。 web监听器是一种servlet中的特殊类，能帮助开发者监听web中的特定事件，比如servletContext，HttpSession，ServletRequest的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控。 编写监听器的步骤： 编写实现类 在web.xml中进行部署 编写测试页...
springBoot(6)---过滤器，监听器，拦截器
a8892117的博客
05-15 1682
过滤器，监听器，拦截器 一、理解它们 看里十几篇博客，总算有点小明白，总的来讲，两张图可以让我看明白点。 通过两幅图我们可以理解拦截器和过滤器的特点 1、过滤器 　　过滤器是在请求进入tomcat容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前。 理解上面这句话我们就可以知道...
Java三大器之拦截器(Interceptor)的实现原理及代码示例
热门推荐
reggergdsg的博客
10-29 26万+
过滤器与拦截器的区别 过滤器可以简单的理解为“取你所想取”，过滤器关注的是web请求；拦截器可以简单的理解为“拒你所想拒”，拦截器关注的是方法调用，比如拦截 敏感词汇。 4.1，拦截器是基于java反射机制来实现的，而过滤器是基于函数回调来实现的。（有人说，拦截器是基于动态代理来实现的） 4.2，拦截器不依赖servlet容器，过滤器依赖于servlet容器。 4.3，拦截器只对Action起作用，过滤器可以对所有请求起作用。 4.4，拦截器可以访问Action上下文和值栈中的对象，过滤器不能。 4
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
过滤器Filter,监听器Listener,拦截器Interceptor
hq091117的博客
08-15 5513
过滤器Filter 概念： Servlet过滤器是在java servlet规范2.3中定义的，他能够对servlet容器的请求和响应对象进行检查和修改。 Servlet过滤器本身并不产生请求和响应对象，他只能提供过滤作用，servlet过滤能够在servlet被调用之前检查request对象，修改request的header和request内容，在调用后检查response对象，修改res...
过滤器、监听器
yuer629
05-28 1814
一、过滤器(Filter)1.概述过滤器是JavaWeb三大组件之一，它与Servlet很相似！不过servlet是用来处理请求，而过滤器是用来过滤请求的。拥有对目标资源的请求和响应进行截取的功能。2.实现方式其实过滤器与Servlet很相似，具体如下: 1.实现Filter接口，重新里面抽象方法2.配置web.xml配置文件步骤一:创建类，实现Filter接口，重新里面的三个方法 public ...
JavaEE - HTTP状态码
最新发布
QIAO182的博客
07-24 540
浏览器和服务器两端进行数据交互，使用的就是HTTP协议（HTTP客⼾端和 HTTP服务器之间的交互数据 的格式）。Web服务器就是对HTTP协议进⾏封装,程序员不需要直接对协议进⾏操作(⾃⼰写代码去解析http协议 规则)，让Web开发更加便捷,所以Web服务器也被称为WWW服务器,HTTP服务器，主要功能是提供网上信息浏览服务。常⻅的Web服务器有:Apache,Nginx,IIS,,Jboss等。SprootBoot内置了Tomcat服务器，无需配置即可直接运行。
【JavaEE】Bean的作用域和生命周期
m0_74105656的博客
07-24 608
1. Bean的作用域共分为6种: singleton, prototype, request, session, application和websocket. 2. Bean的生命周期共分为5大部分: 实例化, 属性复制, 初始化, 使用和销毁
JavaEE (1)
2301_78085386的博客
07-19 1108
● Servlet是Server Applet的简称，意思为用Java编写的服务器端的程序. 它运行在web服务器中，web服务器负责Servlet和客户的通信以及调用 Servlet方法。● Servlet的作用： 1.接收用户发送的请求数据 2.调用其他的java程序来处理请求 3.根据处理结果，将结果响应给客户端● 1.创建一个类继承javax.servlet.http包下的HttpServlet● 2.在web.xml文件中配置Servlet。
【JavaEE初阶】Thread类及常见方法
2301_81510374的博客
07-24 545
Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。每个执行流，也需要有一个对象来描述，类似下图所示，而 Thread 类的对象就是用来描述一个线程执行流的，JVM 会将这些 Thread 对象组织起来，用于线程调度，线程管理​。
【JavaEE进阶】——Spring AOP 实现原理
m0_74438843的博客
07-20 701
从上述程序可以看出, 虽然静态代理也完成了对⽬标对象的代理, 但是由于代码都写死了, 对⽬标对象的每个⽅法的增强都是⼿动完成的，⾮常不灵活. 所以⽇常开发⼏乎看不到静态代理的场景.为其他对象提供⼀种代理以控制对这个对象的访问. 它的作⽤就是通过提供⼀个代理类, 让我们在调⽤⽬标⽅法的时候, 不再是直接对⽬标⽅法进⾏调⽤, ⽽是通过代理类间接调⽤.(Proxy). 同样的, 如果有新增接⼝(Subject)和业务实现类(RealSubject), 也需要对每⼀个业务实现类新增代理类 (Proxy)。
【JavaEE进阶】——Spring事务和事务传播机制
m0_74438843的博客
07-20 1033
可重复读(REPEATABLE READ): 事务不会读到其他事务对已有数据的修改, 即使其他事务已提交. 也就可以确保同⼀事务多次查询的结果⼀致, 但是其他事务新插⼊的数据, 是可以感知到的. 这也就引发了幻读问题. 可重复读, 是 MySQL 的默认事务隔离级别.如果其中一个出现异常，那么都回滚，只有都执行成功，那么事务提交。register事务可以认为是⽗事务, 嵌套事务是⼦事务. ⽗事务出现异常, ⼦事务也会回滚, ⼦事务出现异常, 如果不进⾏处理, 也会导致⽗事务回滚。
JavaEE - Spring Boot 简介
QIAO182的博客
07-23 520
2.1 认识Spring学习SpringBoot之前先认识Spring~一个是Spring家族，全家桶；另一个指Spring Core，也就是Spring Framework。上述是Spring官⽅(https://spring.io/)的介绍。可以看到,Spring让Java程序更加快速,简单和安全.Spring对于速度、简单性和⽣产⼒的关注使其成为 世界上最流⾏的Java框架。
Web过滤器与监听器实战指南
"过滤器与监听器是Web开发中的重要组件，用于增强Web应用程序的功能和管理应用程序的生命周期。本章节主要讲解了Filter的基本概念、工作原理、功能以及如何定义和使用Filter，同时也涵盖了全局对象监听器和会话对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值