java过滤器
Java过滤器Filter使用详解
Java过滤器Filter使⽤详解<div id="post_detail">转载请注明原⽂地址:在我的项⽬中有具体应⽤:https:///ygj0930/CoupleSpace过滤器过滤器是处于客户端与服务器资源⽂件之间的⼀道过滤⽹,在访问资源⽂件之前,通过⼀系列的过滤器对请求进⾏修改、判断等,把不符合规则的请求在中途拦截或修改。
也可以对响应进⾏过滤,拦截或修改响应。
如图,浏览器发出的请求先递交给第⼀个filter进⾏过滤,符合规则则放⾏,递交给filter链中的下⼀个过滤器进⾏过滤。
过滤器在链中的顺序与它在web.xml中配置的顺序有关,配置在前的则位于链的前端。
当请求通过了链中所有过滤器后就可以访问资源⽂件了,如果不能通过,则可能在中间某个过滤器中被处理掉。
在doFilter()⽅法中,chain.doFilter()前的⼀般是对request执⾏的过滤操作,chain.doFilter后⾯的代码⼀般是对response执⾏的操作。
过滤链代码的执⾏顺序如下:过滤器⼀般⽤于登录权限验证、资源访问权限控制、敏感词汇过滤、字符编码转换等等操作,便于代码重⽤,不必每个servlet中还要进⾏相应的操作。
下⾯是过滤器的简单应⽤:1:创建过滤器如图,新建⼀个class,实现接⼝Filter(注意:是javax.servlet中的Filter)。
2:重写过滤器的doFilter(request,response,chain)⽅法。
另外两个init()、destroy()⽅法⼀般不需要重写。
在doFilter⽅法中进⾏过滤操作。
常⽤代码有:获取请求、获取响应、获取session、放⾏。
剩下的代码就是根据session的属性进⾏过滤操作、设置编码格式等等了,看情况⽽定。
HttpServletRequest request=(HttpServletRequest) arg0;//获取request对象HttpServletResponse response=(HttpServletResponse) arg1;//获取response对象HttpSession session=request.getSession();//获取session对象过滤操作代码......chain.doFilter(request, response);//放⾏,通过了当前过滤器,递交给下⼀个filter进⾏过滤3:在web.xml中配置过滤器。
javaweb中监听器、过滤器、拦截器以及AOP的先后顺序和理解
javaweb中监听器、过滤器、拦截器以及AOP的先后顺序和理解java web三⼤器:过滤器、拦截器、监听器(spring框架)spring、springMVC与springBoot的关系详见:⼀、启动顺序监听器---》过滤器---》拦截器案例理解:接到上级命令,要求对电话进去监听,过滤出恐怖分⼦,然后,拦截他们的恐怖袭击⾏动。
配置位置:监听器、过滤器⼀般配置在web.xml中,拦截器⼀般配置在springmvc.xml配置⽂件中⼆、概念监听器:Servlet的监听器Listener,它是实现了javax.servlet.ServletContextListener接⼝的服务器端程序,它也是随web应⽤的启动⽽启动,只初始化⼀次,随web应⽤的停⽌⽽销毁。
主要作⽤是:做⼀些初始化的内容添加⼯作、设置⼀些基本的内容、⽐如⼀些参数或者是⼀些固定的对象等等Filter过滤器:过滤器拦截web访问url地址。
严格意义上讲,filter只是适⽤于web中,依赖于Servlet容器,利⽤Java的回调机制进⾏实现。
Filter过滤器:和框架⽆关,可以控制最初的http请求,但是更细⼀点的类和⽅法控制不了。
过滤器可以拦截到⽅法的请求和响应(ServletRequest request, ServletResponse response),并对请求响应做出像响应的过滤操作,⽐如设置字符编码,鉴权操作等⽐如:(不是login.do的地址请求,如果⽤户没有登陆都过滤掉),或者在传⼊servlet或者struts的action前统⼀设置字符集,或者去除掉⼀些⾮法字符。
主要为了减轻服务器负载,减少压⼒。
Interceptor拦截器:拦截器拦截以 .action结尾的url,拦截Action的访问。
Interfactor是基于Java的反射机制(APO思想)进⾏实现,不依赖Servlet容器。
拦截器可以在⽅法执⾏之前(preHandle)和⽅法执⾏之后(afterCompletion)进⾏操作,回调操作(postHandle),可以获取执⾏的⽅法的名称,请求(HttpServletRequest)Interceptor:可以控制请求的控制器和⽅法,但控制不了请求⽅法⾥的参数(只能获取参数的名称,不能获取到参数的值)(⽤于处理页⾯提交的请求响应并进⾏处理,例如做国际化,做主题更换,过滤等)。
java中的filter中的contains方法
java中的filter中的contains方法1. 引言1.1 概述在Java中,Filter是一种常用的数据处理方式,它可以对集合、数组或字符串进行筛选和过滤操作。
其中,contains方法是Filter类中的一个重要方法之一。
它用于检查目标对象是否包含指定的元素,并返回布尔值以表示是否存在。
1.2 目的本篇文章旨在介绍Java中Filter中的contains方法。
通过阐述该方法的使用场景、参数与返回值说明以及与其他方法的对比分析,读者将深入了解并掌握该方法在实际开发中的应用。
1.3 文章结构本文将围绕以下几个方面展开论述:- 首先,将概述Java中Filter的相关背景知识和技术概念。
- 其次,详细介绍Filter中的contains方法,解释其工作原理和用法。
- 然后,分析contains方法所涉及到的参数以及其返回值,并给出示例代码进行解析。
- 进而,对contains方法与其他相关方法进行比较和对比分析,如startsWith 和endWiths等。
- 最后,总结全文内容并提出存在问题及展望未来可能改进之处,最后给出结语。
通过逐步展示以上章节内容,读者将能够全面了解Java中Filter中contains方法及其相应知识点,并在实际开发中灵活应用和优化这一方法。
2. Java中的Filter简介2.1 Filter概述在Java中,Filter是一种用于处理数据集合的工具,它提供了多种方法来过滤和操作数据。
Filter的主要作用是对集合中的元素进行筛选,只保留满足特定条件的元素。
在Java开发中,经常会遇到需要对数据进行筛选和处理的场景,而Filter正是为此而生。
2.2 Filter中的contains方法简介其中,在Java中的Filter类中,包含了一个常用的方法叫做contains()。
这个方法用于判断一个集合是否包含某个特定元素。
它接收一个参数作为待检查是否存在于集合中的元素,并返回一个布尔值来表示结果。
Java面试题之《过滤器与拦截器的区别》
Java⾯试题之《过滤器与拦截器的区别》过滤器与拦截器的区别过滤器,是在java web中,你传⼊的request,response提前过滤掉⼀些信息,或者提前设置⼀些参数,然后再传⼊servlet或者struts的 action 进⾏业务逻辑,⽐如过滤掉⾮法url(不是login.do的地址请求,如果⽤户没有登陆都过滤掉),或者在传⼊servlet或者 struts的action前统⼀设置字符集,或者去除掉⼀些⾮法字符拦截器,是在⾯向切⾯编程的就是在你的service或者⼀个⽅法,前调⽤⼀个⽅法,或者在⽅法后调⽤⼀个⽅法⽐如动态代理就是拦截器的简单实现,在你调⽤⽅法前打印出字符串(或者做其它业务逻辑的操作),也可以在你调⽤⽅法后打印出字符串,甚⾄在你抛出异常的时候做业务逻辑的操作。
拦截器与过滤器的区别:1. 拦截器是基于java的反射机制的,⽽过滤器是基于函数回调。
2. 拦截器不依赖与servlet容器,过滤器依赖与servlet容器。
3. 拦截器只能对action请求起作⽤,⽽过滤器则可以对⼏乎所有的请求起作⽤。
4. 拦截器可以访问action上下⽂、值栈⾥的对象,⽽过滤器不能访问。
5. 在action的⽣命周期中,拦截器可以多次被调⽤,⽽过滤器只能在容器初始化时被调⽤⼀次6. 拦截器可以获取IOC容器中的各个bean,⽽过滤器就不⾏,这点很重要,在拦截器⾥注⼊⼀个service,可以调⽤业务逻辑。
执⾏顺序:过滤前 - 拦截前 - Action处理 - 拦截后 - 过滤后。
个⼈认为过滤是⼀个横向的过程,⾸先把客户端提交的内容进⾏过滤(例如未登录⽤户不能访问内部页⾯的处理);过滤通过后,拦截器将检查⽤户提交数据的验证,做⼀些前期的数据处理,接着把处理后的数据发给对应的Action;Action处理完成返回后,拦截器还可以做其他过程(还没想到要做啥),再向上返回到过滤器的后续操作。
拦截器与过滤器使⽤场景:SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,⽤于对处理器进⾏预处理和后处理。
java使用过滤器实现登录拦截处理
java使⽤过滤器实现登录拦截处理⽬录滤器实现登录拦截处理⼀、什么是过滤器⼆、⼯作原理及⽣命周期三、过滤器使⽤filter简易实现登录功能拦截LoginFlitercontroller结果图滤器实现登录拦截处理⼀、什么是过滤器过滤器是处于客户端与服务器资源⽂件之间的⼀道过滤⽹(驻留在服务器端的Web组件),在访问资源⽂件之前,通过⼀系列的过滤器对请求进⾏修改、判断等,把不符合规则的请求在中途拦截或修改。
也可以对响应进⾏过滤,拦截或修改响应⼆、⼯作原理及⽣命周期举个例⼦当我们登录系统可以访问到页⾯,当退出登录后,要访问就必须重新登录,这就是过滤器起到的作⽤。
当我们访问某个接⼝时,过滤器会拦截请求,判断当前⽤户是否是登录状态,若登录则放⾏访问,若未登录则返回指定页⾯(通常为登录页或⼀个客户友好的提⽰页)这个过程包含了过滤器的⽣命周期:1.实例化2.初始化3.执⾏过滤操作(包括访问前对request操作和返回时对response的操作处理)4.销毁三、过滤器使⽤在springboot项⽬简单使⽤过滤器进⾏登录拦截处理1.实现过滤器public class MyFilter implements Filter {private static final String CURRENT_USER = "current_user";//配置⽩名单protected static List<Pattern> patterns = new ArrayList<Pattern>();//静态代码块,在虚拟机加载类的时候就会加载执⾏,⽽且只执⾏⼀次static {patterns.add(pile("/index"));patterns.add(pile("/login"));patterns.add(pile("/register"));}@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper(httpResponse);String url = httpRequest.getRequestURI().substring(httpRequest.getContextPath().length());if (isInclude(url)) {//在⽩名单中的url,放⾏访问filterChain.doFilter(httpRequest, httpResponse);return;}if (SessionUtils.getSessionAttribute(CURRENT_USER) != null) {//若为登录状态放⾏访问filterChain.doFilter(httpRequest, httpResponse);return;} else {//否则默认访问index接⼝wrapper.sendRedirect("/index");}}@Overridepublic void destroy() {}//判断当前请求是否在⽩名单private boolean isInclude(String url) {for (Pattern pattern : patterns) {Matcher matcher = pattern.matcher(url);if (matcher.matches()) {return true;}}return false;}}2.注册过滤器@Configurationpublic class WebConfig {/*** 配置过滤器* @return*/@Beanpublic FilterRegistrationBean someFilterRegistration() {FilterRegistrationBean registration = new FilterRegistrationBean();registration.setFilter(myFilter());//拦截/*的访问多级匹配(springboot 过滤器/*以及匹配 /**多级匹配)registration.addUrlPatterns("/*");registration.setName("myFilter");return registration;}/*** 创建⼀个bean* @return*/@Bean(name = "myFilter")public Filter myFilter() {return new MyFilter();}}3.运⾏项⽬访问/index,会发现没有被拦截,返回正确结果在未登录状态,访问/update接⼝,会被拦截跳转⾄/index页在登录状态,访问/update接⼝,可以访问这⾥也可以在程序debug看下。
java 中filter过滤器使用方法
Java 中filter 过滤器的使用:Servlets Filter 是Servlet 2.3 规范中新增加的,它是截取用户从客户端提交的请求,在还没有到达需要访问的资源时运行的一个类。
它操纵来自客户端的请求,在资源还没有初发送到客户端前截取响应,并处理这些还没有发送到客户端的响应。
Filters 有许多的应用场合。
Servlet 2.3 规范建议如下的地方可以应用Filter:authentication filterslogging and auditing filtersimage conversion filtersdata compression filtersencryption filterstokenizing filtersfilters that trigger resource access eventsXSL/T filters that transform XML contentMIME-type chain filters如何实现一个过滤器呢?1.所在的类实现Filter接口public interface Filterpublic void init(FilterConfig filterConfig)throws ServletException过滤器初始化是在容器启动时自动初始化public void doFilter(ServletRequest request,ServletResponse response,FilterChainchain)throws IOException,ServletExcepton在标准Servlet中的doGet或doPost 方法中,传递参数为:HttpServletRequest、HttpServletResponse过滤器销毁public void destroy()例:如下为过滤器基本的主要结构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;public class MyFirstFilter implements Filter{private String encoding;public void destroy(){System.out.println("过滤器销毁");}public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {System.out .println("过滤doFilter");chain.doFilter(request, response);}public void init(FilterConfig filterConfig) throws ServletException {System.out .println("过滤器初始化"); encoding = filterConfig.getInitParameter("encoding"}对应配置文件:<filter ><filter-name >encodingFilter </filter-name ><filter-class >com.shen.test.filter. MyFirstFilter </filter-class ><init-param ><param-name >encoding </param-name ><param-value >Shift_JIS </param-value ></init-param ></filter ><filter-mapping ><filter-name >encodingFilter </filter-name ><servlet-name >action </servlet-name ></filter-mapping ><servlet ><init-param ><<param-value >/WEB-INF/config/struts-config.xml,/WEB-INF/config/st ruts-config-contents.xml </param-value ></init-param ><init-param><param-name>debug</param-name><param-value>2</param-value></init-param><init-param><param-name>detail</param-name><param-value>2</param-value></init-param><load-on-startup>1</load-on-startup></servlet>如果过滤器要将内容传递到目的地,则需要FilterChain,将请求继续向下转发过滤器也会执行两次:FilterChain之前执行一次,之后再执行一次2:对某些文字进行过滤关键方法如下所示:public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {System.out.println("过滤doFilter");//从页面获取内容String content=request.getParameter("content");String filterchar ="色";if(content != null && !"".equals(content)){//如果indexOf返回-1则表示没有查到所要的内容if(-1 == content.indexOf(filterchar)){chain.doFilter(request, response);}else{System.out.println("有非法文字");//可以继续做处理//如果需要的话,此处依然可以使用RequestDispatcher进行跳转}}}3:设置统一编码/*** 对内容进行统一的编码*/request.setCharacterEncoding("GBK");response.setCharacterEncoding("GBK");4:登录验证:/*** 登陆验证*/public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {/*** 登陆验证*///Session属于http范畴,把以ServletRequest对象需要先转换成HttpServletRequest对象HttpServletRequest hrequest =(HttpServletRequest) request;HttpSession session =hrequest.getSession();//request.getScheme();request.getServerName();request.getServerPo rt();//如果session不为空,则可以浏览其它页面if(null != session.getAttribute("username")){chain.doFilter(request, response);}else{//通过requestDispatcher跳转到登陆面request.getRequestDispatcher("login.jsp").forward(request,respons e);}}第二部分:javax.servlet.Filter详细介绍:过滤器(Filter)位于客户端和web应用程序之间,用于检查和修改两者之间流过的请求和响应。
JavaWeb过滤器详解
JavaWeb过滤器详解过滤器是什么玩意?所谓过滤器,其实就是⼀个服务端组件,⽤来截取⽤户端的请求与响应信息。
过滤器的应⽤场景:1.对⽤户请求进⾏统⼀认证,保证不会出现⽤户账户安全性问题2.编码转换,可在服务端的过滤器中设置统⼀的编码格式,避免出现乱码3.对⽤户发送的数据进⾏过滤替换4.转换图像格式5.对响应的内容进⾏压缩其中,第1,2场景经常涉及。
login.jsp<%@ page language="java" import="java.util.*" contentType="text/html; charset=utf-8"%><%String path = request.getContextPath();String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><base href="<%=basePath%>"><title>My JSP 'login.jsp' starting page</title><meta http-equiv="pragma" content="no-cache"><meta http-equiv="cache-control" content="no-cache"><meta http-equiv="expires" content="0"><meta http-equiv="keywords" content="keyword1,keyword2,keyword3"><meta http-equiv="description" content="This is my page"><!--<link rel="stylesheet" type="text/css" href="styles.css">--></head><body><form action="<%=path %>/servlet/LoginServlet" method="post" >⽤户名:<input type="text" name="username" />密码:<input type="password" name="password" /><input type="submit" value="登录" /></form></body></html>success.jsp<%@ page language="java" import="java.util.*" pageEncoding="utf-8" contentType="text/html; charset=utf-8"%> <%String path = request.getContextPath();String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><head><base href="<%=basePath%>"><title>My JSP 'index.jsp' starting page</title><meta http-equiv="pragma" content="no-cache"><meta http-equiv="cache-control" content="no-cache"><meta http-equiv="expires" content="0"><meta http-equiv="keywords" content="keyword1,keyword2,keyword3"><meta http-equiv="description" content="This is my page"><!--<link rel="stylesheet" type="text/css" href="styles.css">--></head><body></body></html>failure.jsp<%@ page language="java" import="java.util.*" contentType="text/html; charset=utf-8"%><%String path = request.getContextPath();String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><base href="<%=basePath%>"><title>My JSP 'login.jsp' starting page</title><meta http-equiv="pragma" content="no-cache"><meta http-equiv="cache-control" content="no-cache"><meta http-equiv="expires" content="0"><meta http-equiv="keywords" content="keyword1,keyword2,keyword3"><meta http-equiv="description" content="This is my page"><!--<link rel="stylesheet" type="text/css" href="styles.css">--></head><body>登录失败,请检查⽤户名或密码!</body></html>LoginFilter.javapackage com.cityhuntshou.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;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;public class LoginFilter implements Filter {private FilterConfig config;public void destroy() {}public void doFilter(ServletRequest arg0, ServletResponse arg1,FilterChain arg2) throws IOException, ServletException {HttpServletRequest request = (HttpServletRequest) arg0;HttpServletResponse response = (HttpServletResponse) arg1;HttpSession session = request.getSession();//过滤器实际应⽤场景之⼆-----编码转换String charset = config.getInitParameter("charset");if(charset == null){charset = "UTF-8";request.setCharacterEncoding(charset);String noLoginPaths = config.getInitParameter("noLoginPaths");if(noLoginPaths != null){String[] strArray = noLoginPaths.split(";");for(int i = 0; i < strArray.length; i++){//空元素,放⾏if(strArray[i] == null || "".equals(strArray[i]))continue;if(request.getRequestURI().indexOf(strArray[i]) != -1){arg2.doFilter(arg0, arg1);return;}}}if(request.getRequestURI().indexOf("login.jsp") != -1|| request.getRequestURI().indexOf("LoginServlet") != -1){arg2.doFilter(arg0, arg1);return;}if(session.getAttribute("username") != null){arg2.doFilter(arg0, arg1);}else{response.sendRedirect("login.jsp");}}public void init(FilterConfig arg0) throws ServletException {config = arg0;}}LoginServlet.javapackage com.cityhuntshou.servlet;import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;public class LoginServlet extends HttpServlet {/*** Constructor of the object.*/public LoginServlet() {super();}/*** Destruction of the servlet. <br>*/public void destroy() {super.destroy(); // Just puts "destroy" string in log// Put your code here}/*** The doGet method of the servlet. <br>** This method is called when a form has its tag value method equals to get. ** @param request the request send by the client to the server* @param response the response send by the server to the client* @throws ServletException if an error occurred* @throws IOException if an error occurred*/}/*** The doPost method of the servlet. <br>** This method is called when a form has its tag value method equals to post.** @param request the request send by the client to the server* @param response the response send by the server to the client* @throws ServletException if an error occurred* @throws IOException if an error occurred*/public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {String username = request.getParameter("username");String password = request.getParameter("password");//new String(username.getBytes("ISO-8859-1"),"UTF-8")System.out.println(username);if("admin".equals(username) && "admin".equals(password)){//校验通过HttpSession session = request.getSession();session.setAttribute("username", username);response.sendRedirect(request.getContextPath()+"/success.jsp");}else{//校验失败response.sendRedirect(request.getContextPath()+"/failure.jsp");}}/*** Initialization of the servlet. <br>** @throws ServletException if an error occurs*/public void init() throws ServletException {// Put your code here}}web.xml<?xml version="1.0" encoding="UTF-8"?><web-app version="2.5"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd"><display-name></display-name><servlet><description>This is the description of my J2EE component</description><display-name>This is the display name of my J2EE component</display-name> <servlet-name>LoginServlet</servlet-name><servlet-class>com.cityhuntshou.servlet.LoginServlet</servlet-class></servlet><servlet-mapping><servlet-name>LoginServlet</servlet-name><url-pattern>/servlet/LoginServlet</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list><filter><filter-name>LoginFilter</filter-name><filter-class>com.cityhuntshou.filter.LoginFilter</filter-class><init-param><param-name>noLoginPaths</param-name><param-value>login.jsp;failure.jsp;loginServlet</param-value></init-param><init-param><param-name>charset</param-name><param-value>UTF-8</param-value></init-param></filter><filter-mapping><filter-name>LoginFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>访问结果:以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
java-过滤器Filter_多个Filter的执行顺序
java-过滤器Filter_多个Filter的执⾏顺序【Filter链】*在⼀个web应⽤中,可以开发编写多个Filter,这些Filter组合起来称为⼀个Filter链。
*web服务器根据Filter在web.xml中的注册顺序,决定先调⽤哪个Filter,当第⼀个Filter的doFilter⽅法被调⽤时,web服务器会创建⼀个代表Filter链的FilterChain对象传递给该⽅法,在doFilter⽅法中,开发⼈员如果调⽤了FilterChain对象的doFilter⽅法,则web服务器会检查FilterChain对象中是否还有filter,如果有,则调⽤第⼆个filter,如果没有,则调⽤⽬标资源。
【⼯程截图】设计了两个Filter和⼀个Servlet,访问Servlet时,查看Filter的执⾏顺序。
【web.xml】<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance" xmlns="/xml/ns/javaee" xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" <display-name>FilterDemo01</display-name><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list><!-- 过滤顺序:谁的写在上⾯,谁先被过滤 --><filter><filter-name>FilterTest01</filter-name><filter-class>com.Higgin.web.filter.FilterTest01</filter-class></filter><filter-mapping><filter-name>FilterTest01</filter-name><url-pattern>/*</url-pattern> <!-- 过滤所有 --></filter-mapping><filter><filter-name>FilterTest02</filter-name><filter-class>com.Higgin.web.filter.FilterTest02</filter-class></filter><filter-mapping><filter-name>FilterTest02</filter-name><url-pattern>/*</url-pattern> <!-- 过滤所有 --></filter-mapping></web-app>【FilterTest01.java】package com.Higgin.web.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;public class FilterTest01 implements Filter{@Overridepublic void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {System.out.println("FilterTest01 执⾏前---");chain.doFilter(request, response);//让⽬标资源执⾏,即:放⾏System.out.println("FilterTest01 执⾏后---");}@Overridepublic void init(FilterConfig arg0) throws ServletException {}@Overridepublic void destroy() {}}【FilterTest02.java】package com.Higgin.web.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;public class FilterTest02 implements Filter{@Overridepublic void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {System.out.println("FilterTest02 执⾏前---");chain.doFilter(request, response); //放⾏System.out.println("FilterTest02 执⾏后---");}@Overridepublic void init(FilterConfig arg0) throws ServletException {}@Overridepublic void destroy() {}}【ServletTest01.java】package com.Higgin.web.servlet;import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;/*** Servlet implementation class ServletTest01*/@WebServlet("/ServletTest01")public class ServletTest01 extends HttpServlet {private static final long serialVersionUID = 1L;public ServletTest01() {super();}protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //response.getWriter().write("中国加油!China Come on!");System.out.println("执⾏ServletTest01---");}protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request,response);}}【运⾏结果】在浏览器中输⼊:http://localhost:8080/FilterDemo01/ServletTest01查看控制台输出结果⾃⼰可以尝试分别注释FilterTest01和FilterTest02中的chain.doFilter⽅法,⽤Junit查看具体的执⾏过程。
java interceptorregistry 实现原理
java interceptorregistry 实现原理摘要:1.Java 拦截器的概念和作用2.InterceptorRegistry 的定义和功能3.InterceptorRegistry 的实现原理4.实例分析5.总结正文:1.Java 拦截器的概念和作用Java 拦截器(Interceptor)是一种可以在请求处理之前或之后执行的特殊类型的过滤器。
拦截器的主要作用是在请求处理过程中,对请求进行预处理或后处理,以达到对请求内容进行修改、验证等目的。
在Java Web 开发中,拦截器广泛应用于权限控制、日志记录、参数校验等场景。
2.InterceptorRegistry 的定义和功能InterceptorRegistry 是Java 中的一个接口,它用于管理拦截器(Interceptor)的注册和添加。
InterceptorRegistry 的主要功能是提供一个容器,用于存放各种拦截器,以便在请求处理过程中调用这些拦截器。
简单来说,InterceptorRegistry 就是一个拦截器注册表,它负责将拦截器与特定的URL 或资源映射关联起来。
3.InterceptorRegistry 的实现原理InterceptorRegistry 的实现原理主要基于Java 的观察者设计模式(Observer Pattern)。
观察者设计模式是一种松耦合的设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生改变时,它的所有依赖者(观察者)都会收到通知并自动更新。
在InterceptorRegistry 中,每一个拦截器都是一个观察者,而InterceptorRegistry 则是一个被观察者(Subject)。
当InterceptorRegistry 中的某个拦截器需要被执行时,InterceptorRegistry 会将这个拦截器添加到它的拦截器列表中。
然后,InterceptorRegistry 会遍历这个列表,找到与请求URL 或资源匹配的拦截器,并将这些拦截器按照指定的顺序执行。
filter过滤器原理
filter过滤器原理Filter过滤器是Java Servlet规范中的一个重要组成部分,它主要用于Web应用程序中对请求或响应进行一些处理或修改。
Filter过滤器能够拦截客户端请求和响应,并对其进行一些预处理或后处理,同时不对底层资源进行任何的改变。
在Web应用程序中,客户端的请求会按照一定的顺序被多个过滤器拦截,最后才会到达目标Servlet或JSP页面。
过滤器的拦截顺序是由web.xml文件中的顺序决定的,顺序越靠前的过滤器越先拦截请求。
Filter过滤器的工作过程可以用下面的流程来描述:1、当客户端发起请求时,服务器会根据客户端请求的URL找到相应的Servlet或JSP 页面。
2、在Servlet或JSP页面被执行之前,在过滤器链中的第一个过滤器会被调用。
这个过滤器可以实现一些真正的过滤操作,比如验证用户身份等。
3、当第一个过滤器完成处理后,请求会按照web.xml文件中定义的顺序,依次经过它后面的过滤器。
4、如果过滤器链中有多个过滤器,请求将根据它们的顺序进行处理。
当请求到达最后一个过滤器时,如果没有被任何一个过滤器拦截,则将请求传递给目标Servlet或JSP 页面。
5、在Servlet或JSP页面处理请求并生成响应后,响应会按照相反的顺序经过过滤器链中的过滤器进行处理或修改,最终响应到达客户端。
通过使用Filter过滤器,可以有效的将Web应用程序的功能模块拆分成多个独立的模块,这些模块可以按照一定的顺序调用,扩展或修改Web应用程序的行为。
具体的优点包括:1、实现模块可复用性:在一个应用程序中,多个模块可能会需要进行相同或相似的过滤操作,而使用Filter可以将这些操作独立出来,易于重复使用。
2、抽象控制流:通过使用Filter可以抽象出整个请求和响应的控制流,实现更细粒度的控制。
3、有效的处理URL:通过Filter可以有效的处理URL,实现URL的解析和路由处理。
4、可扩展性:在Web应用程序中,Filter可以很方便的进行增加、删除或修改,从而实现Web应用程序的功能扩展。
dofilter过滤器的原理
dofilter过滤器的原理dofilter过滤器是指在JavaEE中Servlet规范中的一种过滤器,它可以拦截客户端请求,修改请求和响应,或者执行一些特定的任务。
它的原理主要是基于责任链模式和回调函数机制。
首先,dofilter过滤器是通过实现javax.servlet.Filter接口来实现的,该接口定义了三个方法,init、doFilter和destroy。
init方法在过滤器被初始化时调用,可以用来进行一些初始化操作;doFilter方法是过滤器的核心,它接收客户端请求和响应对象,并可以在请求到达Servlet之前对请求进行预处理,也可以在响应返回客户端之前对响应进行后处理;destroy方法在过滤器被销毁时调用,可以用来进行一些资源的释放操作。
其次,dofilter过滤器的原理是基于责任链模式。
当一个请求到达Servlet容器时,容器会按照过滤器在web.xml文件中的配置顺序依次调用各个过滤器的doFilter方法,然后再调用Servlet的service方法。
这样就形成了一个责任链,每个过滤器都可以对请求进行处理,然后将请求传递给下一个过滤器,或者传递给Servlet。
另外,dofilter过滤器的原理还涉及到回调函数机制。
当容器调用过滤器的doFilter方法时,实际上是在调用过滤器中的回调函数,这些回调函数可以在特定的时机对请求和响应进行处理,比如在请求到达时进行身份验证、日志记录等操作,或者在响应返回时进行数据加工、页面重定向等操作。
总的来说,dofilter过滤器的原理是基于责任链模式和回调函数机制,它可以对客户端请求和响应进行拦截和处理,实现一些特定的功能,比如日志记录、身份验证、字符编码转换等。
希望这个回答能够全面地解释dofilter过滤器的原理。
java中filter用法
在Java中,"filter" 一词通常与集合数据和Stream API相关联。
Java提供了一种称
为过滤器(Filter)的机制,它允许你通过指定条件来筛选集合中的元素。
在Java 中,过滤器通常与Lambda表达式和Stream API一起使用,以便更轻松地编写简洁、可读的代码。
以下是在Java中使用过滤器的一些常见场景和示例:
1. 使用 Stream 的filter方法:
假设有一个包含整数的列表,我们想要过滤出所有偶数:
2. 使用 Stream 的filter和map方法:
在这个例子中,我们筛选出长度大于3的字符串,并将它们转换为大写:
这里的filter方法用于筛选长度大于3的字符串,而map方法用于将它们转换为大写。
3. 使用Predicate自定义过滤条件:
有时候,我们可能想要定义一个自定义的过滤条件,这时可以使用Predicate接口:
这里的customFilter是一个自定义的Predicate,它筛选以字母 "a" 开头的字符串。
总体来说,Java中的过滤器主要使用Stream API中的filter方法,结合Lambda表达式来实现集合元素的条件筛选。
XSS过滤JAVA过滤器filter防止常见SQL注入
XSS过滤JAVA过滤器filter防⽌常见SQL注⼊Java项⽬中XSS过滤器的使⽤⽅法。
简单介绍:XSS : 跨站脚本攻击(Cross Site Scripting),为不和层叠样式表(Cascading Style Sheets, CSS)的缩写混淆,故将跨站脚本攻击缩写为XSS。
恶意攻击者往Web页⾯⾥插⼊恶意html代码,当⽤户浏览该页之时,嵌⼊其中Web⾥⾯的html代码会被执⾏,从⽽达到恶意攻击⽤户的特殊⽬的。
sql注⼊所谓SQL注⼊,就是通过把SQL命令插⼊到Web表单提交或输⼊域名或页⾯请求的查询字符串,最终达到欺骗服务器执⾏恶意的SQL命令。
具体来说,它是利⽤现有应⽤程序,将(恶意)的SQL命令注⼊到后台数据库引擎执⾏的能⼒,它可以通过在Web表单中输⼊(恶意)SQL 语句得到⼀个存在安全漏洞的⽹站上的数据库,⽽不是按照设计者意图去执⾏SQL语句。
实现⽅式,共三步:第⼀步:配置web.xml<filter><filter-name>xssFilter</filter-name><filter-class>com.wfcm.xss.XssFilter</filter-class></filter><filter-mapping><filter-name>xssFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>第⼆步:过滤⼯具类1.XSSFilter.javapackage com.wfcm.xss;import javax.servlet.*;import javax.servlet.http.HttpServletRequest;import java.io.IOException;/*** xss过滤* @author xlf* @email xlfbe696@* @date 2017年4⽉19⽇上午10:41:42*/public class XssFilter implements Filter {@Overridepublic void init(FilterConfig config) throws ServletException {}public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper((HttpServletRequest) request);chain.doFilter(xssRequest, response);}@Overridepublic void destroy() {}}View Code2.XssHttpServletRequestWrapperpackage com.wfcm.xss;import ng.StringEscapeUtils;import ng.StringUtils;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletRequestWrapper;import java.util.LinkedHashMap;import java.util.Map;public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper { // 没被包装过的HttpServletRequest(特殊场景,需求⾃⼰过滤)HttpServletRequest orgRequest;// html过滤private final static HTMLFilter htmlFilter = new HTMLFilter();public XssHttpServletRequestWrapper(HttpServletRequest request) {super(request);orgRequest = request;}@Overridepublic String getParameter(String name) {String value = super.getParameter(xssEncode(name));if (StringUtils.isNotBlank(value)) {value =xssEncode(value);}//SQL注⼊检查// value = SQLFilter.sqlInject(value);value = SQLFilter.sqlInject(value);return StringEscapeUtils.unescapeHtml(value);}@Overridepublic 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]);//SQL注⼊检查// parameters[i] = SQLFilter.sqlInject(parameters[i]);parameters[i] = SQLFilter.sqlInject(parameters[i]);parameters[i] = StringEscapeUtils.unescapeHtml(parameters[i]);}return parameters;}@Overridepublic 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]);//SQL注⼊检查// values[i] = SQLFilter.sqlInject(values[i]);values[i] = SQLFilter.sqlInject(values[i]);values[i] = StringEscapeUtils.unescapeHtml(values[i]);}map.put(key, values);}return map;}@Overridepublic String getHeader(String name) {String value = super.getHeader(xssEncode(name));if (StringUtils.isNotBlank(value)) {value = xssEncode(value);}//SQL注⼊检查// value = SQLFilter.sqlInject(value);value = SQLFilter.sqlInject(value);return StringEscapeUtils.unescapeHtml(value);}private String xssEncode(String input) {return htmlFilter.filter(input);}/*** 获取最原始的request*/public HttpServletRequest getOrgRequest() {return orgRequest;}/*** 获取最原始的request*/public static HttpServletRequest getOrgRequest(HttpServletRequest request) {if (request instanceof XssHttpServletRequestWrapper) {return ((XssHttpServletRequestWrapper) request).getOrgRequest();}return request;}}View Code3.HTMLFilterpackage com.wfcm.xss;import java.util.ArrayList;import java.util.Collections;import java.util.HashMap;import java.util.List;import java.util.Map;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;/**** HTML filtering utility for protecting against XSS (Cross Site Scripting).** This code is licensed LGPLv3** This code is a Java port of the original work in PHP by Cal Hendersen.* /php/lib_filter/** The trickiest part of the translation was handling the differences in regex handling* between PHP and Java. These resources were helpful in the process:** /j2se/1.4.2/docs/api/java/util/regex/Pattern.html* /manual/en/reference.pcre.pattern.modifiers.php* /modifiers.html** A note on naming conventions: instance variables are prefixed with a "v"; global* constants are in all caps.** Sample use:* String input = ...* String clean = new HTMLFilter().filter( input );** The class is not thread safe. Create a new instance if in doubt.** If you find bugs or have suggestions on improvement (especially regarding* performance), please contact us. The latest version of this* source, and our contact details, can be found at ** @author Joseph O'Connell* @author Cal Hendersen* @author Michael Semb Wever*/public 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 = pile("<!--(.*?)-->", Pattern.DOTALL);private static final Pattern P_COMMENT = pile("^!--(.*)--$", REGEX_FLAGS_SI);private static final Pattern P_TAGS = pile("<(.*?)>", Pattern.DOTALL);private static final Pattern P_END_TAG = pile("^/([a-z0-9]+)", REGEX_FLAGS_SI);private static final Pattern P_START_TAG = pile("^([a-z0-9]+)(.*?)(/?)$", REGEX_FLAGS_SI);private static final Pattern P_QUOTED_ATTRIBUTES = pile("([a-z0-9]+)=([\"'])(.*?)\\2", REGEX_FLAGS_SI); private static final Pattern P_UNQUOTED_ATTRIBUTES = pile("([a-z0-9]+)(=)([^\"\\s']+)", REGEX_FLAGS_SI); private static final Pattern P_PROTOCOL = pile("^([^:]+):", REGEX_FLAGS_SI);private static final Pattern P_ENTITY = pile("&#(\\d+);?");private static final Pattern P_ENTITY_UNICODE = pile("&#x([0-9a-f]+);?");private static final Pattern P_ENCODE = pile("%([0-9a-f]{2});?");private static final Pattern P_VALID_ENTITIES = pile("&([^&;]*)(?=(;|&|$))");private static final Pattern P_VALID_QUOTES = pile("(>|^)([^<]+?)(<|$)", Pattern.DOTALL);private static final Pattern P_END_ARROW = pile("^>");private static final Pattern P_BODY_TO_END = pile("<([^>]*?)(?=<|$)");private static final Pattern P_XML_CONTENT = pile("(^|>)([^<]*?)(?=>)");private static final Pattern P_STRAY_LEFT_ARROW = pile("<([^>]*?)(?=<|$)");private static final Pattern P_STRAY_RIGHT_ARROW = pile("(^|>)([^<]*?)(?=>)");private static final Pattern P_AMP = pile("&");private static final Pattern P_QUOTE = pile("\"");private static final Pattern P_LEFT_ARROW = pile("<");private static final Pattern P_RIGHT_ARROW = pile(">");private static final Pattern P_BOTH_ARROWS = pile("<>");private static final Pattern P_DOUBLE_QUOT = pile(""");// @xxx could grow large... maybe use sesat's ReferenceMapprivate 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> a_atts = new ArrayList<String>();a_atts.add("href");a_atts.add("target");vAllowed.put("a", a_atts);final ArrayList<String> img_atts = new ArrayList<String>();img_atts.add("src");img_atts.add("width");img_atts.add("height");img_atts.add("alt");vAllowed.put("img", img_atts);final ArrayList<String> no_atts = new ArrayList<String>();vAllowed.put("b", no_atts);vAllowed.put("strong", no_atts);vAllowed.put("i", no_atts);vAllowed.put("em", no_atts);vSelfClosingTags = new String[]{"img"};vNeedClosingTags = new String[]{"a", "b", "strong", "i", "em"};vDisallowed = new String[]{};vAllowedProtocols = new String[]{"http", "mailto", "https"}; // no ftp.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.*/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 functionspublic 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, "&", result);result = regexReplace(P_QUOTE, """, result);result = regexReplace(P_LEFT_ARROW, "<", result);result = regexReplace(P_RIGHT_ARROW, ">", 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, "<$1", s);s = regexReplace(P_STRAY_RIGHT_ARROW, "$1$2><", 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, pile("<" + 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, pile("<" + tag + "(\\s[^>]*)?/>"));}result = regexReplace(P_REMOVE_SELF_BLANKS.get(tag), "", result);}return result;}private static String regexReplace(final Pattern regex_pattern, final String replacement, final String s) {Matcher m = regex_pattern.matcher(s);return m.replaceAll(replacement);}private String processTag(final String s) {// ending tagsMatcher 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 tagsm = 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()) {paramNames.add(m2.group(1)); //([a-z0-9]+)paramValues.add(m2.group(3)); //(.*?)}while (m3.find()) {paramNames.add(m3.group(1)); //([a-z0-9]+)paramValues.add(m3.group(3)); //([^\"\\s']+)}String paramName, paramValue;for (int ii = 0; ii < paramNames.size(); ii++) {paramName = paramNames.get(ii).toLowerCase();paramValue = paramValues.get(ii);// debug( "paramName='" + paramName + "'" );// debug( "paramValue='" + paramValue + "'" );// debug( "allowed? " + vAllowed.get( name ).contains( paramName ) );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 "";}}// commentsm = 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 insteads = "#" + s.substring(protocol.length() + 1, s.length());if (s.startsWith("#//")) {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 stringMatcher 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, """, 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: "&" + 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));}}View Code4.SQLFilterpackage com.wfcm.xss;import ng.StringUtils;import com.wfcm.utils.RRException;/*** sql过滤** @author xlf* @email xlfbe696@* @date 2017年4⽉19⽇上午10:41:25*/public class SQLFilter {/*** SQL注⼊过滤** @param str* 待验证的字符串*/public static String sqlInject(String str) {if (StringUtils.isBlank(str)) {return null;}// 去掉'|"|;|\字符str = StringUtils.replace(str, "'", "");str = StringUtils.replace(str, "\"", "");str = StringUtils.replace(str, ";", "");str = StringUtils.replace(str, "\\", "");// 转换成⼩写str = str.toLowerCase();// ⾮法字符String[] keywords = { "master", "truncate", "insert", "select", "delete", "update", "declare", "alert", "create", "drop" };// 判断是否包含⾮法字符for (String keyword : keywords) {if (str.equals(keyword)) {throw new RRException("包含⾮法字符", 1);}}return str;}}View Code第三步:⼤功告成!!。
java queryfilter withparam用法 -回复
java queryfilter withparam用法-回复Java QueryFilter withParam用法详解在Java开发中,我们经常需要对数据进行过滤和查询操作。
Java QueryFilter(查询过滤器)是一种用于快速过滤和查询数据的工具,而withParam则是QueryFilter的一个重要方法,用于指定过滤器的筛选条件。
本文将详细介绍Java QueryFilter的使用方法,并逐步解释withParam的用法。
一、QueryFilter简介QueryFilter是一种简单而强大的Java工具,用于在集合或数据库中执行高效的查询和过滤操作。
它提供了一系列的查询方法,可以按照不同的条件进行排序、筛选和分页进行数据查询。
QueryFilter的核心思想是将查询条件封装成一个对象,并通过链式调用方法来指定不同的查询条件和配置,从而实现快速查询和过滤。
二、withParam方法withParam是QueryFilter提供的一个方法,用于指定过滤器的筛选条件。
它接受两个参数,第一个参数是需要筛选的字段名,第二个参数是字段值。
通过调用withParam方法,我们可以向QueryFilter中添加一个筛选条件,从而实现更精确的查询和过滤。
三、使用withParam进行数据查询为了更好地理解withParam的用法,我们将通过一个实例来演示它的具体使用方法。
假设我们有一个User对象的列表,每个User对象都有id、name和age属性。
我们需要根据不同的条件来查询和筛选User对象的列表。
首先,我们需要创建一个QueryFilter对象,代码如下:QueryFilter<User> filter = new QueryFilter<>();接下来,我们可以通过withParam方法来添加筛选条件,代码如下:filter.withParam("age", 18);上述代码表示我们筛选age字段为18的User对象。
java过滤器的工作原理
java过滤器的工作原理
过滤器是Java Web应用程序中的组件,用于对请求和响应进行预处理和后处理。
它的工作原理如下:
1. 客户端发起请求到服务器,请求首先会经过过滤器。
2. 过滤器对请求进行拦截,并可以在请求到达目标资源之前进行预处理操作,如验证用户身份、检查请求参数等。
3. 过滤器可以修改请求的内容,比如添加、修改或删除请求头信息。
4. 过滤器将处理后的请求传递给下一个过滤器或目标资源。
5. 目标资源处理请求并生成响应。
6. 响应首先会经过与请求相反的过滤器链,过滤器可以在响应返回客户端之前进行后处理操作,如对响应内容进行压缩、加密等。
7. 过滤器可以修改响应的内容,比如修改响应头信息、添加新的响应内容等。
8. 经过所有的过滤器链后,响应将返回给客户端。
通过这个过程,过滤器可以对请求和响应进行拦截、加工和修改,实现对Web应用程序的统一处理和控制。
过滤器的工作
原理使得开发者可以在不修改目标资源的情况下,对请求和响应进行控制,提高代码的复用性和可维护性。
Java8过滤器(Filter)
Java8过滤器(Filter)1、在Java之前对List进⾏过滤的⽅式public class BeforeJava8 {public static void main(String[] args) {List<Person> peoples = Arrays.asList(new Person("java", 22),new Person("js", 35),new Person("css", 31));Person result = getStudentByName(peoples, "java");System.out.println(result);}private static Person getStudentByName(List<Person> peoples, String name) {Person result = null;for (Person person : peoples) {if (name.equals(person.getName())) {result = person;}}return result;}}2、在Java8使⽤Filter过滤Listpublic class FilterJava8 {public static void main(String[] args) {List<Person> peoples = Arrays.asList(new Person("java", 22),new Person("js", 35),new Person("css", 31));Person result1 = peoples.stream().filter(p -> "java".equals(p.getName())).findAny().orElse(null);System.out.println(result1);Person result2 = peoples.stream().filter(p -> "spring".equals(p.getName())).findAny().orElse(null);System.out.println(result2);Person result3 = peoples.stream().filter((p) -> "java".equals(p.getName()) && 22 == p.getAge()).findAny().orElse(null);System.out.println(result3);// 使⽤map收集String name = peoples.stream().filter(p -> "js".equals(p.getName())).map(Person::getName).findAny().orElse("");System.out.println(name);System.out.println("---------");List<String> names = peoples.stream().map(Person::getName).collect(Collectors.toList());names.forEach(System.out::println);}}。
java中布隆过滤器写法
布隆过滤器(Bloom Filter)是一种空间效率极高的概率型数据结构,它用来检测一个元素是不是在一个集合里。
它可能会产生错误正例(false positive), 也就是可能会判断元素在集合里,但实际上并不在。
但它不会产生错误反例(false negative),也就是说,如果它判断元素不在集合里,那就肯定不在。
Java中实现布隆过滤器的一个简单例子如下:首先,需要引入`java.util.BitSet`和`java.util.HashMap`,布隆过滤器的主要组成部分是BitSet和HashMap。
```javaimport java.util.BitSet;import java.util.HashMap;import java.util.Map;```然后,定义一个布隆过滤器类:```javapublic class BloomFilter {private static final int DEFAULT_SIZE = 2 << 24;private static final int[] seeds = new int[] { 5, 7, 13, 16, 19, 23, 29, 33 };private BitSet bits = new BitSet(DEFAULT_SIZE);private SimpleHash[] func = new SimpleHash[seeds.length];public BloomFilter() {for (int i = 0; i < seeds.length; i++) {func[i] = new SimpleHash(DEFAULT_SIZE, seeds[i]);}}public void add(String value) {for (SimpleHash f : func) {bits.set(f.hash(value), true);}}public boolean contains(String value) {if (value == null) {return false;}boolean ret = true;for (SimpleHash f : func) {ret = ret && bits.get(f.hash(value));}return ret;}}```这里的`add`方法是用来添加元素到集合中,`contains`方法是用来检测元素是否在集合中。
java过滤器(过滤器排序)
java过滤器(过滤器排序)java过滤器(过滤器排序)定义过滤器顺序是很简单的:匹配请求的过滤器将按照它们出现在部署描述符或者编程式配置中的顺序添加到过滤器链中(记住,如果同时再部署描述符或者编程式配置中设置了⼀些过滤器,那么需要在编程式配置中使⽤addMapping*⽅法的第⼆个参数,决定编程式映射是否应该出现在XML映射之前)。
不同的请求将匹配不同的过滤器,但使⽤的过滤器顺序总是相同的。
不过这个顺序并不是那么简单:URL映射的过滤器优先级⽐Servlet名称映射到的过滤器⾼。
如果两个过滤器都可以匹配某个请求,⼀个是URL模式⽽另⼀个是Servlet名称,那么在过滤器中,由URL模式匹配的过滤器(即使它的映射出现在后⾯)总是出现由Servlet名称匹配的过滤器之前。
有这么⼀段配置:<servlet-mapping><servlet-name>myServlet</servlet-name><url-pattern>/foo*</url-pattern></servlet-mapping><filter-mapping><filter-name>servletFilter</filter-name><url-pattern>myServlet</url-pattern></filter-mapping><filter-mapping><filter-name>myFilter</filter-name><url-pattern>/foo*</url-pattern></filter-mapping><filter-mapping><filter-name>anotherFilter</filter-name><url-pattern>/foo/bar</url-pattern></filter-mapping>如果⼀个普通的请求访问的URL是/foo/bar,那么它将匹配所有这3个过滤器。
java filter用法
Java Filter用法1. 概述Java中的Filter是一种被用于过滤请求和响应的组件。
它可以在请求到达目标资源之前对请求进行预处理,也可以在响应返回给客户端之前对响应进行后处理。
Filter通常被用于实现一些通用的、与业务逻辑无关的功能,如日志记录、权限控制、字符编码转换等。
2. Filter接口在Java中,Filter是一个接口,定义了三个方法:public interface Filter {void init(FilterConfig filterConfig) throws ServletException;void doFilter(ServletRequest request, ServletResponse response, FilterChai n chain) throws IOException, ServletException;void destroy();}•init(FilterConfig filterConfig):在Filter被初始化时调用,可以读取配置信息或者做一些初始化工作。
•doFilter(ServletRequest request, ServletResponse response, FilterChain chain):实际的过滤逻辑需要在这个方法中实现。
在该方法中,可以对请求和响应进行处理,并将处理后的请求和响应传递给下一个Filter或Servlet。
•destroy():在Filter被销毁时调用,可以释放资源或清理工作。
3. 使用Filter要使用Filter,需要按照以下步骤进行配置和编写代码:3.1 配置web.xml首先,在web.xml文件中配置Filter的映射关系。
例如:<filter><filter-name>myFilter</filter-name><filter-class>com.example.MyFilter</filter-class><init-param><param-name>param1</param-name><param-value>value1</param-value></init-param></filter><filter-mapping><filter-name>myFilter</filter-name><url-pattern>/path/*</url-pattern></filter-mapping>上述配置中,我们定义了一个名为myFilter的Filter,并将其映射到了以/path/开头的URL路径上。
Filter过滤器的使用详解
Filter过滤器的使⽤详解⼀.Filter 什么是过滤器1、Filter 过滤器它是 JavaWeb 的三⼤组件之⼀。
三⼤组件分别是:Servlet 程序、Listener 监听器、Filter 过滤器2、Filter 过滤器它是 JavaEE 的规范。
也就是接⼝3、Filter 过滤器它的作⽤是:拦截请求,过滤响应。
拦截请求常见的应⽤场景有:权限检查、⽇记操作、事务管理……等等⼆.Filter 的初体验要求:在你的 web ⼯程下,有⼀个 admin ⽬录。
这个 admin ⽬录下的所有资源(html 页⾯、jpg 图⽚、jsp ⽂件、等等)都必须是⽤户登录之后才允许访问。
思考:根据之前我们学过内容。
我们知道,⽤户登录之后都会把⽤户登录的信息保存到 Session 域中。
所以要检查⽤户是否登录,可以判断 Session 中是否包含有⽤户登录的信息即可Object user = session.getAttribute("user");// 如果等于 null,说明还没有登录if (user == null) {request.getRequestDispatcher("/login.jsp").forward(request,response);return;}Filter 的⼯作流程图:Filter 的代码:package com.atguigu.filter;import javax.servlet.*;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpSession;import java.io.IOException;public class AdminFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}/*** 专门⽤于拦截请求,过滤响应。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
在基于 JSP 页面系统设计开发中,经常有一批页面需要对用户的身份进行验证,只有合法的用户才可以访问这些页面。
显然可以在每个页面中添加身份验证,但这样做会给编程造成很大的麻烦,而且增加多余的代码。
那么,如何解决JSP 页面用户身份验证呢?
二、JSP 页面中用户身份验证分析
在有多个用户使用的 JSP 系统中,为了保障系统的隐秘性安全性,就需要对登录系统的用户进行身份验证以保证用户身份的合法性。
一个用户首次登录系统后会在session 对象中留下它的标识[1],就可以利用这个标识来完成各个JSP页面的用户身份验证。
为了避免每个页面都进行身份验证而出现的麻烦,这里将通过Servlet 过滤器对JSP 页面统一进行身份验证。
三、用户身份验证的设计思路和技术要点
1、设计思路
Servlet 过滤器验证用户是围绕session 对象进行的。
首先是实现用户登录的功能,在用户登录成功后产生一个session 标识;然后创建Servlet 过滤器,判断标识值是否正确,如果正确则通过验证,否则将给出提示信息并跳转到用户登录页面。
2、技术要点
使用 Servlet 过滤器实现JSP 页面中用户身份验证,首先必须实现Filter 接口,且重写doFilter() 方法,由doFilter() 方法去处理过滤业务;其次,在web.xml 文件中配置Servlet 过滤器,指定过滤器的名称、过滤器包所在类的名称及过滤器的映射范围等[2]。
四、JSP 页面中用户身份验证的实现
1、用户身份合法性确认
为了能够使用 Servlet 过滤器实现用户对JSP 页面访问的合法性验证,首先需要根据用户登录号和密码等与数据库中的信息相比较,若能匹配成功,则是用户登录成功,就用session 对象存储该用户的标识;然后再由Servlet 过滤器实现对用户访问的各个页面的过滤。
存储用户登录成功的session 标识的核心代码为:session.setAttribute("user",
用户登录号 )。
2、Servlet 过滤器的实现
用 Servlet 过滤器实现用户身份验证的关键代码如下:
package hzu.util.filters;
public class UserFilter extends HttpServlet implements Filter {
private FilterConfig filterConfig;
public void init(FilterConfig filterConfig)
throws ServletException{
this.filterConfig=filterConfig;
}[NextPage]
public void doFilter(ServletRequest request,ServletResponse response, FilterChain chain) throws ServletException,IOException{
HttpSession session=((HttpServletRequest)
request).getSession();
if(session.getAttribute(“user”)= =null){
PrintWriter out=response.getWriter();
out.print(“<script language=javascript>alert(…您还没登录, 请登录!!‟);javascript:location=‟系统登录的主页面';</script>");
out.flush();
out.close();
}
else{
chain.doFilter(request, response);
}
}
}
3、在web.xml 中配置Servlet 过滤器
在编写完Servlet过滤器后,要在web.xml文件中配置过滤器。
也就是通过<filter></filter>标签指定Servlet过滤器的名称、过滤器包所在类的名称,通过<filter-mapping></filter-mapping>标签配置Servlet 过滤器的映射路径[3]。
其关键代码如下:
<filter>
<filter-name>UserLoginFilter</filter-name>
<filter-class>hzu. erFilter</
filter-class>
</filter>
<filter-mapping>
<filter-name>UserLoginFilter</filter-name>
<url-pattern>[/ 目录名]/*</url-pattern>
<dispatcher>request</dispatcher>
<dispatcher>forward</dispatcher>
<dispatcher>include</dispatcher>
</filter-mapping>。