设计模式（五）------观察者模式

前言

观察者模式：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖它的对象都会得到通知并自动更新。
同时，观察者是观察者和被观察者之间实现了送耦合，被观察者不知道观察者具体的内部实现，体现的是面向接口编程，扩展性也还好，如下所示。

需要注意的是，有许多人说观察者就是发布订阅模式，其实是不对的，如下，发布订阅模式多了一个中介，再观察者模式中，被观察者和观察者有耦合，而发布订阅模式是无耦合。

代码部分

两个接口：

public interface Observer {
    /**
     * 观察者收信息
     */
    void getMessage(String s);
}

public interface Subject {
    /**
     * 添加观察者
     * @param o
     */
    void addObserver(Observer o);

    /**
     * 移除观察者
     * @param o
     */
    void removeObserver(Observer o);

    /**
     * 通知观察者
     */
    void notifyObserver();
}

被观察者

public class SubjectImpl implements Subject {
    private List<Observer> list = new ArrayList<>();
    private String message;
    @Override
    public void addObserver(Observer o) {
        list.add(o);
    }

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

    @Override
    public void notifyObserver() {
        for (Observer o:list) {
            o.getMessage(message);
        }
    }
    public void setMessage(String s){
        this.message = s;
        System.out.println("发送消息："+s);
        notifyObserver();
    }
}

观察者对象

public class User implements Observer {
    private String name;
    private String message;

    public String getName() {
        return name;
    }

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

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    @Override
    public void getMessage(String s) {
        this.message = s;
        read();
    }

    public void read(){
        System.out.println(name+"收到消息："+message);
    }
}

测试代码

public class Test {
    public static void main(String[] args) {
        SubjectImpl subject = new SubjectImpl();
        User observer1 = new User();
        observer1.setName("tony");
        User observer2 = new User();
        observer2.setName("stark");
        User observer3 = new User();
        observer3.setName("hoak");

        subject.addObserver(observer1);
        subject.addObserver(observer2);
        subject.addObserver(observer3);

        subject.setMessage("GO 语言以后会超越 Java");
        System.out.println("================");
        subject.removeObserver(observer1);
        subject.setMessage("放屁，Java无敌，你们都是渣渣");


    }
}

结果

发送消息：GO 语言以后会超越 Java
tony收到消息：GO 语言以后会超越 Java
stark收到消息：GO 语言以后会超越 Java
hoak收到消息：GO 语言以后会超越 Java
================
发送消息：放屁，Java无敌，你们都是渣渣
stark收到消息：放屁，Java无敌，你们都是渣渣
hoak收到消息：放屁，Java无敌，你们都是渣渣