设计模式之观察者模式

概要

设计模式是一门艺术，如果真正了解这门艺术，你会发现，世界都将变得更加优美。

定义

对象间一对多的关系，当对象发生改变，所有跟其对象依赖的对象都会得到通知，发生改变

使用场景

1、夜间模式，关联行为场景
2、事件多级触发改变
3、消息交换场景，通知改变

UML

看上面的图，我们应该能够很清晰的知道，他们之间的情况。

（1）被观察者

被观察者：只能有一个，它也只有一个方法，那就是通知所有的观察者

（2）具体观察者

具体观察者：具体观察者实现了抽象被观察者，复写nofifyObervable方法，里面也添加了自己的一些方法，比如：移除观察者，添加观察者。

（3）观察者

观察者：观察者内部也有一个方法，那就是更新，也就是说，当被观察者通知的时候，我们可以在此方法中接收到信息，从而做一些自己的事情。

（4）具体观察者

具体观察者：同上，具体需求具体实现。

代码实现

上面我们已经很清晰的明白了他们之间的关系，所以接下来就用代码演示，将上面我们的想法和逻辑用代码表现出来：

（1）抽象被观察者

package com.zengtao.demo.observer;

/**
 * 被观察者
 */
public interface Obervable {

    public void notifyObserver();

    public void addOberver(Observer observer);

    public void removeObserver(Observer observer);

}

（2）具体观察者

package com.zengtao.demo.observer;

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

/**
 * 具体被观察者：明星
 */
public class Start implements Obervable {

    private static List<Observer> list = new ArrayList<Observer>();

    private String name;
    private String singName;

    public Start() {

    }

    public Start(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setSingName(String singName) {
        this.singName = singName;
    }

    public String getSingName() {
        return singName;
    }

    @Override
    public void notifyObserver() {
        notifys();
    }

    @Override
    public void addOberver(Observer observer) {
        if (list != null) {
            list.add(observer);
        }
    }

    @Override
    public void removeObserver(Observer observer) {
        if (list != null) {
            list.remove(observer);
        }
    }

    private void notifys() {
        if (list == null) {
            return;
        }
        for (int i = 0; i < list.size(); i++) {
            list.get(i).update("，你关注的：" + this.name + " 有新消息更新了，歌曲：" + getSingName() + "，上榜了");
        }
    }
}

（3）抽象观察者

package com.zengtao.demo.observer;

/**
 * 观察者
 */
public interface Observer {

    void update(String content);

}

（4）具体观察者

package com.zengtao.demo.observer;

/**
 * 具体观察者：粉丝
 */
public class Fan implements Observer {

    private String name;

    public Fan() {

    }

    public Fan(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void update(String content) {
        System.out.println("hi，" + this.name + content);
    }

}

（5）调用

package com.zengtao.demo;

import com.zengtao.demo.observer.Fan;
import com.zengtao.demo.observer.Start;

public class Main {

    public static void main(String[] str) {
        /**
         * 1.创建被观察者
         * 2.创建观察者
         * 3.将观察者和被观察者添加联系
         * 4.通知观察者改变
         */

        Start starts = new Start("胡**");
        starts.setSingName("六月的雨");

        Fan fan1 = new Fan("粉丝-西瓜");
        Fan fan2 = new Fan("粉丝-土豆");
        Fan fan3 = new Fan("粉丝-南瓜");
        Fan fan4 = new Fan("粉丝-苹果");

        starts.addOberver(fan1);
        starts.addOberver(fan2);
        starts.addOberver(fan3);
        starts.addOberver(fan4);

        starts.notifyObserver();
    }
}

（6）结果

以上就完成了，整个观察者模式的设计，但是，不知道有没有发现一个问题

在调用的时候，都是有被观察者去添加观察者或者移除观察者?

这跟现实是完成不符合的，我们知道，平时粉丝订阅的时候，都是自己想订阅那就订阅，想取消就取消，是观察者去做的，而不是被观察者。。。

那接下来该怎么办呢？

下回分析..
…
..
.