首页 > 其他分享> 文章详细

过滤器 & 监听器

2022-01-21 23:32:21 阅读：160 来源： 互联网

标签：监听 javax 监听器过滤器 import servlet public

过滤器

过滤器介绍

什么是过滤器

生活中的例子：

滤网，筛子，渔网

生活中的过滤器：排除我们不需要的东西，留下，需要的。

JavaWeb中的过滤器的概念：对请求和响应进行拦截或者增强的对象，就是过滤器。（重点）

JavaWeb中的过滤器是什么呢？

Filter接口：功能——对请求和响应进行增强，或者进行拦截。

JavaWEB中的过滤器运行图解（重点）

Filter的快速入门（重点：必须掌握）

Filter定义以及创建步骤介绍

定义一个过滤器： * 第一步：创建一个类，实现过滤器接口 * 第二步：具体需要执行的过滤任务，写在doFilter * 第三步：过滤器需要在web.xml中配置

代码演示：

package cn.wit.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;
/**
 * 
 * Filter 是在 Web 应用程序的部署描述符中配置的
 * 
 * 部署描述符:web.xml
 * 
 * 定义一个过滤器：
 * 第一步：创建一个类，实现过滤器接口
 * 第二步：具体需要执行的过滤任务，写在doFilter
 * 第三步：过滤器需要在web.xml中配置
 * */
public class MyFilter implements Filter{

	/**
	 * 初始化方法
	 * */
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub
	}

	/**
	 * 执行过滤任务的方法
	 * */
	@Override
	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		System.out.println("MyFilter....doFilter.....");
		
	}
	/**
	 * 销毁的方法
	 * */
	@Override
	public void destroy() {
		// TODO Auto-generated method stub
	}

}

Filter 是在 Web 应用程序的部署描述符中配置的——过滤器创建好之后，需要在web.xml中做配置

在web.xml文件中配置过滤器

<filter>
  	<filter-name>MyFilter</filter-name>
  	<filter-class>cn.wit.filter.MyFilter</filter-class>
  </filter>
  
  <filter-mapping>
  	<filter-name>MyFilter</filter-name>
  	<url-pattern>/1.txt</url-pattern>
  </filter-mapping>

Filter拦截操作效果

过滤器放行的对象:FilterChain功能介绍

总结：过滤放行，全靠它

FilterChain的doFilter方法：

代码实现

效果：

过滤器放行执行过程：

Filter生命周期

回顾servlet的生命周期：

创建：第一次被访问的时候

销毁：服务器关闭的时候，或者当前项目从服务器中移除

回顾session的生命周期：

创建：第一次调用getsession方法，第一次访问jsp

销毁：服务器非正常关闭，超过生存时间，调用销毁的方法

Filter：

创建：在服务器启动的时候

服务器启动截图：

销毁：在服务器关闭的时候，过滤器销毁。

服务器关闭截图：

FilterConfig介绍

servletConfig对象：获取servlet相关的配置信息。

FilterConfig定义：获取filter相关的配置信息。

API介绍：

API代码演示：

1）设置过滤器初始化参数

2）通过filterconfig对象来获取参数

参数配置：

<filter>
  	<filter-name>MyFilter</filter-name>
  	<filter-class>cn.wit.filter.MyFilter</filter-class>
  	<init-param>
  		<param-name>haha</param-name>
  		<param-value>哈哈</param-value>
  	</init-param>
  	<init-param>
  		<param-name>heihei</param-name>
  		<param-value>嘿嘿</param-value>
  	</init-param>
  </filter>
  
  <filter-mapping>
  	<filter-name>MyFilter</filter-name>
  	<url-pattern>/1.txt</url-pattern>
  </filter-mapping>

效果演示：

Filter配置详解（web.xml中的配置）（重点）

关于url-pattern配置

过滤器如何匹配请求的路径?

回顾servlet的url-pattern：

全路径匹配——

地址栏：localhost:8080/项目根路径/资源路径 localhost:8080/wit-filter2/1.txt

通配符的匹配——

地址栏：localhost:8080/项目根路径/abc/*

以上两种匹配方式，配置路径的时候必须以”/”开头

后缀名匹配—— *.do: *.do *.txt *.action

地址栏：localhost:8080/项目根路径/*.txt

后缀名匹配方式，配置路径的时候不能以”/”开头

Filter的url-pattern配置与servlet一致。

过滤器的执行顺序？

测试方式：

1）两个过滤器，拦截同一个请求

2）调整两个过滤器的配置，再来看执行的顺序

总结：

过滤器执行的顺序是按照，web.xml中filter-mapping标签的书写顺序执行（从上往下执行）

关于filter-name配置

什么是filter-name配置？

定义：针对指定的servlet进行拦截或者增强操作的配置

Servlet：

package cn.wit.servlet;

import java.io.IOException;

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

public class DemoServlet extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		System.out.println("DemoServlet....doGet.....");
	}

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

}

Filter：

package cn.wit.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 DemoFilter implements Filter{

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
	}

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

	@Override
	public void destroy() {
	}

}

Web.xml配置：

<filter>
		<filter-name>demoFilter</filter-name>
		<filter-class>cn.wit.filter.MyFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>demoFilter</filter-name>
		<url-pattern>/demo</url-pattern>
	</filter-mapping>

效果：

案例2–解决shop项目中乱码

需求：请求参数在每一个servlet中单独中文乱码处理，代码重复

优化的思路，使用一个过滤器，在请求到达servlet之前，先对request对象进行设置编码

要对所有的请求都要进行设置编码，都要拦截，进行增强，url-pattern:/*

过滤器代码：

package cn.wit.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;

public class EncodingFilter implements Filter{

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		
		HttpServletRequest req = (HttpServletRequest)request;
		HttpServletResponse res = (HttpServletResponse)response;
		//处理乱码，处理post请求乱码
		req.setCharacterEncoding("utf-8");
		chain.doFilter(req, res);
		
	}

	@Override
	public void destroy() {
	}

}

Web.xml配置：

实现完整版的乱码处理，过滤器：

第一步：还以要有一个过滤器，对请求进行乱码处理的任务（增强任务），写在doFilter方法中

补充（装饰（包装）设计模式心法）：

\1) 定义一个类，实现被装饰对象的接口

\2) 定义一个成员变量，记住被装饰对象的引用

\3) 定义构造方法，传入被装饰对象的实例

\4) 改写要修改的方法

\5) 不需要改写的方法，调用被装饰对象的原来的方法

复杂过滤器实现：

package cn.wit.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 cn.wit.domain.MyRequest;

public class EncodingFilter implements Filter{

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		// 对请求和响应，处理中文乱码
		HttpServletRequest req = (HttpServletRequest)request;
		HttpServletResponse res = (HttpServletResponse)response;
		
		res.setContentType("text/html;charset=utf-8");
		
		
		//针对不同的请求方式，处理乱码，使用一个新的request对象，在新的request对象中，处理乱码
		//设置构造函数有req对象，是为了保证，获取到请求中的数据，然后处理乱码
		MyRequest myRequest = new MyRequest(req);
		//测试获取请求参数
		System.out.println("name1:"+myRequest.getParameter("name"));
		System.out.println("name2:"+myRequest.getParameter("name"));
		
		//处理完成请求和响应乱码，只需要放行
		chain.doFilter(myRequest, res);
		
	}

	@Override
	public void destroy() {
	}

}

自定义增强类：

package cn.wit.domain;

import java.io.UnsupportedEncodingException;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

/**
 * @author yanyue
 *
 * @time 2017年5月26日
 * 
 * MyRequest如何实现：
 * 
 * 1 实现httpservletrequest接口——通过继承HttpServletRequestWrapper
 * 2 设置一个变量，用来保存服务器创建的request对象
 * 3 处理乱码，就是改写获取请求参数的三个方法
 * 4 不需要改写的方法，使用原来的对象方法
 */
public class MyRequest extends HttpServletRequestWrapper{
	//为了后期可以使用服务器创建的request对象中的请求参数
	//设置一个变量，用来保存服务器创建的request对象
	private HttpServletRequest request ;
	//定义一个标记，控制编码的次数，只执行一次
	private boolean flag = false;
	public MyRequest(HttpServletRequest request) {
		super(request);
		this.request = request;
	}
	
	@Override
	public Map<String, String[]> getParameterMap() {
	
		//获取请求方式，根据不同方式处理乱码
		String method = request.getMethod();
		if(method.equalsIgnoreCase("post")){
			try {
				request.setCharacterEncoding("utf-8");
				return request.getParameterMap();
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
				return super.getParameterMap();
			}
		}else if(method.equalsIgnoreCase("get")){
			
			//将所有的请求参数获取出来，然后，一个一个地处理乱码
			Map<String, String[]> map = request.getParameterMap();
			//如果控制编码，让他只执行一次？
			//flag 默认是false，所以往下执行
			//flag 第二次执行，true ，直接结束，不在执行。
			if(flag){
				return map;
			}
			//变量map集合获取数据
			if(map != null){
				for(String key :map.keySet()){
					String[] values = map.get(key);
					if(values != null){
						for (int i = 0; i < values.length; i++) {
							try {
								String string = new String(values[i].getBytes("iso-8859-1"),"utf-8");
								values[i] = string;
							} catch (UnsupportedEncodingException e) {
								e.printStackTrace();
								//如果出异常，希望后边，还没有循环到的数据，继续处理乱码
								//结束当前循环，开启下一个循环
								continue;
							}
						}
					}
				}
			}
			flag = true;
			return map;
		}else{
			return super.getParameterMap();
		}
	}
	
	@Override
	public String[] getParameterValues(String name) {
		Map<String, String[]> map = this.getParameterMap();
		if(map != null){
			String[] values = map.get(name);
			return values;
		}
		return super.getParameterValues(name);
	}
	
	@Override
	public String getParameter(String name) {
		String[] values = this.getParameterValues(name);
		if(values != null){
			return values[0];
		}
		return super.getParameter(name);
	}
	

}

注意：最后还有去掉原来设置编码的代码

监听器

监听器介绍

什么是监听器

监听器：监听事件源，根据事件源上发生事件，做出相应的处理。

监听机制相关概念

事件源：发生事件的源头，监听器需要监听的对象。

事件：事件源上发生的动作，监听器监听的内容。

监听器：负责监听事件源的对象。

web监听器介绍

javaweb监听器介绍

JavaWEB中的监听器主要监听JavaWEB中的request、session、ServletContext对象的各种变化。

主要监听的任务：

监听request、ServletContext 、session对象的创建和销毁

ServletRequestListener

ServletContextListener

HttpSessionListener

监听request、session、ServletContext 对象存放的数据变化情况

ServletContextAttributeListener

HttpSessionAttributeListener

ServletRequestAttributeListener

监听session中保存的JavaBean的状态

HttpSessionBindingListener

HttpSessionActivationListener

javaweb监听器创建步骤（示例：ServletRequestListener）

需要定义一个类实现对应的监听器接口

ServletRequestListener定义（API截图）：

代码演示：

package cn.wit.listener;

import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;

public class MyServletRequestListener implements ServletRequestListener{

	@Override
	//监听request对象销毁的方法
	public void requestDestroyed(ServletRequestEvent sre) {
		System.out.println("MyServletRequestListener.....requestDestroyed....");
		
	}

	@Override
	//监听request对象初始化的方法
	public void requestInitialized(ServletRequestEvent sre) {
		System.out.println("MyServletRequestListener.....requestInitialized....");
	}

}

配置监听器对象

注意：当服务器加载项目的时候，会读取web.xml文件中listener标签，那么服务器会自动创建监听器对象，并且自动调用其方法

自动调用其方法，也是通过反射调用（因为他的方法名称和参数是固定的）

监听器的小结：

1）创建一个类，实现监听器接口

2）在监听器对象的方法中，书写相关的代码

3）在web.xml中配置当前监听器。

ServletContext创建销毁监听

ServletContextListener定义（API截图）：

代码演示：

package cn.wit.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyServletContextListener implements ServletContextListener{

	@Override
	public void contextInitialized(ServletContextEvent sce) {
		System.out.println("MyServletContextListener.....contextInitialized....");
		
	}

	@Override
	public void contextDestroyed(ServletContextEvent sce) {
		System.out.println("MyServletContextListener.....contextDestroyed....");
	}

}

监听器配置：

<listener>
  	<listener-class>cn.wit.listener.MyServletContextListener</listener-class>
  </listener>

监听servletcontext对象初始化截图：

监听servletcontext对象销毁截图：

ServletContextListener案例：定时任务

需求：项目启动时，获取服务器时间（new Date()），每一秒钟更新一次，打印在控制台

思路：

1）监控项目的启动（使用ServletContextListener来监听ServletContext对象的初始化）

1）获取服务器时间：new Date（）；

2）每一秒更新一次：定时器Timer

4）给定时器设置定时任务

Timer：定时器任务调度的对象

task：定时器的任务（类）

delay：从什么时候开始执行，立即执行设置为：0

period：间隔多少时间重复执行，毫秒值，1秒=1000毫秒

TimerTask：定时器的任务（类）

Run方法中应该写我们的定时任务：每一秒钟更新一次时间，打印在控制台上

代码实现：

package cn.wit.listener;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

/**
 * @author wjn
 *  1）	创建一个类，实现监听器接口
	2）	在监听器对象的方法中，书写相关的代码
	3）	在web.xml中配置当前监听器。
 */
public class MyServletContextListener implements ServletContextListener{

	@Override
	public void contextInitialized(ServletContextEvent sce) {
		System.out.println("MyServletContextListener....contextInitialized...");
		//监控项目的启动（使用ServletContextListener来监听ServletContext对象的初始化）
		//2)	获取服务器时间：new Date（）；
		//3）	每一秒更新一次：定时器Timer
		//4）          给定时器设置定时任务
		
		//获取定时器
		Timer timer = new Timer();
		//调用定时器的设置定时任务的方法
		//firstTime 0:立即执行
		//period：间隔多长时间执行一次，1000
		timer.schedule(new TimerTask() {
			
			@Override
			public void run() {
				//在run方法中，书写，要执行的任务
				//过时的方法一般不推荐使用，但是，过时的方法，jdk不会删除它的效果。
				//当前显示时间，可以使用服务器中的时间——java代码，new Date();
				//当前显示时间——javascript代码，new Date();
				//javascript代码，是在浏览器运行，客户端的时间，一般是不使用客户端的时间
				//业务：整点秒杀
				//获取的是服务器时间，用户，是没有办法控制
				//获取客户端时间，时间有客户控制，时间是不对的
				//一般尊循的原则，只要可以控制在服务器的，绝对不给客户端
				System.out.println(new Date().toLocaleString());
			}
		}, 0, 1000);
		
	}

	@Override
	public void contextDestroyed(ServletContextEvent sce) {
		System.out.println("MyServletContextListener....contextDestroyed...");
	}

}

效果：

HttpSessionListener对象监听session的创建与销毁监听

HttpSessionListener定义（API截图）：

代码演示：

package cn.wit.listener;

import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class MyHttpSessionListener implements HttpSessionListener{

	@Override
	public void sessionCreated(HttpSessionEvent se) {
		System.out.println("MyHttpSessionListener....sessionCreated....");
		
	}

	@Override
	public void sessionDestroyed(HttpSessionEvent se) {
		System.out.println("MyHttpSessionListener....sessionDestroyed....");
		
	}

}

配置文件：

<listener>
		<listener-class>cn.wit.listener.MyHttpSessionListener</listener-class>
	</listener>

Invalidate.jsp页面代码：

效果截图：

案例——统计在线人数

需求：统计当前访问网站的人数有多少人？

问题：什么时候我们可以知道用户访问了网站？

只要用户访问了我们的网站，session一定会创建。只要用户离开，点退出（注销），session就销毁。

思路：

只要判断session创建，在线人数就加一

只要判断session销毁，在线人数就减一

在线人数的数据，要存在哪里？

答：ServletContext对象中，所有应用程序范围都可以获取，所有访问当前网站的用户，都应该可以看到在线人数

总思路：

１现在项目启动的时候，初始化在线人数0，保存在ServletContext

2 监听到session创建数据加一

3 监听到session销毁数据减一

4 在页面展示数据

代码实现：

监听器代码：

package cn.wit.listener;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class MyHttpSessionListener implements HttpSessionListener {

	@Override
	public void sessionCreated(HttpSessionEvent se) {
		System.out.println("MyHttpSessionListener....sessionCreated....");
		// 在监听器中只要判断session创建，在线人数就加一

		ServletContext context = se.getSession().getServletContext();
		// 获取里面的在线人数
		Integer onlineNum = (Integer) context.getAttribute("onlineNum");
		onlineNum = onlineNum + 1;
		context.setAttribute("onlineNum", onlineNum);
	}

	@Override
	public void sessionDestroyed(HttpSessionEvent se) {
		System.out.println("MyHttpSessionListener....sessionDestroyed....");
		// 在监听器中只要判断session销毁，在线人数就减去一

		ServletContext context = se.getSession().getServletContext();
		// 获取里面的在线人数
		Integer onlineNum = (Integer) context.getAttribute("onlineNum");
		onlineNum = onlineNum - 1;
		context.setAttribute("onlineNum", onlineNum);

	}

}

index.jsp显示在线人数，显示退出链接:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    
    <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>
    wit-filter2项目主页<br>
    当前在线人数：${onlineNum }
    <a href="${pageContext.request.contextPath }/validate.jsp">退出</a>
  </body>
</html>

页面效果：

属性变化的监听

属性监听器介绍

主要是监听使用setAttribute、removeAttribute方法。

ServletContextAttributeListener 专门用于监听ServletContext对象中的属性的变化情况

HttpSessionAttributeListener 专门用于监听session对象中的属性的变化情况

ServletRequestAttributeListener专门用于监听request对象中的属性的变化情况

它们中的的监听添加、删除、修改的方法名称全部一致：

代码演示：

Jsp：

<%
   		session.setAttribute("name", "一大爷");
   		session.replaceAttribute("name", "二大爷");
   		session.removeAttribute("name");
   
%>

监听器：

package cn.wit.listener;

import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;

public class MyHttpSessionAttributeListener implements HttpSessionAttributeListener    {

	@Override
	public void attributeAdded(HttpSessionBindingEvent se) {
		System.out.println("MyHttpSessionAttributeListener....attributeAdded...");
	}

	@Override
	public void attributeRemoved(HttpSessionBindingEvent se) {
		System.out.println("MyHttpSessionAttributeListener....attributeRemoved...");
	}

	@Override
	public void attributeReplaced(HttpSessionBindingEvent se) {
		System.out.println("MyHttpSessionAttributeListener....attributeReplaced...");
	}

}

配置文件：

<listener>
		<listener-class>cn.wit.listener.MyHttpSessionAttributeListener</listener-class>
	</listener>

Session中的bean(JavaBean)监听

当我们给Session中保存一个Java对象的时候，或者把Java对象从Session中移除的时候会触发专门用来监听Session中对象变化的监听器中的方法。拥有这个方法的对象——HttpSessionBindingListener接口

属性监听和bean监听的区别：

属性监听：是对三个容器中的任何属性（包括对象和不是对象的数据，基本类型数据）的变化，进行监听

Bean监听：它只监听javabean对象往session中保存和session中移出的过程。

由于HttpSessionBindingListener是用来监听某个JavaBean对象的绑定（存入session容器）和解绑（从session容器中移除）的，所以这个监听器的实现类必须是被操作的JavaBean（HttpSessionBindingListener不需要再web.xml中配置）

javaBean：

package cn.wit.domain;

import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;

public class User implements HttpSessionBindingListener{

	private int age;
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + "]";
	}
	@Override
	public void valueBound(HttpSessionBindingEvent event) {
		System.out.println("User....valueBound...");
		
	}
	@Override
	public void valueUnbound(HttpSessionBindingEvent event) {
		System.out.println("User....valueUnbound...");
		
	}
	
}

JSP：

<%
   		 session.setAttribute("user", new User());
    	
    	 session.removeAttribute("user");
     %>

效果：

Bean监听需求：

在线人数，根据 session创建和销毁，来做人数的增减。

在线会员统计：

1）User类实现bean监听接口

2）每次监听到loginUser对象被绑定到session中的时候，会员人数加一

3）每次监听到loginUser对象被解绑的时候，会员人数减一

标签：监听,javax,监听器,过滤器,import,servlet,public
来源： https://blog.csdn.net/WA_MC/article/details/122630920

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

过滤器 & 监听器

过滤器

过滤器介绍

什么是过滤器

JavaWEB中的过滤器运行图解（重点）

Filter的快速入门（重点：必须掌握）

Filter定义以及创建步骤介绍

在web.xml文件中配置过滤器

Filter拦截操作效果

过滤器放行的对象:FilterChain功能介绍

Filter生命周期

FilterConfig介绍

Filter配置详解（web.xml中的配置）（重点）

关于url-pattern配置

关于filter-name配置

案例2–解决shop项目中乱码

监听器

监听器介绍

什么是监听器

监听机制相关概念

web监听器介绍

javaweb监听器介绍

javaweb监听器创建步骤（示例：ServletRequestListener）

需要定义一个类实现对应的监听器接口

配置监听器对象

ServletContext创建销毁监听

ServletContextListener案例：定时任务

HttpSessionListener对象监听session的创建与销毁监听

案例——统计在线人数

属性变化的监听

属性监听器介绍

Session中的bean(JavaBean)监听