鸿蒙5.0开发【两模拟器实现网络通信】

本文概述

问题背景：由于缺少HarmonyOS NEXT 真机，无法处理网络互通测试需求。因此，尝试探索模拟器互通
环境准备：
- 安装最新版DevEco Studio
- [申请最新版模拟器]
新建两个模拟器
演示视频：工程结构 + 操作方法 + 运行效果

核心步骤

由于两个模拟器均位于同一PC，其IP 及端口号均一致，因此，我需做端口转发即可
使用hdc 查询模拟器id 与模拟器对应关系：需提前打开模拟器
- 概述：
  - 红色框内即为模拟器id
  - 只开一个，并执行hdc list targets 即可进行区分
- 对应关系：
  - 127.0.0.1:5554 对应Huawei_Phone，将其用作客户端
  - 127.0.0.1:5557 对应Huawei_Phone_New，将其用作服务端
端口转发：对服务端进行端口转发
- 概述：
  - 假设模拟器实例我们指定为socket tcp服务端A:127.0.0.1:5555,监听端口为8088，客户端B:127.0.0.1:5557，监听端口为8089
  - 则在终端执行端口转发命令：hdc-t127.0.0.1:5555 fport tcp:8088 tcp:8089
  - 特别注意事项:模拟器中 socke(服务端代码监听的本机地址为:127.0.0.1.不是10.0.2.15，端口为8088，客户端socket本机配置地址：10.0.2.15:12340(端囗可随意)，连接地址：10.0.2.2:8089
- 执行命令
```
hdc -t 127.0.0.1:5557 fport ls//查询端口转发任务
hdc -t 127.0.0.1:5557 fport tcp:8089 tcp:8088//执行端口转发任务
```
- 运行截图：
  - 第一条：此时无端口转发任务
  - 第二条：执行端口转发任务
  - 第三条：查询端口转发任务，佐证第二条是否执行成功

代码运行步骤

先运行服务端，再运行客户端
详细步骤，请查阅演示视频

完整代码

公共参数：InfoObject.ets

export class InfoObject{
  messageNumber: number = 0//共计收到多少条消息
  receiveMsg: string = "默认值"//接收的消息的字面量
  ipAddress: string = "默认值"//通信对方的IP 地址
  portNumber: number = 0//通信对方的端口号
  protocolType: string = "默认值"//通信对方所采用的协议类型
  sizeMsg: number = 0//消息的字节数

  constructor(messageNumber: number,receiveMsg: string,ipAddress: string,portNumber: number,protocolType: string,sizeMsg: number) {
    this.messageNumber = messageNumber
    this.receiveMsg = receiveMsg
    this.ipAddress = ipAddress
    this.portNumber = portNumber
    this.protocolType = protocolType
    this.sizeMsg = sizeMsg
  }
}

客户端页面：TCPSocketClientPage.ets

import { TCPSocketClientUtils } from './TCPSocketClientUtils';
import { InfoObject } from './InfoObject'

@Entry
@Component
struct TCPSocketClientPage {

  @State info: InfoObject = new InfoObject(0,"默认值","默认值",0,"默认值",0)

  tcpSocketClient: TCPSocketClientUtils = new TCPSocketClientUtils(this.info);

  build() {
    Row() {
      Column() {
        Text("此为客户端端模拟器")
          .fontSize(20)
          .fontWeight(FontWeight.Bold)
        Button("启动客户端")
          .fontSize(20)
          .onClick((event) => {
            this.tcpSocketClient.init();
          })
        Button("客户端向服务端发送数据")
          .fontSize(20)
          .onClick((event) => {
            this.tcpSocketClient.sendMsg();
          })
        Column(){
          Text("展示客户端接收的消息内容").fontColor(Color.Green)
          Text(`客户端共计收到${this.info.messageNumber} 条消息`)
          Text(`客户端接受到的NO.${this.info.messageNumber} 消息：${this.info.receiveMsg}`).fontColor(Color.Grey)
          Text(`与客户端通信的对方IP ：${this.info.ipAddress}`).fontColor(Color.Orange)
          Text(`与客户端通信的对方端口号：${this.info.portNumber}`).fontColor(Color.Blue)
          Text(`与客户端通信的对方采用的协议：${this.info.protocolType}`).fontColor(Color.Pink)
        }.margin({top: 36})
      }
      .width('100%')
    }
    .height('100%')
  }

  aboutToDisappear() {
    this.tcpSocketClient.closeSocket('界面不可见');
  }
}

客户端工具类：TCPSocketClientUtils.ets

import { socket } from '@kit.NetworkKit';
import { BusinessError } from '@kit.BasicServicesKit';
import hilog from '@ohos.hilog';

import { InfoObject } from "./InfoObject"

const TAG: string = "WAsbry_TCPSocketClient";

class SocketInfo {
  message: ArrayBuffer = new ArrayBuffer(1);
  remoteInfo: socket.SocketRemoteInfo = {} as socket.SocketRemoteInfo;
}

export class TCPSocketClientUtils {

  info: InfoObject

  tcp: socket.TCPSocket;//TCP链接实例

  constructor(info: InfoObject) {
    // 创建一个TCPSocket连接，返回一个TCPSocket对象。
    this.tcp = socket.constructTCPSocketInstance();
    this.info = info
  }

  init() {
    printLog(TAG,"进入客户端绑定环节")
    // 绑定本地IP地址和端口。
    let ipAddress: socket.NetAddress = {} as socket.NetAddress;
    ipAddress.address = "10.0.2.15";//客户端本机IP
    ipAddress.port = 12340;//指定客户端本地端口号
    this.tcp.bind(ipAddress, (err: BusinessError) => {//绑定IP地址和端口号。端口号可以指定，也可以由系统随机分配
      if (err) {
        printLog(TAG, `客户端绑定IP地址和端口号出现异常,err = ${err}`);
        return;
      }
      printLog(TAG, '客户端绑定IP地址和端口号成功');

      // 连接到指定的IP地址和端口。
      ipAddress.address = "10.0.2.2";
      ipAddress.port = 8089;

      let tcpConnect: socket.TCPConnectOptions = {} as socket.TCPConnectOptions;
      tcpConnect.address = ipAddress;
      tcpConnect.timeout = 30000;

      this.tcp.connect(tcpConnect).then(() => {
        printLog(TAG, '客户端建立到指定IP地址和端口号的连接，成功');
        // this.sendMsg();
      }).catch((err: BusinessError) => {
        printLog(TAG, '客户端建立到指定IP地址和端口号的连接，出现异常');
      });
    });

    this.tcp.on('message', (value: SocketInfo) => {
      printLog(TAG,"客户端 TCPSocketConnection成功接收到消息")
      let buffer = value.message;
      let dataView = new DataView(buffer);
      let str = "";
      for (let i = 0; i < dataView.byteLength; ++i) {
        str += String.fromCharCode(dataView.getUint8(i));
      }

      printLog(TAG, "客户端 received message--:" + str);//消息内容
      printLog(TAG, "客户端 received address--:" + value.remoteInfo.address);//绑定的IP地址。
      printLog(TAG, "客户端 received family--:" + value.remoteInfo.family);//网络协议类型。选项包括:IPv4、IPv6。
      printLog(TAG, "客户端 received port--:" + value.remoteInfo.port);//端口号。取值范围是0 ~ 65535。
      printLog(TAG, "客户端 received size--:" + value.remoteInfo.size);//服务器响应消息的长度，以字节为单位。

      this.info.messageNumber++
      this.info.receiveMsg = str
      this.info.ipAddress = value.remoteInfo.address
      this.info.protocolType = value.remoteInfo.family
      this.info.portNumber = value.remoteInfo.port
      this.info.sizeMsg = value.remoteInfo.size
    });
    this.tcp.on('connect', () => {
      printLog(TAG, "客户端TCPSocket连接建立");
    });
    this.tcp.on('close', () => {
      printLog(TAG, "客户端TCPSocket连接关闭");
    });

  }

  sendMsg(){
    let tcpSendOptions: socket.TCPSendOptions = {
      data: 'this data is from client'
    }
    this.tcp.send(tcpSendOptions).then(() => {
      printLog(TAG, '客户端向服务端发送数据成功');
    }).catch((err: BusinessError) => {
      printLog(TAG, '客户端向服务端发送数据失败');
    });
  }

  closeSocket(reason: string) {
    this.tcp.close().then(() => {
      printLog(TAG, reason + ' 客户端到服务端的链接关闭，成功');
    }).catch((err: BusinessError) => {
      printLog(TAG, reason + ' 客户端到服务端的链接关闭，出现异常');
    });
    this.tcp.off('message');
    this.tcp.off('connect');
    this.tcp.off('close');
  }
}

function printLog(tag: string,info: string){
  hilog.info(0xff00,tag,info)
}

服务端页面：TCPSocketServerPage.ets

import { InfoObject } from './InfoObject';
import { TCPSocketServerUtils } from './TCPSocketServerUtils';

@Entry
@Component
struct TCPSocketServerPage {

  @State info: InfoObject = new InfoObject(0,"默认值","默认值",0,"默认值",0)

  tcpSocketServer: TCPSocketServerUtils = new TCPSocketServerUtils(this.info);//创建tcp 服务端工具类对象

  build() {
    Row() {
      Column() {
        Text("此为服务端模拟器")
          .fontSize(20)
        Button('启动服务端')
          .fontSize(20)
          .onClick((event) =>{
            this.tcpSocketServer.init();
          })
        Button('服务端向客户端发送数据')
          .fontSize(20)
          .onClick((event) =>{
            this.tcpSocketServer.sendMsg();
          })
        Column(){
          Text("展示服务端接收的消息内容").fontColor(Color.Green)
          Text(`服务端共计收到${this.info.messageNumber} 条消息`)
          Text(`服务端接受到的NO.${this.info.messageNumber} 消息：${this.info.receiveMsg}`).fontColor(Color.Grey)
          Text(`与服务端通信的对方IP ：${this.info.ipAddress}`).fontColor(Color.Orange)
          Text(`与服务端通信的对方端口号：${this.info.portNumber}`).fontColor(Color.Blue)
          Text(`与服务端通信的对方采用的协议：${this.info.protocolType}`).fontColor(Color.Pink)
        }.margin({top: 36})
      }
      .width('100%')
    }
    .height('100%')
  }

  aboutToDisappear() {
    this.tcpSocketServer.closeClient();
    this.tcpSocketServer.cancelEventSub();
  }

}

服务端工具类：TCPSocketServerUtils.ets

import { socket } from '@kit.NetworkKit';
import { BusinessError } from '@kit.BasicServicesKit';
import hilog from '@ohos.hilog';
import { InfoObject } from './InfoObject';

const TAG: string = "WAsbry_TCPSocketServer";

class SocketInfo {
  message: ArrayBuffer = new ArrayBuffer(1);
  remoteInfo: socket.SocketRemoteInfo = {} as socket.SocketRemoteInfo;
}

export class TCPSocketServerUtils {
  info: InfoObject//传参对象
  tcpServer:socket.TCPSocketServer;//TCP链接服务端实例
  clientRef?: socket.TCPSocketConnection;//TCP链接对象

  constructor(info: InfoObject) {
    // 创建一个TCPSocketServer连接，返回一个TCPSocketServer对象。
    this.tcpServer = socket.constructTCPSocketServerInstance();
    this.info = info
  }

  init() {
    let ipAddress: socket.NetAddress = {} as socket.NetAddress;
    ipAddress.address = "127.0.0.1";//服务端本机IP
    ipAddress.port = 8088;//服务端本地端口号

    // 绑定本地IP地址和端口，进行监听
    this.tcpServer.listen(ipAddress).then(() => {
      printLog(TAG, "服务端监听本地IP地址和端口成功");
    }).catch((err: BusinessError) => {
      printLog(TAG, '服务端监听本地IP地址和端口失败');
    });
    // 订阅TCPSocketServer的connect事件
    this.tcpServer.on("connect", (client: socket.TCPSocketConnection) => {
      this.clientRef = client;
      // 订阅TCPSocketConnection相关的事件
      client.on("close", () => {
        printLog(TAG, "TCPSocketConnection关闭");
      });
      client.on("message", (value: SocketInfo) => {
        printLog(TAG,"服务端TCPSocketConnection成功接收到消息")
        let buffer = value.message;
        let dataView = new DataView(buffer);
        let str = "";
        for (let i = 0; i < dataView.byteLength; ++i) {
          str += String.fromCharCode(dataView.getUint8(i));
        }
        printLog(TAG, "服务端 received message--:" + str);//消息内容
        printLog(TAG, "服务端 received address--:" + value.remoteInfo.address);//绑定的IP地址。
        printLog(TAG, "服务端 received family--:" + value.remoteInfo.family);//网络协议类型。选项包括:IPv4、IPv6。
        printLog(TAG, "服务端 received port--:" + value.remoteInfo.port);//端口号。取值范围是0 ~ 65535。
        printLog(TAG, "服务端 received size--:" + value.remoteInfo.size);//服务器响应消息的长度，以字节为单位。

        this.info.messageNumber++
        this.info.receiveMsg = str
        this.info.ipAddress = value.remoteInfo.address
        this.info.protocolType = value.remoteInfo.family
        this.info.portNumber = value.remoteInfo.port
        this.info.sizeMsg = value.remoteInfo.size
      });
    });

  }

  // 向客户端发送数据
  sendMsg() {
    let tcpSendOptions: socket.TCPSendOptions = {} as socket.TCPSendOptions;
    tcpSendOptions.data = 'this data is from server';
    this.clientRef?.send(tcpSendOptions).then(() => {
      printLog(TAG, '服务端向客户端发送数据成功');
    }).catch((err: Object) => {
      printLog(TAG,`服务端向客户端发送数据失败，info = ${JSON.stringify(err)}`);
    });
  }

  // 关闭与客户端的连接
  closeClient(){
    this.clientRef?.close().then(() => {
      printLog(TAG, '服务端主动关闭与客户端的链接，成功');
    }).catch((err: BusinessError) => {
      printLog(TAG, '服务端主动关闭与客户端的链接，失败');
    });
  }

  cancelEventSub(){
    // 取消TCPSocketConnection相关的事件订阅
    setTimeout(() => {
      this.clientRef?.off("message");
      this.clientRef?.off("close");
    }, 1 * 1000);

    // 取消TCPSocketServer相关的事件订阅
    setTimeout(() => {
      this.tcpServer.off("connect");
    }, 2 * 1000);
  }
}

function printLog(tag: string,info: string){
  hilog.info(0xff00,tag,info)
}

在最后

如果你觉得这篇内容对你还蛮有帮助，我想邀请你帮我三个小忙：
点赞，转发，有你们的『点赞和评论』，才是我创造的动力。
关注小编，同时可以期待后续文章ing🚀，不定期分享原创知识。
上面更多鸿蒙最新技术知识点，请前往作者博客：https://gitee.com/li-shizhen-skin/zhihu/blob/master/README.md

鸿蒙5.0开发【两模拟器实现网络通信】

本文概述

核心步骤

代码运行步骤

完整代码

在最后

悦读