3.观察者模式

设计模式 > 行为型模式 设计模式 行为型模式
发布时间 :
字数:3.1k 阅读 : 评论:
  1. 3.行为型模式-观察者模式
    1. 3.1 基础知识
      1. 学习难度：3
      2. 使用频率：5
      3. 总分：8
      4. 定义
      5. 说人话
      6. 结构图
      7. 实现步骤
      8. 说明
    2. 3.2 模版代码
      1. 观察者接口和具体观察者类
      2. 通知者接口和具体通知者
      3. 客户端
    3. 3.3 CSharp实践
      1. 实践需求
      2. 球迷接口和球迷类
      3. 比赛接口和比赛类
      4. 客户端
    4. 3.4 Unity实践
      1. 实践需求
      2. 具体观察者类
      3. 生命值通知接口和生命值通知者
      4. 其他准备工作
      5. 客户端
      6. 运行结果

3.行为型模式-观察者模式

3.1 基础知识

学习难度：3

使用频率：5

总分：8

定义

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

说人话

通知者维护一系列观察者，向它们发送通知。

结构图

实现步骤

  • 常规实现
    • 观察者接口：定义更新方法
    • 具体观察者类：实现观察者接口，定义需要的成员，实现更新方法
    • 通知者接口：定义添加观察者、移除观察者、通知观察者方法
    • 具体通知者类：实现通知者接口，定义观察者接口列表，实现添加观察者、移除观察者、通知观察者方法。通知观察者方法中遍历观察者接口列表调用更新方法。当某些状态改变时通知所有观察者。
    • 客户端：实例化具体通知者，实例化多个具体观察者添加到通知者中。改变通知者的某些状态来通知所有观察者。
  • 委托实现
    • 不需要观察者接口
    • 具体观察者类：定义需要的成员和方法
    • 通知者接口：定义通知观察者方法
    • 具体通知者类：实现通知者接口，定义通知委托，实现通知观察者方法中调用通知委托。
    • 客户端：实例化具体通知者，实例化一些具体观察者。把观察者要被观察的方法添加到通知者的通知委托中。某些状态下调用通知委托。

说明

观察者模式更常用的是委托实现。

3.2 模版代码

观察者接口和具体观察者类

// 观察者接口
public interface IObserver
{
    void Update(string message);
}

// 具体观察者类
public class ConcreteObserver : IObserver
{
    private string name;

    public ConcreteObserver(string name)
    {
        this.name = name;
    }

    public void Update(string message)
    {
        Console.WriteLine($"观察者 {name} 收到消息：{message}");
    }
}

通知者接口和具体通知者

// 通知者接口
public interface INotifier
{
    void RegisterObserver(IObserver observer);
    void RemoveObserver(IObserver observer);
    void NotifyObservers();
}

// 具体通知者类
public class ConcreteNotifier : INotifier
{
    private List<IObserver> observers = new List<IObserver>();
    private string state;

    public void RegisterObserver(IObserver observer)
    {
        observers.Add(observer);
    }

    public void RemoveObserver(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void NotifyObservers()
    {
        foreach (var observer in observers)
        {
            observer.Update(state);
        }
    }

    public void SetState(string state)
    {
        this.state = state;
        NotifyObservers();
    }
}

客户端

class Program
{
    static void Main(string[] args)
    {
        ConcreteNotifier notifier = new ConcreteNotifier();

        IObserver observer1 = new ConcreteObserver("观察者1");
        IObserver observer2 = new ConcreteObserver("观察者2");

        notifier.RegisterObserver(observer1);
        notifier.RegisterObserver(observer2);

        notifier.SetState("新状态1");
        // 观察者 观察者1 收到消息：新状态1
        // 观察者 观察者2 收到消息：新状态1

        notifier.SetState("新状态2");
        // 观察者 观察者1 收到消息：新状态2
        // 观察者 观察者2 收到消息：新状态2

        notifier.RemoveObserver(observer1);

        notifier.SetState("新状态3");
        // 观察者 观察者2 收到消息：新状态3
    }
}

3.3 CSharp实践

实践需求

使用观察者模式，模拟足球比赛发生的事件，更新球迷的反应。

球迷接口和球迷类

// 观察者接口 - 足球球迷
public interface IFootballFan
{
    void Update(string status);
}

// 具体观察者类 - 足球球迷
public class FootballFan : IFootballFan
{
    public string Name { get; }

    public FootballFan(string name)
    {
        Name = name;
    }

    public void Update(string status)
    {
        Console.WriteLine($"{Name} 收到比赛状态更新：{status}");
    }
}

比赛接口和比赛类

// 主题接口 - 足球比赛
public interface IFootballMatch
{
    void RegisterObserver(IFootballFan observer);
    void RemoveObserver(IFootballFan observer);
    void NotifyObservers();
    void UpdateMatchStatus(string status);
}


// 具体主题类 - 具体足球比赛
public class FootballMatch : IFootballMatch
{
    private List<IFootballFan> fans = new List<IFootballFan>();
    private string matchStatus;

    public void RegisterObserver(IFootballFan fan)
    {
        fans.Add(fan);
    }

    public void RemoveObserver(IFootballFan fan)
    {
        fans.Remove(fan);
    }

    public void NotifyObservers()
    {
        foreach (var fan in fans)
        {
            fan.Update(matchStatus);
        }
    }

    public void UpdateMatchStatus(string status)
    {
        matchStatus = status;
        NotifyObservers();
        
        if (status.Contains("C罗") && status.Contains("进球"))
        {
            foreach (var fan in fans)
            {
                if (fan is FootballFan && ((FootballFan)fan).Name == "甲亢哥")
                {
                    fan.Update("甲亢哥庆祝C罗进球");
                }
                else if (fan is FootballFan && ((FootballFan)fan).Name == "李老八")
                {
                    fan.Update("李老八庆祝C罗进球");
                }
            }
        }
        else if (status.Contains("梅西") && status.Contains("进球"))
        {
            foreach (var fan in fans)
            {
                if (fan is FootballFan && ((FootballFan)fan).Name == "真实球迷会")
                {
                    fan.Update("真实球迷会庆祝梅西进球");
                }
            }
        }
        else if (status.Contains("梅西") && status.Contains("杀死比赛"))
        {
            foreach (var fan in fans)
            {
                if (fan is FootballFan && ((FootballFan)fan).Name == "真实球迷会")
                {
                    fan.Update("真实球迷会庆祝梅西进球");
                }
                else if (fan is FootballFan && ((FootballFan)fan).Name == "甲亢哥")
                {
                    fan.Update("甲亢哥说不装了，我是梅西球迷，庆祝梅西进球");
                }
            }
        }
    }
}

客户端

class Program
{
    static void Main(string[] args)
    {
        IFootballMatch match = new FootballMatch();

        IFootballFan fan1 = new FootballFan("李老八");
        IFootballFan fan2 = new FootballFan("甲亢哥");
        IFootballFan fan3 = new FootballFan("真实球迷会");

        match.RegisterObserver(fan1);
        match.RegisterObserver(fan2);
        match.RegisterObserver(fan3);

        match.UpdateMatchStatus("比赛开始");

        // C罗进球
        match.UpdateMatchStatus("C罗进球，比分1:0");

        // 梅西进球
        match.UpdateMatchStatus("梅西进球，比分1:1");

        // C罗梅开二度
        match.UpdateMatchStatus("C罗再进球，比分2:1");

        // 梅西梅开二度
        match.UpdateMatchStatus("梅西再进球，比分2:2");
        
        // 梅西帽子戏法
        match.UpdateMatchStatus("梅西杀死比赛，比分3:2");

        // 比赛结束
        match.UpdateMatchStatus("比赛结束，C罗梅开二度，梅西帽子戏法，最终比分3:2");


        // 李老八 收到比赛状态更新：比赛开始
        // 甲亢哥 收到比赛状态更新：比赛开始
        // 真实球迷会 收到比赛状态更新：比赛开始

        // 李老八 收到比赛状态更新：C罗进球，比分1:0
        // 甲亢哥 收到比赛状态更新：C罗进球，比分1:0
        // 真实球迷会 收到比赛状态更新：C罗进球，比分1:0

        // 李老八 收到比赛状态更新：李老八庆祝C罗进球
        // 甲亢哥 收到比赛状态更新：甲亢哥庆祝C罗进球
        
        // 李老八 收到比赛状态更新：梅西进球，比分1:1
        // 甲亢哥 收到比赛状态更新：梅西进球，比分1:1
        // 真实球迷会 收到比赛状态更新：梅西进球，比分1:1

        // 真实球迷会 收到比赛状态更新：真实球迷会庆祝梅西进球

        // 李老八 收到比赛状态更新：C罗再进球，比分2:1
        // 甲亢哥 收到比赛状态更新：C罗再进球，比分2:1
        // 真实球迷会 收到比赛状态更新：C罗再进球，比分2:1

        // 李老八 收到比赛状态更新：李老八庆祝C罗进球
        // 甲亢哥 收到比赛状态更新：甲亢哥庆祝C罗进球

        // 李老八 收到比赛状态更新：梅西再进球，比分2:2
        // 甲亢哥 收到比赛状态更新：梅西再进球，比分2:2
        // 真实球迷会 收到比赛状态更新：梅西再进球，比分2:2

        // 真实球迷会 收到比赛状态更新：真实球迷会庆祝梅西进球

        // 李老八 收到比赛状态更新：梅西杀死比赛，比分3:2
        // 甲亢哥 收到比赛状态更新：梅西杀死比赛，比分3:2
        // 真实球迷会 收到比赛状态更新：梅西杀死比赛，比分3:2

        // 甲亢哥 收到比赛状态更新：甲亢哥说不装了，我是梅西球迷，庆祝梅西进球
        // 真实球迷会 收到比赛状态更新：真实球迷会庆祝梅西进球

        // 李老八 收到比赛状态更新：比赛结束，C罗梅开二度，梅西帽子戏法，最终比分3:2
        // 甲亢哥 收到比赛状态更新：比赛结束，C罗梅开二度，梅西帽子戏法，最终比分3:2
        // 真实球迷会 收到比赛状态更新：比赛结束，C罗梅开二度，梅西帽子戏法，最终比分3:2

    }
}

3.4 Unity实践

实践需求

使用委托实现观察者模式，模拟按下空格更新薇恩的生命值和血条，当生命值小于等于0时薇恩死亡。伤害类型包括物理和魔法。

具体观察者类

public class HealthBarObserver : MonoBehaviour
{
    private float width;  // 血条的初始宽度

    private GameObject healthValue;  // 用于显示血量的对象

    public VayneObserver vayneObserver;  // 引用薇恩的观察者对象

    private void Start()
    {
        // 获取血条的初始宽度
        width = this.gameObject.GetComponent<RectTransform>().rect.width;

        // 获取用于显示血量的对象
        healthValue = transform.GetChild(0).gameObject;
    }

    // 更新血条的宽度，根据薇恩的生命值
    public void UpdateHealthBar(float damage)
    {
        // 计算当前宽度，根据薇恩的生命值和最大生命值来计算
        float nowWidth = (vayneObserver.Health / VayneObserver.HEALTH_MAX) * width;

        // 更新血量显示对象的宽度
        healthValue.GetComponent<RectTransform>().sizeDelta =
            new Vector2(nowWidth, healthValue.GetComponent<RectTransform>().sizeDelta.y);

        // 输出更新后的血条宽度信息
        Debug.Log($"更新血条 当前宽度是{nowWidth} 最大宽度是{width}");
    }
}

public class VayneObserver : MonoBehaviour
{
    // 常量，表示最大生命值
    public const float HEALTH_MAX = 100;

    // 当前生命值
    public float health = HEALTH_MAX;

    // 用于显示生命值的 HealthBarObserver
    public HealthBarObserver healthBarObserver;

    // 属性，用于获取和设置生命值
    public float Health
    {
        get => health;
        private set => health = value;
    }

    // 函数用于改变薇恩的生命值
    public void ChangeVayneHealth(float damage)
    {
        // 减少生命值
        Health -= damage;

        // 限制生命值在0到100之间
        Health = Mathf.Clamp(Health, 0, HEALTH_MAX);

        if (Health != 0)
        {
            // 输出受到伤害后的生命值信息
            Debug.Log($"薇恩受到了{damage}点伤害，当前血量是{Health}");
        }
        else
        {
            // 输出薇恩死亡信息并销毁游戏对象
            Debug.Log("薇恩死亡");
            Destroy(this.gameObject);
        }
    }
}

生命值通知接口和生命值通知者

// 定义了一个名为 IHealthNotifier 的接口
public interface IHealthNotifier
{
    // 声明一个方法，用于通知观察者健康变化
    void NotifyObserverHealthChange(params object[] arr);
}

// 枚举类型，表示伤害类型
public enum DamageType
{
    Physical,
    Magic
}

public class HealthNotifier : IHealthNotifier
{
    // 声明一个 Action 委托来处理物理伤害变化 其实这句没必要声明 只是和自定义委托做对比
    public Action<float> physicalHealthChangedHandler;

    // 声明一个事件，用于通知物理伤害变化
    public event Action<float> OnPhysicalHealthChanged;

    // 声明一个自定义委托来处理魔法伤害变化
    public delegate void MagicHealthChangedHandler(float damage);

    // 声明一个事件，用于通知魔法伤害变化
    public event MagicHealthChangedHandler OnMagicHealthChanged;
    
    // 实现 IHealthNotifier 接口中的通知方法
    public void NotifyObserverHealthChange(params object[] arr)
    {
        // 如果参数为空或参数数量不足2，不执行通知
        if (arr == null || arr.Length < 2) return;
        
        float damage = (float)arr[0];
        DamageType damageType = (DamageType)arr[1];
        
        // 输出伤害类型信息
        Debug.Log($"通知者知道了伤害类型是{damageType}");
        
        // 根据伤害类型触发相应的事件
        if (damageType == DamageType.Physical)
        {
            OnPhysicalHealthChanged?.Invoke(damage);
        }
        else if (damageType == DamageType.Magic)
        {
            OnMagicHealthChanged?.Invoke(damage);
        }
    }
}

其他准备工作

客户端

public class TestObserverPattern : MonoBehaviour
{
    // 可在Unity编辑器中设置的薇恩预制体
    public GameObject vayneGameObject;

    // 健康通知者对象
    private HealthNotifier healthNotifier;

    // 薇恩观察者对象
    private VayneObserver vayneObserver;

    // 健康条观察者对象
    private HealthBarObserver healthBarObserver;

    private void Start()
    {
        // 从预制体创建薇恩对象
        GameObject vayne = Instantiate(vayneGameObject, Vector3.zero, Quaternion.identity);

        // 创建健康通知者对象
        healthNotifier = new HealthNotifier();

        // 获取薇恩观察者和健康条观察者
        vayneObserver = vayne.GetComponent<VayneObserver>();
        healthBarObserver = vayneObserver.healthBarObserver;

        // 绑定通知者的事件到薇恩和健康条的处理方法
        healthNotifier.OnPhysicalHealthChanged += vayneObserver.ChangeVayneHealth;
        healthNotifier.OnMagicHealthChanged += vayneObserver.ChangeVayneHealth;
        healthNotifier.OnPhysicalHealthChanged += healthBarObserver.UpdateHealthBar;
        healthNotifier.OnMagicHealthChanged += healthBarObserver.UpdateHealthBar;
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            if (vayneObserver == null || healthBarObserver == null)
            {
                // 如果薇恩或健康条已被销毁，输出消息并返回
                Debug.Log($"薇恩已被销毁");
                return;
            }

            // 随机生成伤害和伤害类型
            float damage = Random.Range(0f, 20f);
            DamageType damageType = (DamageType)Random.Range(0, 2);

            // 输出随机伤害和伤害类型信息
            Debug.Log($"随机出来的伤害是{damage}，伤害类型是{damageType}");

            // 通知观察者关于伤害的变化
            healthNotifier.NotifyObserverHealthChange(damage, damageType);
        }
    }
}

运行结果

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏