设计模式-观察者模式

 
  • 文章目录
    • 一、观察者模式简介
    • 二、实战演练

一、观察者模式简介

  1. 简介:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。
  2. 归类:行为型模式
  3. 特点:一般由两个角色组成:发布者和订阅者(观察者)。观察者通常有一个回调,也可以没有。

二、实战演练

demo事例:发送消息–用户接收

  1. 创建观察者接口 Observer.java

    1
    2
    3
    4
    5
    6
    7
    8
    package com.demo.observer;

    /**
    * 接收消息接口(订阅者--观察者)
    */
    public interface Observer {
    public void receiveMsg(String msg);
    }
  2. 创建被观察者接口(发布者) Observerable.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    package com.demo.observer;

    public interface Observerable {

    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObserver();

    }
  3. 实现被观察者接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    package com.demo.observer;

    import java.util.ArrayList;
    import java.util.List;

    /**
    * 发布者
    * 消息中转站(服务端:注册--移除--发送)
    */
    public class MsgServer implements Observerable {

    private List<Observer> list;
    private String message;

    public MsgServer(){
    list=new ArrayList<Observer>();
    }

    @Override
    public void registerObserver(Observer o) {
    list.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
    if(!list.isEmpty()){
    list.remove(o);
    }
    }

    @Override
    public void notifyObserver() {
    //通知所有观察者,发送到消息
    for(int i = 0; i < list.size(); i++) {
    Observer o = list.get(i);
    o.receiveMsg(message);
    }
    }

    public void sendMsg(String s) {
    this.message = s;
    System.out.println("服务端发送消息: " + s);
    notifyObserver();
    }
    }
  4. 实现被观察者(订阅者)接口 MsgReceive.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package com.demo.observer;

    /**
    * 订阅者(观察者)
    */
    public class MsgReceive implements Observer {

    private String userName;
    private String msg;

    public MsgReceive(String userName){
    this.userName=userName;
    }

    @Override
    public void receiveMsg(String msg) {
    System.out.println(userName + " 收到推送的消息: " + msg);
    }
    }
  5. 创建测试类 ObserverTest.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package com.demo.observer;

    public class ObserverTest {

    public static void main(String[] args) {
    MsgServer server = new MsgServer();
    Observer msgReceive1=new MsgReceive("小肥羊");
    Observer msgReceive2=new MsgReceive("lucksheep");
    server.registerObserver(msgReceive1);
    server.registerObserver(msgReceive2);
    server.sendMsg("我是谁?");
    System.out.println("------------------------------");
    server.removeObserver(msgReceive2);
    server.sendMsg("谁收到了消息?");
    }
    }
  6. 产出结果

    1
    2
    3
    4
    5
    6
    服务端发送消息: 我是谁?
    小肥羊 收到推送的消息: 我是谁?
    lucksheep 收到推送的消息: 我是谁?
    ------------------------------
    服务端发送消息: 谁收到了消息?
    小肥羊 收到推送的消息: 谁收到了消息?

 评论