精华内容
下载资源
问答
  • java中观察模式使用场景

    千次阅读 2016-11-07 10:44:50
    观察模式 是一种非常经典 非常常用的设计模式。  一个对象的行为 依赖于 另一个对象的状态。或者换一种说法,当被观察对象(目标对象)的状态发生改变时 ,会直接影响到观察对象的行为。 特点一 : 被观察...

     观察者模式 是一种非常经典 非常常用的设计模式。

     一个对象的行为 依赖于 另一个对象的状态。或者换一种说法,当被观察对象(目标对象)的状态发生改变时 ,会直接影响到观察对象的行为。

    特点一 : 被观察者 和观察者 一般是 一对多的关系,一个被观察者 对应多个观察者,当一个被观察者的状态发生改变时,被观察者通知观察者, 然后可以在观察者内部 进行业务逻辑的处理。


    JDK 提供了 一套 观察者模式的实现,在java.util包中, java.util.Observable类和java.util.Observer接口。Observable是被观察者,Observer是观察者。


    下边是被观察者 的属性和方法 介绍

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    Class Observable {
     
    obs : Vector // 观察者列表
     
    addObserver(Observer o) //添加观察者
     
    deleteObserver(Observer o) // 删除观察者
     
    notifyObservers()// 通知观察者, 回调 观察者的 update()方法 
     
    notifyObservers(Object arg)
     
    }

    下边是观察者的介绍,观察者会实现Observer借口,重写update方法,然后把观察者 注入到被观察者中

    1
    2
    3
    4
    5
    Interface Observer {
     
     public void update(Event evt);
     
    }

    下面是想到的 一个具体的应用场景。


    涉及到3个类 ,订单类、事件类、工单类、

    订单类 包含 id,state 属性,state 1代表 开启,0代表关闭。

    事件类 包括 id,allowClose 属性,allowClase 代表 是否可关闭。


    当订单状态 发生改变 即 关闭时,订单关联的工单 和事件  也就可以关闭了,否则 如果订单状态时 开启的, 则不允许 关闭 对应的 工单和事件。

    本文出自 “JAVA那些事儿” 博客,请务必保留此出处http://1027187712.blog.51cto.com/5509347/1743743

    展开全文
  • 观察模式应用场景实例

    千次阅读 2017-10-22 16:07:15
    观察模式应用场景实例一个典型的购票网站,以购票为核心业务(此模式不限于该业务),但围绕购票会产生不同的其他逻辑,如: 1. 购票后记录文本日志 2. 购票后记录数据库日志 3. 购票后发送短信 4. 购票送抵扣卷...

    转载自 Robot_G(swengineer)

    观察者模式应用场景实例

    一个典型的购票网站,以购票为核心业务(此模式不限于该业务),但围绕购票会产生不同的其他逻辑,如:
    1. 购票后记录文本日志
    2. 购票后记录数据库日志
    3. 购票后发送短信
    4. 购票送抵扣卷、兑换卷、积分
    5. 其他各类活动等

    传统的解决方案:

    在购票逻辑等类内部增加相关代码,完成各种逻辑。

    存在问题:
    1. 一旦某个业务逻辑发生改变,如购票业务中增加其他业务逻辑,需要修改购票核心文件、甚至购票流程。
    2. 日积月累后,文件冗长,导致后续维护困难。

    存在问题原因主要是程序的”紧密耦合”,使用观察模式将目前的业务逻辑优化成”松耦合”,达到易维护、易修改的目的,同时这也符合面向接口编程的思想。

    代码实现

    #===================定义观察者、被观察者接口============
    /**
     *
     * 观察者接口(通知接口) 观察者接口
     *
     */
    interface ITicketObserver 
    {
        function onBuyTicketOver($sender, $args); 
        //得到通知后调用的方法
    }
    
    /**
     *
     * 主题接口,被观察对象接口
     *
     */
    interface ITicketObservable 
    {
    //提供注册观察者方法
    }
    #====================主题类实现========================
    /**
     *
     * 主题类(购票)
     * 实现主题接口(被观察者)
     *
     */
    class HipiaoBuy implements ITicketObservable { 
        private $_observers = array (); //通知数组(观察者)
    
        //购票核心类,处理购票流程
        public function buyTicket($ticket) 
    {
           // TODO 购票逻辑
    
    
           //循环通知,调用其onBuyTicketOver实现不同业务逻辑
           foreach ( $this->_observers as $obs )
               $obs->onBuyTicketOver ( $this, $ticket ); //$this 可用来获取主题类句柄,在通知中使用
        }
    
        //添加通知
        public function addObserver($observer) //添加N个通知
    {
           $this->_observers [] = $observer;
        }
    }
    
    #=========================定义多个通知====================
    //短信日志通知
    class HipiaoMSM implements ITicketObserver {
        public function onBuyTicketOver($sender, $ticket) {
           echo (date ( 'Y-m-d H:i:s' ) . " 短信日志记录:购票成功:$ticket<br>");
        }
    }
    //文本日志通知
    class HipiaoTxt implements ITicketObserver {
        public function onBuyTicketOver($sender, $ticket) {
           echo (date ( 'Y-m-d H:i:s' ) . " 文本日志记录:购票成功:$ticket<br>");
        }
    }
    //抵扣卷赠送通知
    class HipiaoDiKou implements ITicketObserver {
        public function onBuyTicketOver($sender, $ticket) {
           echo (date ( 'Y-m-d H:i:s' ) . " 赠送抵扣卷:购票成功:$ticket 赠送10元抵扣卷1张。<br>");
        }
    }
    #============================用户购票====================
    $buy = new HipiaoBuy ();
    $buy->addObserver ( new HipiaoMSM () ); //根据不同业务逻辑加入各种通知
    $buy->addObserver ( new HipiaoTxt () );
    $buy->addObserver ( new HipiaoDiKou () );
    //购票
    $buy->buyTicket ( "一排一号" );
    
    ?>
    展开全文
  • java设计模式--观察模式应用场景

    千次阅读 2017-02-17 16:07:43
    观察者分为两种模式:推和拉 推模型是假定知道观察者需要什么数据,传这个数据过去;拉模型是不知道观察者需要什么数据,干脆把自身传给他,按需取值 应用场景如下: 订阅火车票之后,需要记录日志,也需要...

    观察者分为两种模式:推和拉

    推模型是假定知道观察者需要什么数据,传这个数据过去;拉模型是不知道观察者需要什么数据,干脆把自身传给他,按需取值


    应用场景如下:

    订阅火车票之后,需要记录日志,也需要发送短信

    如果常规写法,在订阅火车票内部实现,若以后还需要增加新功能则需要修改核心代码


    推模式实现:

    client.java 传的"ok"可以是任意字符串,也可以是subject的某一个字段,若为拉模式,只需要改为change(this)即可。

    public static void main(String[] args) {
    		 Subject subject=new Subject();
    		 LogObservers observer=new LogObservers(); 
    		 MessageObservers observers=new MessageObservers();
    		 
    		 subject.addObservers(observer);
    		 subject.addObservers(observers);
    		 
    		 subject.change("ok");
    		 
    	}
    subject.java

    public  class Subject {
    
    	private   List<Object> list = new ArrayList<Object>();
    	
    	public void addObservers(Object object) {
    		list.add(object);
    	}
    	
    	public void removeObservers(Object object) {
    		list.remove(object);
    	}
    	
    	public void change(String state) {
    		System.out.println("观察者改变了!");
    		for(Object object : list ) {
    			 if(object instanceof LogObservers)
    			 {
    				 ((LogObservers)object).doWork(state);
    			 }else{
    				 ((MessageObservers)object).doWork(state);
    			 }
    		}
    	}
    }
    接口

    public interface ITicketObserver {
    
    	public void doWork(String state);
    }
    短信观察者

    public class MessageObservers implements ITicketObserver {
    
    	@Override
    	public void doWork(String state) {
    		 System.out.println("短信操作开始!更新状态"+state);
    	}
    
    }
    日志观察者

    public class LogObservers implements ITicketObserver {
    
    	@Override
    	public void doWork(String state) {
    		 System.out.println("日志文件操作开始!更新状态"+state);
    	}
    
    }







    展开全文
  • 观察模式(Observer Pattern)是对象的行为模式,又叫发布-订阅模式、源-监听器模式和从属者模式等。 两种模型(推模型和拉模型): ■推模型是假定主题对象知道观察者需要的数据;而拉模型是主题对象不...

    一句话概括:

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

    关键点:一对多,一个对象改变所有依赖它的对象得到通知

    补充介绍:

    观察者模式(Observer Pattern)是对象的行为模式,又叫发布-订阅模式、源-监听器模式和从属者模式等。

    两种模型(推模型和拉模型):

    推模型是假定主题对象知道观察者需要的数据而拉模型是主题对象不知道观察者具体需要什么数据,没有办法的情况下,干脆把自身传递给观察者,让观察者自己去按需要取值。

    ■推模型可能会使得观察者对象难以复用,因为观察者的update()方法是按需要定义的参数,可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候,就可能提供新的update()方法,或者是干脆重新实现观察者;而拉模型就不会造成这样的情况,因为拉模型下,update()方法的参数是主题对象本身,这基本上是主题对象能传递的最大数据集合了,基本上可以适应各种情况的需要。

    参与角色:

    1)观察者基类(也可以是接口,至少要包含一个update(Subject)方法)

    2)不同观察者的实现类

    3)事件主题基类(可以添加,移除观察者,还有一个可以将事件/状态通知给所有观察者的方法)

    4)事件主题实现类

    优点:

    1)观察者和被观察者是抽象耦合的。

    2)建立一套触发机制

    缺点:

    1)如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间。

    2)如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。

    3)观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的,而仅仅只是知道观察目标发生了变化。

    使用案例或场景:

    比如Node.js的事件驱动程序:

     

    再比如现在很多的消息中间件,RabbitMQ,kafka等,都有发布订阅功能,当一个消息发布后,所有订阅这个消息的队列都会收到这个消息,然后消费者负责去消费这些消息。当然不能简单的将发布-订阅模式与观察者模式混为一谈,发布-订阅模式更像是观察者模式的扩展,不过概念上还是非常相似的。发布-订阅模式中,订阅方可能并不知道发布方是谁,发布方也不需要同步的将状态通知到所有订阅方,他们之间的联系需要消息代理中间件来建立。所以发布-订阅的耦合更低,更利于扩展。需要了解发布-订阅模式和观察者模式不同的朋友可以去看看这条博客:

    http://www.sohu.com/a/207062452_464084

    示例程序

    需要源码的朋友可以前往github下载:

    https://github.com/aharddreamer/chendong/tree/master/design-patterns/demo-code/design-patterns

    程序简介:

    在这段示例程序中,观察者将观察一个会生成数值的对象,并将它生成的数值结果显示出来。不过,不同的观察者显示的方式不一样。DigitObserver会以数字的形式显示数值,而GraphObserver则会以简单的图示形式来呈现数值。

    类和接口一览:

    Observer 表示观察者的接口

    NumberGenerator 表示生成数值的对象的抽象类

    RandomNumberGenerator 生成随机数的类

    DigitObserver 表示以数字形式显示数值的类

    GraphObserver 表示以简单的图示形式显示的数值的类

    ObserverPatternTest 测试观察者模式的类

     

    代码:

    public interface Observer {
       
    void update(NumberGenerator numberGenerator);
    }

     

    public abstract class NumberGenerator {
       
    private List observers = new ArrayList();
       
    public void addObserver(Observer observer) {
           
    observers.add(observer);
        }
       
    public void deleteObserver(Observer observer) {
           
    observers.remove(observer);
        }
       
    public void notifyObservers() {
            Iterator it =
    observers.iterator();
           
    while (it.hasNext()) {
                Observer observer = (Observer) it.next();
                observer.update(
    this);
            }
        }
       
    public abstract int getNumber();
       
    public abstract void execute();
    }

     

    public class RandomNumberGenerator extends NumberGenerator {
       
    private Random random = new Random();
       
    private int number;
       
    public int getNumber() {
           
    return number;
        }
       
    public void execute() {
           
    for (int i = 0; i < 10 ; i++) {
               
    number = random.nextInt(50);
                notifyObservers();
            }
        }
    }

     

    public class DigitObserver implements Observer {
       
    @Override
       
    public void update(NumberGenerator numberGenerator) {
           
    //直接打印数字
           
    System.out.println("DigitObserver: " + numberGenerator.getNumber());
           
    //为了方便演示,延迟100毫秒
           
    try {
                Thread.sleep(
    100);
            }
    catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

     

    public class GraphObserver implements Observer {
       
    @Override
       
    public void update(NumberGenerator numberGenerator) {
           
    //显示n个星号 n = numberGenerator.getNumber()
           
    System.out.print("GraphObserver: ");
           
    for (int i = 0; i < numberGenerator.getNumber(); i++) {
                System.
    out.print("*");
            }
            System.
    out.println();
           
    //为了方便演示,延迟100毫秒
           
    try {
                Thread.sleep(
    100);
            }
    catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

     

     

    public class ObserverPatternTest {
       
    public static void main(String[] args) {
            NumberGenerator generator =
    new RandomNumberGenerator();
            Observer digitObserver =
    new DigitObserver();
            Observer graphObserver =
    new GraphObserver();
            generator.addObserver(digitObserver);
            generator.addObserver(graphObserver);
            generator.execute();
        }
    }

     

     

    运行结果:

    DigitObserver: 32

    GraphObserver: ********************************

    DigitObserver: 11

    GraphObserver: ***********

    DigitObserver: 14

    GraphObserver: **************

    DigitObserver: 11

    GraphObserver: ***********

    DigitObserver: 2

    GraphObserver: **

    DigitObserver: 44

    GraphObserver: ********************************************

    DigitObserver: 37

    GraphObserver: *************************************

    DigitObserver: 40

    GraphObserver: ****************************************

    DigitObserver: 20

    GraphObserver: ********************

    DigitObserver: 37

    GraphObserver: *************************************

     

     

    参考:

    《图解设计模式》【日】结城浩著

    《观察者模式》、《Node.js事件循环》菜鸟教程网站

    《观察者模式和“发布-订阅”模式有区别吗?》https://blog.csdn.net/dean_hu/article/details/71195133

     

     

    展开全文
  • 当对象间存在一对多关系时,则使用观察模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察模式属于行为型模式。 简而言之,就两个点: 一对多 发布&订阅 举个例子 ,...
  • 观察模式的效果有以下的优点:第一、观察模式在被观察者和观察者之间建立一个抽象的耦合。观察模式有下面的缺点:第一、如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很...
  • 求教大神,若干订单组成了配送单,若干配送单组成行车单,订单,配送单,行车单都有运输件数字段,配送单统计所辖订单的全部运输件数,行车单统计所辖配送单全部...适合观察模式吗?如果不适合,还有好的设计方法吗?
  • 单例模式使用场景

    千次阅读 2018-05-29 08:08:58
    单例模式使用场景什么是单例模式呢,单例模式(Singleton)又叫单态模式,它出现目的是为了保证一个类在系统中只有一个实例,并提供一个访问它的全局访问点。从这点可以看出,单例模式的出现是为了可以保证系统中一...
  • php 设计模式使用场景

    千次阅读 2018-07-04 13:43:42
    单例模式工厂模式策略模式观察模式适配器模式管道模式注册模式
  • Java设计模式常见使用场景

    万次阅读 多人点赞 2018-05-09 16:07:16
    一、Java I/O中的设计模式1、适配器模式适配器模式就是把一个类的接口变换成客户端所能接受的另一种接口,从而使两个接口不匹配而无法在一起工作的两个类能够在一起工作。通常被用在一个项目需要引用一些开源框架来...
  • 观察模式的应用场景及实现方式

    千次阅读 2015-05-21 20:56:49
    观察模式应用场景实例  *  *  *  * 场景描述:  * 哈票以购票为核心业务(此模式不限于该业务),但围绕购票会产生不同的其他逻辑,如:  * 1、购票后记录文本日志  * 2、购票后记录数据库...
  • 1.单例模式(在内存中仅实例化一个对象时使用), 2.适配器模式(典型的就是ListView和GridView的适配器), 3.建造者模式(AlertDialog.Builder), 4.观察模式可能比较隐蔽,在Android源码中用BaseAdapater的...
  • ++设计模式是在已有的方案之上发现更好的方案,而不是全新发明,不要为了强迫自己使用已有的设计模式而限制了你的创造力++ 创建型模式 处理对象创建相关问题 1 工厂模式 1.1 工厂方法 ==一个函数==...
  • 观察模式在Android开发中使用频率非常高,最常用的地方如订阅–发布系统,类似微信公众号用户订阅和接收消息的场景,因为这个模式最重要的功能就是解耦,将被观察者和观察者解耦,使得它们之间的依赖性更小,甚至...
  • 观察模式简介及使用示例

    千次阅读 2019-06-10 17:52:55
    文章目录观察模式简介使用示例总结优缺点使用场景扩展联想学习 观察模式简介 观察模式又叫发布订阅(Publish/Subscribe)模式 观察模式(Observer Pattern)定义了一种一对多的依赖关系,让多个观察者对象...
  • JAVA设计模式--观察模式

    万次阅读 2016-06-18 20:43:31
    观察者(Observer)模式是行为模式之一,它的作用是当一个被观察对象的状态发生变化时,能够自动通知相关的观察者对象,自动更新观察者对象中被观察对象的状态。它提供给关联对象一种同步通信的手段,使某个对象与依赖...
  • 观察模式

    千次阅读 2019-09-25 20:27:24
    当对象间存在一对多关系时,则使用观察模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察模式属于行为型模式。 介绍 意图:定义对象间的一种一对多的依赖关系,当一个对象的...
  • 设计模式(五)观察模式

    万次阅读 多人点赞 2016-03-02 17:41:50
    观察模式(又被称为发布-订阅(Publish/Subscribe)模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听莫一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。
  • 0x01.简述 观察模式(Observer Pattern)(有时又被称为模型(Model)-...当对象间存在一对多关系时,可以使用观察模式。 例如,当一个对象被修改时,则会自动通知它的依赖对象。 观察模式属于行为型模式。 0x
  • 设计模式——观察模式

    千次阅读 2018-04-07 11:25:04
    观察模式是一种一对多的设计模式,一个主题多个观察者,当主题发生某种变化时,会发通知给这些观察者,所有的观察者都可以进行各自内部的改变。有时观察模式也被称为发布订阅模式观察者涉及到四个角色: 抽象...
  • C++ 观察模式

    万次阅读 多人点赞 2017-03-13 19:33:34
    观察模式(Observer Pattern),定义了对象间的一对多的依赖关系,让多个观察者对象同时监听某一个主题对象(被观察者)。当主题对象的状态发生更改时,会通知所有观察者,让它们能够自动更新。 简述 背景 模式...
  • 使用观察模式进行订单管理

    千次阅读 2018-01-30 22:06:01
    使用观察模式进行订单管理 概念:观察模式是由发送者和观察者构成,发送者在状态改变时,主动通知所有的观察者做相应的刷新。 观察模式定义了对象之间一对多的依赖关系,以便一个对象状态发生改变时,所有...
  • java与设计模式-观察模式

    千次阅读 2019-11-03 21:53:39
    java与设计模式-观察模式 一、定义 观察模式(Observer ...目中经常使用模式, 其定义如下: Define a one-to-many dependency between objects so that when one object changes state,all its depend...
  • 大话设计模式(五)观察模式

    万次阅读 2016-09-05 17:38:20
    大话设计模式(五)观察模式概念 在阎宏博士的《JAVA与模式》一书中开头是这样描述观察者(Observer)模式的: 观察模式是对象的行为模式,又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-...
  • Java观察模式(Observer)

    千次阅读 多人点赞 2019-02-16 23:57:11
      观察模式java GOF23种设计模式中的一种。在最近介绍的Redis和ActiveMQ中都涉及到了观察模式,所以我们在本文详细介绍下此模式: ...使用场景 广播机制场景 1.聊天室程序的创建。服务器创建好后,...
  • 参考了Java的部分实现,观察模式代码如下: var subject = { observers: [], notify() { this.observers.forEach(observer =>{ observer.update() }) }, attach (observer) { this.observers....
  • Java设计模式实战 ~ 观察模式分析与实战

    千次阅读 多人点赞 2019-09-07 22:48:22
    本文主要介绍了观察模式的原理、使用场景、JDK中的观察模式观察模式的缺点、最后介绍了观察模式在项目中的实践

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 121,361
精华内容 48,544
关键字:

观察模式使用场景