精华内容
下载资源
问答
  • java过滤器全局解析token
    千次阅读
    2020-05-23 16:53:34

    java过滤器全局解析token

    使用过滤器定义一个全局的token解析器

    在进行后端接口的开发过程中,一般涉及到人员用户,权限或者安全方面的考虑接口都会使用token来传递用户或者一些安全系数高的鉴权参数等。

    一般接口定义

    全局AOP解析

    使用AOP,对需要获取token信息的接口,进行方法增强,在进入controller之前,动态的为接口方法鉴权,或者为接口方法添加一个token相关的参数。
    根据需求不同需要的参数也不一样,这个可以根据业务来,这方面代码也很多,原理就是在方法执行前,进行token鉴权,或者参数添加或提取。如果业务比较复杂,可以自己展开想象,自己动手搞。

    接口使用注解@RequestHeader

    另一种方法是,每个接口自己去处理token的鉴权或者参数提取,在请求参数中声明一个从header里面获取的值,然后方法内部去解析

    
    @GetMapping("legend")
    public Response getTheShy(@RequestHeader String token, @RequestParam() String top){
        //解析token鉴权。。
        //业务
    	return null;
    }
    
    

    如果你不怕麻烦,或者只有很少的接口需要token这个方法可以考虑,对于微服务来说,token的鉴权可能是单独的一个服务,或者需要调用其他方法,把这个方法封装起来,其实也还好。

    我的需求以及方法

    需求和现状

    1. 业务几乎每个对外的而接口都需要用户的信息,比如用户ID或者用户名称
    2. 解析和分发token的业务不是我的模块,我获得到的token是由网关分发到后台程序的token,解析需要依赖网关的服务
    3. 我只需要token解析出来的用户某个信息
    4. 我不想每个接口都去关心token是怎么解析的,怎么获取参数的

    实践

    使用过滤器来控制请求参数的获取,控制请求参数的值

    1. 控制层代码
      具体代码:
      controller:
        @GetMapping("top")
        public Response  getTheShy(String token){
       
          log.info(token);    
          return topService.getTheShy(token);
        }
    

    在控制层接口中我直接声明我需要的而用户信息,即需要从token中解析的数据

    1. 过滤器代码

    具体代码:

    @Component
    @WebFilter(filterName="token",urlPatterns= {"/*"})
    public class FilterConfigController implements Filter {
    
    
        private static Logger log = LoggerFactory.getLogger(FilterConfigController.class);
    
        @Override
        public void init(FilterConfig filterConfig) {
            log.info("过滤器初始化");
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            HttpServletRequestWrapper requestWrapper = new HttpServletRequestWrapper((HttpServletRequest) servletRequest){
    
                @Override
                public Map<String, String[]> getParameterMap() {
                    return super.getParameterMap();
                }
    
                @Override
                public String getParameter(String name) {
                    return super.getParameter(name);
                }
    
                @Override
                public String[] getParameterValues(String name) {
                    if("token".equals(name) || "userId".equals(name)){
                        String token = this.getHeader("Token");
                        //鉴权或者获取token
                        if (StringUtils.isEmpty(token)){
                            log.error("缺少token");
                            throw new MyRuntimeException(ErrorCode.ERROR_AUTH_NULL_TOKEN);
                        }
                        if ("token".equals(name)){
                            //具体的解析token逻辑
                        }else if ("userId".equals(name)){
                            //具体的解析token逻辑
                        }
                        
                        return new String[]{token};
                    }
                    return super.getParameterValues(name);
                }
    
                @Override
                public String getQueryString() {
                    return super.getQueryString();
                }
            };
            filterChain.doFilter(requestWrapper,servletResponse);
    
        }
    
    
    }
    
    1. 继承Filter,并实现其方法,主要对 doFilter方法中的getParameterValues方法重写
    2. 该方法的作用就是,如果你得controller需要一个参数值时,会从这里获取,所以我们可以对此进行自定义的参数获取。
    3. 规定好我们要获取的参数名称,可以叫做token,然后这边对这个参数名进行拦截,当需要获取我们指定参数名称的值时,由下面代码生成
    4. 下面的代码就是从请求头获取token,然后鉴权和获取用户信息的具体实现
    5. 如果请求头的token不满足我们的需求,或者解析失败,就可以直接返回前端,而不用进入controller
      6.我采用的直接返回前端的方法是,直接在过滤器中抛出一个自定义的运行时异常(此方法不允许有异常,只能抛运行时异常)
    6. 由全局的异常处理,来处理抛出的自定义运行时异常,并返回给前端
    
    /**
         * 处理运行时异常
         * @param e
         * @return
         */
        @ExceptionHandler
        public Response runtimeExceptionMatchHandle(RuntimeException e, HttpServletResponse response){
    
            if (e instanceof MyRuntimeException){
                e.printStackTrace();
                return Response.failure(((MyRuntimeException) e).getCode());
            }
            return Response.failure(ErrorCode.ERROR);
        }
    

    自定义异常,抛出的时候也把要返回的信息返回

    
    /**
     * 自定义运行时异常
     */
    public class MyRuntimeException extends RuntimeException{
    
        private ErrorCode code;
        public MyRuntimeException(ErrorCode code){
            super(code.getMsg());
            this.code = code;
        }
    
        public ErrorCode getCode() {
            return code;
        }
    }
    

    注意点

    1. 如果在controller的参数上加了@RequestParam注解,那么在获取这个参数值的时候不会进入到过滤器的方法中

      1. 在其他不需要进入自定义过滤的而参数加上注解,不加也可以,只要名称不一样就不会往下走
      2. 要获取的token相关参数,不要加此注解
    2. 自定义的过滤器可以多个参数获取只需要在入口处,多加一个参数名称判断,且在返回参数值的时候,根据名称不同返回不同的值即可

    如果有问题,欢迎指正,不明白的话可以私信博主

    更多相关内容
  • java过滤器防sql注入

    2014-04-04 11:23:03
    外网可能会被攻击,简单的处理可以避免! 外网可能会被攻击,简单的处理可以避免! 外网可能会被攻击,简单的处理可以避免! 外网可能会被攻击,简单的处理可以避免!...外网可能会被攻击,简单的处理可以避免!...
  • java过滤器有什么作用

    千次阅读 2021-03-09 22:09:38
    Java过滤器是处于客户端与服务器资源文件之间的一道过滤网,在访问资源文件之前,通过系列的过滤器可以对请求进行修改、判断等,把不符合规则的请求在中途拦截或修改;也可以对响应进行过滤,拦截或修改响应。Java...

    Java过滤器是处于客户端与服务器资源文件之间的一道过滤网,在访问资源文件之前,通过一系列的过滤器可以对请求进行修改、判断等,把不符合规则的请求在中途拦截或修改;也可以对响应进行过滤,拦截或修改响应。

    7542244033628e335c2640d9b98bb0d1.png

    Java中过滤器也是常用的部分,用于限制某些东西,下面来让我们了解一下吧。

    过滤器是处于客户端与服务器资源文件之间的一道过滤网,在访问资源文件之前,通过一系列的过滤器对请求进行修改、判断等,把不符合规则的请求在中途拦截或修改。也可以对响应进行过滤,拦截或修改响应。

    7336797d113c725eba9ca8b2c402bc22.png如图,浏览器发出的请求先递交给第一个filter进行过滤,符合规则则放行,递交给filter链中的下一个过滤器进行过滤。过滤器在链中的顺序与它在web.xml中配置的顺序有关,配置在前的则位于链的前端。当请求通过了链中所有过滤器后就可以访问资源文件了,如果不能通过,则可能在中间某个过滤器中被处理掉。

    在doFilter()方法中,chain.doFilter()前的一般是对request执行的过滤操作,chain.doFilter后面的代码一般是对response执行的操作。过滤链代码的执行顺序如下:

    0d0be1074803609b95bd864e56fcfbf0.png

    过滤器一般用于登录权限验证、资源访问权限控制、敏感词汇过滤、字符编码转换等等操作,便于代码重用,不必每个servlet中还要进行相应的操作。

    展开全文
  • ①拦截器是基于java的反射机制的,而过滤器是基于函数回调。  ②拦截器不依赖与servlet容器,过滤器依赖与servlet容器。  ③拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用。  ④拦截器...

    拦截器和过滤器的区别

    过滤器和拦截器的区别:
    首先关于文件目录要注意的地方:
    把jsp文件放在WEB-INF目录下其实是:
    为了保证系统的安全性,web应用的内容结构中,把所有的静态内容放在web-content目录下。把所有的动态内容(.jsp)放在WEB-INF目录下的/views/目录下,放在/WEB-INF/views/目录下的jsp是**不能通过浏览器的文件夹地址url直接访问***的。只能通过mvc的controller(控制器)进行的跳转。

    ①拦截器是基于java的反射机制的,而过滤器是基于函数回调。
      ②拦截器不依赖与servlet容器,过滤器依赖与servlet容器。
      ③拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用。
      ④拦截器可以访问action上下文、值栈里的对象,而过滤器不能访问。
      ⑤在action的生命周期中,拦截器可以多次被调用,而过滤器只能在容器初始化时被调用一次。

    ⑥拦截器可以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,可以调用业务逻辑。

    ⑥拦截器可以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,可以调用业务逻辑。

    ⑥拦截器可以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,可以调用业务逻辑。

    ⑥拦截器可以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,可以调用业务逻辑。

    拦截器可以获取ioc中的service bean实现业务逻辑,拦截器可以获取ioc中的service bean实现业务逻辑,拦截器可以获取ioc中的service bean实现业务逻辑,

    触发时机

    触发时机

    触发时机

    有个专业词语叫触发时机

    有个专业词语叫触发时机

    有个专业词语叫触发时机

    1.过滤器和拦截器触发时机不一样:

    过滤器是在请求进入容器后,但请求进入servlet之前进行预处理的。请求结束返回也是,是在servlet处理完后,返回给前端之前。

    1.过滤器和拦截器触发时间和地点不一样:

    过滤器是在请求进入容器后,但请求进入servlet之前进行预处理的。请求结束返回也是,是在servlet处理完后,返回给前端之前。

    1.过滤器和拦截器触发时间和地点不一样:

    过滤器是在请求进入容器后,但请求进入servlet之前进行预处理的。请求结束返回也是,是在servlet处理完后,返回给前端之前。

    总结:过滤器包裹住servlet,servlet包裹住拦截器。

    如下图所示:

    在这里插入图片描述

    2.过滤器的触发时机是容器后,servlet之前,所以过滤器的doFilter(

    ServletRequest request, ServletResponse response, FilterChain chain
    )的入参是ServletRequest ,而不是httpservletrequest。因为过滤器是在httpservlet之前。

    10.过滤器

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    System.out.println(“before…”);
    chain.doFilter(request, response);
    System.out.println(“after…”);
    }
    chain.doFilter(request, response);这个方法的调用作为分水岭。事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。
    chain.doFilter(request, response);这个方法的调用作为分水岭。事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。
    事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。
    事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。
    事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。
    事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。

    1.过滤器是JavaEE标准,采用函数回调的方式进行。是在请求进入容器之后,还未进入Servlet之前进行预处理,并且在请求结束返回给前端这之间进行后期处理。

    复制代码

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

    复制代码

    chain.doFilter(request, response);这个方法的调用作为分水岭。事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。

    2.拦截器是被包裹在过滤器之中的。

    复制代码

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
    

    复制代码

    a.preHandle()这个方法是在过滤器的chain.doFilter(request, response)方法的前一步执行,也就是在 [System.out.println(“before…”)][chain.doFilter(request, response)]之间执行。

    b.preHandle()方法之后,在return ModelAndView之前进行,可以操控Controller的ModelAndView内容。

    c.afterCompletion()方法是在过滤器返回给前端前一步执行,也就是在[chain.doFilter(request, response)][System.out.println(“after…”)]之间执行。

    3.SpringMVC的机制是由同一个Servlet来分发请求给不同的Controller,其实这一步是在Servlet的service()方法中执行的。所以过滤器、拦截器、service()方法,dispatc()方法的执行顺序应该是这样的,大致画了个图:其实非常好测试,自己写一个过滤器,一个拦截器,然后在这些方法中都加个断点,一路F8下去就得出了结论。

    4.SpringMVC的机制是由同一个Servlet来分发请求给不同的Controller,其实这一步是在Servlet的service()方法中执行的。

    5.,SpringMVC的机制是由同一个Servlet来分发请求给不同的Controller,其实这一步是在Servlet的service()方法中执行的。

    6.SpringMVC的机制是由同一个Servlet来分发请求给不同的Controller,其实这一步是在Servlet的service()方法中执行的。

    7.还有,拦截器是spring容器的,是spring支持的,

    7.还有,拦截器是spring容器的,是spring支持的,

    7.还有,拦截器是spring容器的,是spring支持的,

    在这里插入图片描述

    在这里插入图片描述
    转载博客https://www.cnblogs.com/panxuejun/p/7715917.html

    一个实例验证的博客基于springmvc添加链接描述

    展开全文
  • 一个项目中不出意外的话会有两以上的... java封装了一个FilterRegistrationBean对象,可以把他比作一个容器,将过滤器套入这对象中,可以对这对象进行优先级设置、过滤规则设置等属性,下面是几常用的过...

            一个项目中不出意外的话会有两个以上的过滤器,但是直接不配置的话他会按照你的过滤器名字排序执行,这样的话可能会导致一些性能上或者逻辑上的问题。那么,控制一下执行顺序是我们所必须要做的。

            java封装了一个FilterRegistrationBean对象,可以把他比作一个容器,将过滤器套入这个对象中,可以对这个对象进行优先级设置、过滤规则设置等属性,下面是几个常用的过滤器以及过滤器配置。

    过滤器配置:

    package cn.ask.filter;
    
    import javax.servlet.DispatcherType;
    
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.filter.DelegatingFilterProxy;
    
    
    /**
     * Title:      FilterConfig
     * @date       2018年10月25日
     * @version    V1.0
     * Description: 过滤器配置
     */
    @SuppressWarnings("all")
    @Configuration
    public class FilterConfig {
    	/**
    	 * @Description 防xss攻击过滤器
    	 * @date 2018年8月16日下午4:55:44
    	 */
    	@Bean
    	public FilterRegistrationBean xssFilterRegistration() {
    		FilterRegistrationBean registration = new FilterRegistrationBean();
    		registration.setDispatcherTypes(DispatcherType.REQUEST);
    		registration.setFilter(new XssFilter());
    		registration.addUrlPatterns("/*");
    		registration.setName("xssFilter");
            //order数字越小越先执行
    		registration.setOrder(1);
    		return registration;
    	}
    	
    	/**  
    	* @Description 获取登录信息 
    	* @date 2018年10月25日上午9:14:48
    	*/
    	@Bean
    	public FilterRegistrationBean cookieRegistration() {
    		FilterRegistrationBean registration = new FilterRegistrationBean();
    		registration.setDispatcherTypes(DispatcherType.REQUEST);
    		registration.setFilter(new CookieFilter());
    		registration.addUrlPatterns("/*");
    		registration.setName("firstFilter");
    		registration.setOrder(2);
    		return registration;
    	}
    	
    }
    

    常用过滤器之一:sso单点登录(使用cookie记录跨站数据)

    package cn.ask.filter;
    
    import java.io.IOException;
    import java.net.URLDecoder;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.Cookie;
    import javax.servlet.http.HttpServletRequest;
    
    import org.apache.commons.lang3.StringUtils;
    
    /**
     * Servlet Filter implementation class FirstFilter
     */
    public class CookieFilter implements Filter {
    
        /**
         * Default constructor. 
         */
        public CookieFilter() {
            // TODO Auto-generated constructor stub
        }
    
    	/**
    	 * @see Filter#destroy()
    	 */
    	public void destroy() {
    		// TODO Auto-generated method stub
    	}
    
    	/**
    	 * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
    	 */
    	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    		HttpServletRequest req = (HttpServletRequest) request;
    		String tokenHeader = req.getHeader("token");
    		if(StringUtils.isBlank(tokenHeader)) {
    			Cookie[] cookies = req.getCookies();
    			if (cookies != null && cookies.length > 0) {
    				for (int i = 0; i < cookies.length; i++) {
    					String name = cookies[i].getName();
    					String value = cookies[i].getValue();
    					if ("user_accesstoken".equals(name)) { // 用户token
    						req.setAttribute("token", URLDecoder.decode(value, "utf-8"));
    					}
    					if ("user_avatar".equals(name)) { // 头像
    						req.setAttribute("avatar", URLDecoder.decode(value, "utf-8"));
    					}
    					if ("user_nickname".equals(name)) { // 昵称
    						req.setAttribute("nickname", URLDecoder.decode(value, "utf-8"));
    					}
    					String token = (String) req.getAttribute("token");
    					if (StringUtils.isBlank(token)) {
    						req.setAttribute("isLogin", "no");
    					} else {
    						req.setAttribute("isLogin", "yes");
    					}
    				}
    			}else {
    				req.removeAttribute("token");
    				req.removeAttribute("avatar");
    				req.removeAttribute("nickname");
    				req.setAttribute("isLogin", "no");
    			}
    		} else {
    			req.setAttribute("token", tokenHeader);
    		}
    		
    		chain.doFilter(request, response);
    	}
    
    	/**
    	 * @see Filter#init(FilterConfig)
    	 */
    	public void init(FilterConfig fConfig) throws ServletException {
    		// TODO Auto-generated method stub
    	}
    
    }
    

    常用过滤器之二:xss过滤以及防html注入过滤(包括过滤敏感词)

    package cn.ask.filter;
    
    import java.io.IOException;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletRequest;
    
    
    /**
     * Title:      XssFilter
     * @date       2018年8月16日
     * @version    V1.0
     * Description: xss过滤
     */
    public class XssFilter implements Filter {
    
    	@Override
    	public void init(FilterConfig config) throws ServletException {
    	}
    
    	@Override
    	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                throws IOException, ServletException {
    		XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper((HttpServletRequest) request);
    		chain.doFilter(xssRequest, response);
    	}
    
    	@Override
    	public void destroy() {
    	}
    
    }
    package cn.ask.filter;
    
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    import javax.servlet.ReadListener;
    import javax.servlet.ServletInputStream;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.MediaType;
    
    
    /**
     * Title:      XssHttpServletRequestWrapper
     * @date       2018年8月16日
     * @version    V1.0
     * Description:  XSS过滤处理
     */
    public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
        /**没被包装过的HttpServletRequest(特殊场景,需要自己过滤*/
        HttpServletRequest orgRequest;
        /**html过滤*/
        private final static HtmlFilter HTMLFILTER = new HtmlFilter();
    
        public XssHttpServletRequestWrapper(HttpServletRequest request) {
            super(request);
            orgRequest = request;
        }
    
        @Override
        public ServletInputStream getInputStream() throws IOException {
            //非json类型,直接返回
            if(!super.getHeader(HttpHeaders.CONTENT_TYPE).equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)){
                return super.getInputStream();
            }
    
            //为空,直接返回
            String json = IOUtils.toString(super.getInputStream(), "utf-8");
            if (StringUtils.isBlank(json)) {
                return super.getInputStream();
            }
    
            //xss过滤
            json = xssEncode(json);
            final ByteArrayInputStream bis = new ByteArrayInputStream(json.getBytes());
            return new ServletInputStream() {
                @Override
                public boolean isFinished() {
                    return true;
                }
    
                @Override
                public boolean isReady() {
                    return true;
                }
    
                @Override
                public void setReadListener(ReadListener readListener) {
    
                }
    
                @Override
                public int read() throws IOException {
                    return bis.read();
                }
            };
        }
    
        @Override
        public String getParameter(String name) {
            String value = super.getParameter(xssEncode(name));
            if (StringUtils.isNotBlank(value)) {
                value = xssEncode(value);
            }
            return value;
        }
    
        @Override
        public String[] getParameterValues(String name) {
            String[] parameters = super.getParameterValues(name);
            if (parameters == null || parameters.length == 0) {
                return null;
            }
    
            for (int i = 0; i < parameters.length; i++) {
                parameters[i] = xssEncode(parameters[i]);
            }
            return parameters;
        }
    
        @Override
        public Map<String,String[]> getParameterMap() {
            Map<String,String[]> map = new LinkedHashMap<>();
            Map<String,String[]> parameters = super.getParameterMap();
            for (String key : parameters.keySet()) {
                String[] values = parameters.get(key);
                for (int i = 0; i < values.length; i++) {
                    values[i] = xssEncode(values[i]);
                }
                map.put(key, values);
            }
            return map;
        }
    
        @Override
        public String getHeader(String name) {
            String value = super.getHeader(xssEncode(name));
            if (StringUtils.isNotBlank(value)) {
                value = xssEncode(value);
            }
            return value;
        }
        //富文本内容放行
        private String xssEncode(String input) {
        	if(!input.startsWith("<p")&&!input.startsWith("<ol")&&!input.startsWith("<ul")&&!input.startsWith("<hr/>")) {
        		input=HTMLFILTER.filter(input);
        	}
            //敏感词过滤
            input=SensitiveWordUtils.getSensitiveWordUtils().replaceSensitiveWord(input, '*', 2);
            return input;
            
        }
    
        /**
         * 获取最原始的request
         */
        public HttpServletRequest getOrgRequest() {
            return orgRequest;
        }
    
        /**
         * 获取最原始的request
         */
        public static HttpServletRequest getOrgRequest(HttpServletRequest request) {
            if (request instanceof XssHttpServletRequestWrapper) {
                return ((XssHttpServletRequestWrapper) request).getOrgRequest();
            }
    
            return request;
        }
    
    }
    
    package cn.ask.filter;
    
    import java.util.*;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    import java.util.logging.Logger;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * Title:      HTMLFilter
     * @date       2018年8月16日
     * @version    V1.0
     * Description: 防html注入
     */
    public final class HtmlFilter {
    
        /** regex flag union representing /si modifiers in php **/
        private static final int REGEX_FLAGS_SI = Pattern.CASE_INSENSITIVE | Pattern.DOTALL;
        private static final Pattern P_COMMENTS = Pattern.compile("<!--(.*?)-->", Pattern.DOTALL);
        private static final Pattern P_COMMENT = Pattern.compile("^!--(.*)--$", REGEX_FLAGS_SI);
        private static final Pattern P_TAGS = Pattern.compile("<(.*?)>", Pattern.DOTALL);
        private static final Pattern P_END_TAG = Pattern.compile("^/([a-z0-9]+)", REGEX_FLAGS_SI);
        private static final Pattern P_START_TAG = Pattern.compile("^([a-z0-9]+)(.*?)(/?)$", REGEX_FLAGS_SI);
        private static final Pattern P_QUOTED_ATTRIBUTES = Pattern.compile("([a-z0-9]+)=([\"'])(.*?)\\2", REGEX_FLAGS_SI);
        private static final Pattern P_UNQUOTED_ATTRIBUTES = Pattern.compile("([a-z0-9]+)(=)([^\"\\s']+)", REGEX_FLAGS_SI);
        private static final Pattern P_PROTOCOL = Pattern.compile("^([^:]+):", REGEX_FLAGS_SI);
        private static final Pattern P_ENTITY = Pattern.compile("&#(\\d+);?");
        private static final Pattern P_ENTITY_UNICODE = Pattern.compile("&#x([0-9a-f]+);?");
        private static final Pattern P_ENCODE = Pattern.compile("%([0-9a-f]{2});?");
        private static final Pattern P_VALID_ENTITIES = Pattern.compile("&([^&;]*)(?=(;|&|$))");
        private static final Pattern P_VALID_QUOTES = Pattern.compile("(>|^)([^<]+?)(<|$)", Pattern.DOTALL);
        private static final Pattern P_END_ARROW = Pattern.compile("^>");
        private static final Pattern P_BODY_TO_END = Pattern.compile("<([^>]*?)(?=<|$)");
        private static final Pattern P_XML_CONTENT = Pattern.compile("(^|>)([^<]*?)(?=>)");
        private static final Pattern P_STRAY_LEFT_ARROW = Pattern.compile("<([^>]*?)(?=<|$)");
        private static final Pattern P_STRAY_RIGHT_ARROW = Pattern.compile("(^|>)([^<]*?)(?=>)");
        private static final Pattern P_AMP = Pattern.compile("&");
        private static final Pattern P_QUOTE = Pattern.compile("<");
        private static final Pattern P_LEFT_ARROW = Pattern.compile("<");
        private static final Pattern P_RIGHT_ARROW = Pattern.compile(">");
        private static final Pattern P_BOTH_ARROWS = Pattern.compile("<>");
        private static final String SS="#//";
    
        /** @xxx could grow large... maybe use sesat's ReferenceMap */
        private static final ConcurrentMap<String,Pattern> P_REMOVE_PAIR_BLANKS = new ConcurrentHashMap<String, Pattern>();
        private static final ConcurrentMap<String,Pattern> P_REMOVE_SELF_BLANKS = new ConcurrentHashMap<String, Pattern>();
    
        /** set of allowed html elements, along with allowed attributes for each element **/
        private final Map<String, List<String>> vAllowed;
        /** counts of open tags for each (allowable) html element **/
        private final Map<String, Integer> vTagCounts = new HashMap<String, Integer>();
    
        /** html elements which must always be self-closing (e.g. "<img />") **/
        private final String[] vSelfClosingTags;
        /** html elements which must always have separate opening and closing tags (e.g. "<b></b>") **/
        private final String[] vNeedClosingTags;
        /** set of disallowed html elements **/
        private final String[] vDisallowed;
        /** attributes which should be checked for valid protocols **/
        private final String[] vProtocolAtts;
        /** allowed protocols **/
        private final String[] vAllowedProtocols;
        /** tags which should be removed if they contain no content (e.g. "<b></b>" or "<b />") **/
        private final String[] vRemoveBlanks;
        /** entities allowed within html markup **/
        private final String[] vAllowedEntities;
        /** flag determining whether comments are allowed in input String. */
        private final boolean stripComment;
        private final boolean encodeQuotes;
        private boolean vDebug = false;
        /**
         * flag determining whether to try to make tags when presented with "unbalanced"
         * angle brackets (e.g. "<b text </b>" becomes "<b> text </b>").  If set to false,
         * unbalanced angle brackets will be html escaped.
         */
        private final boolean alwaysMakeTags;
    
        /** Default constructor.
         *
         */
        public HtmlFilter() {
            vAllowed = new HashMap<>();
    
            final ArrayList<String> aAtts = new ArrayList<String>();
            aAtts.add("href");
            aAtts.add("target");
            vAllowed.put("a", aAtts);
    
            final ArrayList<String> imgAtts = new ArrayList<String>();
            imgAtts.add("src");
            imgAtts.add("width");
            imgAtts.add("height");
            imgAtts.add("alt");
            vAllowed.put("img", imgAtts);
    
            final ArrayList<String> noAtts = new ArrayList<String>();
            vAllowed.put("b", noAtts);
            vAllowed.put("strong", noAtts);
            vAllowed.put("i", noAtts);
            vAllowed.put("em", noAtts);
    
            vSelfClosingTags = new String[]{"img"};
            vNeedClosingTags = new String[]{"a", "b", "strong", "i", "em"};
            vDisallowed = new String[]{};
            /**no ftp*/
            vAllowedProtocols = new String[]{"http", "mailto", "https"};
            vProtocolAtts = new String[]{"src", "href"};
            vRemoveBlanks = new String[]{"a", "b", "strong", "i", "em"};
            vAllowedEntities = new String[]{"amp", "gt", "lt", "quot"};
            stripComment = true;
            encodeQuotes = true;
            alwaysMakeTags = true;
        }
    
        /** Set debug flag to true. Otherwise use default settings. See the default constructor.
         *
         * @param debug turn debug on with a true argument
         */
        public HtmlFilter(final boolean debug) {
            this();
            vDebug = debug;
    
        }
    
        /** Map-parameter configurable constructor.
         *
         * @param conf map containing configuration. keys match field names.
         */
        @SuppressWarnings("unchecked")
    	public HtmlFilter(final Map<String,Object> conf) {
    
            assert conf.containsKey("vAllowed") : "configuration requires vAllowed";
            assert conf.containsKey("vSelfClosingTags") : "configuration requires vSelfClosingTags";
            assert conf.containsKey("vNeedClosingTags") : "configuration requires vNeedClosingTags";
            assert conf.containsKey("vDisallowed") : "configuration requires vDisallowed";
            assert conf.containsKey("vAllowedProtocols") : "configuration requires vAllowedProtocols";
            assert conf.containsKey("vProtocolAtts") : "configuration requires vProtocolAtts";
            assert conf.containsKey("vRemoveBlanks") : "configuration requires vRemoveBlanks";
            assert conf.containsKey("vAllowedEntities") : "configuration requires vAllowedEntities";
    
            vAllowed = Collections.unmodifiableMap((HashMap<String, List<String>>) conf.get("vAllowed"));
            vSelfClosingTags = (String[]) conf.get("vSelfClosingTags");
            vNeedClosingTags = (String[]) conf.get("vNeedClosingTags");
            vDisallowed = (String[]) conf.get("vDisallowed");
            vAllowedProtocols = (String[]) conf.get("vAllowedProtocols");
            vProtocolAtts = (String[]) conf.get("vProtocolAtts");
            vRemoveBlanks = (String[]) conf.get("vRemoveBlanks");
            vAllowedEntities = (String[]) conf.get("vAllowedEntities");
            stripComment =  conf.containsKey("stripComment") ? (Boolean) conf.get("stripComment") : true;
            encodeQuotes = conf.containsKey("encodeQuotes") ? (Boolean) conf.get("encodeQuotes") : true;
            alwaysMakeTags = conf.containsKey("alwaysMakeTags") ? (Boolean) conf.get("alwaysMakeTags") : true;
        }
    
        private void reset() {
            vTagCounts.clear();
        }
    
        private void debug(final String msg) {
            if (vDebug) {
                Logger.getAnonymousLogger().info(msg);
            }
        }
    
        //---------------------------------------------------------------
        /**my versions of some PHP library functions*/
        public static String chr(final int decimal) {
            return String.valueOf((char) decimal);
        }
    
        public static String htmlSpecialChars(final String s) {
            String result = s;
            result = regexReplace(P_AMP, "&amp;", result);
            result = regexReplace(P_QUOTE, "&quot;", result);
            result = regexReplace(P_LEFT_ARROW, "&lt;", result);
            result = regexReplace(P_RIGHT_ARROW, "&gt;", result);
            return result;
        }
    
        //---------------------------------------------------------------
        /**
         * given a user submitted input String, filter out any invalid or restricted
         * html.
         *
         * @param input text (i.e. submitted by a user) than may contain html
         * @return "clean" version of input, with only valid, whitelisted html elements allowed
         */
        public String filter(final String input) {
            reset();
            String s = input;
    
            debug("************************************************");
            debug("              INPUT: " + input);
    
            s = escapeComments(s);
            debug("     escapeComments: " + s);
    
            s = balanceHTML(s);
            debug("        balanceHTML: " + s);
    
            s = checkTags(s);
            debug("          checkTags: " + s);
    
            s = processRemoveBlanks(s);
            debug("processRemoveBlanks: " + s);
    
            s = validateEntities(s);
            debug("    validateEntites: " + s);
    
            debug("************************************************\n\n");
            return s;
        }
    
        public boolean isAlwaysMakeTags(){
            return alwaysMakeTags;
        }
    
        public boolean isStripComments(){
            return stripComment;
        }
    
        private String escapeComments(final String s) {
            final Matcher m = P_COMMENTS.matcher(s);
            final StringBuffer buf = new StringBuffer();
            if (m.find()) {
            	/**(.*?)*/
                final String match = m.group(1); 
                m.appendReplacement(buf, Matcher.quoteReplacement("<!--" + htmlSpecialChars(match) + "-->"));
            }
            m.appendTail(buf);
    
            return buf.toString();
        }
    
        private String balanceHTML(String s) {
            if (alwaysMakeTags) {
                //
                // try and form html
                //
                s = regexReplace(P_END_ARROW, "", s);
                s = regexReplace(P_BODY_TO_END, "<$1>", s);
                s = regexReplace(P_XML_CONTENT, "$1<$2", s);
    
            } else {
                //
                // escape stray brackets
                //
                s = regexReplace(P_STRAY_LEFT_ARROW, "&lt;$1", s);
                s = regexReplace(P_STRAY_RIGHT_ARROW, "$1$2&gt;<", s);
    
                //
                // the last regexp causes '<>' entities to appear
                // (we need to do a lookahead assertion so that the last bracket can
                // be used in the next pass of the regexp)
                //
                s = regexReplace(P_BOTH_ARROWS, "", s);
            }
    
            return s;
        }
    
        private String checkTags(String s) {
            Matcher m = P_TAGS.matcher(s);
    
            final StringBuffer buf = new StringBuffer();
            while (m.find()) {
                String replaceStr = m.group(1);
                replaceStr = processTag(replaceStr);
                m.appendReplacement(buf, Matcher.quoteReplacement(replaceStr));
            }
            m.appendTail(buf);
    
            s = buf.toString();
    
            // these get tallied in processTag
            // (remember to reset before subsequent calls to filter method)
            for (String key : vTagCounts.keySet()) {
                for (int ii = 0; ii < vTagCounts.get(key); ii++) {
                    s += "</" + key + ">";
                }
            }
    
            return s;
        }
    
        private String processRemoveBlanks(final String s) {
            String result = s;
            for (String tag : vRemoveBlanks) {
                if(!P_REMOVE_PAIR_BLANKS.containsKey(tag)){
                    P_REMOVE_PAIR_BLANKS.putIfAbsent(tag, Pattern.compile("<" + tag + "(\\s[^>]*)?></" + tag + ">"));
                }
                result = regexReplace(P_REMOVE_PAIR_BLANKS.get(tag), "", result);
                if(!P_REMOVE_SELF_BLANKS.containsKey(tag)){
                    P_REMOVE_SELF_BLANKS.putIfAbsent(tag, Pattern.compile("<" + tag + "(\\s[^>]*)?/>"));
                }
                result = regexReplace(P_REMOVE_SELF_BLANKS.get(tag), "", result);
            }
    
            return result;
        }
    
        private static String regexReplace(final Pattern regexPattern, final String replacement, final String s) {
            Matcher m = regexPattern.matcher(s);
            return m.replaceAll(replacement);
        }
    
        private String processTag(final String s) {
            // ending tags
            Matcher m = P_END_TAG.matcher(s);
            if (m.find()) {
                final String name = m.group(1).toLowerCase();
                if (allowed(name)) {
                    if (!inArray(name, vSelfClosingTags)) {
                        if (vTagCounts.containsKey(name)) {
                            vTagCounts.put(name, vTagCounts.get(name) - 1);
                            return "</" + name + ">";
                        }
                    }
                }
            }
            // starting tags
            m = P_START_TAG.matcher(s);
            if (m.find()) {
                final String name = m.group(1).toLowerCase();
                final String body = m.group(2);
                String ending = m.group(3);
                //debug( "in a starting tag, name='" + name + "'; body='" + body + "'; ending='" + ending + "'" );
                if (allowed(name)) {
                    String params = "";
                    final Matcher m2 = P_QUOTED_ATTRIBUTES.matcher(body);
                    final Matcher m3 = P_UNQUOTED_ATTRIBUTES.matcher(body);
                    final List<String> paramNames = new ArrayList<String>();
                    final List<String> paramValues = new ArrayList<String>();
                    while (m2.find()) {
                    	/**([a-z0-9]+)*/
                        paramNames.add(m2.group(1)); 
                        /**(.*?)*/
                        paramValues.add(m2.group(3)); 
                    }
                    while (m3.find()) {
                    	/**([a-z0-9]+)*/
                        paramNames.add(m3.group(1));
                        /**([^\"\\s']+)*/
                        paramValues.add(m3.group(3)); 
                    }
                    String paramName, paramValue;
                    for (int ii = 0; ii < paramNames.size(); ii++) {
                        paramName = paramNames.get(ii).toLowerCase();
                        paramValue = paramValues.get(ii);
                        if (allowedAttribute(name, paramName)) {
                            if (inArray(paramName, vProtocolAtts)) {
                                paramValue = processParamProtocol(paramValue);
                            }
                            params += " " + paramName + "=\"" + paramValue + "\"";
                        }
                    }
                    if (inArray(name, vSelfClosingTags)) {
                        ending = " /";
                    }
                    if (inArray(name, vNeedClosingTags)) {
                        ending = "";
                    }
                    if (ending == null || ending.length() < 1) {
                        if (vTagCounts.containsKey(name)) {
                            vTagCounts.put(name, vTagCounts.get(name) + 1);
                        } else {
                            vTagCounts.put(name, 1);
                        }
                    } else {
                        ending = " /";
                    }
                    return "<" + name + params + ending + ">";
                } else {
                    return "";
                }
            }
            // comments
            m = P_COMMENT.matcher(s);
            if (!stripComment && m.find()) {
                return  "<" + m.group() + ">";
            }
            return "";
        }
    
        private String processParamProtocol(String s) {
            s = decodeEntities(s);
            final Matcher m = P_PROTOCOL.matcher(s);
            if (m.find()) {
                final String protocol = m.group(1);
                if (!inArray(protocol, vAllowedProtocols)) {
                    // bad protocol, turn into local anchor link instead
                    s = "#" + s.substring(protocol.length() + 1, s.length());
                    if (s.startsWith(SS)) {
                        s = "#" + s.substring(3, s.length());
                    }
                }
            }
    
            return s;
        }
    
        private String decodeEntities(String s) {
            StringBuffer buf = new StringBuffer();
    
            Matcher m = P_ENTITY.matcher(s);
            while (m.find()) {
                final String match = m.group(1);
                final int decimal = Integer.decode(match).intValue();
                m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
            }
            m.appendTail(buf);
            s = buf.toString();
    
            buf = new StringBuffer();
            m = P_ENTITY_UNICODE.matcher(s);
            while (m.find()) {
                final String match = m.group(1);
                final int decimal = Integer.valueOf(match, 16).intValue();
                m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
            }
            m.appendTail(buf);
            s = buf.toString();
    
            buf = new StringBuffer();
            m = P_ENCODE.matcher(s);
            while (m.find()) {
                final String match = m.group(1);
                final int decimal = Integer.valueOf(match, 16).intValue();
                m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal)));
            }
            m.appendTail(buf);
            s = buf.toString();
    
            s = validateEntities(s);
            return s;
        }
    
        private String validateEntities(final String s) {
            StringBuffer buf = new StringBuffer();
    
            // validate entities throughout the string
            Matcher m = P_VALID_ENTITIES.matcher(s);
            while (m.find()) {
            	/**([^&;]*)*/
                final String one = m.group(1);
                /**(?=(;|&|$))*/
                final String two = m.group(2);
                m.appendReplacement(buf, Matcher.quoteReplacement(checkEntity(one, two)));
            }
            m.appendTail(buf);
    
            return encodeQuotes(buf.toString());
        }
    
        private String encodeQuotes(final String s){
            if(encodeQuotes){
                StringBuffer buf = new StringBuffer();
                Matcher m = P_VALID_QUOTES.matcher(s);
                while (m.find()) {
                	/**(>|^)*/
                    final String one = m.group(1);
                    /**([^<]+?)*/
                    final String two = m.group(2); 
                    /**(<|$)*/
                    final String three = m.group(3);
                    m.appendReplacement(buf, Matcher.quoteReplacement(one + regexReplace(P_QUOTE, "&quot;", two) + three));
                }
                m.appendTail(buf);
                return buf.toString();
            }else{
                return s;
            }
        }
    
        private String checkEntity(final String preamble, final String term) {
    
            return ";".equals(term) && isValidEntity(preamble)
                    ? '&' + preamble
                    : "&amp;" + preamble;
        }
    
        private boolean isValidEntity(final String entity) {
            return inArray(entity, vAllowedEntities);
        }
    
        private static boolean inArray(final String s, final String[] array) {
            for (String item : array) {
                if (item != null && item.equals(s)) {
                    return true;
                }
            }
            return false;
        }
    
        private boolean allowed(final String name) {
            return (vAllowed.isEmpty() || vAllowed.containsKey(name)) && !inArray(name, vDisallowed);
        }
    
        private boolean allowedAttribute(final String name, final String paramName) {
            return allowed(name) && (vAllowed.isEmpty() || vAllowed.get(name).contains(paramName));
        }
    }

    敏感词过滤工具类

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.Serializable;
    import java.util.*;
    
    import org.springframework.core.io.ClassPathResource;
    
    /**
     * Title:      SensitiveWordUtils
     * @author:    gaodeqiang
     * @date       2018年12月12日
     * @version    V1.0
     * Description: 敏感词过滤
     */
    @SuppressWarnings("all")
    public class SensitiveWordUtils implements Serializable {
    
    	private static final long serialVersionUID = 1L;
    
    	private SensitiveWordUtils() {
    	}
    
    	private static SensitiveWordUtils sensitiveWordUtils = null;
    
    	public synchronized static SensitiveWordUtils getSensitiveWordUtils() {
    		if (sensitiveWordUtils == null) {
    			sensitiveWordUtils = new SensitiveWordUtils();
    		}
    		return sensitiveWordUtils;
    	}
    
    	private static Set<String> sensitiveWordSet = null;
    
    	static {
    		try {
    			readResource("keywords.txt");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		// 初始化敏感词库
    		initSensitiveWordMap();
    	}
    
    	private static final int MinMatchTYpe = 1; // 最小匹配规则,如:敏感词库["中国","中国人"],语句:"我是中国人",匹配结果:我是[中国]人
    	private static final int MaxMatchType = 2; // 最大匹配规则,如:敏感词库["中国","中国人"],语句:"我是中国人",匹配结果:我是[中国人]
    
    	private static HashMap sensitiveWordMap = new HashMap<>();
    
    	/**
    	 * @author gaodeqiang
    	 * @Description 读取资源文件
    	 * @date 2018年12月13日上午9:29:01
    	 */
    	private static void readResource(String name) throws Exception {
    		ClassPathResource resource = new ClassPathResource(name);
    		InputStream inputStream = resource.getInputStream();
    		InputStreamReader read = new InputStreamReader(inputStream, "utf-8");
    		// 初始化set集合
    		sensitiveWordSet = new HashSet<String>();
    		// 缓冲区读取流
    		BufferedReader bufferedReader = new BufferedReader(read);
    		// 循环读取文件中内容,每次读取一行内容
    		String txt = null;
    		while ((txt = bufferedReader.readLine()) != null) {
    			// 读取文件,将文件内容放入到set中
    			sensitiveWordSet.add(txt);
    		}
    		read.close();
    	}
    
    	/**
    	 * @author gaodeqiang
    	 * @Description 初始化敏感词库,构建DFA算法模型
    	 * @date 2018年12月13日上午9:30:08
    	 */
    	private static void initSensitiveWordMap() {
    		// 初始化敏感词容器,减少扩容操作
    		sensitiveWordMap = new HashMap(sensitiveWordSet.size());
    		String key;
    		Map nowMap;
    		Map<String, String> newWorMap;
    		// 迭代sensitiveWordSet
    		Iterator<String> iterator = sensitiveWordSet.iterator();
    		while (iterator.hasNext()) {
    			// 关键字
    			key = iterator.next();
    			nowMap = sensitiveWordMap;
    			for (int i = 0; i < key.length(); i++) {
    				// 转换成char型
    				char keyChar = key.charAt(i);
    				// 库中获取关键字
    				Object wordMap = nowMap.get(keyChar);
    				// 如果存在该key,直接赋值,用于下一个循环获取
    				if (wordMap != null) {
    					nowMap = (Map) wordMap;
    				} else {
    					// 不存在则,则构建一个map,同时将isEnd设置为0,因为他不是最后一个
    					newWorMap = new HashMap<>();
    					// 不是最后一个
    					newWorMap.put("isEnd", "0");
    					nowMap.put(keyChar, newWorMap);
    					nowMap = newWorMap;
    				}
    
    				if (i == key.length() - 1) {
    					// 最后一个
    					nowMap.put("isEnd", "1");
    				}
    			}
    		}
    	}
    
    	/**
    	 * @author gaodeqiang
    	 * @Description 检查文字中是否包含敏感字符
    	 * @date 2018年12月13日上午9:38:35
    	 */
    	private int checkSensitiveWord(String txt, int beginIndex, int matchType) {
    		// 敏感词结束标识位:用于敏感词只有1位的情况
    		boolean flag = false;
    		// 匹配标识数默认为0
    		int matchFlag = 0;
    		char word;
    		Map nowMap = sensitiveWordMap;
    		for (int i = beginIndex; i < txt.length(); i++) {
    			word = txt.charAt(i);
    			// 获取指定key
    			nowMap = (Map) nowMap.get(word);
    			if (nowMap != null) {// 存在,则判断是否为最后一个
    				// 找到相应key,匹配标识+1
    				matchFlag++;
    				// 如果为最后一个匹配规则,结束循环,返回匹配标识数
    				if ("1".equals(nowMap.get("isEnd"))) {
    					// 结束标志位为true
    					flag = true;
    					// 最小规则,直接返回,最大规则还需继续查找
    					if (MinMatchTYpe == matchType) {
    						break;
    					}
    				}
    			} else {// 不存在,直接返回
    				break;
    			}
    		}
    		if (matchFlag < 2 || !flag) {// 长度必须大于等于1,为词
    			matchFlag = 0;
    		}
    		return matchFlag;
    	}
    
    	/**
    	 * @author gaodeqiang
    	 * @Description 判断文字是否包含敏感字符 匹配规则 1:最小匹配规则,2:最大匹配规则
    	 * @date 2018年12月13日上午9:34:23
    	 */
    	public boolean contains(String txt, int matchType) {
    		boolean flag = false;
    		for (int i = 0; i < txt.length(); i++) {
    			int matchFlag = checkSensitiveWord(txt, i, matchType); // 判断是否包含敏感字符
    			if (matchFlag > 0) { // 大于0存在,返回true
    				flag = true;
    			}
    		}
    		return flag;
    	}
    
    	/**
    	 * @author gaodeqiang
    	 * @Description 获取文字中的敏感词
    	 * @date 2018年12月13日上午9:36:00
    	 */
    	public Set<String> getSensitiveWord(String txt, int matchType) {
    		Set<String> sensitiveWordList = new HashSet<>();
    
    		for (int i = 0; i < txt.length(); i++) {
    			// 判断是否包含敏感字符
    			int length = checkSensitiveWord(txt, i, matchType);
    			if (length > 0) {// 存在,加入list中
    				sensitiveWordList.add(txt.substring(i, i + length));
    				i = i + length - 1;// 减1的原因,是因为for会自增
    			}
    		}
    
    		return sensitiveWordList;
    	}
    
    	/**
    	 * @author gaodeqiang
    	 * @Description 替换敏感字字符
    	 * @date 2018年12月13日上午9:36:34
    	 */
    	public String replaceSensitiveWord(String txt, char replaceChar, int matchType) {
    		String resultTxt = txt;
    		// 获取所有的敏感词
    		Set<String> set = getSensitiveWord(txt, matchType);
    		Iterator<String> iterator = set.iterator();
    		String word;
    		String replaceString;
    		while (iterator.hasNext()) {
    			word = iterator.next();
    			replaceString = getReplaceChars(replaceChar, word.length());
    			resultTxt = resultTxt.replaceAll(word, replaceString);
    		}
    
    		return resultTxt;
    	}
    
    	/**
    	 * @author gaodeqiang
    	 * @Description 获取替换字符串
    	 * @date 2018年12月13日上午9:37:53
    	 */
    	private String getReplaceChars(char replaceChar, int length) {
    		String resultReplace = String.valueOf(replaceChar);
    		for (int i = 1; i < length; i++) {
    			resultReplace += replaceChar;
    		}
    		return resultReplace;
    	}
    }
    

     

    展开全文
  • javaWeb过滤器–filter-过滤器执行流程 filter-过滤器执行流程 一个同学进校园,先会遇到保安,如果该同学出校园,也会碰到保安 过滤器执行流程 tomcat引擎将http请求转成request对象,http响应转response...
  • 处理方法②:增加过滤器,接口调用返回到前端前在进行次过滤。 处理方法③:增加拦截器,在postHandle中处理数据。 首先说一下: 过滤器以及拦截器区别 ①拦截器是基于java的反射机制的,而过滤器是基于函数回调。...
  • Java实现布隆过滤器

    千次阅读 2020-05-11 15:47:03
    布隆过滤器(Bloom Filter)是一个叫做 Bloom 的老哥于1970年提出的。 实际上可以把它看作由二进制向量(或者说位数组)和系列随机映射函数(哈希函数)两部分组成的数据结构。 它的优点是空间效率和查询时间都比...
  • java stream过滤_Java Stream过滤器

    千次阅读 2020-07-14 20:24:52
    java stream过滤Java Stream filter can be very helpful when you want to do some processing only on some elements of ... 当您希望仅基于特定条件对Stream的某些元素进行某些处理时,Java Stream过滤器可能会...
  • Java使用过滤器防止SQL注入XSS脚本注入

    千次阅读 多人点赞 2020-12-17 20:29:45
    前几天有客户在系统上面写了... 定义过滤器 package com.cn.unit.filter; import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; im
  • java过滤器Filter

    万次阅读 多人点赞 2019-07-31 19:08:31
    Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序,主要的用途是过滤字符编码、做一些业务逻辑判断如是否有权限访问页面等。其工作原理是,只要你在web.xml文件配置好要拦截的客户端请求,它...
  • Java过滤器Filter讲解(Java基础)

    千次阅读 多人点赞 2020-06-06 19:48:59
    文章目录、什么是过滤器二、如何编写过滤器三、 过滤器的配置四、Filter的生命周期五、多Filter的执行顺序 、什么是过滤器 Filter也称之为过滤器,它是Servlet技术中最激动人心的技术,WEB开发人员通过Filter...
  • java使用hbase过滤器

    千次阅读 2021-12-02 20:02:11
    1.什么是过滤器 ...RegionServer(这是一个服务端过滤器),这样也可以降低网络传输的压力。 2.比较运算符 LESS < LESS_OR_EQUAL <= EQUAL = NOT_EQUAL <> GREAT
  • java Filter过滤器执行步骤

    千次阅读 2018-06-14 11:56:59
    转:http://wangtan471x.blog.163.com/blog/static/231009682012981119122/建立一个过滤器涉及下列五步骤:1)建立一个实现Filter接口的类。这类需要三方法,分别是:doFilter、init和destroy。doFilter方法 ...
  • Java过滤器Filter使用详解

    万次阅读 2018-08-29 22:48:37
     Filter也称之为过滤器,它是Servlet技术中最激动人心的技术之,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态html文件等进行拦截,从而实现一些特殊的功能...
  • Java过滤器链原理解析

    千次阅读 2018-01-05 15:09:53
    在很多Java Web项目中我们会在web.xml中配置一些过滤器来拦截请求,比如下面解决乱码的编码过滤器: encodingFilter org.springframework.web.filter.CharacterEncodingFilter encoding UTF-8 ...
  • Java分页过滤器

    千次阅读 2019-02-11 09:26:16
    过滤器实现统一分页 过滤器实现(分页代码) import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.github.pagehelper.Page; import com.github.pagehelper.PageHelper; ...
  • 我们可以看到,这ApplicationFilterChain就是我们的过滤器链对象,里面保存了我们的过滤器和Servlet,doFilter方法用来切换到下一个过滤器,等所有过滤器都使用过遍之后,最终会调用Servlet。 在这里我们可以...
  • 管道过滤器的实现java

    2012-11-20 20:06:44
    管道过滤器的实现java,希望大家能够一起学习,我只是将文件放到了里面,希望大家自己搭建工程
  • JAVA过滤器

    千次阅读 2018-08-16 10:27:26
    过滤器Filter 1.filter的简介 filter是对客户端访问资源的过滤,符合条件放行,不符合条件不放行,并且可以对目标资源访问前后进行逻辑处理 作用: 代码的抽取(可以对request设置编码,这样所有走过的...
  • 但是过滤器java实现的,它需要依赖于Servlet容器,而拦截器是SprignMVC实现的一个机制,独立于Servlet容器,而且能实现IOC容器中的各个bean。简单的说:过滤器的urlPattern针对的是所有的请求,而拦截器的url...
  • Java Web之过滤器(Filter)

    万次阅读 多人点赞 2018-07-31 16:58:40
    过滤器(Filter) 过滤器实际上就是对web资源进行拦截,做一些处理后再交给servlet。 通常都是用来拦截request进行处理的,也可以对返回的response进行拦截处理 大概流程图如下 应用场景 自动登录 统一设置...
  • Java 过滤器的顺序

    千次阅读 2018-11-27 22:30:42
    现有三个过滤器 &amp;lt;filter&amp;gt; &amp;lt;filter-name&amp;gt;AFilter&amp;lt;/filter-name&amp;gt; &amp;lt;filter-class&amp;gt;com.jerry.filter.AF
  • 1、首先,过滤器是有一个@Order()的注解,参数值越低,执行顺序越靠前,但是在我测试之后,发现并没有成功,过滤器依旧是按照名称的顺序先后执行,那么我们就只能通过编写config文件来决定执行顺序 @Configuration...
  • Java redis 模拟布隆过滤器

    千次阅读 2018-12-13 16:21:40
    基本概念 如果想判断一个元素是不是在一个集合里,一般想到的是将所有元素保存起来,然后通过比较确定...它可以通过一个Hash函数将一个元素映射成一个位阵列(Bit Array)中的一个点。这样一来,我们只要看看这点...
  • Java过滤器配置使用

    千次阅读 2017-10-22 16:51:18
    过滤器的作用:用于过滤请求,...1.要配置Filter,首先建立一个Java类,实现Filter接口,代码如下 import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servl
  • 防止XSS跨站脚本攻击:Java过滤器

    万次阅读 2019-01-25 13:36:18
    XSS问题描述 跨站脚本(Cross site script,简称xss...注入本质上就是把输入的数据变成可执行的程序语句。SQL注入是如此,XSS也如此,只不过XSS一般注入的是恶意的脚本代码,这些脚本代码可以用来获取合法用户的数...
  • 拦截器和过滤器的区别

    千次阅读 2021-03-04 00:20:41
    在实现上基于函数回调,可以对几乎所有请求进行过滤,但是缺点是一个过滤器实例只能在容器初始化时调用次。使用过滤器的目的是用来做一些过滤操作,获取我们想要获取的数据,比如:在过滤器中修改字符编码;在过滤...
  • Java过滤器解决跨域问题

    千次阅读 2020-05-30 10:44:27
    Java后端解决跨域问题 代码: import javax.servlet.*; import javax.servlet.http.HttpServletResponse; import java.io.IOException; public class CORSFilter implements Filter{ @Override public void ...
  • Java设置字符编码过滤器

    千次阅读 2018-10-12 10:31:53
    过滤器 概念简述: 当web获得对资源请求时,web会判断该资源与过滤器是否相关,如果相关就交给过滤器处理,在过滤器中可以对请求的内容作出改变,然后再将请求转交给被请求的资源。当被请求的资源作出响应时,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 388,949
精华内容 155,579
关键字:

java过滤器如何执行下一个

java 订阅