设计模式——观察者模式

设计模式——观察者模式

1观察者模式的定义

观察者模式：多个对象会随着一个对象的改变来同时发生变化，这种设计模式就是观察者模式，这种模式也称为发布-订阅模式，实际项目中常用的MQ就是属于这种模式的典型应用！

No BB，Show Code！

2实现代码

2-1定义通知者接口

定义通知者接口：

package designPattern.test.observer;

/**
 * 通知者接口
 */
public interface Subject {

    //添加观察者方法
    void addObserver(Observer observer);

    //取出观察者方法
    void delObserver(Observer observer);

    //通知方法
    void advice();
}

2-2定义观察者接口

定义观察者接口

package designPattern.test.observer;

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

    //观察者做出改变方法
    void update();
}

2-3定义具体的通知者

为了便于理解观察者模式，定义了两个具体的通知者，Teacher、SchoolMaster，代码如下：

Teacher：

package designPattern.test.observer;

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

/**
 * 老师作为通知者
 */
public class Teacher implements Subject {

    //维护一个观察者的集合
    private List<Observer> observerList = new ArrayList<>();

    @Override
    public void addObserver(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void delObserver(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void advice() {
        System.out.println("老师发出通知");
        for (Observer observer : observerList) {
            observer.update();
        }
    }
}

SchoolMaster：

package designPattern.test.observer;

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

/**
 * 校长作为通知者
 */
public class SchoolMaster implements Subject {

    private List<Observer> observerList = new ArrayList<>();

    @Override
    public void addObserver(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void delObserver(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void advice() {
        System.out.println("校长发出通知");
        for (Observer observer : observerList) {
            observer.update();
        }
    }
}

2-3定义具体的观察者

定义了3种具体的观察者，PlayStudent、TalkStudent、SleepStudent，代码如下

PlayStudent：

package designPattern.test.observer;

/**
 * 玩的学生作为观察者
 */
public class PlayStudent implements Observer {

    private String name;

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

    @Override
    public void update() {
        System.out.println(this + "结束玩耍");
        System.out.println(this + "好好学习");
    }

    @Override
    public String toString() {
        return "PlayStudent{" +
                "name='" + name + '\'' +
                '}';
    }
}

TalkStudent：

package designPattern.test.observer;

/**
 * 聊天的学生作为观察者
 */
public class TalkStudent implements Observer {

    private String name;

    private TalkStudent talkStudent;

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

    @Override
    public void update() {
        System.out.println(this.getName() + "结束和" + talkStudent.getName() + "的聊天");
        System.out.println(this.getName() + "好好学习");
    }

    public String getName() {
        return name;
    }

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

    public TalkStudent getTalkStudent() {
        return talkStudent;
    }

    public void setTalkStudent(TalkStudent talkStudent) {
        this.talkStudent = talkStudent;
    }
}

SleepStudent：

package designPattern.test.observer;

/**
 * 睡觉的学生作为观察者
 */
public class SleepStudent implements Observer {

    private String name;

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

    @Override
    public void update() {
        System.out.println(this + "结束睡觉");
        System.out.println(this + "好好学习");
    }

    @Override
    public String toString() {
        return "SleepStudent{" +
                "name='" + name + '\'' +
                '}';
    }
}

3-测试

测试代码如下：

package designPattern.test.observer;

import org.junit.Test;

/**
 * 观察者模式测试
 */
public class ObServerTest {

    @Test
    public void testObserver() {
        Subject teacher = new Teacher();
        Subject schoolmaster = new SchoolMaster();
        Observer playStudent = new PlayStudent("小强");
        TalkStudent talkStudent1 = new TalkStudent("小红");
        TalkStudent talkStudent2 = new TalkStudent("小静");
        talkStudent1.setTalkStudent(talkStudent2);
        talkStudent2.setTalkStudent(talkStudent1);
        Observer sleepStudent = new SleepStudent("小花");
        teacher.addObserver(playStudent);
        teacher.addObserver(talkStudent1);
        teacher.addObserver(talkStudent2);
        teacher.addObserver(sleepStudent);
        schoolmaster.addObserver(playStudent);
        schoolmaster.addObserver(talkStudent1);
        schoolmaster.addObserver(talkStudent2);
        schoolmaster.addObserver(sleepStudent);
        teacher.advice();
        schoolmaster.advice();
    }

}

打印结果如下：

老师发出通知
PlayStudent{name='小强'}结束玩耍
PlayStudent{name='小强'}好好学习
小红结束和小静的聊天
小红好好学习
小静结束和小红的聊天
小静好好学习
SleepStudent{name='小花'}结束睡觉
SleepStudent{name='小花'}好好学习
校长发出通知
PlayStudent{name='小强'}结束玩耍
PlayStudent{name='小强'}好好学习
小红结束和小静的聊天
小红好好学习
小静结束和小红的聊天
小静好好学习
SleepStudent{name='小花'}结束睡觉
SleepStudent{name='小花'}好好学习

总结：观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新！