当前位置：移动技术网 > IT编程>数据库>MSSQL > 设计模式-观察者模式（Observer）

设计模式-观察者模式（Observer）

2020年04月23日 | 移动技术网IT编程 | 我要评论

刷火车票软件,科技手抄报内容,锅塌豆腐盒是哪个地方的菜

讲故事(user story)

假设我们是一个优惠券提供平台，故事就发生在顾客在我们平台采购完成支付成功后。

支付完成后平台要进行的一些操作:

短信通知客户已经生成订单
增加顾客的积分
开始按订单需求制券

。。。(可能会有许多操作)

接下来就是将故事以代码的形式展现出来。。。

需求分析

我们将上述故事转化为代码中的对象分别是：支付成功 paysuccesssubject、短信通知 messageobserver、积分增加 bonusobserver、制券 couponobserver。

当支付成功paysuccesssubject后，要通知到messageobserver，bonusobserver，couponobserver这三个对象，为了实现上面这个需求，将采用观察者模式（发布-订阅）

敲黑板.划重点

观察者模式又叫发布-订阅(publish/subscribe)模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象在状态发生变化时，通知所有观察者对象，使他们能够自己更新自己。

观察者模式结构图

show code

subject类,把所有观察者对象的引用保存在一个集合了,每个通知者都可以有任何数量的观察者。抽象通知者提供可以增加和删除观察者对象的接口。

/// <summary>
/// 抽象通知者
/// </summary>
public abstract class subject
{
    /// <summary>
    /// 观察者集合
    /// </summary>
    protected list<iobserver> observers = new list<iobserver>();

    public string state { get; set; }

    /// <summary>
    /// 添加观察者
    /// </summary>
    /// <param name="observer">观察者</param>
    public void attach(iobserver observer)
    {
        observers.add(observer);
    }

    /// <summary>
    /// 删除观察者
    /// </summary>
    /// <param name="observer">观察者</param>
    public void detach(iobserver observer)
    {
        observers.remove(observer);
    }

    /// <summary>
    /// 通知
    /// </summary>
    /// <returns></returns>
    public void notify()
    {
        foreach (var observer in observers)
        {
            observer.update();
        }
    }
}

paysuccesssubject类，具体的通知者，给所有登记过的观察者发出通知。
 /// <summary>
 /// 支持成功通知者
 /// </summary>
 public class paysuccesssubject : subject
 {
 }

observer类，抽象观察者，为所有的具体的观察者定义一个接口，一般用抽象类或接口实现。通常包含一个update()更新方法。
 /// <summary>
 /// 抽象观察
 /// </summary>
 public abstract class observer
 {
     public abstract void update();
 }

messageobserver、bonusobserver、couponobserver具体的观察者类，实现更新接口，以便本身的状态与主题的状态相协调。

    /// <summary>
    /// 短信观察者
    /// </summary>
    public class messageobserver : observer
    {
        public subject subject { get; set; }

        public messageobserver(subject subject)
        {
            subject = subject;
        }

        public override void update()
        {
            console.writeline($"{subject.state}:短信通知了...");
        }
    }
    /// <summary>
    /// 积分观察者
    /// </summary>
    public class bonusobserver : observer
    {
        public subject subject { get; set; }

        public bonusobserver(subject subject)
        {
            subject = subject;
        }

        public override void update()
        {
            console.writeline($"{subject.state}:积分增加了...");
        }
    }

    /// <summary>
    /// 券观察者
    /// </summary>
    public class couponobserver : observer
    {
        public subject subject { get; set; }

        public couponobserver(subject subject)
        {
            subject = subject;
        }
        public override void update()
        {
            console.writeline($"{subject.state}:开始制券了...");
        }
    }

客户端代码

        private static void main(string[] args)
        {
            var subject = new paysuccesssubject();
            var observer1 = new couponobserver(subject);
            var observer2 = new messageobserver(subject);
            var observer3 = new bonusobserver(subject);

            //添加订阅
            subject.attach(observer1);
            subject.attach(observer2);
            subject.attach(observer3);

            //发布通知
            subject.state = "星巴克10十元券采购成功";
            subject.notify();

            console.writeline("\n\nhappy ending~");
            console.readline();
        }

结果显示

code upgrade

code review后发现，在通知给观察者时，是顺序执行，如果其中一个观察者卡顿或者错误，会导致其他观察者卡克，所以我们应该采用异步方式。

下面我们将模拟制券过程耗时增加，但不影响通知其他观察者。直接上代码：

    /// <summary>
    /// 抽象观察
    /// </summary>
    public abstract class observer
    {
        public abstract task updateasync();
    }

    /// <summary>
    /// 短信观察者
    /// </summary>
    public class messageobserver : observer
    {
        public subject subject { get; set; }

        public messageobserver(subject subject)
        {
            subject = subject;
        }

        public override task updateasync()
        {
            console.writeline($"{subject.state}:短信通知了...");
            return task.completedtask;
        }
    }

    /// <summary>
    /// 积分观察者
    /// </summary>
    public class bonusobserver : observer
    {
        public subject subject { get; set; }

        public bonusobserver(subject subject)
        {
            subject = subject;
        }

        public override task updateasync()
        {
            console.writeline($"{subject.state}:积分增加了...");
            return task.completedtask;
        }
    }

    /// <summary>
    /// 券观察者
    /// </summary>
    public class couponobserver : observer
    {
        public subject subject { get; set; }

        public couponobserver(subject subject)
        {
            subject = subject;
        }

        public override async task updateasync()
        {
            console.writeline($"{subject.state}:开始制券...");
            //模拟制券耗时
            await task.delay(3000);
            console.writeline($"{subject.state}:制券完成...");
        }
    }

    /// <summary>
    /// 抽象通知者
    /// </summary>
    public abstract class subject
    {
        /// <summary>
        /// 观察者集合
        /// </summary>
        protected list<observer> observers = new list<observer>();

        public string state { get; set; }

        /// <summary>
        /// 添加观察者
        /// </summary>
        /// <param name="observer">观察者</param>
        public void attach(observer observer)
        {
            observers.add(observer);
        }

        /// <summary>
        /// 删除观察者
        /// </summary>
        /// <param name="observer">观察者</param>
        public void detach(observer observer)
        {
            observers.remove(observer);
        }

        /// <summary>
        /// 通知
        /// </summary>
        /// <returns></returns>
        public task notify()
        {
            foreach (var observer in observers)
            {
                observer.updateasync();
            }
            return task.completedtask;
        }
    }

客户端端代码:

        private static async task main(string[] args)
        {
            var subject = new paysuccesssubject();
            var observer1 = new couponobserver(subject);
            var observer2 = new messageobserver(subject);
            var observer3 = new bonusobserver(subject);

            //添加订阅
            subject.attach(observer1);
            subject.attach(observer2);
            subject.attach(observer3);

            //发布通知
            subject.state = "星巴克10十元券采购成功";
            await subject.notify();

            console.writeline("\n\nhappy ending~");
            console.readline();
        }

结果显示:

result

委托加持观察者模式

现实开发中，很多观察者对象共同继承或者实现同一个抽象观察者，不合适；并且所有观察者对象的操作方法统一叫一个 update(),达不到望文生义的效果，所以我们对观察者模式再次进行升级，使用委托来替换掉抽象观察者，

直接上代码：

    /// <summary>
    /// 短信观察者
    /// </summary>
    public class messageobserver
    {
        public isubject subject { get; set; }

        public messageobserver(isubject subject)
        {
            subject = subject;
        }

        /// <summary>
        /// 发送短信
        /// </summary>
        /// <returns></returns>
        public task sendmessageasync()
        {
            console.writeline($"{subject.state}:短信通知了...");
            return task.completedtask;
        }
    }

    /// <summary>
    /// 积分观察者
    /// </summary>
    public class bonusobserver
    {
        public isubject subject { get; set; }

        public bonusobserver(isubject subject)
        {
            subject = subject;
        }

        /// <summary>
        /// 添加积分
        /// </summary>
        /// <returns></returns>
        public task addbonusasync()
        {
            console.writeline($"{subject.state}:积分增加了...");
            return task.completedtask;
        }
    }

    /// <summary>
    /// 券观察者
    /// </summary>
    public class couponobserver
    {
        public isubject subject { get; set; }

        public couponobserver(isubject subject)
        {
            subject = subject;
        }

        /// <summary>
        /// 制券
        /// </summary>
        /// <returns></returns>
        public async task makecouponasync()
        {
            console.writeline($"{subject.state}:开始制券...");
            //模拟制券耗时
            await task.delay(3000);
            console.writeline($"{subject.state}:制券完成...");
        }
    }

    /// <summary>
    /// 抽象通知者
    /// </summary>
    public interface isubject
    {
        /// <summary>
        /// 通知
        /// </summary>
        /// <returns></returns>
        public task notify();

        public string state { get; set; }
    }

    /// <summary>
    /// 支持成功通知者
    /// </summary>
    public class paysuccesssubject : isubject
    {
        public func<task> update;

        public string state { get; set; }

        public task notify()
        {
            update();
            return task.completedtask;
        }
    }
}

客户端调用：

    internal class program
    {
        private static async task main(string[] args)
        {
            var subject = new observerdelegate.paysuccesssubject();
            var observer1 = new observerdelegate.couponobserver(subject);
            var observer2 = new observerdelegate.messageobserver(subject);
            var observer3 = new observerdelegate.bonusobserver(subject);
            //添加订阅
            subject.update += observer1.makecouponasync;
            subject.update += observer2.sendmessageasync;
            subject.update += observer3.addbonusasync;
            //发布通知
            subject.state = "星巴克10十元券采购成功";
            await subject.notify();

            console.writeline("\n\nhappy ending~");
            console.readline();
        }
    }
}

展示结果和上面一样。

源码地址：https://gitee.com/sayook/designmode

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！点击进行留言回复

sql某个日期是当年的第几周

/* *周一作为一周的开始 *当年的1月1号所在的周算作第一周 */ CREATE function GetWeekIndexFirstDate ( @... [阅读全文]
sqlserver 数据库迁移

业务情景客户环境是系统A的1.0版本，开发环境是系统A的2.0版本。2.0版本对于数据库有部分变更（主要是新增表和字段，不涉及字段删除和变更）。这个时... [阅读全文]
数据库SQL---范式

1、数据冗余导致的问题：冗余存储、更新异常、插入异常、删除异常。 2、函数依赖：一种完整性约束。在关系模式r(R)中，α属于R，β属于R。 1）α函数... [阅读全文]
sql server如何用不同语种语言显示报错的错误消息

问题：生产环境的操作系统和数据库可能是英文版的，而我们的母语是中文，如果英语能力差点，可能有时对英语环境下的数据库脚本报错的英文提示看不懂，如果直接拿英... [阅读全文]
数据库SQL---查询

1、查询所有列 select *from emp;--*表示所有的，from emp表示从emp表中查询。 2、查询指定列 select empno,e... [阅读全文]
数据库SQL---数据库、基本表、视图、索引的定义、修改、删除

1、SQL（结构化查询语言）的组成：数据定义语言DDL、数据操纵语言DML、数据控制语言DCL、其他。 2、SQL语言的功能： 1）数据查询：SELEC... [阅读全文]
对比索引、视图、游标、存储过程和触发器

1、索引 1-1、索引的概述我们把一个表中的一列或者多列和列中元素所在表中记录的物理地址组合成一个新的表。这个表的记录大致为列的内容和该列所在记录的物... [阅读全文]
在 Azure CentOS VM 中配置 SQL Server 2019 AG - (上)

前文假定您对Azure和SQL Server HA具有基础知识假定您对Azure Cli具有基础知识目标是在Azure Linux VM上创建一个... [阅读全文]
在 Azure CentOS VM 中配置 SQL Server 2019 AG - (下)

配置 Internal Load Balancer 创建load balancer 我的三台VM都位于sqldemoVNET/linuxsubnet子网... [阅读全文]
数据库SQL---关系模型与关系代数

1、关系数据库：表的集合，即关系的集合。关系数据库=关系数据库模式（型）+关系数据库内容（值） 1）域：一组具有相同数据类型的值的集合。 2）笛卡尔积... [阅读全文]

网友评论


验证码：