servlet 过滤器跳转

2021-10-31 15:16:55

servlet过滤器

1.什么是过滤器

过滤器实际上就是对web资源进⾏拦截，做⼀些处理后再交给下⼀个过滤器或servlet处理，通常都是⽤来拦截request进⾏处理的，也可以对返回的response进⾏拦截处理，可以同时设置多个过滤器。过滤器依赖于servlet，一个过滤器可以加在多个servlet上，（多个过滤器也可以加在一个servlet上）

2.过滤器的语法格式

实现Javax.serlvet.Filter接口，重写里面的方法（对应servlet-api.jar）

package util;


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

public class FirstFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化filter");//当服务器启动时执行init
    }

    @Override   //请求和响应时都会执行这个方法
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("过滤器开始");

        //调取下一个过滤器，或者调取servlet
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("过滤器结束");

    }

    @Override
    public void destroy() {
        System.out.println("销毁filter");
    }
}

3.在web.xml⽂件中配置

<filter>
 <filter-name>过滤器名称</filter-name>
 <filter-class>过滤器所在的路径</filter-class>
 </filter>
 <filter-mapping>
 <filter-name>过滤器名称</filter-name>
 <url-pattern>需要过滤的资源</url-pattern>
 </filter-mapping>

示例：

  <filter>
        <filter-name>f1</filter-name>
        <filter-class>
            util.FirstFilter
        </filter-class>
    </filter>
    <filter-mapping>
        <filter-name>f1</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

4.使⽤场景

1.如何防⽌⽤户未登录就执⾏后续操作

String name=(String)session.getAttribute("key");

if(name==null){ //跳转到登录⻚⾯ }

.2.设置编码⽅式--统⼀设置编码

3.加密解密(密码的加密和解密)

4.⾮法⽂字筛选

5.下载资源的限制过滤器的特点:在servlet之前和之后都会被执⾏

5.过滤器中的url-pattern中的 / 和 /* 和/login

 <filter-mapping>
        <filter-name>testFilter1</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

会过滤所有请求，包括对静态资源的访问，都会进入过滤器。

会匹配所有的url：路径型的和后缀型的url(包括/springmvc，.jsp，.js和*.html等)。这种形式将会覆盖所有其它的servlet。不管你发出了什么样的请求，最终都会在这个servlet中结束。因此，对于servlet来说，这是一个很糟糕的URL模式。通常来讲，你只会想要在一个Filter中使用这种模式。

<filter-mapping>
        <filter-name>testFilter1</filter-name>
        <url-pattern>/</url-pattern>
    </filter-mapping>

会匹配到/springmvc这样的路径型url，不会匹配到模式为*.jsp这样的后缀型url。

这时如果有静态资源的访问，要再处理对静态资源的访问不到的问题。

<filter-mapping>
        <filter-name>testFilter2</filter-name>
        <url-pattern>/login</url-pattern>
    </filter-mapping>

只会过滤/login访问路径

例子：验证用户登录

过滤器

package util;


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

public class FirstFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化filter");//当服务器启动时执行init
    }

    @Override   //请求和响应时都会执行这个方法
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("过滤器开始");
        //处理乱码
        HttpServletRequest request=(HttpServletRequest)servletRequest;
        HttpServletResponse response=(HttpServletResponse)servletResponse;
        request.setCharacterEncoding("utf-8");

        //防止用户在未登录的情况下访问资源
        String requestURI = request.getRequestURI();//获得请求地址
        System.out.println("requestURI="+requestURI);
        Object username = request.getSession().getAttribute("username");

        if(requestURI.endsWith("testsession.jsp")&&username==null){
            response.sendRedirect("index.jsp");
        }

        //调取下一个过滤器，或者调取servlet
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("过滤器结束");

    }

    @Override
    public void destroy() {
        System.out.println("销毁filter");
    }
}

后端

package servlet;

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

@WebServlet(urlPatterns = "/login")
public class LoginServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       resp.sendRedirect("error.jsp");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("login-servlet被执行");
        //1.接收参数
        String username = req.getParameter("username");
        String pass = req.getParameter("pass");
        //2.判断正误
        if("admin".equals(username)&&"123456".equals(pass)){
            //登录成功
            //session存值
            HttpSession session = req.getSession();
            session.setAttribute("username",username);
            session.setAttribute("password",pass);
            session.setMaxInactiveInterval(60*30);//单位是秒
            //重定向或者转发时，session数据是不会丢失的，重定向时，request中的数据会丢失
            resp.sendRedirect("success.jsp");
        }else{
            //登录失败
            //1.后台创建cookie
            Cookie cookie = new Cookie("uname",username);
            //2.返回给前端
            resp.addCookie(cookie);
            resp.sendRedirect("index.jsp");
        }
    }
}

前端


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
<!--需要导入 jstl-jar-->
  <%
    Cookie[] cookies = request.getCookies();
    String value ="";
    if(cookies!=null&&cookies.length>0){
      for (Cookie cookie : cookies) {
        if(cookie.getName().equals("uname")){
          value = cookie.getValue();
          break;
        }
      }
    }
    pageContext.setAttribute("unamecookie",value);

  %>

  <h1>登录</h1>
  <form action="login" method="post">
    用户名:<input type="text" name="username" value="${unamecookie}" ><br>
    密码：<input type="password" name="pass"><br>
    <input type="submit" value="login">

  </form>
  </body>
</html>

SpringMVC 中的拦截器

1.概念

java中的拦截器是动态拦截action调用的对象。依赖于web框架，在springmvc中依赖于SpringMVC框架，在实现上基于Java的反射机制，属于AOP的一种应用，作用类似于过滤器，但是拦截器只能对Controller请求进行拦截，对其他的直接访问静态资源的请求无法拦截处理。

拦截器（ Interceptor）是非常重要的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。

2.拦截时间

拦截的时间点在“处理器映射器HandlerMapping根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器HandlerAdaptor执行处理器之前”。

在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链 HandlerExecutionChain，并返回给了前端控制器。

3.实现拦截器

自定义拦截器，需要实现 HandlerInterceptor 接口。而该接口中含有三个方法：

public interface HandlerInterceptor {


default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return true;
	}
default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}
default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}

}

4.拦截器方法说明

preHandle(request,response, Object handler)：

该方法在处理器方法执行之前执行。其返回值为boolean，若为true，则紧接着会执行处理器方法，且会将afterCompletion()方法放入到一个专门的方法栈中等待执行。 postHandle(request,response, Object handler,modelAndView)：

该方法在处理器方法执行之后执行。处理器方法若最终未被执行，则该方法不会执行。由于该方法是在处理器方法执行完后执行，且该方法参数中包含 ModelAndView，所以该方法可以修改处理器方法的处理结果数据，且可以修改跳转方向。

afterCompletion(request,response, Object handler, Exception ex)：当 preHandle()方法返回true时，会将该方法放到专门的方法栈中，等到对请求进行响应的所工作完成之后才执行该方法。即该方法是在前端控制器渲染（数据填充）了响应页面之后执行的，此时对 ModelAndView再操作也对响应无济于事。

afterCompletion最后执行的方法，清除资源，例如在Controller方法中加入数据

5.方法使用场景

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class MyInterceptor implements HandlerInterceptor {

    //执行时间： 控制器方法执行之前，在ModelAndView返回之前
    //使用场景: 登录验证
    // 返回值 true : 继续执行控制器方法 表示放行    false: 不会继续执行控制器方法，表示拦截
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle-------------------");
        return true;
    }

    //执行时间： 控制器方法执行之hou后，在ModelAndView返回之前，有机会修改返回值
    //使用场景: 日记记录，记录登录的ip,时间
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle-------------------");
    }

    //执行时间： 控制器方法执行之后，在ModelAndView返回之后，没有机会修改返回值
    //使用场景: 全局资源的一些操作
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion-------------------");
    }

6.设置多个拦截器所执行的顺序

（默认对三种方法都实现）

preHandle1-> preHandle2 ->postHande2 ->perHande2 ->afterCompletion2 ->afterCompletion1

测试

上传的文件是否符合定义的格式，不符合的进行拦截

环境搭建

1.需要在maven 的pom.xml中引入的依赖和插件

<!--spring-webmvc依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <!--springmvc底层还是servlet，所以必须添加serlvet依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope><!--插件运行的时候没有范围插件启动会失败-->
        </dependency>

<build>
        <plugins>
            <!-- 编码和编译和JDK版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <target>1.8</target>
                    <source>1.8</source>
                </configuration>
            </plugin>
            <!--tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <port>8080</port>
                </configuration>
            </plugin>
        </plugins>
    </build>

2.springMVC 的xml文件中拦截路径的配置

拦截关键字路径

当使用/user/xxx拦截时候

这时又多了一个需求就是拦截 /user/manager/xxxx

如何对含有关键字manger路径进行拦截

manger前面如果只有一层路径使用/*/manger/** 例如 user/manger/xxxx

manger前面含义多层路径使用 /**/manger/** 此时前面如果没有路径由于/**资源通配符的作用，过滤也起作用

  <!--springmvc的配置文件:控制器的bean对象都在这里扫描-->
    <context:component-scan base-package="com.kkb.controller"/>


 <!--配置拦截器-->
    <mvc:interceptors>
        <!--按顺序配置多个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.kkb.interceptor.MyInterceptor" id="myInterceptor"></bean>
        </mvc:interceptor>

        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.kkb.interceptor.FileInterceptor" id="fileInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

如何放行特定的请求路径

使用<mvc:exclude-mapping path="请求路径"/>

 <mvc:interceptors>
        <!-- 配置登陆拦截器 -->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <!-- 但是排除下面这些，也就是不拦截请求 -->
            <mvc:exclude-mapping path="/login/verify"/>
            <mvc:exclude-mapping path="/register"/>
            <mvc:exclude-mapping path="/index"/>
           <!--admin请求的一级action以login开始的不进行拦截 -->
            <mvc:exclude-mapping path="/amdin/login*"/>
          <!--test请求的一级action不进行拦截 -->
            <mvc:exclude-mapping path="/test/*"/>
            <!-- ajax请求的action不进行拦截 -->
            <mvc:exclude-mapping path="/*.ajax"/>
            <bean class="com.alan.activiti.inteceptor.LoginInteceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

3.实现类

package com.kkb.interceptor;

import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Iterator;
import java.util.Map
public class FileInterceptor implements HandlerInterceptor {
    /**
     * 在文件上传之前判断文件后缀是否合法
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断是否是文件上传的请求
        boolean flag=true;
        if(request instanceof MultipartHttpServletRequest){
            //单一上传文件  method="post" enctype="multipart/form-data"
            MultipartHttpServletRequest multipartRequest= (MultipartHttpServletRequest) request;
            Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
            //遍历文件
               //通过entrySet
//            Set<Map.Entry<String, MultipartFile>> entries = fileMap.entrySet();
//            for (Map.Entry<String, MultipartFile> entry : entries) {
//                System.out.println("key:"+entry.getKey()+" "
//                        +"value:"+entry.getValue());
//            }
            Iterator<String> iterator = fileMap.keySet().iterator();
            while(iterator.hasNext()){
                String key = iterator.next();
                MultipartFile file = multipartRequest.getFile(key);
                String originalFilename = file.getOriginalFilename();
                String hz = originalFilename.substring(originalFilename.lastIndexOf("."));
                //判断后缀是否合法
                if(!hz.toLowerCase().equals(".png") && !hz.toLowerCase().equals(".jpg")){
                    request.getRequestDispatcher("/jsp/fileTypError.jsp").forward(request,response);
                    flag=false;
                }
            }
        }
        return flag;
    }

拦截器实现验证登录

1.aa

2.bb

过滤器和拦截器的区别：

1 、拦截器是基于java的反射机制的，而过滤器是基于函数回调。

2 、拦截器不依赖与servlet容器，过滤器依赖与servlet容器。

3 、拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。

4 、拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。

5 、在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

参考：java中过滤器和拦截器的区别

spring java 后端

更多相关内容

servlet 过滤器及登录页面
2014-04-24 21:25:17

Filter 技术是servlet 2.3 新增加的功能.servlet2.3是sun公司与2000年10月发布的,它的开发者包括许多个人和公司团体,充分体现了sun公司所倡导的代码开放性原则.由于众多的参与者的共同努力,servlet2.3比以往功能都...

收起

Servlet之过滤器

2022-05-08 19:33:18

Servlet之过滤器 过滤器Filter基本使用注解方式：创建一个Filter类实现Servlet的Filter接口，重写他的init()方法，doFilter()方法以及destroy()方法。 init() : 当Servlet容器启动时，初始化创建Filter，就会...

Servlet之过滤器

过滤器Filter基本使用

注解方式：

创建一个Filter类实现Servlet的Filter接口，重写他的init()方法，doFilter()方法以及destroy()方法。

init() : 当Servlet容器启动时，初始化创建Filter，就会执行该方法，该方法只会执行一次。
doFilter()： 因为我配置的是/* 拦截，则每次Http请求都会执行一次doFilter方法。
destroy()： 当Servlet容器被销毁时，该过滤器也就被回收了，此时会调用destroy()方法，也只会执行一次。

注解方式执行多个过滤器时优先执行类名字典顺序在前的过滤器

@WebFilter("/*")
public class Demo1Filter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化...
        System.out.println("filter init ...");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("filter execute ...");
        // 继续执行其他的组件(过滤器/Servlet)
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        // 销毁...
        System.out.println("filter destroy ...");
    }

}

XML方式：

在web项目的WEB-INF下的web.xml配置文件中配置过滤器

如下配置，等同于上面的@WebFilter配置，当有多个过滤器时，则配置在前的优先执行。

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  
  <filter>
    <filter-name>demoFilter</filter-name>
    <filter-class>com.gitee.kenewstar.web.filter.Demo1Filter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>demoFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  
</web-app>

注：当配置文件与注解方式混合使用时，配置文件的方式优先级更高，如果同一个Filter即使用了配置文件，又使用了注解方式，那么Servlet容器将会创建两个Filter对象，配置文件的优先级依然大于注解方式的Filter。

过滤器Filter的使用案例

案例一：限制静态资源访问

在doFilter()方法中，对请求URI路径做限制，判断是否属于静态资源请求，如果是静态资源请求，则转发到no_auth.html页面，表示无权访问

@WebFilter("/*")
public class StaticResourceFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化...
        System.out.println("StaticResourceFilter init ...");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("StaticResourceFilter execute ...");
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        if (request.getRequestURI().startsWith("/front")) {
            request.getRequestDispatcher("no_auth.html").forward(servletRequest, servletResponse);
            return;
        }
        // 继续执行其他的servlet组件
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        // 销毁...
        System.out.println("StaticResourceFilter destroy ...");
    }

}

访问结果如下：

在这里插入图片描述

案例二：基于过滤器实现登录验证

创建一个过滤器用于对登录做校验

首先判断请求是否/login路径，如果是则表示登录成功，并转发至test.html页面，如果不是/login 请求，则判断session中是否有user属性，如果没有，则跳转到no_auth.html页面，如果有，则继续往下执行。

@WebFilter("/*")
public class LoginFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        // 获取session对象
        HttpSession session = request.getSession();
        // 模拟登录
        if (Objects.equals(request.getRequestURI(), "/login")) {
            session.setAttribute("user", "user");
            request.getRequestDispatcher("/front/test.html").forward(request, response);
            return;
        }

        // 未登录，转发至未登录页面
        if (session.getAttribute("user") == null) {
            request.getRequestDispatcher("/front/no_auth.html").forward(request, response);
            return;
        }
        // 执行其他组件
        filterChain.doFilter(servletRequest, servletResponse);

    }

}

no_auth.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>无权访问</title>
</head>
<body>
    <h1>请登录后访问</h1>
    <form action="/login" method="post">
        <input type="submit" value="点击登录">
    </form>
</body>
</html>

如下图所示，访问test.html。跳转至no_auth.html点击登录，则跳转到test.html页面

在这里插入图片描述

收起

展开全文

Java

servlet+jsp实现过滤器 防止用户未登录访问
2021-01-20 14:16:51

我们可能经常会用到这一功能，比如有时，...另一种则是利用过滤器，访问页面时都进行过滤验证，如果存在该用户session，则访问该页面，否则跳转到登陆页面登录，保存session后访问其它页面。以下是我的实现 package c

收起

Servlet过滤器处理中文乱码问题

千次阅读 2020-06-14 15:27:30

2编写过滤器 二实战 1编写Servlet，用于测试 package com.cakin.servlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet....

一 Filter开发步骤

二实战

三测试结果

一 Filter开发步骤

1 导包

2 编写过滤器

二实战

1 编写Servlet，用于测试

package com.cakin.servlet;


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


/**
* @ClassName: ShowSevlet
* @Description: 测试乱码Servlet
* @Date: 2020/6/14
* @Author: cakin
*/
public class ShowServlet extends HttpServlet {
    /**
     * 功能描述：构造乱码
     *
     * @author cakin
     * @date 2020/6/14
     * @param req 请求
     * @param resp 响应
     * @throws IOException 异常
     */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().write("解决过滤器乱码问题");
    }


    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        doGet(req, resp);
    }
}

2 编写过滤器，防止产生中文乱码

package com.cakin.filter;


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


/**
* @ClassName: CharacterEncodingFilter
* @Description: 解决中文乱码问题
* @Date: 2020/6/14
* @Author: cakin
*/
public class CharacterEncodingFilter implements Filter {
    /**
     * 功能描述：初始化
     *
     * @author cakin
     * @date 2020/6/14
     * @param filterConfig 过滤器配置
     * @throws ServletException ServletException
     * @description: web启动就会初始化，同Tomcat一起启动
     */
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter 初始化");
    }


    /**
     * 功能描述：过滤器核心方法
     *
     * @param request  请求
     * @param response 响应
     * @param chain    过滤器链
     * @throws IOException      IOException
     * @throws ServletException IOException
     * @author cakin
     * @date 2020/6/14
     * @description: 关键点
     * 1 针对特定的请求，过滤器会执行，这个特定的请求是在web.xml中配置过滤器
     * 2 为了让程序继续往下走，必须执行 chain.doFilter(request, response);
     */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 处理乱码问题
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=UTF-8");
        System.out.println("执行前");
        // 让我们的程序继续往下走，否则程序就在这里停止了
        chain.doFilter(request, response);
        System.out.println("执行后");
    }
    /**
     * 功能描述：过滤器销毁
     *
     * @author cakin
     * @date 2020/6/14
     * @description: web服务器停止时，会执行这个函数
     */
    public void destroy() {
        System.out.println("CharacterEncodingFilter 销毁");
    }
}

3 编写web.xml，配置Servlet和Filter

<?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>ShowServlet</servlet-name>
        <servlet-class>com.cakin.servlet.ShowServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ShowServlet</servlet-name>
        <!--这个路径会走到下面配置的过滤器-->
        <url-pattern>/servlet/show</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>ShowServlet</servlet-name>
        <url-pattern>/show</url-pattern>
        <!--这个路径不会走到下面配置的不会走过滤器-->
    </servlet-mapping>
    
    <filter>
        <filter-name>EncodingFilter</filter-name>
        <filter-class>com.cakin.filter.CharacterEncodingFilter</filter-class>
    </filter>


    <filter-mapping>
        <filter-name>EncodingFilter</filter-name>
        <!-- /servlet请求都会走这个过滤器-->
        <url-pattern>/servlet/*</url-pattern>
    </filter-mapping>
</web-app>

三测试结果

1 当访问 http://localhost:8080/servlet/show

2 当访问 http://localhost:8080/show

收起

展开全文

java

用servlet和过滤器实现简单的权限管理和敏感词过滤功能

千次阅读 多人点赞 2021-05-23 21:44:09

JavaEE课要求用servlet和过滤器实现权限管理和敏感词过滤功能，故有此文。虽然早已知道了原理和用法，但是实际操作起来还是遇到了各种奇葩的情况。

前言

JavaEE课要求用servlet和过滤器实现权限管理和敏感词过滤功能，故有此文。
虽然早已知道了原理和用法，但是实际操作起来还是遇到了各种奇葩的情况。

一、如何实现权限管理

1.思路

当用户访问某个资源时，我们必须对其权限控制，所以得用到servlet中过滤器来对请求做一次预处理，判断该用户是否有权限访问该资源，如果有则放行;如果没有则返回拒绝访问的通知。

那么我们如何判断该用户是否有权限访问呢？
这就要求我们在用户登录的时候保存其登录状态。

可我们知道http请求是无状态的，即这次请求无法知道上一次请求的内容，那如何保存这个登录状态呢？

这就需要要用到Session/Cookie机制（这里我就不多介绍了，感兴趣的可以去百度，当然我在手把手教你用Java实现一套简单的鉴权服务（SpringBoot，SSM）（万字长文）这篇博文中说的很详细了，感兴趣的同学可以去看看）。

既然如此，那么我们在登录成功的时候就把用户的信息存入到服务器的session中，等用户下次访问的时候，我们就知道是哪位用户以及这位用户有没有权限访问了。

至此我们便实现了简单的权限控制。

但是这里有个地方需要注意，就是过滤器在拦截时需要排除一些路径，比如登录页面，比如静态资源。这个有很多方法，我采取的是我认为比较简单的方法，具体实现在下文。

2.代码实现

①登录页面

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>后台管理-登陆</title>
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <meta http-equiv="Access-Control-Allow-Origin" content="*">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="format-detection" content="telephone=no">
    <link rel="stylesheet" href="/static/lib/layui-v2.6.3/css/layui.css" media="all">
    <!--[if lt IE 9]>
    <script src="https://cdn.staticfile.org/html5shiv/r29/html5.min.js"></script>
    <script src="https://cdn.staticfile.org/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
    <style>
        .main-body {top:50%;left:50%;position:absolute;-webkit-transform:translate(-50%,-50%);-moz-transform:translate(-50%,-50%);-ms-transform:translate(-50%,-50%);-o-transform:translate(-50%,-50%);transform:translate(-50%,-50%);overflow:hidden;}
        .login-main .login-bottom .center .item input {display:inline-block;width:227px;height:22px;padding:0;position:absolute;border:0;outline:0;font-size:14px;letter-spacing:0;}
        .login-main .login-bottom .center .item .icon-1 {background:url(../static/images/icon-login.png) no-repeat 1px 0;}
        .login-main .login-bottom .center .item .icon-2 {background:url(../static/images/icon-login.png) no-repeat -54px 0;}
        .login-main .login-bottom .center .item .icon-3 {background:url(../static/images/icon-login.png) no-repeat -106px 0;}
        .login-main .login-bottom .center .item .icon-4 {background:url(../static/images/icon-login.png) no-repeat 0 -43px;position:absolute;right:-10px;cursor:pointer;}
        .login-main .login-bottom .center .item .icon-5 {background:url(../static/images/icon-login.png) no-repeat -55px -43px;}
        .login-main .login-bottom .center .item .icon-6 {background:url(../static/images/icon-login.png) no-repeat 0 -93px;position:absolute;right:-10px;margin-top:8px;cursor:pointer;}
        .login-main .login-bottom .tip .icon-nocheck {display:inline-block;width:10px;height:10px;border-radius:2px;border:solid 1px #9abcda;position:relative;top:2px;margin:1px 8px 1px 1px;cursor:pointer;}
        .login-main .login-bottom .tip .icon-check {margin:0 7px 0 0;width:14px;height:14px;border:none;background:url(../static/images/icon-login.png) no-repeat -111px -48px;}
        .login-main .login-bottom .center .item .icon {display:inline-block;width:33px;height:22px;}
        .login-main .login-bottom .center .item {width:288px;height:35px;border-bottom:1px solid #dae1e6;margin-bottom:35px;}
        .login-main {width:428px;position:relative;float:left;}
        .login-main .login-top {height:117px;background-color:#148be4;border-radius:12px 12px 0 0;font-family:SourceHanSansCN-Regular;font-size:30px;font-weight:400;font-stretch:normal;letter-spacing:0;color:#fff;line-height:117px;text-align:center;overflow:hidden;-webkit-transform:rotate(0);-moz-transform:rotate(0);-ms-transform:rotate(0);-o-transform:rotate(0);transform:rotate(0);}
        .login-main .login-top .bg1 {display:inline-block;width:74px;height:74px;background:#fff;opacity:.1;border-radius:0 74px 0 0;position:absolute;left:0;top:43px;}
        .login-main .login-top .bg2 {display:inline-block;width:94px;height:94px;background:#fff;opacity:.1;border-radius:50%;position:absolute;right:-16px;top:-16px;}
        .login-main .login-bottom {width:428px;background:#fff;border-radius:0 0 12px 12px;padding-bottom:53px;}
        .login-main .login-bottom .center {width:288px;margin:0 auto;padding-top:40px;padding-bottom:15px;position:relative;}
        .login-main .login-bottom .tip {clear:both;height:16px;line-height:16px;width:288px;margin:0 auto;}
        body {background:url(../static/images/loginbg.png) 0% 0% / cover no-repeat;position:static;font-size:12px;}
        input::-webkit-input-placeholder {color:#a6aebf;}
        input::-moz-placeholder {/* Mozilla Firefox 19+ */            color:#a6aebf;}
        input:-moz-placeholder {/* Mozilla Firefox 4 to 18 */            color:#a6aebf;}
        input:-ms-input-placeholder {/* Internet Explorer 10-11 */            color:#a6aebf;}
        input:-webkit-autofill {/* 取消Chrome记住密码的背景颜色 */            -webkit-box-shadow:0 0 0 1000px white inset !important;}
        html {height:100%;}
        .login-main .login-bottom .tip {clear:both;height:16px;line-height:16px;width:288px;margin:0 auto;}
        .login-main .login-bottom .tip .login-tip {font-family:MicrosoftYaHei;font-size:12px;font-weight:400;font-stretch:normal;letter-spacing:0;color:#9abcda;cursor:pointer;}
        .login-main .login-bottom .tip .forget-password {font-stretch:normal;letter-spacing:0;color:#1391ff;text-decoration:none;position:absolute;right:62px;}
        .login-main .login-bottom .login-btn {width:288px;height:40px;background-color:#1E9FFF;border-radius:16px;margin:24px auto 0;text-align:center;line-height:40px;color:#fff;font-size:14px;letter-spacing:0;cursor:pointer;border:none;}
        .login-main .login-bottom .center .item .validateImg {position:absolute;right:1px;cursor:pointer;height:36px;border:1px solid #e6e6e6;}
        .footer {left:0;bottom:0;color:#fff;width:100%;position:absolute;text-align:center;line-height:30px;padding-bottom:10px;text-shadow:#000 0.1em 0.1em 0.1em;font-size:14px;}
        .padding-5 {padding:5px !important;}
        .footer a,.footer span {color:#fff;}
        @media screen and (max-width:428px) {.login-main {width:360px !important;}
            .login-main .login-top {width:360px !important;}
            .login-main .login-bottom {width:360px !important;}
        }
    </style>
</head>
<body>
<div class="main-body">
    <div class="login-main">
        <div class="login-top">
            <span>LayuiMini后台登录</span>
            <span class="bg1"></span>
            <span class="bg2"></span>
        </div>
        <form class="layui-form login-bottom" action="/login" method="post">
            <div class="center">
                <div class="item">
                    <span class="icon icon-2"></span>
                    <input type="text" name="uname" lay-verify="required"  placeholder="请输入登录账号" maxlength="24"/>
                </div>

                <div class="item">
                    <span class="icon icon-3"></span>
                    <input type="password" name="pwd" lay-verify="required"  placeholder="请输入密码" maxlength="20">
                    <span class="bind-password icon icon-4"></span>
                </div>

            </div>
            <div class="tip">
                <span class="icon-nocheck"></span>
                <span class="login-tip">保持登录</span>
                <a href="javascript:" class="forget-password">忘记密码？</a>
            </div>
            <div class="layui-form-item" style="text-align:center; width:100%;height:100%;margin:0px;">
                <button class="login-btn" type="submit" lay-submit="" lay-filter="login">立即登录</button>
            </div>
        </form>
    </div>
</div>
<div class="footer">
    ©版权所有 2014-2018 叁贰柒工作室<span class="padding-5">|</span><a target="_blank" href="http://www.miitbeian.gov.cn">粤ICP备16006642号-2</a>
</div>
<script src="/static/lib/layui-v2.6.3/layui.js" charset="utf-8"></script>
<script>
    //原本想用json的post发送，结果发现后端数据得自己解析，为了降低难度，直接用form表单的post提交，这样后端直接拿数据即可（不然还得解析Json数据）
    // layui.use(['form','jquery'], function () {
    //     var $ = layui.jquery,
    //         form = layui.form,
    //         layer = layui.layer;
    //
    //     // 登录过期的时候，跳出ifram框架
    //     if (top.location != self.location) top.location = self.location;
    //
    //     $('.bind-password').on('click', function () {
    //         if ($(this).hasClass('icon-5')) {
    //             $(this).removeClass('icon-5');
    //             $("input[name='pwd']").attr('type', 'password');
    //         } else {
    //             $(this).addClass('icon-5');
    //             $("input[name='pwd']").attr('type', 'text');
    //         }
    //     });
    //
    //     $('.icon-nocheck').on('click', function () {
    //         if ($(this).hasClass('icon-check')) {
    //             $(this).removeClass('icon-check');
    //         } else {
    //             $(this).addClass('icon-check');
    //         }
    //     });
    //
    //     // 进行登录操作
    //     form.on('submit(login)', function (data) {
    //         data = data.field;
    //         if (data.uname == '') {
    //             layer.msg('用户名不能为空');
    //             return false;
    //         }
    //         if (data.pwd == '') {
    //             layer.msg('密码不能为空');
    //             return false;
    //         }
    //         $.ajax({
    //             url:'/login',
    //             method:'post',
    //             data:data,
    //             dataType:'JSON',
    //             success:function(res){
    //                 if (res.msg==='登录成功'){
    //                     layer.msg('登录成功', function () {
    //                         window.location = '../index.html';
    //                     });
    //                 }else {
    //                     layer.msg("登录失败");
    //                 }
    //             },
    //             error:function (data) {
    //             }
    //         }) ;
    //
    //
    //         return false;
    //     });
    // });
</script>
</body>
</html>

因为上面我并没有给出图片，css等静态资源，所以直接复制是没有我这里的效果的。

下面这样也是可以的，

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

②登录Servlet类

具体验证的逻辑我这里就不放了。这里登录成功会将用户名存入session，并自动跳转首页。

package com.dreamchaser.loginTest.servlet;

import com.dreamchaser.loginTest.mapper.UserMapper;

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

public class LoginServlet extends HttpServlet {
    static UserMapper userMapper=UserMapper.getUserMapper();

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String uname=req.getParameter("uname");
        String pwd=req.getParameter("pwd");
        ServletOutputStream outputStream = resp.getOutputStream();
        String result;
        if (pwd.equals(userMapper.getPwdByName(uname))){
            req.getSession().setAttribute("user",uname);
            resp.sendRedirect("/index.html");
        }else {
            //响应
            result="登录失败";
            outputStream.write(result.getBytes());
        }

    }
}

③UserFilter过滤器

因为该过滤器配置的路径是/*，即全部路径，但是我们不想拦截一些路径，比如登录页面，静态资源，所以我们在操作前进行一次判断，避免这些路径的处理。

注：innit方法会将配置中排除的路径读取过来，当然你也可以写在程序里

package com.dreamchaser.loginTest.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

public class UserFilter implements Filter {

    private List excludedUrls;

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        // 将req resp 转为子接口的类型
        HttpServletRequest request = (HttpServletRequest)req;
        HttpServletResponse response = (HttpServletResponse)resp;
        String path = request.getServletPath();

        if(!excludedUrls.contains(path)&&!(path.length()>8&&"/static/".equals(path.substring(0,8))))
        {
            if (request.getSession().getAttribute("user")==null){
               response.sendRedirect("/pages/login.html");
            }
        }
        chain.doFilter(req, resp);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        String excludePattern = filterConfig.getInitParameter("excludedUrls");
        excludedUrls = Arrays.asList(excludePattern.split(","));
    }

    @Override
    public void destroy() {
    }
}

④web.xml配置项

init-param标签里存放的是排除在外的路径，这个是自己定义的。

<servlet>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.dreamchaser.loginTest.servlet.LoginServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/login</url-pattern>
  </servlet-mapping>

  <filter>
    <filter-name>UserFilter</filter-name>
    <filter-class>com.dreamchaser.loginTest.filter.UserFilter</filter-class>
    <init-param>
      <param-name>excludedUrls</param-name>
      <param-value>/pages/login.html,/register.html,/login</param-value>
    </init-param>

  </filter>
  <filter-mapping>
    <filter-name>UserFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

二、敏感词过滤

1.思路

利用过滤器提前对请求里要过滤的属性进行处理，但是因为没有setParameter方法（这是故意的，设计者就是不想让我们直接修改），所以我们为了存放过滤后的信息，可以把过滤后的信息放在attribute中，然后servlet直接获取即可。（当然也可以重写一个Request类，那个比较麻烦，感兴趣的自行百度）

2.代码实现

①敏感词过滤页

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/word" method="post" style="margin-top: 300px">
        请输入你要说的垃圾话：<br><input name="word" style="width: 500px" type="text">
        <button type="submit"> 提交</button>
    </form>
</body>
</html>

②WordServlet类

从attribute中获取过滤后的字符串后返回。

package com.dreamchaser.loginTest.servlet;

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

/**
 * 需要敏感词过滤的接口
 */
public class WordServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //因为servlet并没有setParameter方法（这是故意的），所以过滤后word无法通过getparameter来获取
        //所以一般有两种方法一种把它放在attribute里，一种重写Request类，不过这会很麻烦
        String word= String.valueOf(req.getAttribute("word"));
        ServletOutputStream outputStream = resp.getOutputStream();
        String result="词汇已净化，请放心食用："+word;
        outputStream.write(result.getBytes());
    }
}

③WordFilter过滤器类

静态常量sensitiveWords中存放的是需要过滤的字符串，harmoniousWord是过滤后的词汇。
这里就是对需要过滤的借口提前进行处理，把敏感词换成注入“***”这样的字符串，然后存放在attribute中。

package com.dreamchaser.loginTest.filter;


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

/**
 * 敏感词过滤拦截器
 */
public class WordFilter implements Filter {
    static final String[] sensitiveWords={"敏感词1","脏话","骂人"};
    static final String harmoniousWord="***";

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        req.setCharacterEncoding("utf-8");
        // 将req resp 转为子接口的类型
        HttpServletRequest request = (HttpServletRequest)req;
        HttpServletResponse response = (HttpServletResponse)resp;
        String word=req.getParameter("word");
        for (String s:sensitiveWords){
            word=word.replaceAll(s,harmoniousWord);
        }
        request.setAttribute("word",word);
        chain.doFilter(req, resp);
    }
}

web.xml配置项

<servlet>
    <servlet-name>WordServlet</servlet-name>
    <servlet-class>com.dreamchaser.loginTest.servlet.WordServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>WordServlet</servlet-name>
    <url-pattern>/word</url-pattern>
  </servlet-mapping>

  <filter>
    <filter-name>WordFilter</filter-name>
    <filter-class>com.dreamchaser.loginTest.filter.WordFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>WordFilter</filter-name>
    <url-pattern>/word</url-pattern>
  </filter-mapping>

三、效果展示

1.未登录访问其他资源

自动跳转至登录页

在这里插入图片描述

2.密码错误，登录失败

在这里插入图片描述

3.密码正确，自动跳转首页

在这里插入图片描述

4.刷新首页，不会跳转

在这里插入图片描述

5.敏感词过滤

在这里插入图片描述

处理后返回结果

在这里插入图片描述

注：代码已开源至gitee，地址

收起

展开全文

javaee

servlet过滤器有什么作用,一般用在什么地方??_乐字节java
千次阅读 2020-06-29 15:24:01

过滤器 介绍 Filter 即为过滤，用于在 Servlet 之外对 Request 或者 Response 进行修改。它主要用于对用户请求进行预处理，也可以对 HttpServletResponse 进行后处理。使用 Filter 的完整流程： Filter 对用户...

收起
javaWeb基础之 servlet过滤器（实战）登陆验证跳转与 SpringMvc拦截器基本演示
2018-07-22 16:40:00

稍后提交转载于:https://www.cnblogs.com/lanSeGeDiao/p/9350621.html

收起
Java Web实现session过期后自动跳转到登陆页功能【基于过滤器】
2020-08-28 18:24:51

主要介绍了Java Web实现session过期后自动跳转到登陆页功能,涉及java过滤器针对session的判断与跳转相关操作技巧,需要的朋友可以参考下

收起
IDEA学习记录14--Servlet过滤器Filter
2022-01-12 15:57:59

1、生命周期在tomcat初始化时，就加载init方法，执行拦截时使用doFilter方法，tomcat把容器销毁时就执行destroy方法。只要命中过滤规则就...使用filterConfig可以帮忙拿到过滤器基本信息。用debug可看出每一步所获

收起

tomcat java filter
servlet 过滤器实现请求转发（跳转）；跨域转发请求；tomcat 环境下。
千次阅读 2015-08-14 15:15:08

1. 写一过滤器。实现转发，当一个路径，比如 http://localhost:8080/web1/img/1.jpg 这样的URL。理应在这个网站的img文件夹下有某个图片，实际是没有的。将来自 img/*下的所有图片请求，转发到图片服务下。 ...

收起
JavaWeb过滤器实现页面跳转至登录页面
2021-02-13 00:27:33

解决方式：通过session过滤器实现对请求的过滤，如果未登录跳转至登录页面，如果已登录直接放行。在过滤器中不对登录页面进行过滤，不对css、js、img资源进行过滤。如果不是前面说的两种资源，则判断记录用户信息的...

收起
Servlet程序 Filter过滤器图解
2020-11-17 21:28:13

三大组件分别是：Servlet程序、Filter过滤器、Listener监听器。 3、Servlet是运行在服务器上的一个java小程序，它可以接收客户端发送过来的请求，并响应数据给客户端。 Servlet可以连接java代码与前端代码Html之间，...

收起

filter jsp
servlet在登陆界面中添加过滤器
2021-11-16 08:23:59

新建一个过滤器来进行判断此时是否注销类控制来判断是否要进行跳转 package com.rjst.Filter; import com.rjst.util.Content; import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import javax...

收起

java filter
Servlet编程：过滤器实验文件代码
2022-04-29 20:21:55

按课程讲解创建过滤器，并完成相关配置，使页面1和页面2都使用过滤器，假设页面1为登录页面，页面2为业务页面，在过滤器中验证有效登录信息，如果没有登录则可以提示并跳转到登录页面。

收起
servlet3过滤器中跳转问题
2015-05-12 02:12:59

我想在过滤器中跳转到“www.baidu.com”怎么做？ response.sendRedirect（）是跳转项目内的吧？

收起
Servlet过滤器
2019-08-05 17:15:38

Servlet充当控制着的角色,可以用来处理JSP页面的输入参数,可从JavaBean中读取来自数据库数据,最后跳转目标页面在Servlet内实现跳转常用的Servlet内跳转 1.重定向(对应JSP内置对象的sendRedirect) response....

收起
Servlet中Filter过滤器工作原理和应用详解
2020-04-22 22:31:51

Filter过滤器工作原理和应用详解1. Filter 过滤器原理1.1 Filter 基本信息1.2 Filter 过滤器链1.3 Filter 工作原理1.4 Filter 生命周期1.5 Filter 基本使用1.6 Filter 配置方式 × 21.7 Filter 中文乱码处理 - 未完...

收起

java filter
过滤器Filter(拦截jsp页面的跳转)案例：
2021-02-13 00:27:33

创建一个 Filter , class类: 其继承于接口 Filte(接口导包：import javax.servlet.Filter;)在 web.xml 文件中配置并映射该 Filter. 其中 url-pattern 指定该 Filter 可以拦截哪些资源,即可以通过哪些 url 访问到该 ...

收起
Servlet的拦截，页面跳转问题
2022-01-13 16:16:03

在学习servlet时，启动项目页面没有正常跳转出来。原来是下面箭头位置忘记加“/”了，导致这个请求不能正常被拦截下来。加上“/”之后，页面方可正常跳转。

收起

tomcat
解决ajax请求过滤器重定向不跳转 (过滤器)
2021-03-13 01:05:53

最近写的一个servlet过滤器，用于拦截请求，判断用户是否登录。写好后发现一个问题，当我直接在浏览器地址栏里输入地址，可以跳转页面；当点击按钮时，过滤器代码正常执行，但是页面没有跳转；是因为按钮都是ajax...

收起
java servlet过滤器简解及实例
千次阅读 2016-07-20 14:34:08

Filter也称之为过滤器，它是Servlet技术中比较激动人心的技术，WEB开发人员通过Filter技术，对web服务器管理的所有web资源：例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截，从而实现一些特殊的...

收起

java过滤器
servlet、过滤器、生命周期
千次阅读 2018-07-06 23:54:12

servlet是在jsp技术出来之前用来动态生成web页面的，它与jsp的...servlet是server以及applet两个单词的合成，所以它是一种服务器端的java应用程序。但并不是所有服务器端的java的应用程序都是servlet。只有当服务...

收起
使用 Servlet 实现用户登录功能（包含Filter过滤器）
2021-10-26 23:39:39

@WebServlet("/login") public class login_Servlet extends HttpServlet { private static final long serialVersionUID = 1L; /** * @see HttpServlet#HttpServlet() */ public login_Servlet() { super(); // ...

收起

html
乱码过滤器 tomcat7 乱码处理后 servlet 跳转空白页 wrapper包装request 后无法取值
2022-01-22 17:08:27

一下是过滤器处理tomcat 7 8 乱码问题 @WebFilter("/*") // 过滤所有资源 public class EncodingFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException ...

收起

服务器 java
使用Filter过滤器在servlet中实现登录、过滤功能
2021-04-27 14:09:47

2）其次加入过滤器，此时用户若直接访问success.jsp页面，则程序进入过滤器检测session域中是否有用户信息，若没有说明用户并未登录，不可以访问success.jsp页面，程序将重定向到login.jsp页面让用户登录。...

收起
Java 使用过滤器重定向跳转
2020-08-03 17:20:22

//跳转至首页 if(true){ httpResponse.sendRedirect(httpRequest.getContextPath()+ "/index.action"); return; } filterChain.doFilter(httpRequest,httpResponse); } @Override public void destroy() { this....

收起

java
servlet实例-登录跳转--参数传递-编码过滤器--权限过滤器
千次阅读 2017-09-05 18:44:40

1、首先因为我们的输入框中要允许输入中文，为了防止乱码，可以设置编码过滤器。创建编码过滤器，在src中创建filter文件 EncodingFilter package com.ouc.filter; import java.io.IOException; import javax...

收起
spring boot 配置Filter过滤器的方法
2020-08-31 00:28:26

本篇文章主要介绍了spring boot 配置Filter过滤器的方法，实例分析了spring boot 配置Filter过滤器的技巧，有兴趣的可以了解一下。

收起
Servlet的过滤器与Spring拦截器详解
千次阅读 多人点赞 2017-06-07 13:42:18

第一部分：过滤器Filter一：Filter简介Servlet API中提供了一个javax.servlet.Filter接口，开发web应用时，实现了这个接口的Java类，则把这个java类称之为过滤器Filter。通过Filter技术，开发人员可以实现用户在访问...

收起

filter

servlet过滤器

1.什么是过滤器

2.过滤器的语法格式

3.在web.xml⽂件中配置

4.使⽤场景

5.过滤器中的url-pattern中的 / 和 /* 和/login

例子：验证用户登录

过滤器

后端

前端

SpringMVC 中的 拦截器

1.概念

2.拦截时间

3.实现拦截器

4.拦截器方法说明

5.方法使用场景

6.设置多个拦截器所执行的顺序

测试

1.需要在maven 的pom.xml中引入 的依赖和 插件

2.springMVC 的xml文件中拦截路径的配置

拦截关键字路径

如何放行特定的请求路径

3.实现类

拦截器实现验证登录

过滤器和拦截器的区别：

servlet 过滤器及登录页面

Servlet之过滤器

Servlet之过滤器

过滤器Filter基本使用

过滤器Filter的使用案例

案例一：限制静态资源访问

案例二：基于过滤器实现登录验证

servlet+jsp实现过滤器 防止用户未登录访问

Servlet过滤器处理中文乱码问题

一 Filter开发步骤

二 实战

三 测试结果

用servlet和过滤器实现简单的权限管理和敏感词过滤功能

文章目录

前言

一、如何实现权限管理

1.思路

2.代码实现

①登录页面

②登录Servlet类

③UserFilter过滤器

④web.xml配置项

二、敏感词过滤

1.思路

2.代码实现

①敏感词过滤页

②WordServlet类

③WordFilter过滤器类

web.xml配置项

三、效果展示

1.未登录访问其他资源

2.密码错误，登录失败

3.密码正确，自动跳转首页

4.刷新首页，不会跳转

5.敏感词过滤

处理后返回结果

servlet过滤器有什么作用,一般用在什么地方??_乐字节java

javaWeb基础之 servlet过滤器（实战）登陆验证跳转 与 SpringMvc拦截器基本演示

Java Web实现session过期后自动跳转到登陆页功能【基于过滤器】

IDEA学习记录14--Servlet过滤器Filter

servlet 过滤器实现 请求转发（跳转）；跨域转发请求；tomcat 环境下。

JavaWeb过滤器实现页面跳转至登录页面

Servlet程序 Filter过滤器 图解

servlet在登陆界面中添加过滤器

Servlet编程：过滤器实验 文件代码

servlet3过滤器中跳转问题

Servlet过滤器

Servlet中Filter过滤器工作原理和应用详解

过滤器Filter(拦截jsp页面的跳转)案例：

Servlet的拦截，页面跳转问题

解决ajax请求过滤器重定向不跳转 (过滤器)

java servlet过滤器简解及实例

servlet、过滤器、生命周期

使用 Servlet 实现用户登录功能（包含Filter过滤器）

乱码过滤器 tomcat7 乱码处理后 servlet 跳转 空白页 wrapper包装request 后 无法取值

SpringMVC 中的拦截器

1.需要在maven 的pom.xml中引入的依赖和插件

servlet+jsp实现过滤器防止用户未登录访问

二实战

三测试结果

javaWeb基础之 servlet过滤器（实战）登陆验证跳转与 SpringMvc拦截器基本演示

servlet 过滤器实现请求转发（跳转）；跨域转发请求；tomcat 环境下。

Servlet程序 Filter过滤器图解

Servlet编程：过滤器实验文件代码

乱码过滤器 tomcat7 乱码处理后 servlet 跳转空白页 wrapper包装request 后无法取值