观察者模式

1、观察者模式介绍

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

观察者模式是一种对象行为型模式，其主要优点如下。

1. 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
2. 目标与观察者之间建立了一套触发机制。

它的主要缺点如下。

1. 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
2. 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

2、使用场景以及例子

1、简单的使用

public class ObserverPatternDemo01 {

    @Test
    public void demo1() {
        Subject1 subject1 = new Subject1();
        Observer1 observer1 = new Observer1();
        Observer2 observer2 = new Observer2();
        subject1.addObserver(observer1);
        subject1.addObserver(observer2);
        subject1.notifyAllObserver();
    }

    /**
     * 创建观察者接口
     */
    interface Observer {
        //观察者做出响应
        void response();
    }

    //观察者1
    class Observer1 implements Observer {

        @Override
        public void response() {
            System.out.println("观察者1做出反应");
        }
    }

    //观察者2
    class Observer2 implements Observer {

        @Override
        public void response() {
            System.out.println("观察者2做出反应");
        }
    }

    /**
     * 创建目标，被观察者
     */
    interface Subject {
        //引入所有观察者
        List<Observer> observers = new ArrayList<>();

        //增加观察者
        default void addObserver(Observer obser) {
            observers.add(obser);
        }

        //移除观察者
        default void removeObserver(Observer observer) {
            observers.remove(observer);
        }

        //通知所有观察者，这个让具体的目标实现，不提供默认实现
        void notifyAllObserver();
    }

    class Subject1 implements Subject {

        @Override
        public void notifyAllObserver() {
            System.out.println("目标1来了");
            for (Observer observer : observers) {
                observer.response();
            }
        }
    }
}

2、扩展使用–公司业务与汇率

/**
 * 实例1.公司业绩和汇率
 * 分析：当“人民币汇率”升值时，进口公司的进口产品成本降低且利润率提升，出口公司的出口产品收入降低且利润率降低；当“人民币汇率”贬值时，进口公司的进口产品成本提升且利润率降低，出口公司的出口产品收入提升且利润率提升。
 * <p>
 * 这里的汇率（Rate）类是目标类，它包含了保存观察者（Company）的 List 和增加/删除观察者的方法，以及有关汇率改变的抽象方法 change(int number)；而人民币汇率（RMBrate）类是具体目标， 它实现了父类的 change(int number) 方法，
 * 即当人民币汇率发生改变时通过相关公司；公司（Company）类是抽象观察者，它定义了一个有关汇率反应的抽象方法 response(int number)；进口公司（ImportCompany）类和出口公司（ExportCompany）类是具体观察者类，它们实现了父类的 response(int number) 方法，
 * 即当它们接收到汇率发生改变的通知时作为相应的反应
 */
public class ObserverPatternDemo02 {

    @Test
    public void demo1() {
        Rate subject1 = new ChinaRate();
        Company1 observer1 = new Company1();
        Company2 observer2 = new Company2();
        subject1.addObserver(observer1);
        subject1.addObserver(observer2);
        subject1.rateChange(2);
    }

    /**
     * 创建观察者接口
     */
    interface Company {
        //观察者做出响应
        void response(int number);
    }

    //观察者1
    class Company1 implements Company {

        @Override
        public void response(int number) {
            if (number > 0) {
                System.out.println("人民币汇率升值" + number + "个基点，降低了进口产品成本，提升了进口公司利润率。");
            } else if (number < 0) {
                System.out.println("人民币汇率贬值" + (-number) + "个基点，提升了进口产品成本，降低了进口公司利润率。");
            }
        }
    }

    //观察者2
    class Company2 implements Company {

        @Override
        public void response(int number) {
            if (number > 0) {
                System.out.println("人民币汇率升值" + number + "个基点，降低了出口产品收入，降低了出口公司的销售利润率。");
            } else if (number < 0) {
                System.out.println("人民币汇率贬值" + (-number) + "个基点，提升了出口产品收入，提升了出口公司的销售利润率。");
            }
        }
    }

    /**
     * 创建目标，被观察者
     */
    interface Rate {
        //引入所有观察者
        List<Company> companies = new ArrayList<>();

        //增加观察者
        default void addObserver(Company company) {
            companies.add(company);
        }

        //移除观察者
        default void removeObserver(Company company) {
            companies.remove(company);
        }

        //通知所有观察者，这个让具体的目标实现，不提供默认实现
        void rateChange(int rate);
    }

    class ChinaRate implements Rate {

        @Override
        public void rateChange(int rate) {
            System.out.println("中国汇率变了");
            for (Company company : companies) {
                company.response(rate);
            }
        }
    }
}

3、通过Java自带的类实现观察者

在 Java 中，通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式，只要实现它们的子类就可以编写观察者模式实例。

1. Observable类
   Observable 类是抽象目标类，它有一个 Vector 向量，用于保存所有要通知的观察者对象，下面来介绍它最重要的 3 个方法。
   void addObserver(Observer o) 方法：用于将新的观察者对象添加到向量中。
   void notifyObservers(Object arg) 方法：调用向量中的所有观察者对象的 update() 方法，通知它们数据发生改变。通常越晚加入向量的观察者越先得到通知。
   void setChange() 方法：用来设置一个 boolean 类型的内部标志位，注明目标对象发生了变化。当它为真时，notifyObservers() 才会通知观察者。
2. Observer 接口
   Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 void update(Observable o,Object arg) 方法，进行相应的工作。

/**
 * 【例3】利用 Observable 类和 Observer 接口实现原油期货的观察者模式实例。
 * <p>
 * 分析：当原油价格上涨时，空方伤心，多方局兴；当油价下跌时，空方局兴，多方伤心。本实例中的抽象目标（Observable）类在 Java 中已经定义，可以直接定义其子类，即原油期货（OilFutures）类，
 * 它是具体目标类，该类中定义一个 SetPriCe(float price) 方法，当原油数据发生变化时调用其父类的 notifyObservers(Object arg) 方法来通知所有观察者；另外，
 * 本实例中的抽象观察者接口（Observer）在 Java 中已经定义，只要定义其子类，即具体观察者类（包括多方类 Bull 和空方类 Bear），并实现 update(Observable o,Object arg) 方法即可。图 5 所示是其结构图。
 */
public class ObserverPatternDemo03 {

    @Test
    public void demo1() {
        OilFutures oil = new OilFutures();
        Observer bull = new Bull(); //多方
        Observer bear = new Bear(); //空方
        oil.addObserver(bull);
        oil.addObserver(bear);
        oil.setPrice(10);
        oil.setPrice(-8);
    }

    //多方bull
    class Bull implements Observer {

        @Override
        public void update(Observable o, Object arg) {
            Float price = ((Float) arg).floatValue();
            if (price > 0) {
                System.out.println("油价上涨" + price + "元，多方高兴了！");
            } else {
                System.out.println("油价下跌" + (-price) + "元，多方伤心了！");
            }
        }
    }

    //具体观察者类：空方
    class Bear implements Observer {
        public void update(Observable o, Object arg) {
            Float price = ((Float) arg).floatValue();
            if (price > 0) {
                System.out.println("油价上涨" + price + "元，空方伤心了！");
            } else {
                System.out.println("油价下跌" + (-price) + "元，空方高兴了！");
            }
        }
    }

    //目标-原油期货
    class OilFutures extends Observable {

        private float price;

        public float getPrice() {
            return price;
        }

        public void setPrice(float price) {
            super.setChanged();
            super.notifyObservers(price);
            this.price = price;
        }
    }
}

3、总结

总体来说，观察者模式在实际的项目运用中还是非常广泛的，比如通讯、监听等。这个设计模式个人觉得比较能体现java的一个特征，就是多态，通过子类的父类或者实现类的接口，做一个统一的方法调用。这个设计模式和发布订阅模式还有点区别，下次也记录一下。