监听器设计模式

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

设计模式

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

创建型

通过特定的方式创建特定对象的设计模式

（工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式）

结构型

为了解决某一特定问题所搭建的特定代码结构的设计模式

（适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式）

行为型

通过构建不同的角色来完成某一特定功能的设计模式

(策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式)

通过了解以上我们知道设计模式的大概 接下来进入重点 监听器设计模式，监听器设计模式是观察者设计模式的衍生，所以得先了解观察者设计模式。

观察者设计模式

观察者设计模式从名字上来看，首先得有观察者和被观察者，所以它有两个接口：IObserve和IObservable，其主要实现的功能就是当被观察者对象的状态有更改的时候，观察者时时会有相应的通知并做出相应的操作
原理：就是在目标对象中耦合观察者的对象，并且在注册观察者对象的时候调用相应操作的方法； 两者之间的关系是单向关联的；目标类和观察类之间维护的是松耦合的关系；

观察者接口（IObserve）

需要实现的功能

1. 接收并处理被观察者发送来的信息

package IObserve;
public interface IObserve {
//    观察者处理被观察者发送过来额信息void handleNotify(String message);
}

观察者实现类（FirstObserve、SecondObserve）

有多个观察者，所以需要写多个实现类，第一个观察者

package IObserve;
public class FistObserve implements IObserve {@Overridepublic void handleNotify(String message) {System.out.println("1号接受的消息"+message );}
}

第二个观察者

package IObserve;
public class SecondObserve implements IObserve {@Overridepublic void handleNotify(String message) {System.out.println("2号接受的消息"+message);}
}

被观察者接口（IObservable）

需要实现的功能

1. 可以添加观察者
   添加操作可以通过Array List的add()方法实现。
2. 删除观察者
   删除操作通过ArrayList的remove()方法实现。
3. 向观察者发送信息

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<>();}@Overridepublic void addObserve(IObserve observe) {observes.add(observe);}@Overridepublic void removeObserve(IObserve observe) {observes.remove(observe);}@Overridepublic 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 ");}
}

这样就会实现，只有被观察者有动态变化，观察者就会有所反应。

监听器设计模式

监听器设计模式是观察者设计模式的一种实现。他与观察者设计模式不同点有

1. 一个被观察者只能有一个观察者对象，而不是多个
2. 被监听者（事件源）的状态改变，被定义为一个对象，称为事件，而不是字符串

• 监听器（监听者）
  负责监听发生在事件源上的事件
• 事件源（被监听对象，产生事件的对象）
  提供订阅与取消监听者的方法，并负责维护监听者列表，发送事件给监听者
• 事件处理器
  监听器的成员方法，当时事件发生后会触发对应的处理器（成员方法）。

一般情况下，监听器对象被事件触发后，都是需要从事件中获取到事件源对象，然后再从事件源中获取一些数据。也就是说，在事件对象中一般需要提供获取事件源对象的方法，当然，除了获取事件源方法外，根据业务需求，事件对象一般还需要提供一些其他的数据，以便让监听器获取。

监听器在进行工作时，可以分为以下步骤

1. 将监听器绑定到事件源（注册监听器）
2. 事件发生后触发监听器的成员方法，即事件处理器，传递事件对象
3. 事件处理器通过事件对象获得事件源，并对事件源进行处理。

事件接口（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;}@Overridepublic IListenerable getEventSource() {return eventSource;}//根据事件源所执行的不同的方法返回不同的事件类型@Overridepublic 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 {@Overridepublic 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;//注册监听器@Overridepublic void setListener(IListener listener) {this.listener = listener;}//触发监听器@Overridepublic 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();}
}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！