HarmonyOS4.0——IPC与RPC通信

最新推荐文章于 2024-04-27 13:50:40 发布
最新推荐文章于 2024-04-27 13:50:40 发布
阅读量1.9k 收藏 20
点赞数 22
分类专栏： OpenHarmony 鸿蒙 Harmony OS 文章标签： rpc qt 网络协议 harmonyos 鸿蒙开发 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61845324/article/details/135995610
版权
Harmony OS 同时被 3 个专栏收录
314 篇文章 4 订阅
订阅专栏
鸿蒙
249 篇文章 6 订阅
订阅专栏
OpenHarmony
213 篇文章 2 订阅
订阅专栏

基本概念

IPC（Inter-Process Communication）与RPC（Remote Procedure Call）用于实现跨进程通信，不同的是前者使用Binder驱动，用于设备内的跨进程通信，后者使用软总线驱动，用于跨设备跨进程通信。需要跨进程通信的原因是因为每个进程都有自己独立的资源和内存空间，其他进程不能随意访问不同进程的内存和资源，IPC/RPC便是为了突破这一点。IPC和RPC通常采用客户端-服务器（Client-Server）模型，在使用时，请求服务的（Client）一端进程可获取提供服务（Server）一端所在进程的代理（Proxy），并通过此代理读写数据来实现进程间的数据通信，更具体的讲，首先请求服务的（Client）一端会建立一个服务提供端（Server）的代理对象，这个代理对象具备和服务提供端（Server）一样的功能，若想访问服务提供端（Server）中的某一个方法，只需访问代理对象中对应的方法即可，代理对象会将请求发送给服务提供端（Server）；然后服务提供端（Server）处理接受到的请求，处理完之后通过驱动返回处理结果给代理对象；最后代理对象将请求结果进一步返回给请求服务端（Client）。通常，Server会先注册系统能力（System Ability）到系统能力管理者（System Ability Manager，缩写SAMgr）中，SAMgr负责管理这些SA并向Client提供相关的接口。Client要和某个具体的SA通信，必须先从SAMgr中获取该SA的代理，然后使用代理和SA通信。下文直接使用Proxy表示服务请求方，Stub表示服务提供方。

约束与限制

  • 单个设备上跨进程通信时，传输的数据量最大约为1MB，过大的数据量请使用匿名共享内存。
  • 不支持在RPC中订阅匿名Stub对象（没有向SAMgr注册Stub对象）的死亡通知。
  • 不支持把跨设备的Proxy对象传递回该Proxy对象所指向的Stub对象所在的设备，即指向远端设备Stub的Proxy对象不能在本设备内进行二次跨进程传递。

使用建议

首先，需要编写接口类，接口类中必须定义消息码，供通信双方标识操作，可以有未实现的的方法，因为通信双方均需继承该接口类且双方不能是抽象类，所以此时定义的未实现的方法必须在双方继承时给出实现，这保证了继承双方不是抽象类。然后，需要编写Stub端相关类及其接口，并且实现AsObject方法及OnRemoteRequest方法。同时，也需要编写Proxy端，实现接口类中的方法和AsObject方法，也可以封装一些额外的方法用于调用SendRequest向对端发送数据。以上三者都具备后，便可以向SAMgr注册SA了，此时的注册应该在Stub所在进程完成。最后，在需要的地方从SAMgr中获取Proxy，便可通过Proxy实现与Stub的跨进程通信了。

相关步骤：

  • 实现接口类：需继承IRemoteBroker，需定义消息码，可声明不在此类实现的方法。
  • 实现服务提供端（Stub）：需继承IRemoteStub或者RemoteObject，需重写AsObject方法及OnRemoteRequest方法。
  • 实现服务请求端（Proxy）：需继承IRemoteProxy或RemoteProxy，需重写AsObject方法，封装所需方法调用SendRequest。
  • 注册SA：申请SA的唯一ID，向SAMgr注册SA。
  • 获取SA：通过SA的ID和设备ID获取Proxy，使用Proxy与远端通信

场景介绍

IPC/RPC的主要工作是让运行在不同进程的Proxy和Stub互相通信，包括Proxy和Stub运行在不同设备的情况。

接口说明

表1 Native侧IPC接口

类/接口方法功能说明
IRemoteBrokersptr AsObject()返回通信对象。Stub端返回RemoteObject对象本身，Proxy端返回代理对象。
IRemoteStubvirtual int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)请求处理方法，派生类需要重写该方法用来处理Proxy的请求并返回结果。
IRemoteProxyRemote()->SendRequest(code, data, reply, option)消息发送方法，业务的Proxy类需要从IRemoteProxy类派生，该方法用来向对端发送消息。

开发步骤

Native侧开发步骤

1. 添加依赖

SDK依赖：

#ipc场景
external_deps = [
  "ipc:ipc_single",
]

#rpc场景
external_deps = [
  "ipc:ipc_core",
]

此外， IPC/RPC依赖的refbase实现在公共基础库下，请增加对utils的依赖：

    1.  external\_deps = \[
    2.    "c\_utils:utils",
    3.  \]

2. 定义IPC接口ITestAbility

SA接口继承IPC基类接口IRemoteBroker，接口里定义描述符、业务函数和消息码，其中业务函数在Proxy端和Stub端都需要实现。

    1.  #include "iremote\_broker.h"
    
    3.  //定义消息码
    4.  const int TRANS\_ID\_PING\_ABILITY = 5
    
    6.  const std::string DESCRIPTOR = "test.ITestAbility";
    
    8.  class ITestAbility : public IRemoteBroker {
    9.  public:
    10.      // DECLARE\_INTERFACE\_DESCRIPTOR是必需的，入参需使用std::u16string；
    11.      DECLARE\_INTERFACE\_DESCRIPTOR(to\_utf16(DESCRIPTOR));
    12.      virtual int TestPingAbility(const std::u16string &dummy) \= 0; // 定义业务函数
    13.  };

3. 定义和实现服务端TestAbilityStub

该类是和IPC框架相关的实现，需要继承 IRemoteStub。Stub端作为接收请求的一端，需重写OnRemoteRequest方法用于接收客户端调用。

    1.  #include "iability\_test.h"
    2.  #include "iremote\_stub.h"
    
    4.  class TestAbilityStub : public IRemoteStub<ITestAbility> {
    5.  public:
    6.      virtual int OnRemoteRequest(uint32\_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
    7.      int TestPingAbility(const std::u16string &dummy) override;
    8.   };
    
    10.  int TestAbilityStub::OnRemoteRequest(uint32\_t code,
    11.   MessageParcel &data, MessageParcel &reply, MessageOption &option)
    12.  {
    13.      switch (code) {
    14.          case TRANS\_ID\_PING\_ABILITY: {
    15.              std::u16string dummy = data.ReadString16();
    16.              int result = TestPingAbility(dummy);
    17.              reply.WriteInt32(result);
    18.              return 0;
    19.          }
    20.          default:
    21.              return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
    22.      }
    23.  }

4. 定义服务端业务函数具体实现类TestAbility

    1.  #include "iability\_server\_test.h"
    
    3.  class TestAbility : public TestAbilityStub {
    4.  public:
    5.      int TestPingAbility(const std::u16string &dummy);
    6.  }
    
    8.  int TestAbility::TestPingAbility(const std::u16string &dummy) {
    9.      return 0;
    10.  }

5. 定义和实现客户端 TestAbilityProxy

该类是Proxy端实现，继承IRemoteProxy，调用SendRequest接口向Stub端发送请求，对外暴露服务端提供的能力。

    1.  #include "iability\_test.h"
    2.  #include "iremote\_proxy.h"
    3.  #include "iremote\_object.h"
    
    5.  class TestAbilityProxy : public IRemoteProxy<ITestAbility> {
    6.  public:
    7.      explicit TestAbilityProxy(const sptr<IRemoteObject> &impl);
    8.      int TestPingAbility(const std::u16string &dummy) override;
    9.  private:
    10.      static inline BrokerDelegator<TestAbilityProxy> delegator\_; // 方便后续使用iface\_cast宏
    11.  }
    
    13.  TestAbilityProxy::TestAbilityProxy(const sptr<IRemoteObject> &impl)
    14.      : IRemoteProxy<ITestAbility>(impl)
    15.  {
    16.  }
    
    18.  int TestAbilityProxy::TestPingAbility(const std::u16string &dummy){
    19.      MessageOption option;
    20.      MessageParcel dataParcel, replyParcel;
    21.      dataParcel.WriteString16(dummy);
    22.      int error = Remote()->SendRequest(TRANS\_ID\_PING\_ABILITY, dataParcel, replyParcel, option);
    23.      int result = (error == ERR\_NONE) ? replyParcel.ReadInt32() : \-1;
    24.      return result;
    25.  }

6. SA注册与启动

SA需要将自己的TestAbilityStub实例通过AddSystemAbility接口注册到SystemAbilityManager，设备内与分布式的注册参数不同。

    1.  // 注册到本设备内
    2.  auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    3.  samgr->AddSystemAbility(saId, new TestAbility());
    
    5.  // 在组网场景下，会被同步到其他设备上
    6.  auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    7.  ISystemAbilityManager::SAExtraProp saExtra;
    8.  saExtra.isDistributed = true; // 设置为分布式SA
    9.  int result = samgr->AddSystemAbility(saId, new TestAbility(), saExtra);

7. SA获取与调用

通过SystemAbilityManager的GetSystemAbility方法可获取到对应SA的代理IRemoteObject，然后构造TestAbilityProxy即可。

    1.  // 获取本设备内注册的SA的proxy
    2.  sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    3.  sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(saId);
    4.  sptr<ITestAbility> testAbility = iface\_cast<ITestAbility>(remoteObject); // 使用iface\_cast宏转换成具体类型
    
    6.  // 获取其他设备注册的SA的proxy
    7.  sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    
    9.  // networkId是组网场景下对应设备的标识符，可以通过GetLocalNodeDeviceInfo获取
    10.  sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(saId, networkId);
    11.  sptr<TestAbilityProxy> proxy(new TestAbilityProxy(remoteObject)); // 直接构造具体Proxy

JS侧开发步骤

1. 添加依赖

    1.  import rpc from "@ohos.rpc"
    2.  import featureAbility from "@ohos.ability.featureAbility"

2. 绑定Ability

首先，构造变量want，指定要绑定的Ability所在应用的包名、组件名，如果是跨设备的场景，还需要绑定目标设备NetworkId（组网场景下对应设备的标识符，可以使用deviceManager获取目标设备的NetworkId）；然后，构造变量connect，指定绑定成功、绑定失败、断开连接时的回调函数；最后，使用featureAbility提供的接口绑定Ability。

    1.  import rpc from "@ohos.rpc"
    2.  import featureAbility from "@ohos.ability.featureAbility"
    
    4.  let proxy = null
    5.  let connectId = null
    
    7.  // 单个设备绑定Ability
    8.  let want = {
    9.      // 包名和组件名写实际的值
    10.      "bundleName": "ohos.rpc.test.server",
    11.      "abilityName": "ohos.rpc.test.server.ServiceAbility",
    12.  }
    13.  let connect = {
    14.      onConnect:function(elementName, remote) {
    15.          proxy = remote
    16.      },
    17.      onDisconnect:function(elementName) {
    18.      },
    19.      onFailed:function() {
    20.          proxy = null
    21.      }
    22.  }
    23.  connectId = featureAbility.connectAbility(want, connect)
    
    25.  // 如果是跨设备绑定，可以使用deviceManager获取目标设备NetworkId
    26.  import deviceManager from '@ohos.distributedHardware.deviceManager'
    27.  function deviceManagerCallback(deviceManager) {
    28.      let deviceList = deviceManager.getTrustedDeviceListSync()
    29.      let networkId = deviceList\[0\].networkId
    30.      let want = {
    31.          "bundleName": "ohos.rpc.test.server",
    32.          "abilityName": "ohos.rpc.test.service.ServiceAbility",
    33.          "networkId": networkId,
    34.          "flags": 256
    35.      }
    36.      connectId = featureAbility.connectAbility(want, connect)
    37.  }
    38.  // 第一个参数是本应用的包名，第二个参数是接收deviceManager的回调函数
    39.  deviceManager.createDeviceManager("ohos.rpc.test", deviceManagerCallback)

3. 服务端处理客户端请求

服务端被绑定的Ability在onConnect方法里返回继承自rpc.RemoteObject的对象，该对象需要实现onRemoteMessageRequest方法，处理客户端的请求。

    1.  onConnect(want: Want) {
    2.      var robj:rpc.RemoteObject = new Stub("rpcTestAbility")
    3.      return robj
    4.  }
    5.  class Stub extends rpc.RemoteObject {
    6.      constructor(descriptor) {
    7.          super(descriptor)
    8.      }
    9.      onRemoteMessageRequest(code, data, reply, option) {
    10.          // 根据code处理客户端的请求
    11.          return true
    12.      }
    13.  }

4. 客户端处理服务端响应

客户端在onConnect回调里接收到代理对象，调用sendRequestAsync方法发起请求，在期约（JavaScript期约：用于表示一个异步操作的最终完成或失败及其结果值）或者回调函数里接收结果。

    1.  // 使用期约
    2.  let option = new rpc.MessageOption()
    3.  let data = rpc.MessageParcel.create()
    4.  let reply = rpc.MessageParcel.create()
    5.  // 往data里写入参数
    6.  proxy.sendRequestAsync(1, data, reply, option)
    7.      .then(function(result) {
    8.          if (result.errCode != 0) {
    9.              console.error("send request failed, errCode: " + result.errCode)
    10.              return
    11.          }
    12.          // 从result.reply里读取结果
    13.      })
    14.      .catch(function(e) {
    15.          console.error("send request got exception: " + e)
    16.      }
    17.      .finally(() => {
    18.          data.reclaim()
    19.          reply.reclaim()
    20.      })
    
    22.  // 使用回调函数
    23.  function sendRequestCallback(result) {
    24.      try {
    25.          if (result.errCode != 0) {
    26.              console.error("send request failed, errCode: " + result.errCode)
    27.              return
    28.          }
    29.          // 从result.reply里读取结果
    30.      } finally {
    31.          result.data.reclaim()
    32.          result.reply.reclaim()
    33.      }
    34.  }
    35.  let option = new rpc.MessageOption()
    36.  let data = rpc.MessageParcel.create()
    37.  let reply = rpc.MessageParcel.create()
    38.  // 往data里写入参数
    39.  proxy.sendRequest(1, data, reply, option, sendRequestCallback)

  1. 断开连接

    IPC通信结束后，使用featureAbility的接口断开连接。

    1.  import rpc from "@ohos.rpc"
    2.  import featureAbility from "@ohos.ability.featureAbility"
    3.  function disconnectCallback() {
    4.      console.info("disconnect ability done")
    5.  }
    6.  featureAbility.disconnectAbility(connectId, disconnectCallback)

远端状态订阅开发实例

IPC/RPC提供对远端Stub对象状态的订阅机制， 在远端Stub对象消亡时，可触发消亡通知告诉本地Proxy对象。这种状态通知订阅需要调用特定接口完成，当不再需要订阅时也需要调用特定接口取消。使用这种订阅机制的用户，需要实现消亡通知接口DeathRecipient并实现onRemoteDied方法清理资源。该方法会在远端Stub对象所在进程消亡或所在设备离开组网时被回调。值得注意的是，调用这些接口有一定的顺序。首先，需要Proxy订阅Stub消亡通知，若在订阅期间Stub状态正常，则在不再需要时取消订阅；若在订阅期间Stub所在进程退出或者所在设备退出组网，则会自动触发Proxy自定义的后续操作。

使用场景

这种订阅机制适用于本地Proxy对象需要感知远端Stub对象所在进程消亡，或所在设备离开组网的场景。当Proxy感知到Stub端消亡后，可适当清理本地资源。此外，RPC目前不提供匿名Stub对象的消亡通知，即只有向SAMgr注册过的服务才能被订阅消亡通知，IPC则支持匿名对象的消亡通知。

Native侧接口

接口名返回值类型功能描述
AddDeathRecipient(const sptr &recipient);bool订阅远端Stub对象状态。
RemoveDeathRecipient(const sptr &recipient);bool取消订阅远端Stub对象状态。
OnRemoteDied(const wptr &object);void当远端Stub对象死亡时回调。

参考代码

1.  #include "iremote\_broker.h"
2.  #include "iremote\_stub.h"

5.  //定义消息码
6.  enum {
7.      TRANS\_ID\_PING\_ABILITY = 5,
8.      TRANS\_ID\_REVERSED\_MONITOR
9.  };

11.  const std::string DESCRIPTOR = "test.ITestAbility";

13.  class ITestService : public IRemoteBroker {
14.  public:
15.      // DECLARE\_INTERFACE\_DESCRIPTOR是必需的，入参需使用std::u16string；
16.      DECLARE\_INTERFACE\_DESCRIPTOR(to\_utf16(DESCRIPTOR));
17.      virtual int TestPingAbility(const std::u16string &dummy) \= 0; // 定义业务函数
18.  };

20.  class TestServiceProxy : public IRemoteProxy<ITestAbility> {
21.  public:
22.      explicit TestAbilityProxy(const sptr<IRemoteObject> &impl);
23.      virtual int TestPingAbility(const std::u16string &dummy) override;
24.      int TestAnonymousStub();
25.  private:
26.      static inline BrokerDelegator<TestAbilityProxy> delegator\_; // 方便后续使用iface\_cast宏
27.  };

29.  TestServiceProxy::TestServiceProxy(const sptr<IRemoteObject> &impl)
30.      : IRemoteProxy<ITestAbility>(impl)
31.  {
32.  }

34.  int TestServiceProxy::TestPingAbility(const std::u16string &dummy){
35.      MessageOption option;
36.      MessageParcel dataParcel, replyParcel;
37.      dataParcel.WriteString16(dummy);
38.      int error = PeerHolder::Remote()->SendRequest(TRANS\_ID\_PING\_ABILITY, dataParcel, replyParcel, option);
39.      int result = (error == ERR\_NONE) ? replyParcel.ReadInt32() : \-1;
40.      return result;
41.  }

1.  #include "iremote\_object.h"

3.  class TestDeathRecipient : public IRemoteObject::DeathRecipient {
4.  public:
5.      virtual void OnRemoteDied(const wptr<IRemoteObject>& remoteObject);
6.  }

8.  void TestDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remoteObject)
9.  {
10.  }

1.  sptr<IPCObjectProxy> object = new IPCObjectProxy(1, to\_utf16(DESCRIPTOR));
2.  sptr<IRemoteObject::DeathRecipient> deathRecipient (new TestDeathRecipient());// 构造一个消亡通知对象
3.  bool result = object\->AddDeathRecipient(deathRecipient); // 注册消亡通知
4.  result = object\->RemoveDeathRecipient(deathRecipient); // 移除消亡通知

JS侧接口

接口名返回值类型功能描述
addDeathRecipientboolean注册用于接收远程对象消亡通知的回调，增加proxy对象上的消亡通知。
removeDeathRecipientboolean注销用于接收远程对象消亡通知的回调。
onRemoteDiedvoid在成功添加死亡通知订阅后，当远端对象死亡时，将自动调用本方法。

参考代码

import FA from "@ohos.ability.featureAbility";
let proxy;
let connect = {
    onConnect: function(elementName, remoteProxy) {
        console.log("RpcClient: js onConnect called.");
        proxy = remoteProxy;
    },
    onDisconnect: function(elementName) {
        console.log("RpcClient: onDisconnect");
    },
    onFailed: function() {
        console.log("RpcClient: onFailed");
    }
};
let want = {
    "bundleName": "com.ohos.server",
    "abilityName": "com.ohos.server.MainAbility",
};
FA.connectAbility(want, connect);
class MyDeathRecipient {
    onRemoteDied() {
        console.log("server died");
    }
}
let deathRecipient = new MyDeathRecipient();
proxy.addDeathRecipient(deathRecipient, 0);
proxy.removeDeathRecipient(deathRecipient, 0);

Stub感知Proxy消亡（匿名Stub的使用）

正向的消亡通知是Proxy感知Stub的状态，若想达到反向的死消亡通知，即Stub感知Proxy的状态，可以巧妙的利用正向消亡通知。如两个进程A（原Stub所在进程）和B（原Proxy所在进程），进程B在获取到进程A的Proxy对象后，在B进程新建一个匿名Stub对象（匿名指未向SAMgr注册），可称之为回调Stub，再通过SendRequest接口将回调Stub传给进程A的原Stub。这样一来，进程A便获取到了进程B的回调Proxy。当进程B消亡或B所在设备离开组网时，回调Stub会消亡，回调Proxy会感知，进而通知给原Stub，便实现了反向消亡通知。

注意：

反向死亡通知仅限设备内跨进程通信使用，不可用于跨设备。

当匿名Stub对象没有被任何一个Proxy指向的时候，内核会自动回收。

参考代码

1.  //Proxy
2.  int TestAbilityProxy::TestAnonymousStub()
3.  {
4.      MessageOption option;
5.      MessageParcel dataParcel, replyParcel;
6.      dataParcel.UpdateDataVersion(Remote());
7.      dataParcel.WriteRemoteObject(new TestAbilityStub());
8.      int error = Remote()->SendRequest(TRANS\_ID\_REVERSED\_MONITOR,dataParcel, replyParcel, option);
9.      int result = (error == ERR\_NONE) ? replyParcel.ReadInt32() : \-1;
10.      return result;
11.  }

13.  //Stub

15.  int TestAbilityStub::OnRemoteRequest(uint32\_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
16.  {
17.      switch (code) {
18.          case TRANS\_ID\_REVERSED\_MONITOR: {
19.              sptr<IRemoteObject> obj = data.ReadRemoteObject();
20.              if (obj == nullptr) {
21.                  reply.WriteInt32(ERR\_NULL\_OBJECT);
22.                  return ERR\_NULL\_OBJECT;
23.              }
24.              bool result = obj->AddDeathRecipient(new TestDeathRecipient());
25.              result ? reply.WriteInt32(ERR\_NONE) : reply.WriteInt32(\-1);
26.              break;
27.          }
28.          default:
29.              break;
30.      }
31.      return ERR\_NONE;
32.  }

为了能让大家更好的学习鸿蒙 (OpenHarmony) 开发技术，这边特意整理了《鸿蒙 (OpenHarmony)开发学习手册》（共计890页），希望对大家有所帮助：https://qr21.cn/FV7h05

《鸿蒙 (OpenHarmony)开发学习手册》

入门必看：https://qr21.cn/FV7h05

  1. 应用开发导读(ArkTS)
  2. ……

HarmonyOS 概念：https://qr21.cn/FV7h05

  1. 系统定义
  2. 技术架构
  3. 技术特性
  4. 系统安全

如何快速入门？：https://qr21.cn/FV7h05

  1. 基本概念
  2. 构建第一个ArkTS应用
  3. 构建第一个JS应用
  4. ……

开发基础知识：https://qr21.cn/FV7h05

  1. 应用基础知识
  2. 配置文件
  3. 应用数据管理
  4. 应用安全管理
  5. 应用隐私保护
  6. 三方应用调用管控机制
  7. 资源分类与访问
  8. 学习ArkTS语言
  9. ……

基于ArkTS 开发：https://qr21.cn/FV7h05

1.Ability开发
2.UI开发
3.公共事件与通知
4.窗口管理
5.媒体
6.安全
7.网络与链接
8.电话服务
9.数据管理
10.后台任务(Background Task)管理
11.设备管理
12.设备使用信息统计
13.DFX
14.国际化开发
15.折叠屏系列
16.……

码中之牛
关注
  • 22
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HarmonyOS跨进程通信—IPC与RPC通信开发
2401_82772199的博客
02-02 745
IPC/RPC的主要工作是让运行在不同进程的Proxy和Stub互相通信，包括Proxy和Stub运行在不同设备的情况。
RPC通信
个人技术博客
04-16 2462
跨语言平台PRC框架，根据IDL（Interface Description Language接口描述语言）定义服务端提供的接口与通信所使用的消息。编译时通过protobuf工具编译成对应的代码，生成的代码与业务代码编译到一起。
鸿蒙南向开发实战：IPC通信鉴权开发
最新发布
shudaoshanQAQ的博客
04-27 613
系统服务通过IPC跨进程方式开放的接口......
由浅入深RPC通信原理实战
赵广陆
05-15 1316
目录 1 背景知识 2 RPC概述 3 RPC框架实现要点 3.1 注册中心 3.2 代理技术 3.3 序列化技术 3.4 RPC通信协议 3.5 系统IO 3.6 超时重试机制 3.7 时间轮算法 3.8 负载均衡策略 3.9 熔断限流 3.10 滑动窗口算法 3.11 限流组件
详细教程 - 从零开发 Vue 鸿蒙harmonyOS应用 第七节-—— 鸿蒙应用进程通信深度剖析
爱蹦跶的全栈大A阿
12-18 642
不同进程间需要通过通信来协作完成任务良好的IPC机制是构建模块化应用的必要手段鸿蒙的高效RPC机制可实现跨进程通信线程池、队列、序列化等手段优化性能以上就是这篇完整的鸿蒙应用进程通信实现和优化策略的深度剖析博客。我尽量涵盖各个部分的技术细节,同时提供完整的代码示例。希望这些内容能够全面地帮助您进一步理解鸿蒙的IPC机制!如果还有可以补充和完善的部分,欢迎提出建议!
RPC——RPC协议介绍及原理详解
热门推荐
Andya_net的博客
06-11 1万+
RPC（Remote Procedure Call Protocol） 远程过程调用协议。RPC是一种通过网络从远程计算机程序上请求服务，不需要了解底层网络技术的协议。RPC主要作用就是不同的服务间方法调用就像本地调用一样便捷。序列化：将消息对象转换为二进制流。反序列化：将二进制流转换为消息对象。
鸿蒙系统调研
三翼鸟数字化平台的技术实践分享
10-19 2871
鸿蒙系统基础知识及案例分析
Matlab生成dsp程序——IPC通信.zip
07-14
采用的是matlab官方给的例程学习，ccs程序是通过matlab中的simulink模型直接导出生成的。记得配合博文使用啊！
华为认证 HarmonyOS 系列教程
12-26
【 HarmonyOS 系统定义与技术特性】 HarmonyOS 是华为公司推出的一款面向全场景的分布式操作系统，旨在打破不同设备间的界限，实现跨平台、跨设备的无缝协同体验。作为一个现代操作系统，HarmonyOS 具有以下核心...
android IPC之binder通信机制
01-05
Binder通信机制说来简单，但是在使用的过程的遇到了一些问题，最后终于解决了，在这总结一下，一并分享给大家： 1、要使用Binder通信，首先要定义接口，然后实现服务端BnInterface***和客户端BpInterface***，说到底...
ipc.zip_ipc 进程通信
09-23
linux管道和信号量等进程通信机制的基础源代码。
C# 进程间通信,IPC通信
03-25
NET Remoting、消息队列、WCF（集成了前述方法的功能，但太新，不支持Windows2000及以前的系统），其中Remoting可以支持TCP、...本例由一个服务端，一个客户端组成，它们之间使用IPC进行通信 1、进程间通信 2、IPC通信
RPC通信原理
m0_62214699的博客
06-02 418
是一个计算机通信协议/规范/标准。允许运行于一台计算机的程序通过网络调用另一台计算机的子程序，这种调用就像调用本地程序一样，且是一种Client/Server模式。可以实现进程间的通信，许多技术框架都是基于这种概念实现的。主要功能目标是让构建分布式计算(应用)更容易，是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议规范，简单来说就是像调用本地服务一样调用远程服务，对开发者而言是透明的。
鸿蒙通用业务模型与IPC
weixin_40870382的博客
12-17 1129
鸿蒙通用业务模型与抽象API 鸿蒙跨线程远过程调用 鸿蒙跨进程远过程调用
RPC通信原理概述
KingAarmy的博客
06-03 4304
RPC通信原理概述 1、RPC概述 1、什么是RPC RPC（Remote Procedure Call Protocol）远程过程调用协议。它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。说白了就是客户端在不知道调用细节的情况下，调用存在于远程计算上的某个过程或函数，就像调用本地应用程序中的一样。 2、传统服务调用 1、获取IP、端口、接口名： 2、设置请求行、请求头、请求体等信息 3、编码处理 .....等等等等 以上这些只是一些基本的功能 3、作用及优势 作用： 1、使
什么是RPC？RPC框架dubbo的核心流程
duan18888的博客
05-14 1876
一、REST 与 RPC 1、什么是 REST 和 RPC 协议？ 在单体应用中，各模块间的调用是通过编程语言级别的方法函数来实现，但分布式系统运行在多台机器上，一般来说，每个服务实例都是一个进程，服务间必须使用进程间通信机制来交互，而常见的通信协议主要有 RPC 和 REST 协议。 （1）REST： REST 是基于 HTTP 实现，使用 HTTP 协议处理数据通信，更加标准化与通用，因为无论哪种语言都支持 HTTP 协议。常见的 http API 都可以称为 Rest 接口。RES...
RPC服务和HTTP服务对比
ziyouniao719672119的专栏
08-28 4418
关于HTTP协议，一篇就够了 https://www.cnblogs.com/ranyonsue/p/5984001.html 很长时间以来都没有怎么好好搞清楚RPC（即Remote Procedure Call，远程过程调用）和HTTP调用的区别，不都是写一个服务然后在客户端调用么？这里请允许我迷之一笑~Naive！本文简单地介绍一下两种形式的C/S架构，先说一下他们最本质的区别，...
系统间通信：基于TCP协议的RPC实现范例
追梦客
12-15 4564
系统间通信：基于TCP协议的RPC实现范例 一、RPC名词解释          RPC的全称是Remote Process Call，即远程过程调用，它应用广泛，实现方式也很多，拥有RMI、WebService等诸多成熟的方案，在业界得到了广泛的使用。单台服务的处理能力受到硬件成本的限制，不可能无限制地提升。RPC将原来的本地调用转变为调用远端的服务器上的方法，给系统的处理能力和吞吐量带来了
harmony os镜像
11-06
Harmony OS镜像是指用于安装和运行Harmony OS操作系统的映像文件。它包含了安装和运行操作系统所需的核心文件和组件。 Harmony OS是华为公司开发的一款全场景智能终端操作系统，具有高效、安全、低延迟的特点。为了让用户能够在不同设备上享受到Harmony OS的优势，华为提供了Harmony OS镜像供用户下载和安装。 使用Harmony OS镜像可以让用户将Harmony OS操作系统安装到自己的设备上，例如智能手机、平板电脑、智能电视、智能家居设备等等。通过安装Harmony OS镜像，用户可以体验到Harmony OS所带来的高效性能、智能连接和全场景协同等特性。 通常，用户可以从官方网站或者开发者社区获取Harmony OS镜像文件。在安装过程中，用户需要将镜像文件写入一个U盘或者SD卡，然后将该存储介质插入到目标设备中。接下来，用户需要按照操作指南，通过设备的引导菜单选择从外部存储设备中启动，然后选择安装Harmony OS的选项，最后按照安装程序的提示进行操作即可。 总之，Harmony OS镜像是帮助用户在自己的设备上安装和运行Harmony OS操作系统的映像文件。它为用户提供了使用Harmony OS的机会，让用户能够体验到这款操作系统所带来的全新特性和优势。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值