javaWEB一一过滤器和监听器

Web之过滤器和监听器

1.2 如何编写过滤器

1、编写java类实现Filter接口
2、重写doFilter方法
3、设置拦截的url

入门案例:

package com.qf.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

	/**
	 * /**
	 * 2019/8/1216:26
	 * <p>
	 * 未知的事情 永远充满变数
	 */
	 */
	@WebFilter("/myservlet1")//过滤路径
	public class MyFilter1 implements Filter {

    //初始化过滤器
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器初始化了........init...  "+filterConfig);
    }

    //执行过滤
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("过滤前........doFilter ");
        //放行
        chain.doFilter(request, response);

        System.out.println("过滤后.......doFilter");

    }

    //销毁
    @Override
    public void destroy() {
        System.out.println("销毁了.....destroy");
    }
}

#####1.3 过滤器的配置

1.3.1 注解式配置

在自定义的Filter类上使用注解@WebFilter(“/*”)

1.3.2 xml配置

在web.xml中进行过滤器的配置：

<!--过滤器的xml配置  -->
  <filter>
  <!--名称-->
    <filter-name>sf</filter-name>
    <!--过滤器类全称-->
    <filter-class>com.qf.web.filter.SecondFilter</filter-class>
  </filter>
 <!--映射路径配置-->
  <filter-mapping>
     <!--名称-->
    <filter-name>sf</filter-name>
     <!--过滤的url匹配规则和Servlet类似-->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

过滤器的拦截匹配路径通常有三种形式:
(1)精确拦截地址匹配 ，比如/index.jsp
(2)后缀拦截地址匹配，比如*.jsp、*.html、*.jpg
(3)通配符匹配/*，表示匹配所有、注意过滤器不能使用/匹配。

#####1.4 过滤器链

	通常客户端对服务器请求之后，服务器调用Servlet之前会执行一组过滤器（多个过滤器）,那么这组过滤器就称为一条过滤器链。
	每个过滤器实现某个特定的功能，当第一个Filter的doFilter方法被调用时，web服务器会创建一个代表Filter链的FilterChain对象传递给该方法。在doFilter方法中，开发人员如果调用了FilterChain对象的doFilter方法，则web服务器会检查FilterChain对象中是否还有filter，如果有，则调用第2个filter，如果没有，则调用目标资源。

1.5 过滤器的优先级

	在一个web应用中，可以开发编写多个Filter，这些Filter组合起来称之为一个Filter链。这些过滤器的执行顺序由filter-mapping的顺序决定,前面filter-mapping优先级高于后面的。
	注意：	
	（1）如果为注解的话，是按照类名的字符串顺序进行起作用的
	（2）如果web.xml，按照 filter-mapping注册顺序，从上往下
	（3）web.xml配置高于注解方式
	（4）如果注解和web.xml同时配置，会创建多个过滤器对象，造成过滤多次。

1.6 过滤器的初始化参数

在过滤器的创建的时候，可以传递初始化参数

第一种：基于注解的

/**
 * Servlet Filter implementation class FirstFilter 创建过滤器
 */
@WebFilter(value="/*",initParams= {@WebInitParam(name = "version", value = "1.0")})
public class FirstFilter implements Filter {

	/**
	 * Default constructor.
	 */
	public FirstFilter() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * @see Filter#destroy() 销毁
	 */
	public void destroy() {
		// TODO Auto-generated method stub
		System.out.println("destroy销毁……");
	}

	/**
	 * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain) 过滤
	 */
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		// TODO Auto-generated method stub
		// place your code here
		System.out.println("doFilter……过滤");
		// 是否继续---访问下一个
		chain.doFilter(request, response);
	}

	/**
	 * @see Filter#init(FilterConfig)
	 * 初始化
	 */
	public void init(FilterConfig fConfig) throws ServletException {
		// TODO Auto-generated method stub
		System.out.println("init……初始化");
		System.out.println("初始化参数：版本号："+fConfig.getInitParameter("version"));
	}
}

第二种：基于xml配置

/**
 *  创建过滤器
 */
public class SecondFilter implements Filter {

	/**
	 * Default constructor.
	 */
	public SecondFilter() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * @see Filter#destroy() 销毁
	 */
	public void destroy() {
		// TODO Auto-generated method stub
	}

	/**
	 * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain) 过滤
	 */
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		// 是否继续---访问下一个
		chain.doFilter(request, response);
	}

	/**
	 * @see Filter#init(FilterConfig)
	 * 初始化
	 */
	public void init(FilterConfig fConfig) throws ServletException {
		// TODO Auto-generated method stub
		System.out.println("初始化参数：版本号："+fConfig.getInitParameter("version"));
	}

}

Web.xml实现配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>Web_Day</display-name>
  
  <!--过滤器的xml配置  -->
  <filter>
    <filter-name>myfilter</filter-name>
    <filter-class>com.qf.web.filter.SecondFilter</filter-class>
     <!--过滤器的初始化参数  -->
    <init-param>
      <param-name>version</param-name>
      <param-value>1.0</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>myfilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
  </welcome-file-list>
</web-app>

1.7 过滤器的优点

可以实现 Web 应用程序中的预处理和后期处理逻辑

1.8 过滤器的典型应用

案例1 禁止浏览器缓存动态页面

对于目前现在的浏览器，get请求动态资源缓存问题已经解决。

对于静态资源部分浏览器（IE，FixFox）使用Cache-Control头和Expires头设置缓存时间。chrome浏览器设置不设置都无效而是每次都请求服务器。

对于静态资源服务器会采用304状态码控制是否再次发送数据，从而节省带宽；可以通过Cache-Control=no-store控制304无效。

过滤器的代码：

/**
 * Servlet Filter implementation class NoCacheFilter
 * 实现禁止浏览器缓存动态页面
 */
@WebFilter("*.jsp")
public class NoCacheFilter implements Filter {

    /**
     * Default constructor. 
     */
    public NoCacheFilter() {
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see Filter#destroy()
	 */
	public void destroy() {
		// TODO Auto-generated method stub
	}

	/**
	 * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
	 */
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
		// TODO Auto-generated method stub
		//把ServletRequest强转成HttpServletRequest
	    HttpServletRequest req = (HttpServletRequest) request;
	    //把ServletResponse强转成HttpServletResponse
	    HttpServletResponse resp = (HttpServletResponse) response;
	    //禁止浏览器缓存所有动态页面
	    resp.setDateHeader("Expires", -1);
	    resp.setHeader("Cache-Control", "no-cache"); //no-store
	    resp.setHeader("Pragma", "no-cache");
	    //放行
		chain.doFilter(req, resp);
	}
	/**
	 * @see Filter#init(FilterConfig)
	 */
	public void init(FilterConfig fConfig) throws ServletException {
		// TODO Auto-generated method stub
	}
}

带缓存过滤器

@WebFilter(filterName = "CacheFilter",value = "*.html")
public class CacheFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request= (HttpServletRequest) req;
        HttpServletResponse response= (HttpServletResponse) resp;

        response.setDateHeader("Expires",System.currentTimeMillis()+600000);//毫秒 10分钟
        response.setHeader("Cache-Control", "max-age=600");//秒

        chain.doFilter(req, resp);
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

案例2 自动登录

创建数据库和用户表

DbHelper类：

package com.qf.utils;

import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;

import com.mchange.v2.c3p0.ComboPooledDataSource;

//数据库工具类
public class DbHelper {

	private static DataSource ds;
	private static QueryRunner qr;
	static{
		ds=new ComboPooledDataSource();
		qr=new QueryRunner(ds);
	}
	//执行非查询语句，返回值受影响的行数
	public static int execute(String sql,Object... vs){
		try {
			return qr.execute(sql, vs);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return 0;
	}
	//执行查询语句
	public static <T> T querySingle(String sql,Class<T> clz,Object... vs){
		try {
			
			return qr.query(sql, new BeanHandler<>(clz),vs);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
}

User类：

public class User {
	private int id;
	private String username;
	private String pass;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPass() {
		return pass;
	}
	public void setPass(String pass) {
		this.pass = pass;
	}
}

过滤器代码：

/**
 * Servlet Filter implementation class AutoLoginFilter
 * 实现自动登录，只是拦截登录页面
 */
@WebFilter(value="/login.html")
public class AutoLoginFilter implements Filter {
    /**
     * Default constructor. 
     */
    public AutoLoginFilter() {
        // TODO Auto-generated constructor stub
    }
	/**
	 * @see Filter#destroy()
	 */
	public void destroy() {
		// TODO Auto-generated method stub
	}

	/**
	 * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
	 */
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
		//强制转换为Http的请求和响应
		HttpServletRequest req=(HttpServletRequest) request;
		HttpServletResponse rep=(HttpServletResponse) response;
		
		//验证是否登录
		if(req.getSession().getAttribute("user")==null){
			//从Cookie获取上次保存的账号和密码
			Cookie[] cks=req.getCookies();
			User user=null;
			for(Cookie c:cks){
				if(c.getName().equals("user")){
					String[] us=c.getValue().split("@");
					user=new User();
					user.setUsername(us[0]);
					user.setPass(us[1]);
					break;
				}
			}
			//如果存储Cookie，那么就实现自动登录
			if(user!=null){//需要自动登录
				// 登录校验
				User user1 = DbHelper.querySingle("select * from tb_user where username=?", User.class, user.getUsername());
				boolean res=true;
				if (user1 != null) {
					if (user.getPass().equals(user1.getPass())) {
						req.getSession().setAttribute("user", user1);
						res=false;
						rep.sendRedirect(req.getServletContext().getContextPath()+"/success.jsp");
					}
				}
				if(res){//登录失败，之前的记录账号和密码错误
					Cookie ck=new Cookie("user","");
					ck.setPath("/");
					ck.setMaxAge(0);
					rep.addCookie(ck);
					rep.sendRedirect(req.getServletContext().getContextPath()+"/login.jsp");
				}
			}
			else{//直接登录页面
				chain.doFilter(request, response);
			}	
		}
		else{//如果已经登录，那么就直接放行
			rep.sendRedirect("success.jsp");
		}	
	}
	/**
	 * @see Filter#init(FilterConfig)
	 */
	public void init(FilterConfig fConfig) throws ServletException {
		// TODO Auto-generated method stub
	}
}

案例3 过滤脏词

public class DirtyFilter 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 {
		
		chain.doFilter(new DirtyHttpServletRequest((HttpServletRequest)request), response);

	}

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
	}
	static class DirtyHttpServletRequest extends HttpServletRequestWrapper{

		private List<String> dirtywords=new ArrayList<String>();
		public DirtyHttpServletRequest(HttpServletRequest request) {
			super(request);
			dirtywords.add("sb");
			dirtywords.add("狗蛋");
			dirtywords.add("扯淡");
		}
		@Override
		public String getParameter(String name) {
			// TODO Auto-generated method stub
			String v=super.getParameter(name);
			for (String s : dirtywords) {
				v=v.replaceAll(s, "***");
			}
			return v;
		}
	}
}

案例4 过滤器解决编码

public class CharacterEncodingFilter implements Filter {

	//filter配置
	private FilterConfig config;
	//默认编码
	private String defaultcharset="utf-8";
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub
		this.config=filterConfig;
	}
	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		String charset=config.getInitParameter("charset");
		if(charset==null){
			charset=defaultcharset;
		}
		//1设置请求和响应的编码
		request.setCharacterEncoding(charset);
		response.setContentType("text/html;charset="+charset);
		//2放行
		chain.doFilter(request, response);
		System.out.println("xxxxxxxxxxxxxxxx");
	
	}

	@Override
	public void destroy() {
		
	}
}

案例5 Jsp或Servlet响应内容压缩

文本内容压缩就是将服务器的响应结果给压缩为gzip的格式，以便达到浏览器和服务器传输，设置消息头让浏览器自动解压。

过滤器：

/**
 * Servlet Filter implementation class GlobalGzipFilter
 * 实现文本内容压缩
 */
@WebFilter("*.jsp")
public class GlobalGzipFilter implements Filter {

    /**
     * Default constructor. 
     */
    public GlobalGzipFilter() {
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see Filter#destroy()
	 */
	public void destroy() {
		// TODO Auto-generated method stub
	}

	/**
	 * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
	 */
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
		// TODO Auto-generated method stub
		// 重构响应对象
		GzipResponse rsp=new GzipResponse((HttpServletResponse)response, new ByteArrayOutputStream());
		
		// pass the request along the filter chain
		chain.doFilter(request, rsp);
		//获取响应的内容
		ByteArrayOutputStream baos=rsp.getOutStream();
		System.out.println("压缩之前："+baos.size()+"字节");
		//开始压缩
		//创建内存流对象，存储压缩之后的的内容
		ByteArrayOutputStream newbaos=new ByteArrayOutputStream();
		GZIPOutputStream gzip=new GZIPOutputStream(newbaos);
		gzip.write(baos.toByteArray());
		gzip.flush();
		gzip.close();
		System.out.println("压缩之后："+newbaos.size()+"字节");
		HttpServletResponse resp=(HttpServletResponse)response;
		//设置消息头，标记内容为gzip
		resp.setHeader("Content-Encoding", "gzip");
		resp.getOutputStream().write(newbaos.toByteArray());//写出真正的内容	
	}

	/**
	 * @see Filter#init(FilterConfig)
	 */
	public void init(FilterConfig fConfig) throws ServletException {
		// TODO Auto-generated method stub
	}
	//自定义的响应对象
	private class GzipResponse extends HttpServletResponseWrapper{

		private ByteArrayOutputStream baos;//内存输出字节流
		private PrintWriter pw;
		public GzipResponse(HttpServletResponse response,ByteArrayOutputStream baos) {
			super(response);
			this.baos=baos;
			// TODO Auto-generated constructor stub
		}
		//获取响应内容的内存流对象，存储着要响应的数据
		public ByteArrayOutputStream getOutStream(){
			// TODO Auto-generated method stub
			if(pw!=null){
				pw.flush();
			}
			return baos;
		}
		@Override
		public PrintWriter getWriter() throws IOException {
			//将响应的内容写出到指定的内存流中
			pw=new PrintWriter(new OutputStreamWriter(baos,"UTF-8"));
			return pw;
		}	
	}
}

案例6 实现图片防盗链

原理：http 协议中，如果从一个网页跳到另一个网页，http 头字段里面会带个 Referer。图片服务器通过检测 Referer 是否来自规定域名，来进行防盗链。

图片防盗链有什么用?

防止其它网站盗用你的图片，浪费你宝贵的流量。

package com.qf.filter2;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * wgy 2019/4/25 9:01
 */
@WebFilter(filterName = "StealFilter",urlPatterns = {"*.jpg","*.png"})
public class StealFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request= (HttpServletRequest) req;
        HttpServletResponse response= (HttpServletResponse) resp;
        String referer = request.getHeader("referer");
        String url="http://localhost:8080"+request.getContextPath();
        System.out.println(url);
        if(referer!=null&&referer.startsWith(url)){
            System.out.println("页面正常请求");
            chain.doFilter(req, resp);
        }else{
            System.out.println("盗链");
            request.getRequestDispatcher("/error/steal.jpg").forward(request, response);
        }

    }

    public void init(FilterConfig config) throws ServletException {

    }
}

第二节 监听器的使用

2.0 Java的事件监听机制

 1、事件监听涉及到三个组件：事件源、事件参数对象、事件监听器
 2、当事件源上发生某一个动作时，它会调用事件监听器的一个方法，并在调用该方法时把事件参数对象传递进去，
	开发人员在监听器中通过事件参数对象，就可以拿到事件源，从而对事件源进行操作。

案例一:GUI编程中监听机制

public static void main(String[] args) {
		Frame f = new Frame();
		f.setSize(400, 400);
		f.setVisible(true);
		
		f.addWindowListener(new WindowListener(){

			public void windowActivated(WindowEvent e) {
				// TODO Auto-generated method stub
				
			}

			public void windowClosed(WindowEvent e) {
				// TODO Auto-generated method stub
				
			}

			public void windowClosing(WindowEvent e) {
				Frame f = (Frame) e.getSource();
				f.dispose();
			}

			public void windowDeactivated(WindowEvent e) {
				// TODO Auto-generated method stub
				
			}

			public void windowDeiconified(WindowEvent e) {
				// TODO Auto-generated method stub
				
			}

			public void windowIconified(WindowEvent e) {
				// TODO Auto-generated method stub
				
			}

			public void windowOpened(WindowEvent e) {
				// TODO Auto-generated method stub
				
			}
			
		});
		

	}

案例二:观察者设计模式的实现

//设计一个事件源，被监听器监听  Observer（观察者设计模式）
public class Demo2 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		Person p = new Person();
		p.registerListener(new PersonListener(){

			public void doeat(Event e) {
				Person p = (Person)e.getSource();
				System.out.println(p.getName() + "吃啥呢");
			}

			public void dorun(Event e) {
				Person p = (Person)e.getSource();
				System.out.println(p.getName() + "减肥呢");
			}
			

		});
		p.eat();
	}

}

class Person{
	private String name;
	private PersonListener listener;
	
  	public String getName(){
        return name;
    }
  	public void setName(String name){
        this.name=name;
    }
	public void eat(){
      	 System.out.println(name+"要吃东西了...");
		if(listener!=null){
			listener.doeat(new Event(this));
		}
	}
	
	public void run(){
      	 System.out.println(name+"要跑步了...");
		if(listener!=null){
			listener.dorun(new Event(this));
		}
	}
	
	public void registerListener(PersonListener listener){
		this.listener = listener;
	}
}

interface PersonListener{
	
	public void doeat(Event e);
	
	public void dorun(Event e);
	
}

class Event{
	
	private Object source;

	
	public Event() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Event(Person source) {
		super();
		this.source = source;
	}

	public Object getSource() {
		return source;
	}

	public void setSource(Object source) {
		this.source = source;
	}
	
}

2.1 什么是监听器

​ 监听器用于监听web应用中某些对象(request,session,application)、信息的创建、销毁、增加，修改，删除等动作的发生，然后作出相应的响应处理。当范围对象的状态发生变化的时候，服务器自动调用监听器对象中的方法。常用于统计访问人数和在线用户，系统加载时进行信息初始化，统计网站的访问量等等。

2.2 监听器类型

2.2.1 生命周期监听器：

1 ServletContext上下文监听器

ServletContextListener接口
		内部方法：
		初始化：contextInitialized
		销毁：contextDestroyed

2 Session监听器

HttpSessionListener
		内部方法：
		sessionCreated：监听Session对象的创建
		sessionDestroyed：监听Session对象的销毁

3 request监听器

ServletRequestListener
		监听request对象的初始化和销毁
		内部方法：
			1、requestInitialized：监听request对象的初始化
			2、requestDestroyed：监听request对象的销毁

2.2.2属性变化监听器：

1 ServletContext属性变化监听器

 ServletContextAttributeListener接口        
 		内部的方法：        
 		attributeAdded：监听属性的添加        
 		attributeRemoved：监听属性的移除        
 		attributeReplaced：监听属性的修改

2 session属性变化监听器

HttpSessionAttributeListener
		监听HttpSession的内容的变化
		内部的方法：
		attributeAdded：监听属性的添加
		attributeRemoved：监听属性的移除
		attributeReplaced：监听属性的修改

3 request属性变化监听器

ServletRequestAttributeListener
		监听属性内容变化
		内部方法：
		attributeAdded：监听属性的添加
		attributeRemoved：监听属性的移除
		attributeReplaced：监听属性的修改

2.2.3感知型监听器：

1 对象从session添加或移除

HttpSessionBindingListener
		监听对象的添加和移除
		内部方法：
		valueBound：监听对象的绑定
		valueUnbound：监听对象的解除绑定

2 对象钝化和活化

HttpSessionActivationListener
		监听session的钝化和活化
		内部方法：
		sessionWillPassivate：监听Session内部存储对象的钝化-写入
		sessionDidActivate：监听Session内部存储对象的活化-读取
		对应类需要实现序列化接口Serializable
		
在 web目录下创建META-INF文件夹，在META-INF文件夹中创建context.xml文件		
<?xml version='1.0' encoding='utf-8'?>
<Context>
	<Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="60">
	<Store className="org.apache.catalina.session.FileStore" directory="qf">  
	</Store>
</Manager>
</Context>
<!-- maxIdleSwap: session中的对象最大多长时间不使用就被钝化 (秒单位，但是时间不是太准确) -->
<!-- directory: 钝化后的对象的文件写到磁盘的哪个目录下 -->
<!-- 配置钝化的对象文件在${TOMCAT_HOME}/work/Catalina/localhost/YOUR_PROJECT/qf -->

2.3 监听器的2种配置

2.3.1 xml的配置

在web.xml中进行配置

<listener>
<!--直接写出自定义的监听器的类名即可-->
    <listener-class>com.qf.web.listener.RequestLeftListener</listener-class>
</listener>

2.3.2注解式配置

Servlet3.0之后新增的，使用注解@WebListener进行监听器的注册

2.4 代码实现

2.4.1 ServletContext的监听器：

a. 实现ServletContext生命周期的监听

/**
 * Application Lifecycle Listener implementation class FirstListener
 *监听ServletContext的初始化和销毁
 */
@WebListener//注解式注册
public class ApplicationListener implements ServletContextListener {

    /**
     * Default constructor. 
     */
    public ApplicationLeftListener() {
        // TODO Auto-generated constructor stub
    	
    }

	/**
     * @see ServletContextListener#contextDestroyed(ServletContextEvent)
     * 销毁
     */
    public void contextDestroyed(ServletContextEvent sce)  { 
         // TODO Auto-generated method stub
    	System.out.println("网站被销毁了"+sce.getServletContext().hashCode());
    }

	/**
     * @see ServletContextListener#contextInitialized(ServletContextEvent)
     * 初始化
     */
    public void contextInitialized(ServletContextEvent sce)  { 
         // TODO Auto-generated method stub
    	System.out.println("网站初始化完成"+sce.getServletContext().hashCode());
    	sce.getServletContext().setAttribute("fwrs", 0);
    }	
}

b. ServletContext属性内容的变化

/**
 * Application Lifecycle Listener implementation class ApplicationAttributeListener
 * 实现ServletContext属性内容变化
 */
@WebListener
public class ApplicationAttributeListener implements ServletContextAttributeListener {

    /**
     * Default constructor. 
     */
    public ApplicationAttributeListener() {
        // TODO Auto-generated constructor stub
    }

	/**
     * @see ServletContextAttributeListener#attributeAdded(ServletContextAttributeEvent)
     * 新增内容
     */
    public void attributeAdded(ServletContextAttributeEvent event)  { 
         // TODO Auto-generated method stub
    	System.out.println("attributeAdded:"+event.getName());
    }

	/**
     * @see ServletContextAttributeListener#attributeRemoved(ServletContextAttributeEvent)
     * 删除属性内容
     */
    public void attributeRemoved(ServletContextAttributeEvent event)  { 
         // TODO Auto-generated method stub
    	System.out.println("attributeRemoved:"+event.getName());
    }

	/**
     * @see ServletContextAttributeListener#attributeReplaced(ServletContextAttributeEvent)
     * 修改内容
     */
    public void attributeReplaced(ServletContextAttributeEvent event)  { 
         // TODO Auto-generated method stub
    	System.out.println("attributeReplaced:"+event.getName());
    }
}

2.4.2 HttpSession监听器

a. 实现HttpSession生命周期的变化和属性内容的变化和id变化

/**
 * Application Lifecycle Listener implementation class SessionLeftListener
 * 该监听器实现HttpSession的生命周期变化和属性内容的变化
 *
 */
@WebListener
public class SessionListener implements HttpSessionListener, HttpSessionAttributeListener{

    /**
     * Default constructor. 
     */
    public SessionLeftListener() {
        // TODO Auto-generated constructor stub
    }

	/**
     * @see HttpSessionListener#sessionCreated(HttpSessionEvent)
     * Session的创建
     */
    public void sessionCreated(HttpSessionEvent se)  { 
         // TODO Auto-generated method stub
    	System.out.println("sessionCreated");
    	int ct=(int) se.getSession().getServletContext().getAttribute("fwrs");
    	se.getSession().getServletContext().setAttribute("fwrs", ++ct);
    	se.getSession().setAttribute("tea", new Teacher("西施"));
    }

	/**
     * @see HttpSessionListener#sessionDestroyed(HttpSessionEvent)
     * Session的销毁
     */
    public void sessionDestroyed(HttpSessionEvent se)  { 
         // TODO Auto-generated method stub
    	System.out.println("sessionDestroyed");
    }

	/**
     * @see HttpSessionAttributeListener#attributeAdded(HttpSessionBindingEvent)
     * Session中属性内容的添加
     */
    public void attributeAdded(HttpSessionBindingEvent event)  { 
         // TODO Auto-generated method stub
    }

	/**
     * @see HttpSessionAttributeListener#attributeRemoved(HttpSessionBindingEvent)
     * Session中属性内容的移除
     */
    public void attributeRemoved(HttpSessionBindingEvent event)  { 
         // TODO Auto-generated method stub
    }

	/**
     * @see HttpSessionAttributeListener#attributeReplaced(HttpSessionBindingEvent)
     * Session中属性内容的修改
     */
    public void attributeReplaced(HttpSessionBindingEvent event)  { 
         // TODO Auto-generated method stub
    }

    //监听HttpSession的id的变化，Servlet3.1新特性
	@Override
	public void sessionIdChanged(HttpSessionEvent event, String oldSessionId) {
		// TODO Auto-generated method stub
		
	}
}

案例：实现访问人数统计

public class VisitCountListener implements HttpSessionListener {


	@Override
	public void sessionCreated(HttpSessionEvent se) {
		//负责人数增加
		ServletContext application=se.getSession().getServletContext();
		Integer count=(Integer)application.getAttribute("count");
		if(count==null){
			application.setAttribute("count", 1);
		}else{
			application.setAttribute("count", count+1);
		}
		System.out.println("人数增加了");
		
	}

	@Override
	public void sessionDestroyed(HttpSessionEvent se) {
		//负责人数的减少
		ServletContext application=se.getSession().getServletContext();
		Integer count=(Integer)application.getAttribute("count");
		application.setAttribute("count", count-1);
		System.out.println("人数减少了");
	}

}

2.4.3 ServletRequest监听器

a. 监听ServletRequest生命周期和属性内容变化

/**
 * Application Lifecycle Listener implementation class RequestLeftListener
 *监听Request对象的内容
 */
//@WebListener
public class RequestListener implements ServletRequestAttributeListener,ServletRequestListener {

    /**
     * Default constructor. 
     */
    public RequestLeftListener() {
        // TODO Auto-generated constructor stub
    }



    /**
     * @see ServletRequestListener#requestInitialized(ServletRequestEvent)
     * 请求对象的初始化
     */
    public void requestInitialized(ServletRequestEvent sre)  { 
         // TODO Auto-generated method stub
    }
	/**
     * @see ServletRequestListener#requestDestroyed(ServletRequestEvent)
     * 销毁
     */
    public void requestDestroyed(ServletRequestEvent sre)  { 
         // TODO Auto-generated method stub
    }

	/**
     * @see ServletRequestAttributeListener#attributeRemoved(ServletRequestAttributeEvent)
     * 移除属性内容
     */
    public void attributeRemoved(ServletRequestAttributeEvent srae)  { 
         // TODO Auto-generated method stub
    }
	/**
     * @see ServletRequestAttributeListener#attributeAdded(ServletRequestAttributeEvent)
     * 添加
     */
    public void attributeAdded(ServletRequestAttributeEvent srae)  { 
         // TODO Auto-generated method stub
    }
	/**
     * @see ServletRequestAttributeListener#attributeReplaced(ServletRequestAttributeEvent)
     * 修改
     */
    public void attributeReplaced(ServletRequestAttributeEvent srae)  { 
         // TODO Auto-generated method stub
    }	
}

案例：Session管理器

​ 自定义Session管理器，session会话，会话的默认有效30分钟, 需要使用开发人员自己管理session的有效期，不需要系统管理。

​ 功能1：把所有的session放入集合中。

​ 功能2：遍历集合中每个session, 判断session有多长时间没有访问了，如果超过1分钟，把session失效了。###### 案例：Session管理器

​

package com.qf.listener;

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import javax.enterprise.inject.New;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class SessionManagerListener implements HttpSessionListener,ServletContextListener {

	private static Object lock=new Object();
	private Timer timer;
	//保存所有的session
	private List<HttpSession> sessions=new LinkedList<HttpSession>();
	
	@Override
	public void sessionCreated(HttpSessionEvent se) {
		// TODO Auto-generated method stub
		synchronized (lock) {
			sessions.add(se.getSession());
		}
		System.out.println("添加了session....."+se.getSession().getId());
	}

	@Override
	public void sessionDestroyed(HttpSessionEvent se) {
		// TODO Auto-generated method stub
		System.out.println("销毁了session...."+se.getSession().getId());
	}

	@Override
	public void contextInitialized(ServletContextEvent sce) {
		// TODO Auto-generated method stub
		//启动定时器
	    timer=new Timer();
		timer.schedule(new MyTimerTask(), 0, 60*1000);
		System.out.println("定时器启动");
		//把集合放入application中
		sce.getServletContext().setAttribute("sessions", sessions);
		
	}

	@Override
	public void contextDestroyed(ServletContextEvent sce) {
		// TODO Auto-generated method stub
		timer.cancel();//取消定时器
		System.out.println("定时器取消了...");
	}
	class MyTimerTask extends TimerTask{

		@Override
		public void run() {
			Iterator<HttpSession> it=sessions.iterator();
			synchronized (lock) {
				while(it.hasNext()){
					HttpSession session=it.next();
					if(System.currentTimeMillis()-session.getLastAccessedTime()>60000){
						session.invalidate();//session失效
						it.remove();
					}
				}
			}
			
			
		}
		
	}

}