一．监听器的定义
 
是指专门用于对其他对象身上发生的事件或状态改变进行监听和相应处理的对象，当被监视的对象发生变化时，立即采取相应的行动。
 
Web应用当中监听器是什么？
 

 web监听器由servlet规范提供的，它可以监听客户端的请求，服务端的操作，监听的对象包括ServletContext,HttpSession,ServletRequest三个预对象(内置对象)，分别对应aplication，session，request。
 
 
内置对象
 
JSP中一共预先定义了9个这样的内置对象，分别为：request、response、session、application、out、pagecontext、config、page、exception
 内置对象（又叫隐含对象)特点:
 
由JSP规范提供,不用编写者实例化。
通过Web容器实现和管理
所有JSP页面均可使用
只有在脚本元素的表达式或代码段中才可使用(<%=使用内置对象%>或<%使用内置对象%>)
 
request对象
 
request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息，主要用于接受通过HTTP协议传送到服务器的数据。（包括头信息、系统信息、请求方式以及请求参数等）。request对象的作用域为一次请求。
 
session对象
 
session 对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象，用于保存该用户的信息，跟踪用户的操作状态。session对象内部使用Map类来保存数据，因此保存数据的格式为 “Key/value”。 session对象的value可以使复杂的对象类型，而不仅仅局限于字符串类型。
 
application对象
 
application 对象可将信息保存在服务器中，直到服务器关闭，否则application对象中保存的信息会在整个应用中都有效。与session对象相比，application对象生命周期更长，类似于系统的“全局变量”。
 
Web监听器概念
 
Servlet规范中定义的一种特殊类
 用于监听ServletContext，HttpSession和ServletRequest等域对象的创建与销毁事件用于监听域对象的属性发生修改的事件可以在事件发生前，发生后做一些必要的处理
 
二．Web监听器的用途
 
1.统计在线人数和在线用户
 2.系统启动时加载初始化信息
 3.统计网站访问量
 4.跟Spring结合
 
三．第一个Web监听器
 
实现步骤
 
1.创建一个实现监听器接口的类
 

 
 代码如下：
 
package com.java.listener;

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

/**
 * @author : xiayj
 * @date : 2019/8/3 17:58
 */
public class FirstListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("contextInitialized");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("contextDestroyed");
    }
}
 
2.配置web.xml进行注册
 
把监听对象放到web.xml中
 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <listener>
        <listener-class>com.java.listener.FirstListener</listener-class>
    </listener>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <login-config>
        <auth-method>BASIC</auth-method>
    </login-config>
</web-app>
 
启动tomcat，控制台输出如下说明当web应用启动时会自动创建一个application对象，且只有一个
 
 关闭tomcat，如下表示当前应用销毁
 
 
监听器的启动顺序
 
 
四．监听器的分类
 
1.按监听的对象划分
 
1)用于监听应用程序环境对象(ServletContext)的事件监听器
 2)用于监听用户会话对象(HttpSession)的事件监听器
 3)用于监听请求消息对象(ServletRequest)的事件监听器
 
2.按监听的事件划分
 
1)监听域对象自身的创建和销毁的事件监听器
 
 
ServletContext的创建与销毁
 
ServletContext实现了ServletContextListener用于监听它的创建与销毁事件，一个web项目可以定义多个ServletContextListener，但一个web项目只有一个ServletContext对象。
 ServletContextListener有两个事件处理方法，这两个方法都会传入ServletContextEvent事件对象，可以获取ServletContext对象以及一些初始化参数。ServletContextListener主要用途：可以做定时器，加载全局属性对象，创建全局的数据库连接，加载一些缓存信息。
 
 web.xml配置如下
 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <listener>
        <listener-class>com.java.listener.FirstListener</listener-class>
    </listener>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <login-config>
        <auth-method>BASIC</auth-method>
    </login-config>
<!--配置初始化参数-->
    <context-param>
        <param-name>initParam</param-name>
        <param-value>listener</param-value>
    </context-param>
</web-app>
 
代码实现：
 
package com.java.listener;

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

/**
 * @author : xiayj
 * @date : 2019/8/3 17:58
 */
public class FirstListener implements ServletContextListener {
    //ServletContext是上下文对象，当web应用启动时创建，web应用销毁时销毁
    @Override
    public void contextInitialized(ServletContextEvent sce) {
//项目启动时获取初始化参数
        String initParam = sce.getServletContext().getInitParameter("initParam");
        System.out.println("contextInitialized : initParam = " + initParam);
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
//销毁主要用于当数据库连接关闭时释放一些不必要的资源
        System.out.println("contextDestroyed");
    }
}
 
项目启动结果如下，说明当项目启动时就加载了在web.xml中配置的参数
 
 
HttpSession的创建与销毁
 
与ServletContext类似，HttpSession实现了HttpSessionListener用于监听它的创建与销毁事件，一个web项目可以定义多个HttpSessionListener，但一个web项目只有一个HttpSession对象。HttpSessionEvent事件对象，可以获取当前被创建的HttpSession对象。HttpSessionListener主要用途：统计在线人数，记录访问日志。
 
 Session创建：用户打开浏览器第一次访问我们应用时，这次会话web容器会分配一个session，可以在session中保存一些信息
 Session销毁：1.手动点退出，关闭服务器2.关闭浏览器一段时间直到session过期3.不关闭浏览器，session超时
 实现HttpSessionListener：
 
package com.java.listener;

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

/**
 * @author : xiayj
 * @date : 2019/8/4 16:59
 */
public class MyHttpSessionListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        System.out.println("sessionCreated");
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        System.out.println("sessionDestroyed");
    }
}
 
web.xml文件加如下配置
 
<!--配置session超时时间,1表示1分钟0表示没有超时限制-->
<session-config>
    <session-timeout>1</session-timeout>
</session-config>
 
访问项目
 
 控制台输出如下Listener监听到session创建
 
 等一分钟后，监听到session被销毁
 
 
ServletRequest的创建与销毁
 
ServletRequest实现了ServletRequestListener用于监听它的创建与销毁事件，一个web项目可以定义多个ServletRequestListener，但一个web项目只有一个ServletRequest对象。ServletRequestListener主要用途：读取request里的参数，记录访问历史，路径。
 
 实现ServletRequestListener
 
package com.java.listener;

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

/**
 * @author : xiayj
 * @date : 2019/8/4 17:54
 */
public class MyServletRequestListener implements ServletRequestListener {
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        //获取当前的请求参数
        String name = sre.getServletRequest().getParameter("name");
        System.out.println("requestInitialized");
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("requestDestroyed");
    }
}
 
Web.xml中增加监听器配置信息
 
<listener>
    <listener-class>com.java.listener.MyServletRequestListener</listener-class>
</listener>
 
启动项目，打开浏览器，查看控制台如下，可知request监听到了用户的访问请求，并在请求结束后销毁
 
 
2)监听域对象中的属性的增加和删除的事件监听器
 

 代码实现:
 新建三个类
 
package com.java.listener;

import javax.servlet.ServletRequestAttributeEvent;
import javax.servlet.ServletRequestAttributeListener;

/**
 * @author : xiayj
 * @date : 2019/8/10 17:18
 */
public class MyServletRequestAttributeListener implements ServletRequestAttributeListener {
    @Override
    public void attributeAdded(ServletRequestAttributeEvent srae) {
//可知是什么对象添加了什么属性，移除了什么属性       System.out.println("ServletRequest_attributeAdded:"+srae.getName());
    }

    @Override
    public void attributeRemoved(ServletRequestAttributeEvent srae) {
        System.out.println("ServletRequest_attributeRemoved:"+srae.getName());
    }

    @Override
    public void attributeReplaced(ServletRequestAttributeEvent srae) {
        System.out.println("ServletRequest_attributeReplaced:"+srae.getName());
    }
}
 
package com.java.listener;

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

/**
 * @author : xiayj
 * @date : 2019/8/10 16:55
 */
public class MyHttpSessionAttributeListener implements HttpSessionAttributeListener {
    @Override
    public void attributeAdded(HttpSessionBindingEvent se) {
        System.out.println("HttpSession_attributeAdded:"+se.getName());
    }

    @Override
    public void attributeRemoved(HttpSessionBindingEvent se) {
        System.out.println("HttpSession_attributeRemoved:"+se.getName());
    }

    @Override
    public void attributeReplaced(HttpSessionBindingEvent se) {
        System.out.println("HttpSession_attributeReplaced:"+se.getName());
    }
}
 
package com.java.listener;

import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;

/**
 * @author : xiayj
 * @date : 2019/8/10 16:52
 */
public class MyServletContextAttributeListener implements ServletContextAttributeListener {
    @Override
    public void attributeAdded(ServletContextAttributeEvent scae) {
        System.out.println("ServletContext_attributeAdded:"+scae.getName());
    }

    @Override
    public void attributeRemoved(ServletContextAttributeEvent scae) {
        System.out.println("ServletContext_attributeRemoved:"+scae.getName());
    }

    @Override
    public void attributeReplaced(ServletContextAttributeEvent scae) {
        System.out.println("ServletContext_attributeReplaced:"+scae.getName());
    }
}
 
Web.xml文件中注册监听器
 
<listener>
    <listener-class>com.java.listener.MyHttpSessionAttributeListener</listener-class>
</listener>
<listener>
    <listener-class>com.java.listener.MyServletContextAttributeListener</listener-class>
</listener>
<listener>
    <listener-class>com.java.listener.MyServletRequestAttributeListener</listener-class>
</listener>
 
创建新增各个属性值得jsp界面，为了方便在每个页面都加上了初始化，销毁的按钮
 index.jsp
 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>这是myweb应用</title>
  </head>
  <body>
  你好！这是一个listener
  <button onclick="location.href='<%=request.getContextPath()%>/init.jsp';">Init</button>
  <button onclick="location.href='<%=request.getContextPath()%>/destory.jsp';">Destory</button>
  </body>
</html>
 
init.jsp
 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServletPath();
//添加属性，让Listener监听执行attributeAdded方法
request.setAttribute("requestName","requestValue");
request.getSession().setAttribute("sessionName","sessionValue");
request.getSession().getServletContext().setAttribute("contextName","contextValue");
%>
<html>
<head>
    <title>Title</title>
</head>
<body>
这是初始化值得界面
<button onclick="location.href='<%=request.getContextPath()%>/init.jsp';">Init</button>
<button onclick="location.href='<%=request.getContextPath()%>/destory.jsp';">Destory</button>
</body>
</html>
 
destory.jsp
 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServletPath();
    //移除属性，让Listener监听执行attributeRemoved方法
    request.removeAttribute("requestName");
    request.getSession().removeAttribute("sessionName");
    request.getSession().getServletContext().removeAttribute("contextName");
%>
<html>
<head>
    <title>Title</title>
</head>
<body>
这是销毁界面
<button onclick="location.href='<%=request.getContextPath()%>/init.jsp';">Init</button>
<button onclick="location.href='<%=request.getContextPath()%>/destory.jsp';">Destory</button>
</body>
</html>
 
超时时间改为0
 
<!--配置session超时时间,1表示1分钟0表示没有超时限制-->
<session-config>
    <session-timeout>0</session-timeout>
</session-config>
 
打开主页面
 
 点击init，控制台输出如下
 
 再次点击init
 
 点击destory，属性被移除，request对象因为已经被销毁了，域中已没有requestName属性，所以没有移除信息
 
 
3)监听绑定到HttpSession域中的某个对象的状态的事件监听器
 

 绑定：通过getSession().setAttribute将对象保存到session对象中
 解除绑定：通过getSession().removeAttribute将对象从session对象中移除
 钝化：将session对象持久化到存储设备上
 活化：将session对象从存储设备上恢复
 

 
 
 
 代码实现：
 新建user类
 
package com.java.entity;

import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionEvent;
import java.io.Serializable;

/**
 * @author : xiayj
 * @date : 2019/8/17 16:09
 */
/** 想要钝化或活化必须实现Serializable接口*/
public class User implements HttpSessionBindingListener, HttpSessionActivationListener, Serializable {
    private String username;
    private String password;
    /** 对象绑定执行*/
    @Override
    public void valueBound(HttpSessionBindingEvent event) {
        System.out.println("valueBound Name:"+event.getName());
    }
    /** 对象解除绑定执行*/
    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {
        System.out.println("valueUnbound Name:"+event.getName());
    }
    /** 钝化*/
    @Override
    public void sessionWillPassivate(HttpSessionEvent se) {
        System.out.println("sessionWillPassivate"+se.getSource());
    }
    /** 活化*/
    @Override
    public void sessionDidActivate(HttpSessionEvent se) {
        System.out.println("sessionDidActivate"+se.getSource());
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
 
绑定/解除绑定测试：
 
在init文件里增加如下：
 
//将用户实例放到session中
request.getSession().setAttribute("currentUser",new com.java.entity.User());
 
在destory文件里增加如下：
 
request.getSession().removeAttribute("currentUser");
 
启动项目，打开首页：
 
 点击init和destory，控制台分别输出如下，表明当对象实现HttpSessionBindingListener接口后，只要对象被session绑定，就会触发事件，执行valueBound方法，当解除绑定后，执行valueUnBound方法
 
 
 
钝化/活化测试
 
启动tomcat，打开项目，可以看到控制台已经创建session
 
 点击init，可以看到session中保存了几个属性值
 
 关闭tomcat，控制输出如下，sessionWillPassivateorg.apache.catalina.session.StandardSessionFacade@1e7c7811 就是session钝化的输出，StandardSession是默认的钝化管理器
 
 钝化的文件保存位置如下
 
 在首页新增如下：
 
<!-- 在首页获取用户对象 正常情况下因为tomcat已关闭，session中用户对象应该已被销毁，
但因为实现了HttpSessionActivationListener接口，tomcat重新启动时会活化保存的session文件-->
<%=request.getSession().getAttribute("currentUser")%>
你好！这是一个listener
<button onclick="location.href='<%=request.getContextPath()%>/init.jsp';">Init</button>
<button onclick="location.href='<%=request.getContextPath()%>/destory.jsp';">Destory</button>
 
重启tomcat，控制台输出如下：
 
 打开首页，可以看到之前钝化的user对象被输出
 
 Ps：如果出现可以活化，但是无法钝化的问题即重启tomcat没有调用 sessionDidActivate()方法,浏览器端也获取不到重启前存入的对象
 这是因为每次重启tomcat会将如下目录删除并重新生成，之前钝化的session文件也会被一起删除
 
 解决方法：在tomcat安装目录下conf/context.xml配置文件里增加如下配置，directory里是自定义的session文件存储路径
 
<Manager className="org.apache.catalina.session.PersistentManager" saveOnRestart="true">
        <Store className="org.apache.catalina.session.FileStore" directory="D:\tomcat\session"/>
</Manager>
 
在Servlet3.0版本以上提供@WebListener注解将一个实现了特定监听器接口（比如ServletContextListener，HttpSessionListener）的类定义为监听器，这样在web应用中使用监听器时不需要在web.xml文件中配置监听器的相关描述信息，感兴趣的可以自己去研究一下，用法差不多。
 
 
 
参考文章：Jsp：九大内置对象https://my.oschina.net/u/3805464/blog/1813805
 本文章内容是对慕课网课程内容的一个总结，感兴趣的同学可以去慕课网学习该课程
 地址如下：https://www.imooc.com/learn/271
 

 
监听器设计模式
 
设计模式
创建型
结构型
行为型
  
观察者设计模式
观察者接口（IObserve）
观察者实现类（FirstObserve、SecondObserve）
   
被观察者接口（IObservable）
被观察者实现类
   
测试类
  
监听器设计模式
事件接口（ICurdEvent）
事件实现类
   
监听器接口（IListener）
监听器实现类
   
事件源接口（IListenerable）
事件源实现类
   
测试类
 

 
设计模式
 
设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
 
创建型
 
通过特定的方式创建特定对象的设计模式
 
（工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式）
 
结构型
 
为了解决某一特定问题所搭建的特定代码结构的设计模式
 
（适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式）
 
行为型
 
通过构建不同的角色来完成某一特定功能的设计模式
 
(策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式)
 
通过了解以上我们知道设计模式的大概 接下来进入重点 监听器设计模式，监听器设计模式是观察者设计模式的衍生，所以得先了解观察者设计模式。
 
观察者设计模式
 
观察者设计模式从名字上来看，首先得有观察者和被观察者，所以它有两个接口：IObserve和IObservable，其主要实现的功能就是当被观察者对象的状态有更改的时候，观察者时时会有相应的通知并做出相应的操作
 原理：就是在目标对象中耦合观察者的对象，并且在注册观察者对象的时候调用相应操作的方法； 两者之间的关系是单向关联的；目标类和观察类之间维护的是松耦合的关系；
 
 
观察者接口（IObserve）
 
需要实现的功能
 
接收并处理被观察者发送来的信息
 
package IObserve;
public interface IObserve {
//    观察者处理被观察者发送过来额信息
    void handleNotify(String message);
}
 
观察者实现类（FirstObserve、SecondObserve）
 
有多个观察者，所以需要写多个实现类，第一个观察者
 
package IObserve;
public class FistObserve implements IObserve {
    @Override
    public void handleNotify(String message) {
        System.out.println("1号接受的消息"+message );
    }
}
 
第二个观察者
 
package IObserve;
public class SecondObserve implements IObserve {
    @Override
    public void handleNotify(String message) {
        System.out.println("2号接受的消息"+message);
    }
}
 
被观察者接口（IObservable）
 
需要实现的功能
 
可以添加观察者
 添加操作可以通过Array List的add()方法实现。
删除观察者
 删除操作通过ArrayList的remove()方法实现。
向观察者发送信息
 
package IObservable;
import IObserve.IObserve;

public interface IObservable {
//    添加观察者
    void addObserve(IObserve observable);
//    删除观察者
    void removeObserve(IObserve observable);
//    向观察者发送信息
    void notifyObservers(String message);
}
 
被观察者实现类
 
由于一个被观察者可以有多个观察者，所以可以创建一个ArrayList来存放多个观察者。
 
package IObservable;
import IObserve.IObserve;
import java.util.ArrayList;
import java.util.List;

public class Some implements IObservable{
//    由于一个被观察者可以被多个观察者所观察，所以要设置一个观察者链表里
    private List<IObserve> observes;
    public Some(){
        //在被观察者对象被创建时，就将集合创建
        observes = new ArrayList<>();
    }
    @Override
    public void addObserve(IObserve observe) {
        observes.add(observe);
    }
    @Override
    public void removeObserve(IObserve observe) {
        observes.remove(observe);
    }
    @Override
    public void notifyObservers(String message) {
        for (IObserve observe :
                observes) {
            observe.handleNotify(message);
        }
    }
}
 
测试类
 
首先需要创建观察者类的对象，然后创建被观察者类的对象，因为在被观察者类中写入的构造方法中有ArrayList的创建，所以在创建其对象的时候就已经准备好一个链表observes来存放观察者的对象observe，被观察者类Some其对象调用notifyObservers()方法，向观察者发送信息，最后通过遍历observes来调用观察者实现类的handleNotify(message)方法来实现观察者实现的操作。
 
package test;

import IObservable.Some;
import IObserve.SecondObserve;
import IObserve.FistObserve;
import IObserve.IObserve;

public class Test {
    public static void main(String[] args) {
        //创建多个观察者
        IObserve iObserve1 = new FistObserve();
        IObserve iObserve2 = new SecondObserve();
        //创建被观察者
        Some some =new Some();
        //被观察者添加观察者
        some.addObserve(iObserve1);
        some.addObserve(iObserve2);
        //被观察者向观察者发送信息
        some.notifyObservers("GOGOGOGOGOGO");
        //删除观察者后
        some.removeObserve(iObserve1);
        some.notifyObservers("GO ");
    }
}
 
这样就会实现，只有被观察者有动态变化，观察者就会有所反应。
 
 
监听器设计模式
 
监听器设计模式是观察者设计模式的一种实现。他与观察者设计模式不同点有
 
一个被观察者只能有一个观察者对象，而不是多个
被监听者（事件源）的状态改变，被定义为一个对象，称为事件，而不是字符串
 
监听器（监听者）
 负责监听发生在事件源上的事件
事件源（被监听对象，产生事件的对象）
 提供订阅与取消监听者的方法，并负责维护监听者列表，发送事件给监听者
事件处理器
 监听器的成员方法，当时事件发生后会触发对应的处理器（成员方法）。
 
一般情况下，监听器对象被事件触发后，都是需要从事件中获取到事件源对象，然后再从事件源中获取一些数据。也就是说，在事件对象中一般需要提供获取事件源对象的方法，当然，除了获取事件源方法外，根据业务需求，事件对象一般还需要提供一些其他的数据，以便让监听器获取。
 
监听器在进行工作时，可以分为以下步骤
 
将监听器绑定到事件源（注册监听器）
事件发生后触发监听器的成员方法，即事件处理器，传递事件对象
事件处理器通过事件对象获得事件源，并对事件源进行处理。
 
 
事件接口（ICurdEvent）
 
package event;
//定义增删改查事件
//C: Create
//U: Update
//R: Retrieve
//D: Delete
//通常对于事件对象，我们一般需要从事件对象中获取到事件源对象
public interface ICurdEvent{
    //声明事件类型
    String Create_EVENT = "create event";
    String Update_EVENT = "update event";
    String Retrieve_EVENT = "retrieve event";
    String Delete_EVENT = "delete event";
    //获取事件源对象
    IListenerable getEventSource();
    //获取事件类型
    String getEventType();

}
 
事件实现类
 
package implement;
import event.ICurdEvent;
import event.IListenerable;

public class CurdEvent implements ICurdEvent {
    private IListenerable eventSource;  //事件源
    private String methodname;          //事件源所执行的方法名称
    public CurdEvent(IListenerable eventSource,String methodname){
        super();
        this.eventSource = eventSource;
        this.methodname = methodname;
    }
    @Override
    public IListenerable getEventSource() {
        return eventSource;
    }
    //根据事件源所执行的不同的方法返回不同的事件类型
    @Override
    public String getEventType() {
        String eventType = null;
        if (methodname.startsWith("save")){
            eventType = Create_EVENT;
        }else if (methodname.startsWith("remove")){
            eventType = Delete_EVENT;
        }else if (methodname.startsWith("modify")){//修改
            eventType = Update_EVENT;
        }else if (methodname.startsWith("find")){
            eventType = Retrieve_EVENT;
        }else {
            eventType = "have not this event type";
        }
        return eventType;
    }
}
 
监听器接口（IListener）
 
package event;
//监听器接口（观察者）
//作用：处理消息（事件）
public interface IListener {
    void handle(ICurdEvent event);
}
 
监听器实现类
 
package implement;

import event.ICurdEvent;
import event.IListener;
//定义监听器类
public class Listener implements IListener {
    @Override
    public void handle(ICurdEvent event) {
        String eventType = event.getEventType();
        if (ICurdEvent.Create_EVENT.equals(eventType)){
            System.out.println("添加操作");
        }else if (ICurdEvent.Delete_EVENT.equals(eventType)){
            System.out.println("删除操作");
        }else if (ICurdEvent.Update_EVENT.equals(eventType)){
            System.out.println("修改操作");
        }else if (ICurdEvent.Retrieve_EVENT.equals(eventType)){
            System.out.println("查找操作");
        }
    }
}
 
事件源接口（IListenerable）
 
package event;
//事件源接口（被观察者）
public interface IListenerable {
    //为事件源注册监听器
    void setListener(IListener listener);
    //触发监听器
    void triggerListener(ICurdEvent event);
}
 
事件源实现类
 
package implement;

import event.ICurdEvent;
import event.IListener;
import event.IListenerable;

//事件源类
public class Some implements IListenerable {
    private IListener listener;
    //注册监听器
    @Override
    public void setListener(IListener listener) {
        this.listener = listener;
    }
    //触发监听器
    @Override
    public void triggerListener(ICurdEvent event) {
        listener.handle(event);
    }
    public void saveStudent(){
        System.out.println("插入了一条数据");
        ICurdEvent event = new CurdEvent(this,"saveStudent");
        this.triggerListener(event);
    }
    public void removeStudent(){
        System.out.println("删除了一条数据");
        ICurdEvent event = new CurdEvent(this,"removeStudent");
        this.triggerListener(event);
    }
    public void modifyStudent(){
        System.out.println("修改了一条数据");
        ICurdEvent event = new CurdEvent(this,"modifyStudent");
        this.triggerListener(event);
    }
    public void findStudent(){
        System.out.println("插入了一条数据");
        ICurdEvent event = new CurdEvent(this,"findStudent");
        this.triggerListener(event);
    }
}
 
测试类
 
package test;
import event.IListener;
import implement.Listener;
import implement.Some;

public class Test {
    public static void main(String[] args) {
        //定义监听器
        IListener listener = new Listener();
        //定义事件源
        Some some = new Some();
        //事件源注册监听器
        some.setListener(listener);
        some.saveStudent();
        some.removeStudent();
    }
}
 

前面学习的只是如何布置使用 swing控件，但是对它们进行点击等动作时，相应控件没有任何反应。
 
所以要给每个控件添加一个事件处理机制，当我们(用户)对 Swing组件 进行某些操作时，对应 Swing组件 会自动产生各种事件来响应用户行为。如当用户点击按钮时，Swing组件会产生一个 ActionEvent。
 
Swing组件会产生许多事件，如：ActionEvents，ChangeEvents，ItemEvents等，来响应用户的鼠标点击等行为。
 
动作事件监听器
 动作事件监听器是 Swing 中比较常用的事件监听器，它的具体信息如下：
 
事件名称：ActionEvent。
 事件监听接口: ActionListener。这个接口需要被 需要处理ActionEvent的类实现
 事件相关方法：addActionListener() 添加监听，对于需要响应ActionEvent的控件(像需要响应点击的按钮等)要使用这个方法。removeActionListener() 删除监听等…
 
以按钮的单击响应为例编写一个小程序，当鼠标单击按钮时，文本框显示总共单击的次数
 具体代码如下：
 要导入的类，之后不再赘述：
 
import javax.swing.JPanel; //中间容器 （嵌板）最常用的面板
import javax.swing.JButton;  //按钮
import javax.swing.JFrame;   //顶层容器 (框架)
import javax.swing.JTextField;  //文本框实现类
import java.awt.event.ActionEvent;   //动作事件
import java.awt.event.ActionListener;  //动作事件监听接口
 
public class text_ ActionEvent
{
	static int clicks = 0;  //记录点击次数
	public static void main(String[] args) 
	{
		JFrame jframe = new JFrame("动作监听");  //窗口
		jframe.setSize(200, 100);   //设置窗口大小
		JPanel jpanel1 = new JPanel();  //面板
		JButton jbutton1 = new JButton("按钮1");  //按钮1
		JTextField jtextfield1 = new JTextField("",15);  //用于显示的文本框,为15列
		
		//创建响应动作监听的类，它需要重写ActionListener接口的actionPerformed()方法
		class jbutton1hander implements ActionListener
	    {
	        @Override
	        public void actionPerformed(ActionEvent e)
	        {
	        	jtextfield1.setText("按钮1被单击 " + (++clicks) + " 次");
	        	//当单击设置了动作响应的按钮的时候，会显示单击的总次数
	        }
	    }
		
		jbutton1.addActionListener(new jbutton1hander()); //这句话很关键,添加动作监听器
		jpanel1.add(jtextfield1);  //文本框添加入面板
		jpanel1.add(jbutton1);    //按钮1添加入面板
		jframe.add(jpanel1);    //面板添加入窗口
		
		jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭时操作
		jframe.setVisible(true);   //设置可见
	}
}
 
运行结果：
 没开始单击时界面
 
 单击1次时界面
 
 单击2次时界面
 
 这是最简单的一种情况，只有一个按钮响应一个事件，但是在实际中，情况不是这么简单。
 
1.由于同一个控件(事件源)上可能发生多种事件，因此，Java 采取了授权模型（Delegation Model），控件(事件源)可以把在其自身上所有可能发生的事件分别授权给不同的事件处理者(实现各个事件类的接口的类)来处理。eg：
 
//假设有两个分别实现两个不同事件接口的监听类（伪码，有残缺，举例用）
class ActionHander implements ActionListener{}
class ChangeHander implements ChangeListener{}
Jbutton jbutton; //一个按钮
//按钮上会发生上面两个事件，就分别授权给不同事件处理者
jbutton1.addActionListener(new ActionHander());  //授权Action事件
jbutton1.addChangeListener(new ChangeHander());  //授权Change事件
 
2.当多个控件需要响应一个事件的时候，这里有三种方法，以ActionEvent动作事件，和两个按钮为例。当鼠标单击某个按钮时，文本框显示这个按钮总共单击的次数。
 
ActionEvent的三种实现方法
 <1>基于if-slse语句的实现
 
public class text_ ActionEvent
{
	static int clicks1 = 0;  //用于保存按钮1单击次数
	static int clicks2 = 0;  //用于保存按钮2单击次数
	public static void main(String[] args) 
	{
		JFrame jframe = new JFrame("动作监听");  //窗口
		jframe.setSize(200, 100);  //设置窗口大小
		JPanel jpanel1 = new JPanel();  //面板
		JButton jbutton1 = new JButton("按钮1");  //按钮1
		JButton jbutton2 = new JButton("按钮2");  //按钮2
		JTextField jtextfield1 = new JTextField("",15);  //用于显示的文本框,为15列
		
		//创建响应动作监听的类，它需要重写ActionListener接口的actionPerformed()方法
		class jbutton1hander implements ActionListener
	    {
	        @Override
	        public void actionPerformed(ActionEvent e)
	        {
	        //下面是重点
	        	String name = e.getActionCommand();   //这个方法用于获取动作命令
	            if(name.equals("按钮1"))
	            {
	            	jtextfield1.setText("按钮1被单击 " + (++clicks1) + " 次");
	            }
	            else
	            {
	            	jtextfield1.setText("按钮2被单击 " + (++clicks2) + " 次");
	            }  
	        }
	    }
		jbutton1.addActionListener(new jbutton1hander()); //这句话很关键,添加动作监听器
		jbutton2.addActionListener(new jbutton1hander()); //两个按钮添加同一个动作监听器
		
		jpanel1.add(jtextfield1);  //文本框添加入面板
		jpanel1.add(jbutton1);    //按钮1添加入面板
		jpanel1.add(jbutton2);    //按钮2添加入面板
		jframe.add(jpanel1);    //面板添加入窗口
		
		jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭时操作
		jframe.setVisible(true);   //设置可见
	}
}
 
运行结果：
 没有开始单击时
 
 第1次单击，单击按钮1
 
 第2次单击，单击按钮1
 
 第3次单击，单击按钮2
 
 第4次单击，单击按钮1
 
 第一种方法，在处理的事件比较少时比较方便，代码集中易于理解。
 
但是它的缺点也很明显，因为只有一个监听器，当程序比较复杂时，需要大串的if-else语句来实现，程序代码就变得难阅读与维护。
 
<2>使用匿名内部类的实现
 
public class text_ ActionEvent
{
	static int clicks1 = 0;   //记录按钮1的点击次数
	static int clicks2 = 0;   //记录按钮2的点击次数
	public static void main(String[] args) 
	{
		JFrame jframe = new JFrame("动作监听");  //窗口
		jframe.setSize(200, 100);   //设置窗口大小
		JPanel jpanel1 = new JPanel();  //面板
		JButton jbutton1 = new JButton("按钮1");  //按钮1
		JButton jbutton2 = new JButton("按钮2");  //按钮1
		JTextField jtextfield1 = new JTextField("",15);  //用于显示的文本框,为15列
		//下面很关键
		//使用匿名内部类添加监听器
		jbutton1.addActionListener
		(
			new ActionListener()  //需要实现的接口
			{
				@Override        //必须重写ActionListener接口的actionPerformed方法
				public void actionPerformed(ActionEvent e)
				{
					jtextfield1.setText("按钮1被单击 " + (++clicks1) + " 次");
				}
			}
		);
		
		jbutton2.addActionListener
		(
			new ActionListener()  //需要实现的接口
			{
				@Override        //必须重写ActionListener接口的actionPerformed方法
				public void actionPerformed(ActionEvent e)
				{
					jtextfield1.setText("按钮2被单击 " + (++clicks2) + " 次");
				}
			}
		);
		
		jpanel1.add(jtextfield1);  //文本框添加入面板
		jpanel1.add(jbutton1);    //按钮1添加入面板
		jpanel1.add(jbutton2);    //按钮2添加入面板
		jframe.add(jpanel1);    //面板添加入窗口
		
		jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭时操作
		jframe.setVisible(true);   //设置可见
	}
}
 
运行结果同上不再赘述
 
第二种方法也会出现一定的问题，现实中，因为整个程序中的组件不是全部定义在一起的，当组件变多，分散在程序中，也不便于阅读和修改。
 
<3>使用一般的命名内部类的实现
 
public class text_ ActionEvent
{
	static int clicks1 = 0;  //记录按钮1的单击次数
	static int clicks2 = 0;  //记录按钮2的单击次数
	public static void main(String[] args) 
	{
		JFrame jframe = new JFrame("动作监听");  //窗口
		jframe.setSize(200, 100);   //设置窗口大小
		JPanel jpanel1 = new JPanel();  //面板
		JButton jbutton1 = new JButton("按钮1");  //按钮1
		JButton jbutton2 = new JButton("按钮2");  //按钮1
		JTextField jtextfield1 = new JTextField("",15);  //用于显示的文本框,为15列
		
		//下面很关键
		//使用一般类创建动作监听者
		class jbutton1Handler implements ActionListener
		{
			@Override        //必须重写ActionListener接口的actionPerformed方法
			public void actionPerformed(ActionEvent e)
			{
				jtextfield1.setText("按钮1被单击 " + (++clicks1) + " 次");
			}
		}
		
		class jbutton2Handler implements ActionListener
		{
			@Override        //必须重写ActionListener接口的actionPerformed方法
			public void actionPerformed(ActionEvent e)
			{
				jtextfield1.setText("按钮2被单击 " + (++clicks2) + " 次");
			}
		}
		
		//按钮分别添加不同动作监听者
		jbutton1.addActionListener(new jbutton1Handler());
		jbutton2.addActionListener(new jbutton2Handler());
		
		jpanel1.add(jtextfield1);  //文本框添加入面板
		jpanel1.add(jbutton1);    //按钮1添加入面板
		jpanel1.add(jbutton2);    //按钮2添加入面板
		jframe.add(jpanel1);    //面板添加入窗口
		
		jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭时操作
		jframe.setVisible(true);   //设置可见
	}
}

Vue中监听数组解析
 
1，简单监听一个参数，demo如下
 
data() {
        return {
            msg: "test---test",
        }
    },
    watch: {
        msg(newVal, oldVal) {
            console.log(newVal)
            console.log(oldVal)
        },
    },
    created() {
        this.msg = "change"
    }
 
 
2，对数组的监听，上代码
 
    data() {
        return {
            list: [1, 2, 3, 4, 6],  //需要被监听的数组
        }
    },
    watch: {
        list(newVal, oldVal) {  //对数组进行监听
            console.log(newVal)
            console.log(oldVal)
        },
    },
    created() {
        this.list[2] = "666"   //将数组对应下标值改变
    }
 
以上方法watch并不会有任何监听结果，此时监听失败。那么这个问题的由来，可以参考这篇文章监听数组变化
 解决办法，
 方法一
 使用vuejs提供的变异方法，例如splice（） push() 等
 
    created() {
        this.list.splice(1,1,666)  //用splice方法，将数组index=1的数值改成换成666
        // this.list.push("") // 增加空值  也能监听到
        // this.list.pop()
        // this.list.shift()
        //this.length = 10  //直接改变数组长度  无效
    }
 

 以上方法就可以监听数组中某个值或属性改变，类似还有push，pop，等方法，这里不进行列举。补充一下，如果直接这样写 this.list.length = 7 或 增加深度监听（handler方法和immediate属性）这样都是无法监听到的。直接增加数组长度，而由于 JavaScript 的限制，Vue 不能检测以下变动的数组：
 
 
 
//当你利用索引直接设置一个项时，例如：vm.items[indexOfItem] = newValue
 //当你修改数组的长度时，例如：vm.items.length = newLength
 
 
方法二 Vue.set （简洁明了 推荐使用）
 Vue.set(vm.items, indexOfItem, newValue) (要改变的数组, 下标 , 新值)
 或者使用 this.$set(this.list,1,888) 以上例子输出结果，也可以检测到数组变化
 
 
 
[1, 888, 3, 4, 6, ob: Observer]
 [1, 888, 3, 4, 6, ob: Observer]
 
 
以上有个问题,那就是你会发现打印的新值和旧值是一样的。虽然它监听到改变，但是无法判断具体是哪个值发生了改变，官方给出了说明
 
 
解决办法
 
可采用computed计算属性进行对源对象的深拷贝，完成新值更新。
 
export default {
    name: 'App',
    data() {
        return {
            list: [1, 2, 3, 4, 6],
        }
    },
    computed: {
        newList(){    
            return JSON.parse(JSON.stringify(this.list))
        }
    },
    watch: {
        newList(newVal, oldVal) {
            console.log(newVal)
            console.log(oldVal)
        },
    },
    created() {
        this.$set(this.list,1,888)
    }
}
 

 到这里，就可以实现对数组多方位监听以及数值的变化了，希望可以帮到你。