• QFramework引入Utility和System

    存储问题：

    在前面我们已经通过基础的学习了解了QFramework的架构以及引入Command和引入Event。那么

    如果我们想支持CounterApp的存储功能，应该如何做呢？

    如果时候未来我们需要存储的数据非常多的时候，Model 层就会充斥大量存储、加载相关的代码。

    还有就是，我们以后如果不想使用 PlayperPrefs 了，想使用 EasySave 或者 SQLite 的时候，就会

    造成大量的修改工作量。

    解决办法：

    于是 QFramework 提供了一个 Utility 层，专门用来解决上述两个问题的，使用方法非常简单：

    1.     using UnityEngine;
    2.     using UnityEngine.UI;
    3.  
    4.     // 1. 定义一个 Model 对象
    5.     public class CounterAppModel : AbstractModel
    6.     {
    7.         private int mCount;
    8.  
    9.         public int Count
    10.         {
    11.             get => mCount;
    12.             set
    13.             {
    14.                 if (mCount != value)
    15.                 {
    16.                     mCount = value;
    17.                     PlayerPrefs.SetInt(nameof(Count),mCount);
    18.                 }
    19.             }
    20.         }
    21.  
    22.         protected override void OnInit()
    23.         {
    24.             var storage = this.GetUtility();
    25.  
    26.             Count = storage.LoadInt(nameof(Count));
    27.  
    28.             // 可以通过 CounterApp.Interface 监听数据变更事件
    29.             CounterApp.Interface.RegisterEvent(e =>
    30.             {
    31.                 this.GetUtility().SaveInt(nameof(Count), Count);
    32.             });
    33.         }
    34.     }
    35.  
    36.     // 定义 utility 层
    37.     public class Storage : IUtility
    38.     {
    39.         public void SaveInt(string key, int value)
    40.         {
    41.             PlayerPrefs.SetInt(key,value);
    42.         }
    43.  
    44.         public int LoadInt(string key, int defaultValue = 0)
    45.         {
    46.             return PlayerPrefs.GetInt(key, defaultValue);
    47.         }
    48.     }
    49.  
    50.  
    51.     // 2.定义一个架构（提供 MVC、分层、模块管理等）
    52.     public class CounterApp : Architecture<CounterApp>
    53.     {
    54.         protected override void Init()
    55.         {
    56.             // 注册 Model
    57.             this.RegisterModel(new CounterAppModel());
    58.  
    59.             // 注册存储工具的对象
    60.             this.RegisterUtility(new Storage());
    61.         }
    62.     }
    63.  
    64.     // 定义数据变更事件
    65.     public struct CountChangeEvent // ++
    66.     {
    67.  
    68.     }
    69.  
    70.     // 引入 Command
    71.     public class IncreaseCountCommand : AbstractCommand 
    72.     {
    73.         protected override void OnExecute()
    74.         {
    75.             this.GetModel().Count++;
    76.             this.SendEvent(); // ++
    77.         }
    78.     }
    79.  
    80.     public class DecreaseCountCommand : AbstractCommand
    81.     {
    82.         protected override void OnExecute()
    83.         {
    84.             this.GetModel().Count--;
    85.             this.SendEvent(); // ++
    86.         }
    87.     }
    88.  
    89.     // Controller
    90.     public class CounterAppController : MonoBehaviour , IController /* 3.实现 IController 接口 */
    91.     {
    92.         // View
    93.         private Button mBtnAdd;
    94.         private Button mBtnSub;
    95.         private Text mCountText;
    96.  
    97.         // 4. Model
    98.         private CounterAppModel mModel;
    99.  
    100.         void Start()
    101.         {
    102.             // 5. 获取模型
    103.             mModel = this.GetModel();
    104.  
    105.             // View 组件获取
    106.             mBtnAdd = transform.Find("BtnAdd").GetComponent
    107.             mBtnSub = transform.Find("BtnSub").GetComponent
    108.             mCountText = transform.Find("CountText").GetComponent();
    109.  
    110.  
    111.             // 监听输入
    112.             mBtnAdd.onClick.AddListener(() =>
    113.             {
    114.                 // 交互逻辑
    115.                 this.SendCommand();
    116.             });
    117.  
    118.             mBtnSub.onClick.AddListener(() =>
    119.             {
    120.                 // 交互逻辑
    121.                 this.SendCommand(new DecreaseCountCommand(/* 这里可以传参（如果有） */));
    122.             });
    123.  
    124.             UpdateView();
    125.  
    126.             // 表现逻辑
    127.             this.RegisterEvent(e =>
    128.             {
    129.                 UpdateView();
    130.  
    131.             }).UnRegisterWhenGameObjectDestroyed(gameObject);
    132.         }
    133.  
    134.         void UpdateView()
    135.         {
    136.             mCountText.text = mModel.Count.ToString();
    137.         }
    138.  
    139.         // 3.
    140.         public IArchitecture GetArchitecture()
    141.         {
    142.             return CounterApp.Interface;
    143.         }
    144.  
    145.         private void OnDestroy()
    146.         {
    147.             // 8. 将 Model 设置为空
    148.             mModel = null;
    149.         }
    150.     }

    这样当我们，想要将 PlayerPrefs 方案替换成 EasySave 的时候，只需要对 Storage 里的代码进行修改即可。

    最后给出流程图，如下：

     

     成就问题：

    这里我们假设一个功能，即策划提出了一个成就达成的功能，即 Count 到 10 的时候，触发一个点击达人成就，点击二十次 则触发一个 点击专家成就。

     但是这个时候策划说，希望再增加一个当点击 - 号到 -10 时，触发一个 点击菜鸟成就，然后策划还说，点击达人 和 点击专家 成就太容易达成了，需要分别改成 1000 次 和 2000 次。

    而这次策划提出的需求，需要我们修改两处的代码，即 IncreaseCountCommand 里需要修改数值为 1000 和 2000，然后再 DecreaseCountCommand 增加一个判断逻辑。

    一次提出的需求，结果造成了多处修改，这说明代码有问题。

    首先像这种规则类的逻辑，比如分数统计或者成就统计等代码，不适合分散写在 Command 里，而适合统一写在一个对象里，而这种对象，在 QFramework 里有提供，就是 System 对象。

    解决办法：

    代码如下：

    1.      using UnityEngine;
    2.      using UnityEngine.UI;
    3.  
    4.     // 1. 定义一个 Model 对象
    5.     public class CounterAppModel : AbstractModel
    6.     {
    7.         private int mCount;
    8.  
    9.         public int Count
    10.         {
    11.             get => mCount;
    12.             set
    13.             {
    14.                 if (mCount != value)
    15.                 {
    16.                     mCount = value;
    17.                     PlayerPrefs.SetInt(nameof(Count),mCount);
    18.                 }
    19.             }
    20.         }
    21.  
    22.         protected override void OnInit()
    23.         {
    24.             var storage = this.GetUtility();
    25.  
    26.             Count = storage.LoadInt(nameof(Count));
    27.  
    28.             // 可以通过 CounterApp.Interface 监听数据变更事件
    29.             CounterApp.Interface.RegisterEvent(e =>
    30.             {
    31.                 this.GetUtility().SaveInt(nameof(Count), Count);
    32.             });
    33.         }
    34.     }
    35.  
    36.  
    37.     public class AchievementSystem : AbstractSystem // +
    38.     {
    39.         protected override void OnInit()
    40.         {
    41.             var model = this.GetModel();
    42.  
    43.             this.RegisterEvent(e =>
    44.             {
    45.                 if (model.Count == 10)
    46.                 {
    47.                     Debug.Log("触发 点击达人 成就");
    48.                 }
    49.                 else if (model.Count == 20)
    50.                 {
    51.                     Debug.Log("触发 点击专家 成就");
    52.                 } else if (model.Count == -10)
    53.                 {
    54.                     Debug.Log("触发 点击菜鸟 成就");
    55.                 }
    56.             });
    57.         }
    58.     }
    59.  
    60.     // 定义 utility 层
    61.     public class Storage : IUtility
    62.     {
    63.         public void SaveInt(string key, int value)
    64.         {
    65.             PlayerPrefs.SetInt(key,value);
    66.         }
    67.  
    68.         public int LoadInt(string key, int defaultValue = 0)
    69.         {
    70.             return PlayerPrefs.GetInt(key, defaultValue);
    71.         }
    72.     }
    73.  
    74.  
    75.     // 2.定义一个架构（提供 MVC、分层、模块管理等）
    76.     public class CounterApp : Architecture<CounterApp>
    77.     {
    78.         protected override void Init()
    79.         {
    80.             // 注册 System 
    81.             this.RegisterSystem(new AchievementSystem()); // +
    82.  
    83.             // 注册 Model
    84.             this.RegisterModel(new CounterAppModel());
    85.  
    86.             // 注册存储工具的对象
    87.             this.RegisterUtility(new Storage());
    88.         }
    89.     }
    90.  
    91.     // 定义数据变更事件
    92.     public struct CountChangeEvent // ++
    93.     {
    94.  
    95.     }
    96.  
    97.     // 引入 Command
    98.     public class IncreaseCountCommand : AbstractCommand 
    99.     {
    100.         protected override void OnExecute()
    101.         {
    102.             var model = this.GetModel();
    103.  
    104.             model.Count++;
    105.             this.SendEvent(); // ++
    106.         }
    107.     }
    108.  
    109.     public class DecreaseCountCommand : AbstractCommand
    110.     {
    111.         protected override void OnExecute()
    112.         {
    113.             this.GetModel().Count--;
    114.             this.SendEvent(); // ++
    115.         }
    116.     }
    117.  
    118.     // Controller
    119.     public class CounterAppController : MonoBehaviour , IController /* 3.实现 IController 接口 */
    120.     {
    121.         // View
    122.         private Button mBtnAdd;
    123.         private Button mBtnSub;
    124.         private Text mCountText;
    125.  
    126.         // 4. Model
    127.         private CounterAppModel mModel;
    128.  
    129.         void Start()
    130.         {
    131.             // 5. 获取模型
    132.             mModel = this.GetModel();
    133.  
    134.             // View 组件获取
    135.             mBtnAdd = transform.Find("BtnAdd").GetComponent
    136.             mBtnSub = transform.Find("BtnSub").GetComponent
    137.             mCountText = transform.Find("CountText").GetComponent();
    138.  
    139.  
    140.             // 监听输入
    141.             mBtnAdd.onClick.AddListener(() =>
    142.             {
    143.                 // 交互逻辑
    144.                 this.SendCommand();
    145.             });
    146.  
    147.             mBtnSub.onClick.AddListener(() =>
    148.             {
    149.                 // 交互逻辑
    150.                 this.SendCommand(new DecreaseCountCommand(/* 这里可以传参（如果有） */));
    151.             });
    152.  
    153.             UpdateView();
    154.  
    155.             // 表现逻辑
    156.             this.RegisterEvent(e =>
    157.             {
    158.                 UpdateView();
    159.  
    160.             }).UnRegisterWhenGameObjectDestroyed(gameObject);
    161.         }
    162.  
    163.         void UpdateView()
    164.         {
    165.             mCountText.text = mModel.Count.ToString();
    166.         }
    167.  
    168.         // 3.
    169.         public IArchitecture GetArchitecture()
    170.         {
    171.             return CounterApp.Interface;
    172.         }
    173.  
    174.         private void OnDestroy()
    175.         {
    176.             // 8. 将 Model 设置为空
    177.             mModel = null;
    178.         }
    179.     }

    到此，我们就接触到了 QFramework 架构所提供的核心概念。

    QFramework 总共分四个层级，即

    • 表现层：IController
    • 系统层：ISystem
    • 数据层：IModel
    • 工具层：IUtility

    除了四个层级，还接触了为 Controller 的交互逻辑减负的 Command 和 为表现逻辑减负的 Event。

    还有一个非常重要的 CQRS 原则的简易版本，Command->Model->State Changed Event。

    到目前为止 QFramework 的基本用法我们过了一遍了。

  • 相关阅读:
    Spring的copy属性
    刘锦程荣获2022年度中国电商行业创新人物奖
    2022年《微信小程序从基础到uni-app项目实战》
    我梦想中的学习组织-勤学会
    大数据之力：从数据湖到数据智能的升级之路
    微信小程序开发---小程序的页面配置
    计算机三级UML与数据库应用系统练习题（一）
    【宋红康 MySQL数据库 】【高级篇】【19】多版本并发控制MVCC
    软件测试中如何测试算法？
    Qt应用开发(基础篇)——输入对话框 QInputDialog
  • 原文地址：https://blog.csdn.net/LiKe11807/article/details/126492101