Java设计模式--观察者模式-阿里云开发者社区

开发者社区> yexx> 正文

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

简介: 观察者模式(别名:依赖,发布-订阅) 定义对象间的一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖它的对象都得到通知并被自动更新。 Observer Pattern(Another Name: Dependents, Publish-Subscribe) Define a one-to-many dependency between objects so
+关注继续查看

观察者模式(别名:依赖,发布-订阅)

定义对象间的一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖它的对象都得到通知并被自动更新。

Observer Pattern(Another Name: Dependents, Publish-Subscribe)

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

类图

模式的结构与使用

观察者模式的结构中包括四个角色。
+ 主题(Subject):主题是一个接口,该接口规定了具体主题需要实现的方法,比如,添加、删除观察者以及通知观察者更新数据的方法。
+ 具体主题(Concrete Subject):具体主题是实现主题接口类的一个实例,该实例包含有可以经常发生变化的数据。具体主题需使用一个集合,比如ArrayList,存放观察者的引用,以便数据变化时通知具体观察者。
+ 观察者(Observer):观察者一个接口或者抽象类,该接口规定了具体观察者用来更新数据的方法。
+ 具体观察者(Concrete Observer):具体观察者是实现观察者接口类的一个实例。具体观察者包含有可以存放具体主题引用的主题接口变量,以便具体观察者让具体主题将自己的引用添加到具体主题中,使自己成为它的观察者,或让这个具体主题将自己从具体主题的集合中删除,使自己不再是它的观察者。

简单的例子(推数据)

Subject接口类Subject.java

package Observer;

public interface Subject {
    public void addObserver(Observer o);
    public void deleteObserver(Observer o);
    public void notifyObservers();
}

ConcreteSubject的实现类SeekJobCenter.java

package Observer;

import java.util.ArrayList;

public class SeekJobCenter implements Subject {
    String mess;
    ArrayList<Observer> personList;
    boolean changed;

    public SeekJobCenter() {
        personList = new ArrayList<Observer>();
        mess = "";
        changed = false;
    }

    @Override
    public void addObserver(Observer o) {
        if (!personList.contains(o)) {
            personList.add(o);
        }
    }

    @Override
    public void deleteObserver(Observer o) {
        if (personList.contains(o)) {
            personList.remove(o);
        }
    }

    @Override
    public void notifyObservers() {
        if (changed) {
            for (int i = 0; i < personList.size(); i++) {
                Observer o = personList.get(i);
                o.hearTelephone(this.mess);
            }
            changed = false;
        }
    }

    public void giveNewMessage(String str) {
        if (str.equals(mess)) {
            System.out.println("重复信息");
            changed = false;
        } else {
            this.mess = str;
            changed = true;
        }
    }
}

Observer的接口类Observer.java

package Observer;

public interface Observer {
    public void hearTelephone(String mess);
}

ConcreteObserver的实现类UniversityStudent.java

package Observer;

public class UniversityStudent implements Observer {

    Subject subject;

    public UniversityStudent(Subject subject) {
        this.subject = subject;
        subject.addObserver(this);
    }

    @Override
    public void hearTelephone(String mess) {
        System.out.println("我是一个大学生");
        System.out.println(mess);
    }

}

ConcreteObserver的实现类MiddleSchoolStudent.java

package Observer;

public class MiddleSchoolStudent implements Observer {

    Subject subject;

    public MiddleSchoolStudent(Subject subject) {
        this.subject = subject;
        subject.addObserver(this);
    }

    @Override
    public void hearTelephone(String mess) {
        System.out.println("我是一名中学生");
        if (mess.contains("中学生")) {
            System.out.println(mess);
        } else {
            System.out.println("我是中学生,这次信息中没有我需要的信息");
        }
    }
}

测试类Application.java

package Observer;

public class Application {

    public static void main(String[] args) {
        SeekJobCenter center = new SeekJobCenter();
        new UniversityStudent(center);
        new MiddleSchoolStudent(center);
        center.giveNewMessage("大学生工作");
        center.notifyObservers();
        center.giveNewMessage("大学生工作");
        center.notifyObservers();
        center.giveNewMessage("中学生工作");
        center.notifyObservers();
    }
}

观察者模式中的“推”数据与“拉”数据

1.推数据方式

推数据方式是指具体主题将变化后的数据全部交给具体观察者,即将变化后的数据传给具体观察者用于更新数据方法的参数。当具体主题认为具体观察者需要这些变化后的全部数据时往往采用推数据方式。

2.拉数据方式

拉数据方式是指具体主题不将变化后的数据交给具体观察者,而是提供了获得这些数据的方法,具体观察者在得到通知后,可以调用具体主题提供的方法得到数据(观察者自己数据“拉”过来),但需要自己判断数据是否发生变化。当具体主题不知道具体观察者是需要这些变换后的数据时往往采用拉数据的方式。

简单的例子(拉数据)

Subject接口类Subject.java

package ObserverPull;

public interface Subject {
    public void addObserver(Observer o);
    public void deleteObserver(Observer o);
    public void notifyObserver();
}

ConcreteSubject的实现类ShopSubject.java

package ObserverPull;

import java.util.ArrayList;

public class ShopSubject implements Subject {

    String goodsName;
    double oldPrice, newPrice;

    public String getGoodsName() {
        return goodsName;
    }

    public double getOldPrice() {
        return oldPrice;
    }

    public double getNewPrice() {
        return newPrice;
    }

    public ArrayList<Observer> getCustomerList() {
        return customerList;
    }

    ArrayList<Observer> customerList;

    public ShopSubject() {
        customerList = new ArrayList<Observer>();
    }

    @Override
    public void addObserver(Observer o) {
        if (!customerList.contains(o)) {
            customerList.add(o);
        }
    }

    @Override
    public void deleteObserver(Observer o) {
        if (customerList.contains(o)) {
            customerList.remove(o);
        }
    }

    @Override
    public void notifyObserver() {
        for (int i = 0; i < customerList.size(); i++) {
            customerList.get(i).update();
        }
    }

    public void setDiscountGoods(String name, double oldP, double newP) {
        goodsName = name;
        oldPrice = oldP;
        newPrice = newP;
        notifyObserver();
    }
}

Observer的接口类Observer.java

package ObserverPull;

public interface Observer {
    public abstract void update();
}

ConcreteObserver的实现类CustomerOne.java

package ObserverPull;

public class CustomerOne implements Observer {

    Subject subject;
    String goodsName,personName;

    public CustomerOne(Subject subject, String personName) {
        this.subject = subject;
        this.personName = personName;
        subject.addObserver(this);
    }

    @Override
    public void update() {
        if (subject instanceof ShopSubject) {
            goodsName = ((ShopSubject) subject).getGoodsName();
            System.out.println(personName + "只对打折商品的名字感兴趣");
            System.out.println("打折商品是:" + goodsName);
        }
    }
}

ConcreteObserver的实现类CustomerTwo.java

package ObserverPull;

public class CustomerTwo implements Observer {
    Subject subject;
    String personName;
    double oldP,newP;

    public CustomerTwo(Subject subject, String personName) {
        this.subject = subject;
        this.personName = personName;
        subject.addObserver(this);
    }

    @Override
    public void update() {
        if (subject instanceof ShopSubject) {
            oldP = ((ShopSubject) subject).getOldPrice();
            newP = ((ShopSubject) subject).getNewPrice();
            System.out.println(personName + "只对商品的新旧价格感兴趣");
            System.out.println("商品旧价格是:" + oldP);
            System.out.println("商品新价格是:" + newP);
        }
    }
}

测试类Application.java

package ObserverPull;

public class Application {

    public static void main(String[] args) {
        ShopSubject shop = new ShopSubject();
        new CustomerOne(shop, "yxx");
        new CustomerTwo(shop, "yn");
        shop.setDiscountGoods("pen", 20, 10);
        shop.setDiscountGoods("相机", 1000, 800);
    }
}

观察者与多主体

一个具体观察者可以依赖于多个主题,当所有依赖的任何具体主题的数据发生变化时,该观察者都能得到通知。多主题所涉及的主要问题是观察者如何处理主题中变化后的数据,因为,不同的具体主题所包含有的数据结构可能很大不同。
在处理多主题时,主题应当采用拉数据方式,观察者接口可以将更新数据方法的参数类型设置为主题接口类型,比如update(Subject subject),即具体主题数据放生变化时将自己的引用传递给具体的观察者,然后具体观察者让这个具体主题调用有关的方法返回该具体主题中的数据。

观察者模式的优点

  • 具体主题和具体观察者是松耦合关系。由于主题接口仅仅依赖于观察者接口,因此具体主题只是知道它的观察者是实现观察者接口的某个类的实例,但不需要知道具体哪个类。同样,由于观察者仅仅依赖于主题接口,因此具体观察者只是知道它依赖的主题是实现主题接口的某个类的实例,但不需要知道具体是哪一个类。
  • 观察模式满足“开-闭原则”。主题接口仅仅依赖于观察者接口,这样,就可以让创建具体主题的类也仅仅是依赖于观察者接口,因此如果增加新的实现观察者接口的类,不必修改创建具体主题的类的代码。同样,创建具体观察者的类仅仅依赖于主题接口,如果增加新的实现主题接口的类,也不必修改创建具体观察者类的代码。

适用观察者模式的情景

  • 当一个对象的数据更新时需要通过其他对象,但这个对象又不希望和被通知的那些对象形成紧耦合。
  • 当一个对象的数据更新时,这个对象需要让其他对象也各自更新自己的数据,但这个对象不知道具体有多少对象需要更新数据。

下载源码请到

MyGitHub

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
大话设计模式之观察者模式
          从前,有个放羊娃,每天都去山上放羊,一天,他觉得十分无聊,就想了个捉弄大家寻开心的主意。他向着山下正在种田的农夫们大声喊:“狼来了!狼来了!救命啊!”农夫们听到喊声急忙拿着锄头和镰刀往山上跑,他们边跑喊:“不要怕,孩子,我们来帮你打恶狼!”农夫们气喘吁吁地赶到山上一看,连狼的影子也没有!放羊娃哈哈大笑:“真有意思,你们上当了!”农夫们生气地走了。
992 0
使用OpenApi弹性释放和设置云服务器ECS释放
云服务器ECS的一个重要特性就是按需创建资源。您可以在业务高峰期按需弹性的自定义规则进行资源创建,在完成业务计算的时候释放资源。本篇将提供几个Tips帮助您更加容易和自动化的完成云服务器的释放和弹性设置。
12072 0
JAVA 设计模式 备忘录模式
用途   备忘录模式 (Memento) 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。 这样以后就可将该对象恢复到原先保存的状态。 备忘录模式是一种行为型模式。
594 0
Java 设计模式
原文出处:https://javadoop.com/post/design-pattern 一直想写一篇介绍设计模式的文章,让读者可以很快看完,而且一看就懂,看懂就会用,同时不会将各个模式搞混。
636 0
带你读《Java程序设计与计算思维》之一:计算思维与Java设计初步体验
程序设计的过程就是一种计算思维的表现,《Java程序设计与计算思维》结合Java程序设计语言的教学特点,遵循计算思维的方式,图解重要概念,通过大量的范例程序讲解和上机编程实践来指导读者活用Java程序语法,兼顾培养计算思维和学习面向对象程序设计的双目标。
875 0
JAVA内置的观察者模式样本
DisplayElement.java public interface DisplayElement { public void display(); } CurrentConditionsDisplay.
544 0
JAVA设计模式之单例模式
概念:  java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例类只能有一个实例。  2、单例类必须自己创建自己的唯一实例。
952 0
设计模式之观察者模式
写作方法:    一般用于异步通讯1. 定义ObServer类   定义允许调用的虚函数,保护其他函数使不可见。
588 0
+关注
yexx
CSDN博客地址---http://blog.csdn.net/bug_moving GitHub地址---https://github.com/androidwolf
308
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载