我要评论前言
本篇博客将从零实现一个鸿蒙 arkts tcp 客户端与java 多线程 tcp 服务器的双向聊天功能，涵盖【绑定端口→建立连接→持续收发→资源释放】全流程，代码可直接运行，适配鸿蒙 5.0 + 与 java 8 + 环境。
1.整体通信架构
鸿蒙客户端（arkts）
绑定本地端口 → 连接java服务端 → 发送消息（带换行符做边界）
java服务端（java）
监听端口（serversocket）→ 线程池分配工作线程 → 读取客户端消息（按行解析） → 控制台输入回发消息 → 客户端接收并展示
2.鸿蒙 arkts tcp 客户端实现
2.1 完整代码
import { socket } from "@kit.networkkit"
import { businesserror } from "@kit.basicserviceskit"
// 导入鸿蒙工具库，这里主要用其编解码能力（textdecoder）
import util from "@ohos.util"
// 构建tcp套接字实例，这是整个tcp通信的核心对象，所有tcp操作都基于该实例
let tcpsocket: socket.tcpsocket = socket.constructtcpsocketinstance()
@entry
@component
struct index {
// 本地绑定的端口号，默认9990
@state localport: number = 9990
// 消息历史记录，拼接所有收发消息
@state msghistory: string = ""
scroller: scroller = new scroller()
// 远程tcp服务器的ip地址，默认局域网ip
@state serverip: string = "192.168.247.1"
// 远程tcp服务器的端口号
@state serverport: number = 9980
// 控制“连接服务器”按钮的可用状态：绑定本地端口成功后才启用
@state visibleflag: boolean = false
// 控制“发送消息”按钮的可用状态：连接服务器成功后才启用
@state sendflag: boolean = false
// 输入框中待发送的消息内容
@state sendmsg: string = ""
// 绑定本地ip和端口
async bindport() {
// 定义本地地址对象：address为0.0.0.0表示绑定本机“所有网卡”的该端口
let localaddress: socket.netaddress = { address: "0.0.0.0", port: this.localport }
await tcpsocket.bind(localaddress).then(() => {
this.msghistory = '绑定服务成功' + "\r\n"
this.visibleflag = true
}).catch((e: businesserror) => {
this.msghistory = "绑定服务失败" + "\r\n"
})
// 注册tcp的message事件监听：服务器发送消息时，触发该回调
tcpsocket.on("message", async (value) => {
console.log("鸿蒙接受到服务器传递的消息")
// value.message是服务器发送的“二进制缓冲区”，鸿蒙的tcpsocket接收的消息是arraybuffer类型，必须通过util.textdecoder解码为字符串才能展示
let buffer = value.message
// 创建utf-8解码器（鸿蒙标准编解码api）
let textdecoder = util.textdecoder.create("utf-8")
// 将二进制缓冲区转为uint8array，再解码为utf-8字符串
let str = textdecoder.decodetostring(new uint8array(buffer))
// 拼接消息历史：服务器消息+时间戳+换行，实现日志式展示
this.msghistory +="服务器发送的消息为:["+this.getcurrenttimestring()+"]:"+str+"\r\n"
// 滚动器自动滚到底部，显示最新的服务器消息
this.scroller.scrolledge(edge.bottom)
})
}
// 连接远程 tcp 服务器
async connserver() {
// 封装服务器地址对象：由ui输入框的serverip/serverport赋值
let serveraddress: socket.netaddress = { address: this.serverip, port: this.serverport }
// 异步连接服务器：tcp的三次握手过程，io操作需异步处理
await tcpsocket.connect({ address: serveraddress }).then(() => {
this.msghistory = "连接服务器成功" + "\r\n"
this.sendflag = true
}).catch(() => {
this.msghistory = "连接服务器失败" + "\r\n"
})
}
// 补零工具函数
padzero = (n: number) => n < 10 ? "0" + n : n
// 获取当前时间戳
getcurrenttimestring(): string {
let time = ""
let date = new date()
// time = date.gethours().tostring() + ":" + date.getminutes().tostring() + ":" + date.getseconds().tostring()
// 加上补零处理后的时间戳
time = this.padzero(date.gethours()) + ":" + this.padzero(date.getminutes()) + ":" + this.padzero(date.getseconds())
return time
}
// 向服务器发送消息
sendmessageserver() {
// tcp是面向字节流的协议，没有“消息边界”，服务器无法区分连续发送的多条消息，因此添加换行符作为消息分隔符，是 tcp 字节流通信的通用解决方案。
tcpsocket.send({ data: this.sendmsg + "\r\n" })
.then(() => {
this.msghistory += "我:[" + this.getcurrenttimestring() + "]:" + this.sendmsg + "\r\n"
}).catch(() => {
this.msghistory += "我:发送失败" + "\r\n"
})
}
build() {
column({ space: 20 }) {
text("鸿蒙套接字通信示例").width("100%").textalign(textalign.center).fontweight(fontweight.bold)
// 本地端口绑定区
flex({ direction: flexdirection.row, justifycontent: flexalign.start, alignitems: itemalign.center }) {
text("本地ip和端口:").width("30%").fontsize(12)
// 数字类型输入框，绑定localport，输入变化时更新变量
textinput({ text: this.localport.tostring() }).type(inputtype.number).width("40%").onchange((value) => {
this.localport = number(value)
console.log("输入本地的端口为:" + this.localport)
})
button("绑定ip和端口").onclick(() => {
this.bindport()
}).width("30%").fontsize(12)
}
// 服务器连接区
flex({ direction: flexdirection.row, justifycontent: flexalign.start, alignitems: itemalign.center }) {
text("服务器地址：").width("20%").fontsize(12)
textinput({ text: this.serverip }).width("25%").onchange((value) => {
this.serverip = value
console.log("输入服务器ip地址为:" + this.serverip)
})
textinput({ text: this.serverport.tostring() }).width("25%").onchange((value) => {
this.serverport = number(value)
console.log("输入服务器port为:" + this.serverport)
})
// 连接按钮：仅visibleflag为true时可用，点击触发connserver()
button("连接服务器").enabled(this.visibleflag).width("30%").onclick(() => {
this.connserver()
})
}
// 消息发送区
flex({ direction: flexdirection.row, justifycontent: flexalign.start, alignitems: itemalign.center }) {
textinput({ placeholder: "请输入要发送的消息:" }).onchange((value) => {
this.sendmsg = value
})
// 发送按钮：仅sendflag为true时可用，点击触发sendmessageserver()
button("发送消息").enabled(this.sendflag).width("30%").onclick(() => {
this.sendmessageserver()
})
}
// 消息历史展示区
scroll(this.scroller) {
text(this.msghistory)
.textalign(textalign.start)
.padding(10).width("100%")
}
.align(alignment.top)
.height(300)
.backgroundcolor(0xeeeeee)
.scrollable(scrolldirection.vertical)
.scrollbar(barstate.on)
.scrollbarwidth(20)
}.width("100%").height("100%")
}
}2.2 核心代码解析
（1）tcp 套接字初始化
鸿蒙提供的tcpsocket是核心通信对象，所有 tcp 操作（绑定、连接、收发）都基于该实例。
let tcpsocket: socket.tcpsocket = socket.constructtcpsocketinstance()
（2）绑定本地端口
0.0.0.0表示绑定本机所有网卡，确保局域网内其他设备可连接。绑定成功后启用【连接服务器】按钮。
let localaddress: socket.netaddress = { address: "0.0.0.0", port: this.localport }
await tcpsocket.bind(localaddress)（3）消息监听与解码
服务器消息是二进制arraybuffer，需用textdecoder解码为 utf-8 字符串，自动滚动到底部保证最新消息可见。
tcpsocket.on("message", async (value) => {
let buffer = value.message
let textdecoder = util.textdecoder.create("utf-8")
let str = textdecoder.decodetostring(new uint8array(buffer))
this.msghistory += "服务器发送的消息为:[" + this.getcurrenttimestring() + "]:" + str + "\r\n"
this.scroller.scrolledge(edge.bottom)
})（4）发送消息（带边界）
tcp 是字节流协议，无天然消息边界，添加\r\n作为分隔符，与 java 服务端的readline()完美匹配。
tcpsocket.send({ data: this.sendmsg + "\r\n" })3.java 多线程 tcp 服务器实现
3.1 主服务类server.java
package com.pp.chapter1;
import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstreamreader;
import java.io.printwriter;
import java.net.serversocket;
import java.net.socket;
import java.util.scanner;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
public class server {
// 服务器端的核心套接字对象，用于监听客户端的tcp连接请求
private serversocket serversocket;
// 固定线程池：管理工作线程，避免线程泛滥
private executorservice threadpool;
// 服务器绑定端口（与鸿蒙客户端默认端口一致）
private static final int server_port = 9980;
// 线程池核心线程数
private static final int thread_pool_size = 10;
// 构造方法：初始化服务、启动监听、线程池
public server()
{
try {
// 初始化固定线程池
threadpool = executors.newfixedthreadpool(thread_pool_size);
// 创建serversocket并绑定端口
serversocket = new serversocket(server_port);
// 避免端口被占用
serversocket.setreuseaddress(true);
system.out.println("=== tcp服务器启动成功 ===");
system.out.println("监听端口：" + server_port);
system.out.println("线程池初始化完成，核心线程数：" + thread_pool_size);
// 死循环：持续监听客户端连接
while(true)
{
// 阻塞方法：调用后程序会暂停执行，直到有客户端发起 tcp连接请求并完成三次握手，才会返回socket对象并继续执行
socket socket = serversocket.accept();
// 获取客户端ip+端口并打印
string clientinfo = socket.getinetaddress().gethostaddress() + ":" + socket.getport();
system.out.println("【新客户端连接】" + clientinfo);
// 将通信任务提交到线程池
threadpool.execute(new workthread(socket));
}
} catch (ioexception e) {
system.err.println("=== tcp服务器启动失败 ===");
system.err.println("失败原因：端口" + server_port + "被占用/权限不足，" + e.getmessage());
system.exit(1); // 启动失败直接退出程序
}
}
public static void main(string[] args) {
new server();
}
}
3.2 工作线程类workthread.java
package com.pp.chapter1;
import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstreamreader;
import java.io.outputstreamwriter;
import java.io.printwriter;
import java.net.socket;
import java.util.scanner;
public class workthread implements runnable {
// 与单个客户端通信的socket对象（由server的accept()返回）
private final socket socket;
// 客户端ip+端口（用于日志打印）
private string clientinfo;
// 构造方法：接收客户端socket
public workthread(socket socket) {
this.socket = socket;
this.clientinfo = socket.getinetaddress().gethostaddress() + ":" + socket.getport();
}
@override
public void run() {
// try-with-resources语法：自动关闭所有实现autocloseable的资源
// 一次性创建流，循环复用，避免重复创建；统一指定utf-8编码，解决跨语言乱码
try (
// 客户端消息输入流：字节流→字符流（utf-8）→缓冲流，一次创建持续使用
bufferedreader clientreader = new bufferedreader(
new inputstreamreader(socket.getinputstream(), "utf-8")
);
// 服务器向客户端输出流：字节流→打印流（utf-8+自动刷新），无需手动flush
printwriter serverwriter = new printwriter(
new outputstreamwriter(socket.getoutputstream(), "utf-8"),
true // 自动刷新
);
// 服务器控制台输入流：读取控制台回发消息，utf-8编码
bufferedreader consolereader = new bufferedreader(
new inputstreamreader(system.in, "utf-8")
)
) {
system.out.println("【通信线程启动】" + clientinfo + "，开始监听客户端消息...");
string clientmsg;
// 循环读取客户端消息
// readline()返回null → 客户端主动断开连接（鸿蒙应用关闭/网络断开）
while ((clientmsg = clientreader.readline()) != null) {
// 过滤客户端空消息（避免无效处理）
if (clientmsg.trim().isempty()) {
system.out.println("【空消息忽略】" + clientinfo + "发送了空消息");
continue;
}
// 打印客户端消息：线程名+客户端信息+消息
system.out.printf("[%s] 【客户端消息】%s：%s%n",
thread.currentthread().getname(), clientinfo, clientmsg);
// 服务器控制台输入回发消息
system.out.print("请输入要回发给" + clientinfo + "的消息：");
string servermsg = consolereader.readline();
// 过滤服务器空消息，避免发送空内容给客户端
if (servermsg == null || servermsg.trim().isempty()) {
servermsg = "【服务器】消息不能为空，已忽略";
}
// 发送消息给客户端：printwriter开启自动刷新，直接println即可
serverwriter.println(servermsg);
system.out.printf("[%s] 【服务器回发】%s：%s%n",
thread.currentthread().getname(), clientinfo, servermsg);
}
} catch (ioexception e) {
// 精细化异常日志：区分客户端正常断开/异常断开
if (socket.isclosed() || e.getmessage().contains("connection reset")) {
system.out.println("【客户端断开】" + clientinfo + "（正常/异常断开）");
} else {
system.err.println("【通信异常】" + clientinfo + "，原因：" + e.getmessage());
}
} finally {
// 确保socket关闭（即使try-with-resources出问题）
try {
if (socket != null && !socket.isclosed()) {
socket.close();
}
} catch (ioexception e) {
system.err.println("【socket关闭失败】" + clientinfo + "，原因：" + e.getmessage());
}
system.out.println("【通信线程销毁】" + clientinfo + "，释放所有通信资源\n");
}
}
}
3.3 核心代码解析
（1）线程池管理多客户端
固定线程池避免大量客户端连接导致的线程泛滥，保证服务端稳定性，核心线程数可根据业务调整。
threadpool = executors.newfixedthreadpool(thread_pool_size);
（2）try-with-resources自动释放资源
jvm 自动关闭所有实现autocloseable的资源，彻底解决 io 流泄漏问题，关闭顺序与声明顺序逆序（先关输出流，再关输入流）。
try (
bufferedreader clientreader = new bufferedreader(...);
printwriter serverwriter = new printwriter(...);
bufferedreader consolereader = new bufferedreader(...)
) {
// 业务逻辑
}（3）utf-8 编码统一
所有流转换显式指定 utf-8，与鸿蒙客户端编码一致，避免跨语言乱码。
new inputstreamreader(socket.getinputstream(), "utf-8") new outputstreamwriter(socket.getoutputstream(), "utf-8")
（4）循环监听客户端消息
readline()按\r\n分割消息，返回null表示客户端断开连接，自动退出循环并释放资源。
while ((clientmsg = clientreader.readline()) != null) {
// 处理消息
}4.运行效果展示
4.1 鸿蒙客户端界面
- 绑定本地端口（9990）→ 连接服务器（192.168.247.1:9980）
- 输入消息发送，服务端回发
- 消息面板自动滚动，展示带时间戳的收发记录
4.2 java 服务端控制台
- 服务端启动后监听 9980 端口，线程池初始化完成
- 客户端连接后打印 ip + 端口，分配工作线程处理通信
- 接收客户端消息后，控制台输入回发内容，自动发送给客户端
5.核心知识点总结
跨语言通信关键：统一 utf-8 编码 + 换行符做消息边界，保证 arkts 与 java 的字节流解析一致。
tcp 服务端架构：serversocket监听 + 线程池管理 +workthread处理单客户端。
资源管理：java 用try-with-resources自动释放 io 流，鸿蒙用异步 api 避免阻塞主线程。
ui 状态联动：鸿蒙客户端用@state变量控制按钮可用状态，实现【绑定→连接→发送】的流程化交互。
到此这篇关于鸿蒙与java跨平台socket通信实战的文章就介绍到这了,更多相关鸿蒙与java跨平台socket通信内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论