精华内容
下载资源
问答
  • 下面小编就为大家带来一篇基于java servlet过滤器和监听器(详解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Servlet过滤器的简单使用,实现一个登陆界面。代码和博文几乎一致。
  • Servlet过滤器简介 Servlet过滤器实际上就是一个标准的java类,这个类通过实现Filter接口获得过滤器的功能。它在jsp容器启动的时候通过web.xml配置文件被系统加载。Servlet过滤器在接收到用户请求的时候被调用,当...
  • java-web servlet 拦截器 过滤器使用 java-web servlet 拦截器 过滤器使用
  • 主要介绍了浅谈SpringMVC的拦截器(Interceptor)和Servlet过滤器(Filter)的区别与联系 及SpringMVC 的配置文件,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们...
  • servlet过滤器实例经典过滤器

    热门讨论 2011-11-05 20:25:24
    servlet过滤器实例经典过滤器,手把手交你配置过滤器,五大常用过滤器源码,走过路过的同事们注意了!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  • 主要为大家详细介绍了servlet+jsp实现过滤器,防止用户未登录访问,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 本文实例讲述了JSP使用Servlet过滤器进行身份验证的方法。分享给大家供大家参考,具体如下: 1、Servlet过滤器的作用描述 (1)在HttpServletRequest到达Servlet 之前,拦截客户的HttpServletRequest。 根据需要...
  • Servlet 编写过滤器

    2021-01-03 01:54:23
    Servlet 编写过滤器 Servlet 过滤器可以动态地拦截请求和响应,以变换或使用包含在请求或响应中的信息。 可以将一个或多个 Servlet 过滤器附加到一个 Servlet 或一组 ServletServlet 过滤器也可以附加到 Java...
  • JavaWeb Servlet中Filter过滤器的详解 1.简述  Filter过滤器,对web服务器所有web资源进行过滤,从而实现一些特殊的功能(权限访问控制、过滤敏感词汇、压缩响应信息)。Filter能够对Servlet容器的请求和响应进行检查...
  • servlet过滤器和监听器,servlet过滤器和监听器课件,servlet过滤器和监听器PPT
  • Servlet过滤器

    千次阅读 2019-03-11 10:48:46
    Servlet过滤器是从Servlet2.3规范开始新增的功能,并在Servlet2.4规范中得到增强。Servlet过滤器主要用于对客户端(浏览器)的请求进行过滤处理,先将过滤后的请求转交给下一资源,它在Java Web开发中具有十分重要的...

    Servlet过滤器是从Servlet2.3规范开始新增的功能,并在Servlet2.4规范中得到增强。Servlet过滤器主要用于对客户端(浏览器)的请求进行过滤处理,先将过滤后的请求转交给下一资源,它在Java Web开发中具有十分重要的作用。

    1、过滤器的介绍

    Servlet过滤器与Servlet十分相似,但它具有拦截客户端(浏览器)请求的功能,Servlet过滤器可以改变请求中的内容,来满足实际开发中的需要。对于程序开发人员而言,过滤器实质就是在Web应用服务器上的一个Web应用组件,用于拦截客户端(浏览器)与目标资源的请求,并对这些请求进行一定过滤处理再发送给目标资源,过滤器的处理方式如下图所示。

    在Web服务器中部署了过滤器以后,不仅客户端发送的请求会经过过滤器的处理,而且请求在发送到目标资源处理以后,请求的回应信息也同样要经历过滤器。如果一个Web应用中使用一个过滤器不能解决实际中的业务需要,那么可以部署多个过滤器对业务请求进行多次处理,这样做就组成了一个过滤器链。Web服务器在处理过滤器链时,将按过滤器的先后顺序对请求进行处理。

     

    2、过滤器核心对象

    过滤器对象放置在javax.servlet包中,其名称为Filter,它是一个接口。除这个接口外,与过滤器相关的对象还有FilterConfig对象与FilterChain对象,这个两个对象也同样是接口对象,位于javax.servlet包中,分别为过滤器的配置对象与过滤器的传递工具。

    在实际开发中,定义过滤器对象只需要直接或间接地实现Filter接口即可。如上图所示中的MyFilter1过滤器与MyFilter2过滤器,而FilterConfig对象与FilterChain对象用于对过滤器的相关操作。

    2.1 Filter接口

    每一个过滤器对象都要直接或间接地实现Filter接口,在Filter接口中定义了3个方法,其方法声明及说明如下表:

    Filter接口的方法声明及说明:

    方法声明说明
    public default void init(FilterConfig filterConfig) throws ServletException过滤器初始化方法,该方法在过滤器初始化时调用。
    public void doFilter(ServletRequest request, ServletResponse response,
                FilterChain chain) throws IOException, ServletException
    对请求进行过滤处理。
    public default void destroy()销毁方法,以便释放资源。

    2.2 FilterConfig接口

    FilterConfig接口由Servlet容器进行实现,主要用于获取过滤器中的配置信息,其方法声明及说明如下表:

    FilterConfig接口的方法声明及说明:

    方法声明说明
    public String getFilterName()用于获取过滤器的名字。
    public ServletContext getServletContext()获取Servlet上下文。
    public String getInitParameter(String name)获取过滤器的初始化参数值。
    public Enumeration<String> getInitParameterNames()获取过滤器的所有初始化参数。

    2.3 FilterChain对象

    FilterChain对象仍然有Servlet容器进行实现,在这个接口中只有一个方法,其方法声明如下:

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

    该方法用于将过滤后的请求传递给下一个过滤器,如果此过滤器已经是过滤器链中的最后一个过滤器,那么,请求将传送给目标资源。

     

    3、过滤器创建与配置

    示例:创建一个过滤器,实现网站访问计数器的功能,并在 web.xml 配置中将网站访问量的初始值设置为5000。

    (1)创建名称为CountFilter的类,该类实现 javax.servlet.Filter 接口,同时实现Filter接口的三个方法,是一个过滤器对象,通过该过滤器实现统计网站访问人数功能。

    package com.pjb.filter;
    
    import java.io.IOException;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * 计数器过滤器
     * 
     * @author pan_junbiao
     *
     */
    public class CountFilter implements Filter
    {
    	// 来访数量
    	private int count;
    
    	// 初始化方法
    	@Override
    	public void init(FilterConfig filterConfig) throws ServletException
    	{
    		String param = filterConfig.getInitParameter("count"); // 获取初始化参数
    		count = Integer.valueOf(param); // 将字符串转换为int类型
    	}
    
    	// 过滤处理方法
    	@Override
    	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    			throws IOException, ServletException
    	{
    		count++;
    		// 将ServletResponse对象转换成HttpServletRequest
    		HttpServletRequest req = (HttpServletRequest) request;
    		// 获取ServletContext
    		ServletContext context = req.getServletContext();
    		// 将来访数量保存到ServletContext对象中
    		context.setAttribute("count", count);
    		// 向下传递过滤器
    		chain.doFilter(request, response);
    	}
    
    	// 销毁方法
    	@Override
    	public void destroy()
    	{
    		// 释放资源
    	}
    
    }
    

    (2)过滤器的配置主要分为两个步骤,分别为:声明过滤器对象、创建过滤器映射。

    配置已创建的CountFilter对象,此操作通过配置web.xml文件进行实现。

    <!-- 过滤器声明 -->
    <filter>
    	<!-- 过滤器的名称 -->
    	<filter-name>CountFilter</filter-name>
    	<!-- 过滤器的完整类名 -->
    	<filter-class>com.pjb.filter.CountFilter</filter-class>
    	<!-- 设置初始化参数 -->
    	<init-param>
    		<!-- 参数名 -->
    		<param-name>count</param-name>
    		<!-- 参数值 -->
    		<param-value>5000</param-value>
    	</init-param>
    </filter>
    
    <!-- 过滤器映射 -->
    <filter-mapping>
    	<!-- 过滤器名称 -->
    	<filter-name>CountFilter</filter-name>
    	<!-- 过滤器URL映射 -->
    	<url-pattern>/index.jsp</url-pattern>
    </filter-mapping>

    <filter>标签用于声明过滤器对象,在这个标签中必须配置两个子元素,分别为过滤器的名称与过滤器完整类名,其中:

    <filter-name>子标签:用于定义过滤器的名称。

    <filter-class>子标签:用于指定过滤器的完整类名。

    <init-param>子标签:用于指定过滤器的初始化参数,非必填项。

    <filter-mapping>标签用于创建过滤器的映射,它的主要作用就是指定Web应用中,哪些URL应用哪一个过滤器进行处理。在<filter-mapping>标签中需要指定过滤器的名称与过滤器的URL映射,其中:

    <filter-name>子标签:用于定义过滤器的名称,它需要与<filter>标签中的<filter-name>一一对应。

    <url-pattern>子标签:用于指定过滤器应用的URL。

    问题:如何匹配所有页面的请求?

    答:使用 “/*” 来匹配所有页面的请求。在 web.xml 文件中配置过滤器,其过滤器的URL映射可以使用正则表达进行配置。

    (3)创建程序中的首页 index.jsp ,在该页面中通过JSP内置对象 Application 获取计数器的值。

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>人数统计</title>
    </head>
    <body>
    	<h2>欢迎访问 pan_junbiao的博客</h2>
    	您是本站的第【
    		<%= application.getAttribute("count") %>
    	】位访客!
    </body>
    </html>

    执行结果:

    由于在 web.xml 文件中将计数器的初始值设置为5000,所以实例运行后,计数器的数值变为大于5000的数,在多次刷新页面后,计数器的数值会跟着变大。

     

    4、Servlet3.0新特性

    4.1 @WebFilter注释

    在Servlet3.0中新增了@WebFilter注释,通过使用该注释就无需在web.xml文件中对过滤器进行配置。@WebFilter注释用于声明过滤器,该注释将会在部署时被容器处理,容器将根据具体的属性配置将相应的类部署为过滤器。

    @WebFilter注释主要属性列表:

    属性名类型描述
    filterNameString指定过滤器的name属性,等价于<filter-name>标签。
    valueString[]该属性等价于urlPatterns属性,但是两者不应该同时使用。
    urlPatternsString[]指定一组过滤器的URL匹配模式,等价于<url-pattern>标签。
    servletNamesString[]指定过滤器将应用于哪些Servlet,是@WebServlet中的name属性的取值,或者是web.xml文件中的<servlet-name>标签的取值。
    initParamsWebInitParam[]指定一组过滤器初始化参数,等价于<init-param>标签。
    asyncSupportedboolean声明过滤器是否支持异步操作模式,等价于<async-supported>标签。
    descriptionString该过滤器的描述信息,等价于<description>标签。
    displayNameString该过滤器的显示名,通常配合工具使用,等价于<display-name>标签。
    dispatcherTypesDispatcherType[]指定过滤器的转发模式。具体取值包括:ASYNC、ERROR、FORWARD、INCLUDE 和 REQUEST。

    4.2 @WebInitParam注释

    @WebInitParam注释等价于web.xml文件中的<servlet>和<filter>的<init-param>子标签,该注释通常不单独使用,而是配合@WebServlet或者@WebFilter使用。

    @WebInitParam注释主要属性列表:

    属性名类型描述
    nameString指定参数的名字,等价于<param-name>标签,必填项。
    valueString指定参数的值,等价于<param-value>标签,必填项。
    descriptionString关于参数的描述,等价于<description>标签,非必填项。

    示例:创建过滤器,使用@WebFilter注释和@WebInitParam注释进行配置。

    /**
     * 计数器过滤器
     * 
     * @author pan_junbiao
     *
     */
    @WebFilter(filterName = "CountFilter", urlPatterns = "/index.jsp", 
    initParams = { @WebInitParam(name = "count", value = "5000") })
    public class CountFilter implements Filter
    {
    	// 省略了过滤器中间的代码
    }

    如此配置之后,就不需要在 web.xml 文件中配置相应的<filter>、<filter-mapping>和<init-param>元素了,容器会在部署时根据指定的属性将该类发布为过滤器。使用@WebFilter注释,等价于在 web.xml 文件中进行如下配置:

    <filter>
      <filter-name>CountFilter</filter-name>
      <filter-class>com.pjb.filter.CountFilter</filter-class>
      <init-param>
        <param-name>count</param-name>
        <param-value>5000</param-value>
      </init-param>
    </filter>
    <filter-mapping>
      <filter-name>CountFilter</filter-name>
      <url-pattern>/index.jsp</url-pattern>
    </filter-mapping>

     

    5、字符编码过滤器

    在Java Web程序开发中,由于Web容器内部所使用编码格式并不支持中文字符集,所以,处理浏览器请求中的中文数据,就会出现乱码现象。如下图:

    由于Web容器使用了ISO-8859-1的编码格式,所以在Web应用的业务处理中也会使用ISO-8859-1的编码格式。虽然浏览器提交的使用的是中文编码格式UTF-8,但经过业务处理中的ISO-8859-1编码,仍然会出现中文乱码现象。解决此问题的方法非常简单,在业务处理中重新指定中文字符集进行编码即可解决。在实际开发过程中,如果通过每一个业务处理指定中文字符集编码,则操作过于烦琐,而且容易遗漏某一个业务中的字符编码设置;如果通过过滤器来处理字符编码,就可以做到简单又万无一失。

    示例:实现图书信息的添加功能,并创建字符编码过滤器,避免中文乱码现象的产生。

    (1)创建字符编码过滤器对象,其名称为CharactorFilter类。该类实现了 javax.servlet.Filter 接口,并在doFilter()方法中对请求中的字符编码进行设置。

    package com.pjb.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.annotation.WebFilter;
    import javax.servlet.annotation.WebInitParam;
    
    /**
     * 字符编码过滤器
     * 
     * @author pan_junbiao
     */
    @WebFilter(filterName = "CharactorFilter", urlPatterns = "/*", 
    initParams = { @WebInitParam(name = "encoding", value = "UTF-8") })
    public class CharactorFilter implements Filter
    {
    	// 字符编码
    	String encoding = null;
    
    	// 初始化方法
    	@Override
    	public void init(FilterConfig filterConfig) throws ServletException
    	{
    		// 获取初始化参数
    		encoding = filterConfig.getInitParameter("encoding");
    	}
    
    	// 过滤处理方法
    	@Override
    	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    			throws IOException, ServletException
    	{
    		// 判断字符编码是否为空
    		if (encoding != null)
    		{
    			// 设置request的编码格式
    			request.setCharacterEncoding(encoding);
    			// 设置response字符编码
    			response.setContentType("text/html; charset=" + encoding);
    		}
    		// 传递给下一过滤器
    		chain.doFilter(request, response);
    	}
    
    	// 销毁方法
    	@Override
    	public void destroy()
    	{
    		encoding = null;
    	}
    }
    

    (2)创建名称为AddServlet的类,该类继承 HttpServlet,是处理添加图书信息请求的Servlet对象。

    package com.pjb.servlet;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    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类
     * 
     * @author pan_junbiao
     *
     */
    @WebServlet(name = "AddServlet", urlPatterns = "/servlet/AddServlet")
    public class AddServlet extends HttpServlet
    {
    	private static final long serialVersionUID = 1L;
    
    	// 处理GET请求
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
    	{
    		doPost(request, response);
    	}
    
    	// 处理POST请求
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
    	{
    		// 获取 PrintWriter
    		PrintWriter out = response.getWriter();
    		// 获取图书编号
    		String id = request.getParameter("id");
    		// 获取名称
    		String name = request.getParameter("name");
    		// 获取作者
    		String author = request.getParameter("author");
    		// 获取价格
    		String price = request.getParameter("price");
    		// 输出图书信息
    		out.print("<h2>图书信息添加成功</h2><hr>");
    		out.print("图书编号:" + id + "<br>");
    		out.print("图书名称:" + name + "<br>");
    		out.print("作者:" + author + "<br>");
    		out.print("价格:" + price + "<br>");
    		// 刷新流
    		out.flush();
    		// 关闭流
    		out.close();
    	}
    }
    

    (3)创建名称为AddBook.jsp的页面,该页面主要用于放置添加图书信息的表单。

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>添加图书信息</title>
    </head>
    <body>
    	<form action="servlet/AddServlet" method="post">
    		<table align="center" border="1" width="350">
    			<tr>
    				<td class="2" align="center" colspan="2">
    					<h2>添加图书信息</h2>
    				</td>
    			</tr>
    			<tr>
    				<td align="right">图书编号:</td>
    				<td>
    					<input type="text" name="id">
    				</td>
    			</tr>
    			<tr>
    				<td align="right">图书名称:</td>
    				<td>
    					<input type="text" name="name">
    				</td>
    			</tr>
    			<tr>
    				<td align="right">作  者:</td>
    				<td>
    					<input type="text" name="author">
    				</td>
    			</tr>
    			<tr>
    				<td align="right">价  格:</td>
    				<td>
    					<input type="text" name="price">
    				</td>
    			</tr>
    			<tr>
    				<td class="2" align="center" colspan="2">
    					<input type="submit" value="添 加">
    				</td>
    			</tr>
    		</table>
    	</form>
    </body>
    </html>

    执行结果:

    (1)添加图书信息:

    (2)显示图示信息:

     

    展开全文
  • servlet过滤器原理及使用

    千次阅读 2019-04-12 17:06:08
    首先了解什么是过滤器,各种文章已经写的很清楚了 引用来自这篇大牛的博客 是Servlet技术中最激动人心的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态 ...

    原理

    首先了解什么是过滤器,各种文章已经写的很清楚了

    引用来自这篇大牛的博客

    是Servlet技术中最激动人心的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截,从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能

     

    提取关键字  :所有web资源    说明了过滤器的作用范围是所有web资源

    过滤器是对所有web资源引用前的一层“过滤

    这个“过滤”是什么意思呢,就是对一次访问进行一些预处理,比如设定字符集,权限控制,过滤敏感字符或者任何自定义的操作

    原理图

    过滤器是怎么实现实现的呢?

    过滤器是Servlet的一个组件,是设计模式中过滤器模式(又叫责任链模式)的一种经典实现

    详情查看我的另一篇文章设计模式—过滤器模式的java实现

    简单来说,就是对一个请求进行一层一层的处理

    /**
     * 请求类,模拟一次请求
     * 有名字和信息两个属性,根据实际情况自定义
     * @author tiancaixiaoniuniu
     * @date 2019/4/12  15:13
     */
    public class Request {
        private String name;
        private String info="";
    
        public Request(String name, int num) {
            this.name = name;
            this.num = num;
        }
    
        //一个条件数值,用来过滤条件判断
        private int num;
        //get set 略
    }
    
    
    
    /**
     * 过滤器接口
     * @author tiancaixiaoniuniu
     * @date 2019/4/12  15:11
     */
    public interface Filter {
        /**
         *对请求进行一次过滤或者处理
         * 如果继续执行后面的过滤器,返回true,否则返回false
         * @param request    请求类
         */
        public boolean execute(Request request);
    }
    
    /**
     * @author tiancaixiaoniuniu
     * @date 2019/4/12  15:48
     */
    public class Filter_A implements Filter{
        @Override
        public boolean execute( Request request) {
            System.out.println("请求"+request.getName()+"正在执行Filter_A过滤器-----------------------");
            //对请求进行判断
            if (request!=null&&request.getNum()>10){
                System.out.println(request.getInfo()+"通过了Filter_A过滤器,继续执行下一个");
                request.setInfo(request.getInfo()+"通过了Filter_A过滤器 ");
                return true;
            }else if (request!=null){
                request.setInfo(request.getInfo()+"未通过了Filter_A过滤器,停止执行\n");
            }
            return false;
        }
    }
    
    
    /**
     * @author tiancaixiaoniuniu
     * @date 2019/4/12  15:48
     */
    public class Filter_B implements Filter{
        @Override
        public boolean execute( Request request) {
            System.out.println("请求"+request.getName()+"正在执行Filter_B过滤器-----------------------");
            //对请求进行判断
            if (request!=null&&request.getNum()>20){
                System.out.println(request.getInfo()+"通过了Filter_B过滤器,继续执行下一个");
                request.setInfo(request.getInfo()+"通过了Filter_B过滤器 ");
                return true;
            }else if (request!=null){
                request.setInfo(request.getInfo()+"未通过了Filter_B过滤器,停止执行\n");
            }
            return false;
        }
    }
    
    
    /**
     * @author tiancaixiaoniuniu
     * @date 2019/4/12  15:48
     */
    public class Filter_C implements Filter{
        @Override
        public boolean execute( Request request) {
            System.out.println("请求"+request.getName()+"正在执行Filter_C过滤器-----------------------");
            //对请求进行判断
            if (request!=null&&request.getNum()>30){
                System.out.println(request.getInfo()+"通过了Filter_C过滤器,继续执行下一个");
                request.setInfo(request.getInfo()+"通过了Filter_C过滤器 ");
                return true;
            }else if (request!=null){
                request.setInfo(request.getInfo()+"未通过了Filter_C过滤器,停止执行\n");
            }
            return false;
        }
    }
    
    
    /**
     * 过滤器容器类   用来管理过滤器
     * @author tiancaixiaoniuniu
     * @date 2019/4/12  15:16
     */
    public class FilterContainer {
        private List<Filter> list=new ArrayList<>();
        //设置要执行的过滤器列表
        public void setFilterList(List<Filter> list){
            this.list=list;
        }
        //执行
        public void doFilter(Request request){
            for (Filter filter:list) {
                //如果返回false,结束执行
                if (!filter.execute( request)){
                    break;
                }
            }
            System.out.println("执行完成!");
        }
    }
    
    
    
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author tiancaixiaoniuniu
     * @date 2019/4/12  16:25
     */
    public class Client {
        public static void main(String[] args) {
            //配置过滤器执行列表
            List<Filter> list=new ArrayList<>();
            list.add(new Filter_A());
            list.add(new Filter_B());
            list.add(new Filter_C());
            //加载过滤器容器
            FilterContainer filterContainer=new FilterContainer();
            filterContainer.setFilterList(list);
            //请求
            Request request1=new Request("请求1",25);
            Request request2=new Request("请求2",35);
            filterContainer.doFilter(request1);
            System.out.println(request1.getInfo());
            filterContainer.doFilter(request2);
            System.out.println(request2.getInfo());
        }
    }
    

     

     

     

     

    使用

    那么我们是怎么在web中使用过滤器呢

    1.实现Filter接口

     

    public class FilterDemo01 implements Filter {
     
         @Override
         public void init(FilterConfig filterConfig) throws ServletException {
             System.out.println("----过滤器初始化----");
         }
     
         @Override
         public void doFilter(ServletRequest request, ServletResponse response,
                 FilterChain chain) throws IOException, ServletException {
             
             //对request和response进行一些预处理比如设置字符
             //可以是任何想要的自定义操作
             request.setCharacterEncoding("UTF-8");
             response.setCharacterEncoding("UTF-8");
             response.setContentType("text/html;charset=UTF-8");
             
             //继续执行剩下的过滤器
             chain.doFilter(request, response);  //让目标资源执行,放行
    
         }
     
         @Override
         public void destroy() {
             System.out.println("----过滤器销毁----");
         }
    }

    2.web.xml中配置这个过滤器

    <!--配置过滤器-->
       <filter>
           <filter-name>FilterDemo01</filter-name>
           <filter-class>me.gacl.web.filter.FilterDemo01</filter-class>
       </filter>
       
       <!--映射过滤器-->
       <filter-mapping>
           <filter-name>FilterDemo01</filter-name>
           <!--“/*”表示拦截所有的请求 -->
           <url-pattern>/*</url-pattern>
       </filter-mapping>

    完成!

     

    *原创作品,转载请表明出处。有建议或者问题欢迎联系我,QQ1595787997

    展开全文
  • Servlet3.0使用注解标注过滤器 Servlet3.0使用注解标注过滤器
  • servlet过滤器和监听器

    千次阅读 2018-08-03 17:13:26
    顾名思义是起到过滤的作用,所有的请求在真正到达servlet之前都会首先经过过滤器过滤一遍。过滤器也是Servlet的一种,因此也有init和destroy方法,还有一个服务方法,只是这里提供的服务是过滤; 一个Servlet要想...

    过滤器

    顾名思义是起到过滤的作用,所有的请求在真正到达servlet之前都会首先经过过滤器过滤一遍。过滤器也是Servlet的一种,因此也有init和destroy方法,还有一个服务方法,只是这里提供的服务是过滤;

    一个Servlet要想成为过滤器需要实现javax.servlet.Filter接口;

    一般客户端发出请求后会交给Servlet;如果过滤器存在,则客户端发出的请求都是先交给过滤器,然后交给Servlet

    我们可以完成一些在执行Servlet之前必须要做的事,比如request.setCharacterEncoding("GBK");

    必须实现以下方法:

    1.public void init(FilterConfig config) throws ServletException{}   //   init方法在Web容器启动时就会调用;

    2.public void doFilter(ServletRequest req,ServletResponse resp,FilterChain chain){}  // doFilter的参数是ServletRequestServletResponse而不是Http的;

    3.public void destroy(){}//应用被关闭时调用

    在实现doFilter方法时一定要执行如下操作:

    public void doFilter(ServletRequest req,ServletResponse resp,FilterChain chain){

        chain.doFilter(req,resp);        //servlet传递请求,否则servlet无法执行

    }

    写完过滤器后,我们必须要限制过滤器调用的范围,即域名为多少时会调用过滤器,我们在web.xml 中进行配置

    1. <filter>  
    2.     <filter-name>myFilter</filter-name><!--filter的名字-->  
    3.     <filter-class>com.lq.Filter.Myfilter</filter-class><!--filter的类全路径-->  
    4. </filter>  
    5. <filter-mapping>  
    6.     <filter-name>myFilter</filter-name><!--和filter的名字一一对应-->  
    7.     <url-pattern>/*</url-pattern><!--比如url-pattern中为 /* ,则对于所有请求进行过滤-->             
    8. </filter-mapping> 

     

    那么过滤器可以用来干嘛呢?大家可以做两个简单的案例:

    案例1:统一设置字符集

    案例2:拦截URL,不登录不允许直接访问页面

     

    监听器

    监听器顾名思义就是监听某种事件的发生,即当某个事件发生时,就触发了某个设置好的监听器,但是这里触发的原因不同。例如地震监测仪器监听地震的发生,大气监测仪,监测空气的变化以提供预警。

    servlet中因监听对象的不同也分为不同的监听器,这里指的监听对象是applicationsession对象,每种对象有各自的监听器。

    1.application监听器:ServletContextListener

    需要实现的方法:

    (1)public void contextInitialized(ServletContextEvent e);       //application创建时就调用

    (2)public void contextDestroyed(ServletContextEvent e);        //application销毁时调用

    ServletContextEventgetServletContext()方法可以取得application对象;

    创建完成监听器后需要在web.xml中做如下配置

    <listener>标签是单独出现的

    包含一个子标签,指定了监听类的全称(包名+类名)

    2.application属性监听器:ServletContextAttributeListener

    需要实现的方法:

    (1)public void attributeAdded(ServletContextAttributeEvent e);            //当调用application.setAttribute()时调用

    (2)public void attributeRemoved(ServletContextAttributeEvent e);        //当调用applcaition.removeAttribute()时调用

    (3)public void attributeReplaced(ServletContextAttributeEvent e);        //当调用两次application.setAttribute()赋予相同属性时调用

     

    参数ServletContextAttributeEvent可以获得触发该监听器的属性名称和属性值,方法有:

    (1)getName();  取得属性的名称;

    (2)getValue();   取得属性的值;(注意:返回的是Object,必须转型)

    3.session监听器:HttpSessionListener

    需要实现的方法:

    (1)public void sessionCreated(HttpSessionEvent e);                //当打开一个浏览器时,就会触发这个方法;

    (2)public void sessionDestroyed(HttpSessionEvent e);            //当调用session.invalidate();或超时时调用

    HttpSessionEvent的方法getSession()获得触发监听器的session对象;  

     

    销毁session常用的有2种方式:

    (1)session.invalidate();//直接销毁

    (2)web.xml中设置超时时间://所有session起作用

     

    1. <session-config>  
    2.     <session-timeout>5</session-timeout>  <!-- 5分钟 -->  
    3. </session-config>  

    注意:如果会话超时时间设置为-1,则表示会话永远不会超时;

    4.session属性监听器:HttpSessionAttributeListener

    需要实现的方法:

    (1)public void attributeAdded(HttpSessionBindingEvent e);            //当调用session.setAttribute()时调用

    (2)public void attributeRemoved(HttpSessionBindingEvent e);        //当调用session.removeAttribute()时调用

    (3)public void attributeReplaced(HttpSessionBindingEvent e);         //当调用两次session.setAttribute()赋予相同属性时调用

    HttpSessionBindingEvent 方法:

    (1)getSession();//获取触发监听器的session

    (2)getName();//获取属性名称

    (3)getValue();//获取属性值

     

    监听器应用场景

    ServletContextListener:在任何Servlet提供服务之前执行、在Servlet销毁时执行,用于提前初始化一些资源,比如数据库连接、销毁一些资源,比如数据库连接;

    ServletContextAttributeListener:上下文中添加、删除、替换了属性;

    HttpSessionListener:多少个在线用户,即跟踪会话;

    HttpSessionAttributeListener:会话属性添加、删除、替换;

     

    综合案例:

    做一个网站在线人数统计,可以通过ServletContextListener监听,当Web应用上下文启动时,在ServletContext中添加一个List.用来准备存放在线的用户名,然后通过HttpSessionAttributeListener监听,当用户登录成功,把用户名设置到Session中。同时将用户名放到ServletContext的List中,最后通过HttpSessionListener监听,当用户注销会话时,将用户名从应用上下文范围中的List列表中删除。

     



     

     

    展开全文
  • 过滤器来验证用户是否登录
  • 介绍了Servlet 过滤器,有需要的朋友可以参考一下
  • 最近在开发一个web模拟平台时要实现对指定的几个Servlet资源进行过滤拦截,但是在同一个包下还有其他过滤器要过滤的资源,拆开另建一个包反而让结构上不规范,这时就可以通过创建虚拟目录的方式,通过对一个虚拟目录...

    Javaweb 通过创建虚拟目录实现对多个Servlet文件资源的过滤拦截

    最近在开发一个web模拟平台时要实现对指定的几个Servlet资源进行过滤拦截,但是在同一个包下还有其他过滤器要过滤的资源,拆开另建一个包反而让结构上不规范,这时就可以通过创建虚拟目录的方式,通过对一个虚拟目录的过滤实现对多个Servlet文件资源的过滤拦截。
    所谓虚拟就是我们实际上不存在,但是在计算机编译时会识别为存在的虚拟文件,以下实例:
    我们在原有的Servlet访问路径上加上一个自定义的虚拟目录名User,使原来的Servlet虚拟成虚拟文件夹下的资源
    在这里插入图片描述
    在这里插入图片描述
    然后我们在过滤器上指定要过滤的资源路径为虚拟目录User下的所有资源,这样在不改变项目结构的基础上就实现了对指定Servlet资源的过滤与拦截了
    在这里插入图片描述

    展开全文
  • servlet过滤器

    2015-04-07 18:36:20
    tomcat容器中servlet过滤器用法举例
  • Jsp+JavaBean+Servlet+Session+过滤器+sql2008数据库,代码绝对正确!运用MyEclipse10.0+Tomcat7.0开发。
  • Step_1:Servlet过滤器的创建和配置,创建一个过滤器对象需要实现javax.servlet.Filter接口,同时实现Filter的 3个方法。其中过滤器中的init()方法用于对过滤器的初始值进行处理,destory()方法是过滤器的销毁方法...
  • springbootServlet3.0过滤器
  • servlet过滤器设置

    2018-05-09 21:20:31
    sevlet里设置过滤器,利用索引过滤不符合自己想要的url,达到重定向的目的
  • Servlet过滤器示例代码

    2014-06-09 09:13:34
    这里面的代码,是对Servlet过滤器,进行学习的,里面详尽的写出了Servlet过滤器的作用,以及一些使用方法!
  • Servlet过滤器与SpringMVC拦截器

    千次阅读 2017-03-30 22:09:02
    Servlet API中提供了一个Filter接口,开发web应用时,如果编写的Java类实现了这个接口,则把这个java类称之为过滤器Filter。 通过Filter技术,开发人员可以实现用户在访问某个目标资源之前,对访问的请求和响应进行...
  • Servlet过滤器小实例

    2011-08-06 22:50:42
    比较好也比较常见的方法是用专门的servlet过滤器进行过滤。java中有个Filter类专门从事这类工作,下面以一个简单的实例进行演示: 实例说明:假设有一个web应用软件,如果是正常途径登录,我们会在其session中放入...
  • servlet 过滤器做的简单登陆demo 初学者的简单例子。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 140,939
精华内容 56,375
关键字:

过滤器过滤servlet