过滤器
过滤器介绍
什么是过滤器
生活中的例子:
滤网,筛子,渔网
生活中的过滤器:排除我们不需要的东西,留下,需要的。
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对象中,所有应用程序范围都可以获取,所有访问当前网站的用户,都应该可以看到在线人数
总思路:
1 现在项目启动的时候,初始化在线人数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对象被解绑的时候,会员人数减一