Android设计模式--观察者模式

叁歲伎倆 2022-12-21 12:59 76阅读 0赞

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

*  观察者模式主要用来解耦，将被观察者和观察者解耦，让他们之间没有没有依赖或者依赖关系很小。

## **适用场景**： ##

1.  当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变；
2.  当一个对象必须通知其它对象，而它又不能假定其它对象是谁.

观察者模式主要有观察者和被观察者2个对象，在该模式中，Observable表示被观察者，这个对象是一个抽象类，只能被继承。 Observer表示观察者，他是一个接口，所以观察者可以有多个，实现了该接口的类都是属于观察者。

# **一、基本使用** #

这是网上一个生动细致的demo：  
**被观察者**：

public class MyPerson extends Observable {
    
        private int age;
        private String name;
        private String sax;
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
            setChanged();
            notifyObservers();
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
            setChanged();
            notifyObservers();
        }
    
        public String getSax() {
            return sax;
        }
    
        public void setSax(String sax) {
            this.sax = sax;
        }
    
        @Override public String toString() {
            return "MyPerson [age=" + age + ", name=" + name + ", sax=" + sax + "]";
        }
    }

MyPerson是被观察者，类中调用了setChange()以及notifyObservers()两个方法，前者是告知数据改变，后者是发送信号通知观察者。

**观察者**：

public class MyObserver implements Observer {
    
        private int i;
        private MyPerson myPerson; //观察的对象
        public MyObserver(int i) {
            System.out.println("我是观察者---->" + i);
            this.i = i;
        }
    
        public int getI() {
            return i;
        }
    
        public void setI(int i) {
            this.i = i;
        }
    
        public MyPerson getMyPerson() {
            return myPerson;
        }
    
        public void setMyPerson(MyPerson myPerson) {
            this.myPerson = myPerson;
        }
    
        @Override public void update(Observable observable, Object data) {
            System.out.println("观察者---->" + i + "得到更新！");
            this.myPerson = (MyPerson) observable;
            System.out.println(((MyPerson) observable).toString());
        }
    
    }

观察者需要实现Observer接口，其中只有一个update方法，当观察者收到 （被观察者）的通知信号，就会执行该动作。

# **二、自定义** #

上面使用的是JDK内部内置的Observable（抽象被观察者），Observer（抽象观察者），也可以自定义，如下：

角色说明：

*  Subject（抽象主题）：又叫抽象被观察者，把所有观察者对象的引用保存到一个集合里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
 *  ConcreteSubject（具体主题）：又叫具体被观察者，将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。
 *  Observer (抽象观察者):为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
 *  ConcrereObserver（具体观察者）：实现抽象观察者定义的更新接口，当得到主题更改通知时更新自身的状态。

我们看一下具体的例子：

上课铃声响起时候，老师与学生们的不同反应。

1、定义一个抽象主题：

该抽象主题定义了一些通用的方法，即具体主题里面需要实现的。

//抽象被观察者
    public interface Observable {
        //添加观察者
        void addObserver(Observer observer);
    
        //移除观察者
        void deleteObserver(Observer observer);
    
        //通知观察者
        void notifyObserver(String msg);
    }

2、创建一个具体主题（上课铃声）：

public class AlarmClock implements Observable {
        //保存观察者对象
        List<Observer> list = new ArrayList<>();
    
        @Override
        public void addObserver(Observer observer) {
            list.add(observer);
        }
    
        @Override
        public void deleteObserver(Observer observer) {
            list.remove(observer);
        }
    
        /**
         * 通知观察者
         * @param msg
         */
        @Override
        public void notifyObserver(String msg) {
            for (Observer observer : list) {
                observer.action(msg);
            }
        }
    }

3、创建抽象观察者：

定义了所有具体观察者需要实现的方法，听到铃声后的行为

//抽象观察者
    public interface Observer {
        void action(String msg);
    }

4、创建具体观察者：

public class Students implements Observer {
    
        String name;
    
        public Students(String name) {
            this.name = name;
        }
    
        @Override
        public void action(String msg) {
            System.out.println(msg + name + "开始听课");
        }
    }
    public class Teacher implements Observer {
        @Override
        public void action(String msg) {
            System.out.print(msg + "老师开始讲课");
        }
    }

6、实现：

Observable alarmClock = new AlarmClock();
    
    Observer student1 = new Students("小屁孩");
    Observer student2 = new Students("大屁孩");
    Observer teacher = new Teacher();
    
    //注册观察者
    alarmClock.addObserver(student1);
    alarmClock.addObserver(student2);
    alarmClock.addObserver(teacher);
    
    //被观察者通知已经注册的观察者
    alarmClock.notifyObserver("上课铃声已经响了");

7、结果：

![16a26443d22b6fe58ac67ec73c9d9d05.png][]

到这里我们便实现了观察者模式。

# **三、观察者模式的优点和缺点** #

### 优点 ###

*  解除观察者与主题之间的耦合。让耦合的双方都依赖于抽象，而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。
 *  易于扩展，对同一主题新增观察者时无需修改原有代码。

### 缺点 ###

*  依赖关系并未完全解除，抽象主题仍然依赖抽象观察者。
 *  使用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。
 *  可能会引起多余的数据通知。

[16a26443d22b6fe58ac67ec73c9d9d05.png]: /images/20221120/92015baebed4472e98d61a7da126e798.png