java观察者模式,我的世界java观察者模式

本文目录一览：

• 1、java中常用到得设计模式有哪几种？
• 2、java设计模式-回调、事件监听器、观察者模式
• 3、java设计模式的两大主题是什么，
• 4、Java的回调函数和观察者模式的区别
• 5、观察者模式解析
• 6、求 JAVA 异步观察者模式 的源代码（完整的），不要同步的，好的给加分

java中常用到得设计模式有哪几种？

一共23种设计模式！

按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。

创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。

创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：

 工厂方法模式（Factory Method Pattern）

 抽象工厂模式（Abstract Factory Pattern）

 建造者模式（Builder Pattern）

 原型模式（Prototype Pattern）

 单例模式（Singleton Pattern）

结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：

 适配器模式（Adapter Pattern）

 桥接模式（Bridge Pattern）

 组合模式（Composite Pattern）

 装饰者模式（Decorator Pattern）

 外观模式（Facade Pattern）

 享元模式（Flyweight Pattern）

 代理模式（Proxy Pattern）

行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：

 责任链模式（Chain of Responsibility Pattern）

 命令模式（Command Pattern）

 解释器模式（Interpreter Pattern）

 迭代器模式（Iterator Pattern）

 中介者模式（Mediator Pattern）

 备忘录模式（Memento Pattern）

 观察者模式（Observer Pattern）

 状态模式（State Pattern）

 策略模式（Strategy Pattern）

 模板方法模式（Template Method Pattern）

 访问者模式（Visitor Pattern）

推荐你一本好书：《软件秘笈：设计模式那点事》，里面讲解的23中设计模式例子很生动，容易理解，还有JDK中设计模式应用情况，看了收获挺大的！百度里面搜“设计模式”，第一条中设计模式百度百科中就有首推该图书，浏览量在20几万以上的，不会错的。好东西大家一起分享！

祝你早日学会设计模式！

java设计模式-回调、事件监听器、观察者模式

转自( )

背景

关于设计模式，之前笔者写过工厂模式，最近在使用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 VectorEventListener ListenerList = new VectorEventListener();

//注册监听器

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设计模式的两大主题是什么，

设计模式的两大主题是系统复用与系统扩展。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

扩展资料

由四方面组成：

（1）Java编程语言

（2）Java类文件格式

（3）Java虚拟机

（4）Java应用程序接口

当编辑并运行一个Java程序时，需要同时涉及到这四种方面。使用文字编辑软件（例如记事本、写字板、UltraEdit等）或集成开发环境（Eclipse、MyEclipse等）在Java源文件中定义不同的类 ，通过调用类（这些类实现了Java API）中的方法来访问资源系统，把源文件编译生成一种二进制中间码，。

存储在class文件中，然后再通过运行与操作系统平台环境相对应的Java虚拟机来运行class文件，执行编译产生的字节码，调用class文件中实现的方法来满足程序的Java API调用。

Java的回调函数和观察者模式的区别

java的回调 叫listener 模式。

无论是listener模式，还是C++里面的callback模式，本质是一样的

他们都是观察者模式的具体实现。

观察者模式是设计模式中定义的一种思想，而具体到不同的语言环境，使用不同的语法表现出来就会有java的listener objc的 delegate，或者C++的 callback。

观察者模式解析

定义 ：对象间的一种一对多的依赖关系，使得当每一个对象改变状态，则所有依赖于他的对象都会得到通知，并自动更新。

交互对象之间松耦合

1）观察者定义了对象之间一对多的关系

2）被观察者用一个共同的接口来更新观察者

3）观察者和被观察者用松耦合方式结合，被观察者不知道观察者的细节，只知道观察者实现了观察者接口

优点：

1）观察者与被观察者抽象耦合，容易扩展；

2）建立了一套触发机制。

缺点：

1）循环依赖会导致系统崩溃；

2）观察者太多会浪费时间。

1）定义对象之间的一对多依赖关系而不使对象紧密耦合。

2）确保当一个对象改变状态时，自动更新开放数量的从属对象。

3）一个对象应该可以通知开放式数量的其他对象。

观察者模式 vs 发布-订阅模式

观察者模式（Observer）

如何使用 Java8 实现观察者模式？（上）

如何使用 Java8 实现观察者模式？（下）

求 JAVA 异步观察者模式 的源代码（完整的），不要同步的，好的给加分

package TestObserver;

import java.util.Iterator;

import java.util.Vector;

/**

*

* @author Seastar

*/

interface Observed {

public void addObserver(Observer o);

public void removeObserver(Observer o);

public void update();

}

interface Observer {

public void takeAction();

}

class Invoker {

private Observer o;

Handler handler;

public Invoker(Observer o) {

new Handler();

this.o = o;

}

private class Handler extends Thread {

public Handler() {

handler = this;

}

@Override

public void run() {

o.takeAction();

}

}

public boolean TestSameObserver(Observer o) {

return o == this.o;

}

public void invoke() {

handler.start();

}

}

class ObservedObject implements Observed {

private VectorInvoker observerList = new VectorInvoker();

public void addObserver(Observer o) {

observerList.add(new Invoker(o));

}

public void removeObserver(Observer o) {

IteratorInvoker it = observerList.iterator();

while (it.hasNext()) {

Invoker i = it.next();

if (i.TestSameObserver(o)) {

observerList.remove(i);

break;

}

}

}

public void update() {

for (Invoker i : observerList) {

i.invoke();

}

}

}

class ObserverA implements Observer {

public void takeAction() {

System.out.println(“I am Observer A ,state changed ,so i have to do something”);

}

}

class ObserverB implements Observer {

public void takeAction() {

System.out.println(“I am Observer B ,i was told to do something”);

}

}

class ObserverC implements Observer {

public void takeAction() {

System.out.println(“I am Observer C ,I just look ,and do nothing”);

}

}

public class Main {

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

ObserverA a = new ObserverA();

ObserverB b = new ObserverB();

ObserverC c = new ObserverC();

ObservedObject oo = new ObservedObject();

oo.addObserver(a);

oo.addObserver(b);

oo.addObserver(c);

for (int i = 0; i 5; ++i) {

oo.addObserver(new Observer() {

public void takeAction() {

System.out.println(“我是山寨观察者”+”，谁敢拦我”);

}

});

}

//sometime oo changed ,so it calls update and informs all observer

oo.update();

}

}

观察者模式的精髓在于注册一个观察者观测可能随时变化的对象，对象变化时就会自动通知观察者，

这样在被观测对象影响范围广，可能引起多个类的行为改变时很好用，因为无需修改被观测对象的代码就可以增加被观测对象影响的类，这样的设计模式使得代码易于管理和维护，并且减少了出错几率

至于异步机制实际是个噱头，可以有观测对象来实现异步，也可以有观察者自身实现，这个程序实际是观测对象实现了异步机制，方法是在观察者类外包装了一层invoker类