ActiveData在HarmonyOS中的原理分析和运用

想了解更多内容，请访问：

创新互联建站服务项目包括清涧网站建设、清涧网站制作、清涧网页制作以及清涧网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，清涧网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到清涧省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

和华为官方合作共建的鸿蒙技术社区

https://harmonyos.

在讲解ActiveData实现原理之前，我们有必要先了解一下两个重要的类Lifecycle以及DataObserver，这两个类在ActiveData整个运行过程中扮演了非常重要的角色。

  • Lifecycle提供了观察Ability和AbilitySlice的生命周期能力
  • DataObserver通过持有一个Lifecycle对象来观察Ability或者AbilitySlice的生命周期变化，同时DataObserver还允许ActiveData观察其生命周期变化，因此DataObserver和ActiveData相互观察，DataObserver观察ActiveData的数据变化，ActiveData观察DataObserver的生命周期变化。

ActiveData作用和特点

ActiveData是一个具有感知生命周期能力变化的数据通知类组件，非常适合在一些对数据同步性较高的场景下使用，它具有以下三个特点。

基于观察者模式：

ActiveData是一个持有可被观察数据的类，ActiveData需要一个观察者对象，一般是DataObserver类的具体实现。

感知生命周期：

ActiveData具有生命周期感知能力，目前ActiveData具有两种通知模式，一种是Ability/AbilitySlice生命周期是活跃(ACTIVE)状态时才更新数据，另一种是Ability/AbilitySlice生命周期处于任何存活状态(即只要没有被销毁)都可以更新数据。

自动解除数据订阅：

ActiveData必须配合实现了Lifecycle的对象使用。当Ability/AbilitySlice被销毁(STOP状态)后，会自动解除订阅，这在一定程度上可以避免内存泄漏等问题。

实践

1.基础用法

 
 
 
 
    
  
  
  
  
  1. public class MainAbilitySlice extends AbilitySlice { 
    2. 
  
  
  
  
  2.     private ActiveData activeData; 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.     private Text mText; 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.     private final DataObserver dataObserver = new DataObserver() { 
    7. 
  
  
  
  
  7.         @Override 
    8. 
  
  
  
  
  8.         public void onChanged(String s) { 
    9. 
  
  
  
  
  9.             mText.setText(s); 
    10. 
  
  
  
  
  10.         } 
    11. 
  
  
  
  
  11.     }; 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.     @Override 
    14. 
  
  
  
  
  14.     public void onStart(Intent intent) { 
    15. 
  
  
  
  
  15.         super.onStart(intent); 
    16. 
  
  
  
  
  16.         super.setUIContent(ResourceTable.Layout_ability_main); 
    17. 
  
  
  
  
  17.         activeData = new ActiveData<>(); 
    18. 
  
  
  
  
  18.         dataObserver.setLifecycle(getLifecycle()); 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20.         mText = (Text) findComponentById(ResourceTable.Id_text_helloworld); 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.         subscribe(); 
    23. 
  
  
  
  
  23.     } 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.     private void subscribe() { 
    26. 
  
  
  
  
  26.         activeData.addObserver(dataObserver, true); 
    27. 
  
  
  
  
  27.     } 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29.     @Override 
    30. 
  
  
  
  
  30.     public void onActive() { 
    31. 
  
  
  
  
  31.         super.onActive(); 
    32. 
  
  
  
  
  32.         activeData.setData("New Hello World"); 
    33. 
  
  
  
  
  33.     } 
    34. 
  
  
  
  
  34. } 
    35.

运行之后的截图:

从运行结果可以看出，setData调用后会立即触发onChanged回调方法

2.主线程手动调用

 
 
 
 
    
  
  
  
  
  1. // 添加如下代码测试DataObserver的onChanged方法是否会执行 
    2. 
  
  
  
  
  2. findComponentById(ResourceTable.Id_button) 
    3. 
  
  
  
  
  3.                 .setClickedListener(component -> activeData.setData("I Love China")); 
    4.

 运行结果如下：

从运行结果我们可以看到，onChanged方法会一直触发，并不会因为值相同而不执行，虽然暂时看不了鸿蒙源码，但我们可以大胆猜测，鸿蒙底层维护了一个类似于版本号的标记，每次setData，该标记会自动+1，从而通过此版本号来判断data是否有变化，进而决定是否触发onChanged回调方法。

3.子线程调用

 
 
 
 
    
  
  
  
  
  1. @Override 
    2. 
  
  
  
  
  2.    public void onActive() { 
    3. 
  
  
  
  
  3.        super.onActive(); 
    4. 
  
  
  
  
  4.        new Thread(() -> activeData.setData("New Hello World")).start(); 
    5. 
  
  
  
  
  5.    }  
    6.

4.运行后发现没有问题，可以正常调用，说明setData方法可以在子线程调用。

 
 
 
 
    
  
  
  
  
  1. public class MainAbilitySlice extends AbilitySlice { 
    2. 
  
  
  
  
  2.     private ActiveData activeData; 
    3. 
  
  
  
  
  3.     private ActiveData activeData2; 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.     private Text mText; 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.     private final DataObserver dataObserver = new DataObserver() { 
    8. 
  
  
  
  
  8.         @Override 
    9. 
  
  
  
  
  9.         public void onChanged(String s) { 
    10. 
  
  
  
  
  10.             mText.setText(s); 
    11. 
  
  
  
  
  11.             System.out.println("ActiveData:---onChange:"+s); 
    12. 
  
  
  
  
  12.         } 
    13. 
  
  
  
  
  13.     }; 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.     private final DataObserver dataObserver2 = new DataObserver() { 
    16. 
  
  
  
  
  16.         @Override 
    17. 
  
  
  
  
  17.         public void onChanged(String s) { 
    18. 
  
  
  
  
  18.             mText.setText(s); 
    19. 
  
  
  
  
  19.             System.out.println("ActiveData:---onChange:"+s); 
    20. 
  
  
  
  
  20.         } 
    21. 
  
  
  
  
  21.     }; 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.     @Override 
    24. 
  
  
  
  
  24.     public void onStart(Intent intent) { 
    25. 
  
  
  
  
  25.         super.onStart(intent); 
    26. 
  
  
  
  
  26.         super.setUIContent(ResourceTable.Layout_ability_main); 
    27. 
  
  
  
  
  27.         activeData = new ActiveData<>(); 
    28. 
  
  
  
  
  28.         activeData2 = new ActiveData<>(); 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30.         dataObserver.setLifecycle(getLifecycle()); 
    31. 
  
  
  
  
  31.         dataObserver2.setLifecycle(getLifecycle()); 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33.         mText = (Text) findComponentById(ResourceTable.Id_text_helloworld); 
    34. 
  
  
  
  
  34.         findComponentById(ResourceTable.Id_button) 
    35. 
  
  
  
  
  35.                 .setClickedListener(component -> activeData.setData("I Love China")); 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37.         findComponentById(ResourceTable.Id_addObserver_true).setClickedListener(component -> { 
    38. 
  
  
  
  
  38.             System.out.println("ActiveData:-------------"); 
    39. 
  
  
  
  
  39.             Intent intent1 = new Intent(); 
    40. 
  
  
  
  
  40.             Operation operation = new Intent.OperationBuilder() 
    41. 
  
  
  
  
  41.                     .withDeviceId("") 
    42. 
  
  
  
  
  42.                     .withBundleName(getBundleName()) 
    43. 
  
  
  
  
  43.                     .withAbilityName(SecondAbility.class.getName()) 
    44. 
  
  
  
  
  44.                     .build(); 
    45. 
  
  
  
  
  45.  
    46. 
  
  
  
  
  46.             intent1.setOperation(operation); 
    47. 
  
  
  
  
  47.             startAbility(intent1); 
    48. 
  
  
  
  
  48.             // 此处是为了验证Ability在inActive状态的值的变化情况 
    49. 
  
  
  
  
  49.             new EventHandler(EventRunner.getMainEventRunner()).postTask(() -> activeData.setData("New Hello World"), 2000); 
    50. 
  
  
  
  
  50.         }); 
    51. 
  
  
  
  
  51.  
    52. 
  
  
  
  
  52.         findComponentById(ResourceTable.Id_addObserver_false).setClickedListener(component -> { 
    53. 
  
  
  
  
  53.             System.out.println("ActiveData:-------------"); 
    54. 
  
  
  
  
  54.             Intent intent1 = new Intent(); 
    55. 
  
  
  
  
  55.             Operation operation = new Intent.OperationBuilder() 
    56. 
  
  
  
  
  56.                     .withDeviceId("") 
    57. 
  
  
  
  
  57.                     .withBundleName(getBundleName()) 
    58. 
  
  
  
  
  58.                     .withAbilityName(SecondAbility.class.getName()) 
    59. 
  
  
  
  
  59.                     .build(); 
    60. 
  
  
  
  
  60.  
    61. 
  
  
  
  
  61.             intent1.setOperation(operation); 
    62. 
  
  
  
  
  62.             startAbility(intent1); 
    63. 
  
  
  
  
  63.             // 此处是为了验证Ability在inActive状态的值的变化情况 
    64. 
  
  
  
  
  64.             new EventHandler(EventRunner.getMainEventRunner()).postTask(() -> activeData2.setData("New Hello World"), 2000); 
    65. 
  
  
  
  
  65.         }); 
    66. 
  
  
  
  
  66.  
    67. 
  
  
  
  
  67.         subscribe(); 
    68. 
  
  
  
  
  68.     } 
    69. 
  
  
  
  
  69.  
    70. 
  
  
  
  
  70.     private void subscribe() { 
    71. 
  
  
  
  
  71.         activeData.addObserver(dataObserver, true); 
    72. 
  
  
  
  
  72.         activeData2.addObserver(dataObserver, false); 
    73. 
  
  
  
  
  73.     } 
    74. 
  
  
  
  
  74.  
    75. 
  
  
  
  
  75.     @Override 
    76. 
  
  
  
  
  76.     public void onActive() { 
    77. 
  
  
  
  
  77.         super.onActive(); 
    78. 
  
  
  
  
  78.         System.out.println("ActiveData:---onActive"); 
    79. 
  
  
  
  
  79.     } 
    80. 
  
  
  
  
  80.  
    81. 
  
  
  
  
  81.     @Override 
    82. 
  
  
  
  
  82.     protected void onInactive() { 
    83. 
  
  
  
  
  83.         super.onInactive(); 
    84. 
  
  
  
  
  84.         System.out.println("ActiveData:---onInactive"); 
    85. 
  
  
  
  
  85.     } 
    86. 
  
  
  
  
  86.  
    87. 
  
  
  
  
  87.     @Override 
    88. 
  
  
  
  
  88.     protected void onBackground() { 
    89. 
  
  
  
  
  89.         super.onBackground(); 
    90. 
  
  
  
  
  90.         System.out.println("ActiveData:---onBackground"); 
    91. 
  
  
  
  
  91.     } 
    92. 
  
  
  
  
  92.  
    93. 
  
  
  
  
  93.     @Override 
    94. 
  
  
  
  
  94.     public void onForeground(Intent intent) { 
    95. 
  
  
  
  
  95.         super.onForeground(intent); 
    96. 
  
  
  
  
  96.     System.out.println("ActiveData:---onForeground"); 
    97. 
  
  
  
  
  97.     } 
    98. 
  
  
  
  
  98. } 
    99.

运行效果如下： 

从以上运行结果，可以看出addObserver(dataObserver, true/false)方法的特点，当为true是表示无论Ability/AbilitySlice处于任何生命周期状态，均会触发onChanged回调方法，当为false时表示Ability/AbilitySlice只有处于ACTIVE状态时才会触发onChanged方法。

总结

  • ActiveData内部是依靠Lifecycle来感知组件的生命周期，从而可以避免内部泄漏
  • 开发者无需维护observer对象，当Ability/AbilitySlice被销毁时，相关联的observer会被自动移除
  • 当Ability/AbilitySlice处于活跃(ACTIVE)状态时，当ActiveData数据源发生变化时onChanged方法会立即触发，去更新UI或者执行我们想要的任何操作
  • setData方法可在任意线程中去调用，开发者无需关心调用者是否在主线程中
  • setData方法即使设置同样的数据对象，onChanged方法仍然会被触发

想了解更多内容，请访问：

和华为官方合作共建的鸿蒙技术社区

https://harmonyos.

分享标题：ActiveData在HarmonyOS中的原理分析和运用
本文链接：http://www.shufengxianlan.com/qtweb/news43/20393.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸建站知识

同城分类信息

企业网站建设　　 　蜀锦在线　　 　绵阳网站制作　　 　护栏打桩机　　 　微信开发　　 　传美奇电器　　 　成都装饰装修　　 　盐亭网站制作公司　　 　微信公众号开发　　 　微信公众号二次开发　　 　成都做网站　　 　小程序开发　　 　成都木托盘　　 　模板商城网站　　 　成都气球装饰　　 　温江网站建设　　 　德信企业管理　　 　资中网站建设　　 　微信小程序　　 　网站设计