java监听
Ⅰ java设计模式-回调、事件监听器、观察者模式
转自( https://my.oschina.net/u/923324/blog/792857 )
背景
关于设计模式，之前笔者写过工厂模式，最近在使用gava ListenableFuture时发现事件监听模型特别有意思，于是就把事件监听、观察者之间比较了一番，发现这是一个非常重要的设计模式，在很多框架里扮演关键的作用。
回调函数
为什么首先会讲回调函数呢？因为这个是理解监听器、观察者模式的关键。
什么是回调函数
所谓的回调，用于回调的函数。 回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。 有这么一句通俗的定义：就是程序员A写了一段程序（程序a），其中预留有回调函数接口，并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法，于是，他通过a中的接口回调自己b中的方法。
举个例子：
这里有两个实体：回调抽象接口、回调者（即程序a）
回调接口（ICallBack ）
public interface ICallBack {
public void callBack();
}
回调者（用于调用回调函数的类）
public class Caller {
}
回调测试：
public static void main(String[] args) {
Caller call = new Caller();
call.call(new ICallBack(){
控制台输出：
start...
终于回调成功了！
end...
还有一种写法
或实现这个ICallBack接口类
class CallBackC implements ICallBack{
@Override
public void callBack() {
System.out.println("终于回调成功了！");
}
}
有没有发现这个模型和执行一个线程，Thread很像。 没错，Thread就是回调者，Runnable就是一个回调接口。
new Thread(new Runnable(){
@Override
public void run() {
System.out.println("回调一个新线程！");
}}).start();
Callable也是一个回调接口，原来一直在用。 接下来我们开始讲事件监听器
事件监听模式
什么是事件监听器
监听器将监听自己感兴趣的事件一旦该事件被触发或改变，立即得到通知，做出响应。例如：android程序中的Button事件。
java的事件监听机制可概括为3点：
java的事件监听机制涉及到 事件源，事件监听器，事件对象 三个组件,监听器一般是接口，用来约定调用方式
当事件源对象上发生操作时，它将会调用事件监听器的一个方法，并在调用该方法时传递事件对象过去
事件监听器实现类,通常是由开发人员编写，开发人员通过事件对象拿到事件源，从而对事件源上的操作进行处理
举个例子
这里我为了方便，直接使用jdk，EventListener 监听器，感兴趣的可以去研究下源码，非常简单。
监听器接口
public interface EventListener extends java.util.EventListener {
//事件处理
public void handleEvent(EventObject event);
}
事件对象
public class EventObject extends java.util.EventObject{
private static final long serialVersionUID = 1L;
public EventObject(Object source){
super(source);
}
public void doEvent(){
System.out.println("通知一个事件源 source :"+ this.getSource());
}
}
事件源
事件源是事件对象的入口，包含监听器的注册、撤销、通知
public class EventSource {
//监听器列表，监听器的注册则加入此列表
private Vector<EventListener> ListenerList = new Vector<EventListener>();
//注册监听器
public void addListener(EventListener eventListener){
ListenerList.add(eventListener);
}
//撤销注册
public void removeListener(EventListener eventListener){
ListenerList.remove(eventListener);
}
//接受外部事件
public void notifyListenerEvents(EventObject event){
for(EventListener eventListener:ListenerList){
eventListener.handleEvent(event);
}
}
}
测试执行
public static void main(String[] args) {
EventSource eventSource = new EventSource();
}
控制台显示：
通知一个事件源 source :openWindows
通知一个事件源 source :openWindows
doOpen something...
到这里你应该非常清楚的了解，什么是事件监听器模式了吧。 那么哪里是回调接口，哪里是回调者，对！EventListener是一个回调接口类，handleEvent是一个回调函数接口，通过回调模型，EventSource 事件源便可回调具体监听器动作。
有了了解后，这里还可以做一些变动。 对特定的事件提供特定的关注方法和事件触发
public class EventSource {
...
public void onCloseWindows(EventListener eventListener){
System.out.println("关注关闭窗口事件");
ListenerList.add(eventListener);
}
}
public static void main(String[] args) {
EventSource windows = new EventSource();
/**
* 另一种实现方式
*/
//关注关闭事件，实现回调接口
windows.onCloseWindows(new EventListener(){
}
这种就类似于，我们的窗口程序，Button监听器了。我们还可以为单击、双击事件定制监听器。
观察者模式
什么是观察者模式
观察者模式其实原理和监听器是一样的，使用的关键在搞清楚什么是观察者、什么是被观察者。
观察者(Observer)相当于事件监器。有个微博模型比较好理解，A用户关注B用户，则A是B的观察者，B是一个被观察者，一旦B发表任何言论，A便可以获得。
被观察者(Observable)相当于事件源和事件，执行事件源通知逻辑时，将会回调observer的回调方法update。
举个例子
为了方便，同样我直接使用jdk自带的Observer。
一个观察者
public class WatcherDemo implements Observer {
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("openWindows")){
System.out.println("已经打开窗口");
}
}
}
被观察者
Observable 是jdk自带的被观察者，具体可以自行看源码和之前的监听器事件源类似。
主要方法有
addObserver() 添加观察者，与监听器模式类似
notifyObservers() 通知所有观察者
类Watched.java的实现描述：被观察者，相当于事件监听的事件源和事件对象。又理解为订阅的对象 主要职责：注册/撤销观察者（监听器），接收主题对象（事件对象）传递给观察者（监听器），具体由感兴趣的观察者（监听器）执行
/**
}
测试执行
public static void main(String[] args) {
Watched watched = new Watched();
WatcherDemo watcherDemo = new WatcherDemo();
watched.addObserver(watcherDemo);
watched.addObserver(new Observer(){
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("closeWindows")){
System.out.println("已经关闭窗口");
}
}
});
//触发打开窗口事件，通知观察者
watched.notifyObservers("openWindows");
//触发关闭窗口事件，通知观察者
watched.notifyObservers("closeWindows");
控制台输出：
已经打开窗口
已经关闭窗口
总结
从整个实现和调用过程来看，观察者和监听器模式基本一样。
有兴趣的你可以基于这个模型，实现一个简单微博加关注和取消的功能。 说到底，就是事件驱动模型，将调用者和被调用者通过一个链表、回调函数来解耦掉，相互独立。
“你别来找我，有了我会找你”。
整个设计模式的初衷也就是要做到低耦合，低依赖。
再延伸下，消息中间件是什么一个模型？ 将生产者+服务中心（事件源）和消费者（监听器）通过消息队列解耦掉. 消息这相当于具体的事件对象，只是存储在一个队列里（有消峰填谷的作用），服务中心回调消费者接口通过拉或取的模型响应。 想必基于这个模型，实现一个简单的消息中间件也是可以的。
还比如gava ListenableFuture，采用监听器模式就解决了future.get()一直阻塞等待返回结果的问题。
有兴趣的同学，可以再思考下观察者和责任链之间的关系， 我是这样看的。
同样会存在一个链表，被观察者会通知所有观察者，观察者自行处理，观察者之间互不影响。 而责任链，讲究的是击鼓传花，也就是每一个节点只需记录继任节点，由当前节点决定是否往下传。 常用于工作流，过滤器web filter。
Ⅱ 什么是java侦听器
1、监听器也叫Listener，是Servlet的监听器，它可以监听客户端的请求、服务端的操作等。通过监听器，可以自动激发一些操作，比如监听在线的用户的数量。当增加一个HttpSession时，就激发sessionCreated(HttpSessionEvent se)方法，这样
就可以给在线人数加1。
2、常用的监听接口有以下几个：
1）监听对ServletContext属性的操作，比如增加、删除、修改属性。
2）、ServletContextListener监听ServletContext。当创建ServletContext时，激发contextInitialized(ServletContextEvent sce)方法；当销毁ServletContext时，激发contextDestroyed(ServletContextEvent sce)方法。
HttpSessionListener监听HttpSession的操作。当创建一个Session时，激发session Created(HttpSessionEvent se)方法；当销毁一个Session时，激发sessionDestroyed (HttpSessionEvent se)方法。
4）HttpSessionAttributeListener监听HttpSession中的属性的操作。当在Session增加一个属性时，激发attributeAdded(HttpSessionBindingEvent se) 方法；当在Session删除一个属性时，激发attributeRemoved(HttpSessionBindingEvent se)方法；当在Session属性被重新设置时，激发attributeReplaced(HttpSessionBindingEvent se) 方法。
3、参考样例example:随服务器启动
＜web-app＞
<listener>
<listener-class>com.tb.listener.CountStartListener</listener-class>
</listener>
package com.tb.listener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpServlet;
import com.tb.timertask.DoCountTask;
public class CountStartListener extends HttpServlet implements ServletContextListener
{
private static final long serialVersionUID = 1824920962239905170L;
public CountStartListener()
{
// TODO Auto-generated constructor stub
}
public void contextDestroyed(ServletContextEvent arg0)
{
// TODO Auto-generated method stub
}
public void contextInitialized(ServletContextEvent arg0)
{
DoCountTask.dotask();
Ⅲ java中的事件监听是怎样实现随时监听的，是通过线程吗
java中的事件监听不是通过线程实现的，它是通过一种注册--通知机制实现的。在java的设计模式中，有一种模式叫：观察者模式，和这个类似。
Ⅳ java监听器原理
Java最新的事件处理方法是基于授权事件模型，事件源生成事件并将其发送至一个或多个监听器，监听器简单地等待，直到它收到一个事件。一旦事件被接受，监听器将处理这些事件，然后返回。
事件：在授权事件模型中，事件是一个描述事件源状态改变的对象。 通过鼠标、键盘与GUI界面直接或间接交互都会生成事件。如：按下一个按钮、通过键盘输入一个字符、选择列表框中的一项、点击一下鼠标等。
事件源：事件源是一个生成事件的对象
一个事件源可能会生成不同类型的事件，事件源提供了一组方法，用于为事件注册一个或多个监听器。
每种事件的类型都有其自己的注册方法。一般形式为：publicvoidadd<EventType>Listener(TypeListenere)
AWT采取的事件控制过程：监听器对象属于一个类的实例，这个类实现了一个特殊的接口，名为“监听者接口”
事件源是一个对象，它可以注册一个或多个监听器对象，并向其发送事件对象。
事件源将在发生事件时向所有注册的监听器发送事件对象。
监听器对象使用事件对象中的信息来确定它们对事件的响应
事件模型：
基于代理(授权)事件模型，事件处理是一个事件源授权到一个或者多个事件监听器。其基本原理是：组件激发事件，事件监听器监听和处理事件，可以调用组件的add<EventType>Listener方法向组件注册监听器。把其加入到组件以后，如果组件激发了相应类型的事件，那么定义在监听器中的事件处理方法会被调用。
此模型主要由以三种对象为中心组成
事件源由它来激发产生事件
是产生或抛出事件的对象。
事件监听器由它来处理事件
实现某个特定EventListener接口,此接口定义了一种或多种方法，事件源调用它们以响应该接口所处理的每一种特定事件类型。
事件具体的事件类型
事件类型封装在以java.util.EventObject为根的类层次中。当事件发生时，事件记录发生的一切事件，并从事件源传播到监听器对象
Ⅳ java怎样监听一个值是否发生了变化，具体代码
java 自定义监听器监听属性变化
import java.util.EventObject;
public class MyEvent extends EventObject
{
private Object obj;
private String sName;
public MyEvent(Object source,String sName)
{
super(source);
this.obj=source;
this.sName=sName;
}
public Object getObj()
{
return obj;
}
public String getsName()
{
return sName;
}
}
import java.util.EventListener;
public interface MyEventListener extends EventListener
{
public void handleEvent (MyEvent me);
}
import java.util.Iterator;
import java.util.Vector;
import demo.DemoEvent;
public class MyEventSource
{
private Vector list=new Vector();
private String sName = "";
public MyEventSource()
{
super();
}
public void addMyEventListener(MyEventListener me)
{
list.add(me);
}
public void deleteMyEventListener(MyEventListener me)
{
list.remove(me);
}
public void notifyMyEvent(MyEvent me)
{
Iterator it=list.iterator();
while(it.hasNext())
{
((MyEventListener) it.next()).handleEvent(me);
}
}
public void setName(String str)
{
boolean bool = false;
if (str == null && sName != null)
bool = true;
else if (str != null && sName == null)
bool = true;
else if (!sName.equals(str))
bool = true;
this.sName = str;
// 如果改变则执行事件
if (bool)
notifyMyEvent(new MyEvent(this, sName));
}
public String getsName()
{
return sName;
}
}
public class Test implements MyEventListener
{
public Test()
{
MyEventSource mes = new MyEventSource();
mes.addMyEventListener(this);
mes.setName("niu");
}
public static void main(String args[])
{
new Test();
}
public void handleEvent(MyEvent me)
{
System.out.println(me.getSource());
System.out.println(me.getsName());
}
}
Ⅵ java监听文件Error listenerStart错误
最近项目中采用开启java线程来监听文件目录 在本地测试正常启动 但是当采用maven中的mvn tomcat:deploy部署到tomcat中时就报如下错误
严重: Error listenerStart : : re StandardContext start 严重: Context [/cms] startup failed e to previous errors
: : DEBUG (cms templet TempletController: ) – >>>>监听停止了!! : : re StandardContext listenerStop 严重: Exception sending context destroyed event to listener instance of class ut il tools ThemePicFileListenerTools java lang NullPointerException陪搏芦答祥 at util tools ThemePicFntextDestroyed(ThemePicFileLis tenerTools java: ) at re StandardContext listenerStop(StandardContext java: ) at re StandardContext stop(StandardContext java: ) at re StandardContext start(StandardContext java: ) at re ContainerBase start(ContainerBase java: )
at re StandardHost start(StandardHost java: ) at re ContainerBase start(ContainerBase java: )
at re StandardEngine start(StandardEngine java: ) at apache catalina startup Embedded start(Embedded java: ) at dehaus mojo tomcat AbstractRunMojo startContainer(AbstractRunMo jo java: )举物 at dehaus mojo tomcat AbstractRunMojo execute(AbstractRunMojo java : ) at apache maven plugin DefaultPluginManager executeMojo(DefaultPlugi nManager java: ) at apache maven lifecycle DefaultLifecycleExecutor executeGoals(Defa ultLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor executeStandalone Goal(DefaultLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor executeGoal(Defau ltLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor executeGoalAndHan dleFailures(DefaultLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor executeTaskSegmen ts(DefaultLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor execute(DefaultLi fecycleExecutor java: ) at apache maven DefaultMaven doExecute(DefaultMaven java: ) at apache maven DefaultMaven execute(DefaultMaven java: ) at apache maven cli MavenCli main(MavenCli java: ) at sun reflect NativeMethodAccessorImpl invoke (Native Method) at sun reflect NativeMethodAccessorImpl invoke(NativeMethodAccessorImpl java: ) at sun reflect DelegatingMethodAccessorImpl invoke(DelegatingMethodAcces sorImpl java: ) at java lang reflect Method invoke(Method java: ) at dehaus classworlds Launcher launchEnhanced(Launcher java: ) at dehaus classworlds Launcher launch(Launcher java: ) at dehaus classworlds Launcher mainWithExitCode(Launcher java: )
at dehaus classworlds Launcher main(Launcher java: )
这个错误让我郁闷了好久 最后找到错误原因 是因为监听的文件夹下面没有内容 maven在发布项目的时候侯就不创建此文件夹 当程序启动的时候 找不到此目录 此时监听就会停止 报以上错误
lishixin/Article/program/Java/hx/201311/26397
Ⅶ java 监听器中定义参数有什么意义，可以被调用吗
java监听器（Listener）和Servlet是两个不同功能的JavaWeb组件。
监听器是实现了javax.servlet.ServletContextListener这个接口的类，斗山竖里面有两个方法需要你在唯弯子类实现：
public void contextDestroyed(ServletContextEvent evt) {
//监听器被销毁的时候调用
}
public void contextInitialized(ServletContextEvent evt) {
//监听启动的时候调用，初始化servletcontext事件
}
创建好后，配置到web.xml中即可。
对于Servlet自己没有监听器，只有当空大用户请求Servlet映射的路径时会触发Servlet对应的方法来处理，以此来响应客户的请求。
监听参数是用来初始化监听上下文使用的，不能被其他入口所调用。
<!--Spring ApplicationContext载入-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Spring ApplicationContext配置文件的路径,此参数用于后面的Spring-Contextloader -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:beans.xml</param-value>
</context-param>
<!-- 系统服务初始化 -->
<listener>
<listener-class>pams.servlet.SysInitServlet</listener-class>
</listener>
Ⅷ 怎样用JAVA来监听数据库里的变化
可以使用ContentObserver对象监听，如下：
public final void registerContentObserver(Uri uri, boolean notifyForDescendents, ContentObserver observer)
功能：为指定的Uri注册一个ContentObserver派生类实例，当给定的Uri发生改变时，回调该实例对象去处理。
参数：uri 需要观察的Uri(需要在UriMatcher里注册，否则该Uri也没有意义了)
notifyForDescendents 为false 表示精确匹配，即只匹配该Uri
为true 表示可以同时匹配其派生的Uri，举例如下：
假设UriMatcher 里注册的Uri共有一下类型：
1 、content://com.qin.cb/student (学生)
2 、content://com.qin.cb/student/#
3、 content://com.qin.cb/student/schoolchild(小学生，派生的Uri)
假设我们当前需要观察的Uri为content://com.qin.cb/student，如果发生数据变化的 Uri 为
content://com.qin.cb/student/schoolchild ，当notifyForDescendents为 false，那么该ContentObserver会监听不到，
但是当notifyForDescendents 为ture，能捕捉该Uri的数据库变化。
Ⅸ java中为什么要设置监听器，有什么用
猪哥解答：
1、private JButton jb=new JButton("按钮");这句话声明了一个按钮，名字叫jb。
2、jb.addActionListener(this);这里给jb那个按钮设置了监听，默认为点击触发，当然棚启你写的这个监听有点怪异~
3、点击按钮jb触发监听处理方法actionPerformed，在这里可以做你想要的操作，你代码实现的是改变lab这个label标签的内容。
4、至于java中为什野源么要用监听，这就像银行装监控一样，监视你的一举一动，银行装监控是为了捕捉每个进银行的人的动作，预防危险的发生。
java中做监听同样是为了监视某个客户端动作用的，万一你给我搞破坏怎么办（监听颂和态的作用远不止如此），当然也像平时生活中不是所有的地方都要放监控，要不就没法过了，java中也不是所有的地方都要放监听，具体哪里要放监听，不该是在课本里学的，应该根据实际工厂、公司的需求来定。
Ⅹ java监听键盘
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
public class KeyBoardListener extends JFrame {
public KeyBoardListener() throws FileNotFoundException {
this.setTitle("监听键盘事件");
this.setSize(800, 600);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
this.addKeyListener(new KeyAdapter() {
@Override
public void keyReleased(KeyEvent e) {
char ch = e.getKeyChar();
try {
System.out.println(“结果");
} catch (IOException e1) {
JOptionPane.showMessageDialog(null, "出错了");
}
}
});
}
public static void main(String[] args) throws FileNotFoundException {
new KeyBoardListener();
}
}