Web之過濾器和監聽器
回顧
1 jsp 本質就是一個Servlet 繼承HttpJspBase--->HttpServlet
_jspService( request ,response){
}
包含的內容
指令 腳本 腳本表達式 聲明 HTML css javascript
<%@page language="java" contentType="" pageEncoding="utf-8"%>
<%
%>
<%=aaa%>
<%!
%>
2 指令
page指令
language
contentType
pageEncoding
session
errorPage
isErrorPage
isELIngnored
include包含指令
靜態包含：編譯時就把包含的頁面加入進來。
taglib 指令：導入標籤庫JSTL
3 jsp動作標籤
jsp:include:動態包含：編譯時沒有加入進來，執行時再加入包含頁面
jsp:forward：轉發：request.getRequestDispatcher().forward();
jsp:parm:轉發的參數
jsp:useBean:如果pageContext域中不存在，創建對象並放入pageContext域，如果存在不創建。
jsp:setPropertity：屬性賦值
jsp:getPropertity：獲取屬性值
4 jsp內置對象（rrsa ceo pp）
request
response
session
application
config
exception
out(JspWriter)
pageContext
page:this
5 pageContext: 1獲取其他八個內置對象 ，2 作爲容器使用，可以獲取或設置其他容器中的數據
6 4個域對象 request session application pageContext
7 EL表達式 ：代替頁面中的腳本表達式（輸出語句）
${表達式}
7.1 輸出簡單數據
${ username}
7.2 輸出對象的屬性
${user.username}
${user.address.counry}
7.3 輸出集合數據
list集合
${list[0]}
${list[1]}
map集合
${maps.cn}
${maps["10"]}
7.4執行運算
算術運算 + - * / %
關係元素 > < == >= <= gt lt eq ge le
邏輯元素 && || ! and or not
三元操作 ? :
empty空判斷 ${!empty user} 1 沒有user 2 null 3 ""
7.5 EL 11個隱式對象
pageContext ${pageContext.request.contextpath}
pageScope 、requestScope、sessionScope、applicationScope
param
paramValues
header
headerValues
initparam
cookie
8 JSTL （1.1.2）
三個通用標籤 set out remove
邏輯控制 if choose foreach
url
<!-- 創建一個地址，並放入pageContxt域中 myurl 1 url重寫 2 對中文編碼-->
<c:url var="myurl" value="/index.jsp">
<c:param name="username" value="張三"></c:param>
<c:param name="age" value="20"></c:param>
</c:url>
今日內容
1、什麼是過濾器
2、過濾器鏈
3、過濾器的優先級和參數
4、過濾器的典型應用
5、什麼是監聽器
6、常用的監聽器
教學目標
1、熟悉什麼是過濾器
2、掌握過濾器鏈
3、掌握過濾器的優先級和參數
4、掌握過濾器的典型應用
5、熟悉什麼是監聽器
6、掌握常用的監聽器
第一節 過濾器
1.1 什麼是過濾器
Filter也稱之爲過濾器，它是Servlet技術中最激動人心的技術，WEB開發人員通過Filter技術，對web服務器管理的所有web資源：例如Jsp, Servlet, 靜態圖片文件或靜態 html 文件等進行攔截，從而實現一些特殊的功能。例如實現URL級別的權限訪問控制、過濾敏感詞彙、壓縮響應信息等一些高級功能。
Servlet API中提供了一個Filter接口，開發web應用時，如果編寫的Java類實現了這個接口，則把這個java類稱之爲過濾器Filter。通過Filter技術，開發人員可以實現用戶在訪問某個目標資源之前，對訪問的請求和響應進行攔截。
1.2 如何編寫過濾器
1、編寫java類實現Filter接口
2、重寫doFilter方法
3、設置攔截的url
#####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.4 過濾器鏈
通常客戶端對服務器請求之後，服務器調用Servlet之前會執行一組過濾器（多個過濾器）,那麼這組過濾器就稱爲一條過濾器鏈。
每個過濾器實現某個特定的功能，一個過濾器檢測多個Servlet。（匹配幾個，檢測幾個）。
一組過濾器中的執行順序與<filter-mapping>的配置順序呢有關。
當第一個Filter的doFilter方法被調用時，web服務器會創建一個代表Filter鏈的FilterChain對象傳遞給該方法。在doFilter方法中，開發人員如果調用了FilterChain對象的doFilter方法，則web服務器會檢查FilterChain對象中是否還有filter，如果有，則調用第2個filter，如果沒有，則調用目標資源
1.5 過濾器的優先級
在一個web應用中，可以開發編寫多個Filter，這些Filter組合起來稱之爲一個Filter鏈。web服務器根據Filter在web.xml文件中的註冊順序，決定先調用哪個Filter。當第一個Filter的doFilter方法被調用時，web服務器會創建一個代表Filter鏈的FilterChain對象傳遞給該方法。在doFilter方法中，開發人員如果調用了FilterChain對象的doFilter方法，則web服務器會檢查FilterChain對象中是否還有filter，如果有，則調用第2個filter，如果沒有，則調用目標資源
如果爲註解的話，是按照類名的字符串順序進行起作用的
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");
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
}
}
案例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放行
MyHttpServletRequest myrequest=new MyHttpServletRequest((HttpServletRequest)request);
chain.doFilter(myrequest, response);
System.out.println("xxxxxxxxxxxxxxxx");
}
@Override
public void destroy() {
}
}
案例5 文本內容壓縮（Servlet響應內容的壓縮）
文本內容壓縮就是將服務器的響應結果給壓縮爲gzip的格式，以便達到瀏覽器和服務器傳輸，設置消息頭讓瀏覽器自動解壓。
過濾器：
/**
* Servlet Filter implementation class GlobalGzipFilter
* 實現文本內容壓縮
*/
@WebFilter("/*")
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;
}
}
}
第二節 監聽器的使用
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) {
System.out.println("美死你！！");
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 = e.getSource();
System.out.println(p + "吃啥呢");
}
public void dorun(Event e) {
// TODO Auto-generated method stub
}
});
p.eat();
}
}
class Person{
private PersonListener listener;
public void eat(){
if(listener!=null){
listener.doeat(new Event(this));
}
}
public void run(){
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 Person source;
public Event() {
super();
// TODO Auto-generated constructor stub
}
public Event(Person source) {
super();
this.source = source;
}
public Person getSource() {
return source;
}
public void setSource(Person source) {
this.source = source;
}
}
2.1 什麼是監聽器
監聽器用於監聽web應用中某些對象、信息的創建、銷燬、增加，修改，刪除等動作的發生，然後作出相應的響應處理。當範圍對象的狀態發生變化的時候，服務器自動調用監聽器對象中的方法。常用於統計訪問人數和在線用戶，系統加載時進行信息初始化，統計網站的訪問量等等
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
監聽服務器的鈍化和活化
內部方法：
sessionWillPassivate：監聽Session內部存儲對象的鈍化-存儲
sessionDidActivate：監聽Session內部存儲對象的活化---讀取
對應類需要實現序列化接口Serializable
<Context>
<Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
<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 OnlineCountListener 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管理器
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();
}
}
}
}
}
}
案例：登錄人數統計
作業題
1、使用監聽器實現當前登錄用戶人數和今日訪問人數統計
2、使用過濾器實現未登錄攔截
面試題
1、過濾器有哪些作用和用法？
2、監聽器有哪些作用和用法？
