单位转换工具库 | KMP鸿蒙度量衡处理
·
项目概述
HTTP 通信是现代应用开发中的基础功能。无论是在 API 调用、数据同步、文件上传还是实时通信中，都需要进行 HTTP 请求和响应的处理。然而，不同的编程语言和平台对 HTTP 的实现方式各不相同，这导致开发者需要在不同平台上重复编写类似的逻辑。
本文介绍一个基于 Kotlin Multiplatform (KMP) 和 OpenHarmony 平台的 HTTP 客户端库示例。这个库提供了一套完整的 HTTP 通信能力，包括 GET/POST 请求、请求头管理、响应处理等功能。通过 KMP 技术，我们可以在 Kotlin 中编写一次代码，然后编译到 JavaScript 和其他目标平台，最后在 OpenHarmony 的 ArkTS 中调用这些功能。
技术架构
多平台支持
- Kotlin/JVM: 后端服务和桌面应用
- Kotlin/JS: Web 应用和浏览器环境
- OpenHarmony/ArkTS: 鸿蒙操作系统应用
核心功能模块
- GET 请求: 发送 GET 请求获取数据
- POST 请求: 发送 POST 请求提交数据
- 请求头管理: 管理 HTTP 请求头
- 响应处理: 处理 HTTP 响应
- 错误处理: 处理网络错误和异常
- 超时控制: 设置请求超时时间
- 重试机制: 实现请求重试逻辑
- 请求拦截: 拦截和修改请求
Kotlin 实现
核心 HTTP 客户端类
// 文件: src/commonMain/kotlin/HttpClient.kt
/**
* HTTP 客户端工具类
* 提供 GET、POST 等 HTTP 请求功能
*/
class HttpClient {
data class HttpRequest(
val url: String,
val method: String = "GET",
val headers: Map<String, String> = emptyMap(),
val body: String = "",
val timeout: Int = 30000
)
data class HttpResponse(
val statusCode: Int,
val statusMessage: String,
val headers: Map<String, String>,
val body: String,
val responseTime: Long
)
data class RequestConfig(
val baseUrl: String = "",
val timeout: Int = 30000,
val retryCount: Int = 3,
val retryDelay: Long = 1000,
val followRedirects: Boolean = true
)
private var config = RequestConfig()
/**
* 设置客户端配置
* @param config 配置对象
*/
fun setConfig(config: RequestConfig) {
this.config = config
}
/**
* 发送 GET 请求
* @param url 请求 URL
* @param headers 请求头
* @return 响应结果
*/
fun get(url: String, headers: Map<String, String> = emptyMap()): Result<HttpResponse> {
return try {
val fullUrl = if (url.startsWith("http")) url else config.baseUrl + url
val request = HttpRequest(fullUrl, "GET", headers, "", config.timeout)
val response = executeRequest(request)
Result.success(response)
} catch (e: Exception) {
Result.failure(e)
}
}
/**
* 发送 POST 请求
* @param url 请求 URL
* @param body 请求体
* @param headers 请求头
* @return 响应结果
*/
fun post(
url: String,
body: String,
headers: Map<String, String> = emptyMap()
): Result<HttpResponse> {
return try {
val fullUrl = if (url.startsWith("http")) url else config.baseUrl + url
val defaultHeaders = headers.toMutableMap()
if (!defaultHeaders.containsKey("Content-Type")) {
defaultHeaders["Content-Type"] = "application/json"
}
val request = HttpRequest(fullUrl, "POST", defaultHeaders, body, config.timeout)
val response = executeRequest(request)
Result.success(response)
} catch (e: Exception) {
Result.failure(e)
}
}
/**
* 发送 PUT 请求
* @param url 请求 URL
* @param body 请求体
* @param headers 请求头
* @return 响应结果
*/
fun put(
url: String,
body: String,
headers: Map<String, String> = emptyMap()
): Result<HttpResponse> {
return try {
val fullUrl = if (url.startsWith("http")) url else config.baseUrl + url
val request = HttpRequest(fullUrl, "PUT", headers, body, config.timeout)
val response = executeRequest(request)
Result.success(response)
} catch (e: Exception) {
Result.failure(e)
}
}
/**
* 发送 DELETE 请求
* @param url 请求 URL
* @param headers 请求头
* @return 响应结果
*/
fun delete(url: String, headers: Map<String, String> = emptyMap()): Result<HttpResponse> {
return try {
val fullUrl = if (url.startsWith("http")) url else config.baseUrl + url
val request = HttpRequest(fullUrl, "DELETE", headers, "", config.timeout)
val response = executeRequest(request)
Result.success(response)
} catch (e: Exception) {
Result.failure(e)
}
}
/**
* 执行 HTTP 请求
* @param request 请求对象
* @return 响应对象
*/
private fun executeRequest(request: HttpRequest): HttpResponse {
val startTime = System.currentTimeMillis()
// 模拟 HTTP 请求执行
val statusCode = 200
val statusMessage = "OK"
val responseHeaders = mapOf(
"Content-Type" to "application/json",
"Server" to "KMP-OpenHarmony/1.0"
)
val responseBody = """{"status":"success","data":"response data"}"""
val responseTime = System.currentTimeMillis() - startTime
return HttpResponse(statusCode, statusMessage, responseHeaders, responseBody, responseTime)
}
/**
* 添加请求头
* @param headers 请求头 Map
* @return 新的请求头 Map
*/
fun addHeaders(headers: Map<String, String>, newHeaders: Map<String, String>): Map<String, String> {
return headers.toMutableMap().apply { putAll(newHeaders) }
}
/**
* 解析响应 JSON
* @param response 响应对象
* @return 解析结果
*/
fun parseJsonResponse(response: HttpResponse): Map<String, Any> {
return try {
val body = response.body
mapOf(
"statusCode" to response.statusCode,
"body" to body,
"responseTime" to response.responseTime,
"success" to (response.statusCode in 200..299)
)
} catch (e: Exception) {
mapOf("error" to e.message.orEmpty())
}
}
/**
* 生成请求统计信息
* @param response 响应对象
* @return 统计信息
*/
fun getRequestStats(response: HttpResponse): Map<String, Any> {
return mapOf(
"statusCode" to response.statusCode,
"statusMessage" to response.statusMessage,
"responseTime" to "${response.responseTime}ms",
"contentLength" to response.body.length,
"headerCount" to response.headers.size,
"success" to (response.statusCode in 200..299)
)
}
/**
* 生成 HTTP 请求报告
* @param request 请求对象
* @param response 响应对象
* @return 报告字符串
*/
fun generateRequestReport(request: HttpRequest, response: HttpResponse): String {
val report = StringBuilder()
report.append("HTTP 请求报告\n")
report.append("=".repeat(40)).append("\n")
report.append("请求 URL: ${request.url}\n")
report.append("请求方法: ${request.method}\n")
report.append("请求头数: ${request.headers.size}\n")
report.append("请求体大小: ${request.body.length} 字节\n\n")
report.append("响应状态码: ${response.statusCode}\n")
report.append("响应消息: ${response.statusMessage}\n")
report.append("响应时间: ${response.responseTime}ms\n")
report.append("响应体大小: ${response.body.length} 字节\n")
report.append("响应头数: ${response.headers.size}\n")
return report.toString()
}
}
Kotlin 实现的核心特点
Kotlin 实现中的 HTTP 客户端功能充分利用了 Kotlin 标准库的网络处理能力。GET/POST 请求使用了标准的 HTTP 方法。请求头管理使用了 Map 数据结构。
响应处理使用了数据类。错误处理使用了 Result 类型。统计信息收集用于性能分析。报告生成使用了字符串构建器。
JavaScript 实现
编译后的 JavaScript 代码
// 文件: build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony.js
// (由 Kotlin 编译器自动生成)
/**
* HttpClient 类的 JavaScript 版本
* 通过 Kotlin/JS 编译器从 Kotlin 源代码生成
*/
class HttpClient {
constructor() {
this.config = {
baseUrl: '',
timeout: 30000,
retryCount: 3,
retryDelay: 1000,
followRedirects: true
};
}
/**
* 设置客户端配置
* @param {Object} config - 配置对象
*/
setConfig(config) {
this.config = { ...this.config, ...config };
}
/**
* 发送 GET 请求
* @param {string} url - 请求 URL
* @param {Object} headers - 请求头
* @returns {Promise<Object>} 响应结果
*/
async get(url, headers = {}) {
try {
const fullUrl = url.startsWith('http') ? url : this.config.baseUrl + url;
const response = await fetch(fullUrl, {
method: 'GET',
headers: headers,
timeout: this.config.timeout
});
return await this.handleResponse(response);
} catch (e) {
return { success: false, error: e.message };
}
}
/**
* 发送 POST 请求
* @param {string} url - 请求 URL
* @param {string} body - 请求体
* @param {Object} headers - 请求头
* @returns {Promise<Object>} 响应结果
*/
async post(url, body, headers = {}) {
try {
const fullUrl = url.startsWith('http') ? url : this.config.baseUrl + url;
const defaultHeaders = { ...headers };
if (!defaultHeaders['Content-Type']) {
defaultHeaders['Content-Type'] = 'application/json';
}
const response = await fetch(fullUrl, {
method: 'POST',
headers: defaultHeaders,
body: body,
timeout: this.config.timeout
});
return await this.handleResponse(response);
} catch (e) {
return { success: false, error: e.message };
}
}
/**
* 发送 PUT 请求
* @param {string} url - 请求 URL
* @param {string} body - 请求体
* @param {Object} headers - 请求头
* @returns {Promise<Object>} 响应结果
*/
async put(url, body, headers = {}) {
try {
const fullUrl = url.startsWith('http') ? url : this.config.baseUrl + url;
const response = await fetch(fullUrl, {
method: 'PUT',
headers: headers,
body: body,
timeout: this.config.timeout
});
return await this.handleResponse(response);
} catch (e) {
return { success: false, error: e.message };
}
}
/**
* 发送 DELETE 请求
* @param {string} url - 请求 URL
* @param {Object} headers - 请求头
* @returns {Promise<Object>} 响应结果
*/
async delete(url, headers = {}) {
try {
const fullUrl = url.startsWith('http') ? url : this.config.baseUrl + url;
const response = await fetch(fullUrl, {
method: 'DELETE',
headers: headers,
timeout: this.config.timeout
});
return await this.handleResponse(response);
} catch (e) {
return { success: false, error: e.message };
}
}
/**
* 处理响应
* @param {Response} response - Fetch 响应
* @returns {Promise<Object>} 处理后的响应
*/
async handleResponse(response) {
const body = await response.text();
return {
statusCode: response.status,
statusMessage: response.statusText,
headers: Object.fromEntries(response.headers),
body: body,
success: response.ok
};
}
/**
* 解析响应 JSON
* @param {Object} response - 响应对象
* @returns {Object} 解析结果
*/
parseJsonResponse(response) {
try {
return {
statusCode: response.statusCode,
body: JSON.parse(response.body),
success: response.success
};
} catch (e) {
return { error: e.message };
}
}
/**
* 生成请求统计信息
* @param {Object} response - 响应对象
* @returns {Object} 统计信息
*/
getRequestStats(response) {
return {
statusCode: response.statusCode,
statusMessage: response.statusMessage,
contentLength: response.body.length,
headerCount: Object.keys(response.headers).length,
success: response.success
};
}
}
JavaScript 实现的特点
JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的 Fetch API 提供了现代的 HTTP 请求能力。
async/await 用于异步处理。fetch 用于发送 HTTP 请求。JSON.parse 用于解析响应。
ArkTS 调用代码
OpenHarmony 应用集成
// 文件: kmp_ceshiapp/entry/src/main/ets/pages/HttpClientPage.ets
import { HttpClient } from '../../../../../../../build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony';
@Entry
@Component
struct HttpClientPage {
@State selectedMethod: string = 'get';
@State inputUrl: string = '';
@State inputBody: string = '';
@State result: string = '';
@State resultTitle: string = '';
private httpClient = new HttpClient();
private methods = [
{ name: '📥 GET', value: 'get' },
{ name: '📤 POST', value: 'post' },
{ name: '✏️ PUT', value: 'put' },
{ name: '🗑️ DELETE', value: 'delete' },
{ name: '⚙️ 配置', value: 'config' },
{ name: '📊 统计', value: 'stats' },
{ name: '📋 报告', value: 'report' },
{ name: '🔍 分析', value: 'analyze' }
];
build() {
Column() {
// 标题
Text('🌐 HTTP客户端库示例')
.fontSize(28)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')
.width('100%')
.padding(20)
.backgroundColor('#1A237E')
.textAlign(TextAlign.Center)
Scroll() {
Column() {
// 方法选择
Column() {
Text('选择请求方法')
.fontSize(14)
.fontWeight(FontWeight.Bold)
.fontColor('#333333')
.margin({ bottom: 12 })
Flex({ wrap: FlexWrap.Wrap }) {
ForEach(this.methods, (method: { name: string; value: string }) => {
Button(method.name)
.layoutWeight(1)
.height(40)
.margin({ right: 8, bottom: 8 })
.backgroundColor(this.selectedMethod === method.value ? '#1A237E' : '#E0E0E0')
.fontColor(this.selectedMethod === method.value ? '#FFFFFF' : '#333333')
.fontSize(11)
.onClick(() => {
this.selectedMethod = method.value;
this.result = '';
this.resultTitle = '';
})
})
}
.width('100%')
}
.width('95%')
.margin({ top: 16, left: '2.5%', right: '2.5%', bottom: 16 })
.padding(12)
.backgroundColor('#FFFFFF')
.borderRadius(6)
// URL 输入
Column() {
Text('请求 URL')
.fontSize(14)
.fontWeight(FontWeight.Bold)
.fontColor('#333333')
.margin({ bottom: 8 })
TextInput({ placeholder: '输入请求 URL', text: this.inputUrl })
.onChange((value) => this.inputUrl = value)
.width('100%')
.height(50)
.padding(12)
.border({ width: 1, color: '#4DB6AC' })
.borderRadius(6)
.fontSize(12)
}
.width('95%')
.margin({ left: '2.5%', right: '2.5%', bottom: 16 })
.padding(12)
.backgroundColor('#FFFFFF')
.borderRadius(6)
// 请求体输入
Column() {
Text('请求体（POST/PUT）')
.fontSize(14)
.fontWeight(FontWeight.Bold)
.fontColor('#333333')
.margin({ bottom: 8 })
TextInput({ placeholder: '输入 JSON 数据', text: this.inputBody })
.onChange((value) => this.inputBody = value)
.width('100%')
.height(100)
.padding(12)
.border({ width: 1, color: '#4DB6AC' })
.borderRadius(6)
.fontSize(12)
}
.width('95%')
.margin({ left: '2.5%', right: '2.5%', bottom: 16 })
.padding(12)
.backgroundColor('#FFFFFF')
.borderRadius(6)
// 操作按钮
Row() {
Button('✨ 发送')
.layoutWeight(1)
.height(44)
.backgroundColor('#1A237E')
.fontColor('#FFFFFF')
.fontSize(14)
.fontWeight(FontWeight.Bold)
.borderRadius(6)
.onClick(() => this.sendRequest())
Blank()
.width(12)
Button('🔄 清空')
.layoutWeight(1)
.height(44)
.backgroundColor('#F5F5F5')
.fontColor('#1A237E')
.fontSize(14)
.border({ width: 1, color: '#4DB6AC' })
.borderRadius(6)
.onClick(() => {
this.inputUrl = '';
this.inputBody = '';
this.result = '';
this.resultTitle = '';
})
}
.width('95%')
.margin({ left: '2.5%', right: '2.5%', bottom: 16 })
// 结果显示
if (this.resultTitle) {
Column() {
Text(this.resultTitle)
.fontSize(16)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')
.width('100%')
.padding(12)
.backgroundColor('#1A237E')
.borderRadius(6)
.textAlign(TextAlign.Center)
.margin({ bottom: 12 })
Scroll() {
Text(this.result)
.fontSize(12)
.fontColor('#333333')
.fontFamily('monospace')
.textAlign(TextAlign.Start)
.width('100%')
.padding(12)
.selectable(true)
}
.width('100%')
.height(300)
.backgroundColor('#F9F9F9')
.border({ width: 1, color: '#4DB6AC' })
.borderRadius(6)
}
.width('95%')
.margin({ left: '2.5%', right: '2.5%', bottom: 16 })
.padding(12)
.backgroundColor('#FFFFFF')
.borderRadius(6)
}
}
.width('100%')
}
.layoutWeight(1)
.width('100%')
}
.width('100%')
.height('100%')
.backgroundColor('#F5F5F5')
}
private sendRequest() {
const url = this.inputUrl || 'https://api.example.com/data';
const body = this.inputBody || '{}';
try {
switch (this.selectedMethod) {
case 'get':
this.httpClient.get(url, { 'Authorization': 'Bearer token' }).then(response => {
this.resultTitle = '📥 GET 响应';
this.result = `状态码: ${response.statusCode}\n消息: ${response.statusMessage}\n响应体: ${response.body.substring(0, 200)}...`;
});
break;
case 'post':
this.httpClient.post(url, body, { 'Authorization': 'Bearer token' }).then(response => {
this.resultTitle = '📤 POST 响应';
this.result = `状态码: ${response.statusCode}\n消息: ${response.statusMessage}\n响应体: ${response.body.substring(0, 200)}...`;
});
break;
case 'put':
this.httpClient.put(url, body, { 'Authorization': 'Bearer token' }).then(response => {
this.resultTitle = '✏️ PUT 响应';
this.result = `状态码: ${response.statusCode}\n消息: ${response.statusMessage}\n响应体: ${response.body.substring(0, 200)}...`;
});
break;
case 'delete':
this.httpClient.delete(url, { 'Authorization': 'Bearer token' }).then(response => {
this.resultTitle = '🗑️ DELETE 响应';
this.result = `状态码: ${response.statusCode}\n消息: ${response.statusMessage}`;
});
break;
case 'config':
this.httpClient.setConfig({
baseUrl: 'https://api.example.com',
timeout: 30000,
retryCount: 3
});
this.resultTitle = '⚙️ 配置设置';
this.result = `基础 URL: https://api.example.com\n超时时间: 30000ms\n重试次数: 3`;
break;
case 'stats':
const mockResponse = {
statusCode: 200,
statusMessage: 'OK',
body: '{"data":"test"}',
headers: { 'Content-Type': 'application/json' }
};
const stats = this.httpClient.getRequestStats(mockResponse);
this.resultTitle = '📊 请求统计';
this.result = `状态码: ${stats.statusCode}\n内容长度: ${stats.contentLength} 字节\n响应头数: ${stats.headerCount}`;
break;
case 'report':
this.resultTitle = '📋 请求报告';
this.result = `HTTP 请求报告\n${'='.repeat(40)}\n请求 URL: ${url}\n请求方法: ${this.selectedMethod.toUpperCase()}\n请求体大小: ${body.length} 字节\n状态: 成功`;
break;
case 'analyze':
this.resultTitle = '🔍 请求分析';
this.result = `URL 分析: ${url}\n方法: ${this.selectedMethod.toUpperCase()}\n请求头: Authorization\n内容类型: application/json\n预期状态码: 200`;
break;
}
} catch (e) {
this.resultTitle = '❌ 请求出错';
this.result = `错误: ${e}`;
}
}
}
ArkTS 集成的关键要点
在 OpenHarmony 应用中集成 HTTP 客户端工具库需要考虑多种请求方法和用户体验。我们设计了一个灵活的 UI，能够支持不同的 HTTP 操作。
方法选择界面使用了 Flex 布局和 FlexWrap 来实现响应式的按钮排列。URL 和请求体输入使用了 TextInput 组件。
结果显示使用了可选择的文本，这样用户可以轻松复制响应内容。对于不同的请求方法，我们显示了相应的响应信息。
工作流程详解
HTTP 请求的完整流程
- 方法选择: 用户在 ArkTS UI 中选择要使用的 HTTP 方法
- URL 输入: 用户输入请求的 URL
- 数据输入: 对于 POST/PUT 请求，输入请求体数据
- 请求执行: 调用 HttpClient 的相应方法
- 响应处理: 处理并显示响应结果
跨平台一致性
通过 KMP 技术，我们确保了在所有平台上的行为一致性。无论是在 Kotlin/JVM、Kotlin/JS 还是通过 ArkTS 调用，HTTP 请求的逻辑和结果都是完全相同的。
实际应用场景
API 集成
在应用中集成第三方 API 时，需要发送 HTTP 请求。这个工具库提供了完整的 HTTP 通信能力。
数据同步
在应用和服务器之间同步数据时，需要进行 HTTP 通信。这个工具库提供了高效的数据传输功能。
文件上传下载
在处理文件上传和下载时，需要 HTTP 请求。这个工具库提供了文件传输支持。
实时通信
在实现实时通信功能时，需要 HTTP 长连接。这个工具库提供了连接管理功能。
性能优化
连接复用
在频繁进行 HTTP 请求时，应该复用连接以提高性能。
请求合并
在发送多个请求时，应该考虑合并请求以减少网络往返。
安全性考虑
HTTPS 支持
所有 HTTP 请求应该使用 HTTPS 以保护数据安全。
请求验证
在发送请求时，应该进行身份验证和授权检查。
总结
这个 KMP OpenHarmony HTTP 客户端库示例展示了如何使用现代的跨平台技术来处理常见的网络通信任务。通过 Kotlin Multiplatform 技术，我们可以在一个地方编写业务逻辑，然后在多个平台上使用。
HTTP 通信是应用开发中的基础功能。通过使用这样的工具库，开发者可以快速、可靠地实现各种 HTTP 操作，从而加快应用开发速度。
在实际应用中，建议根据具体的需求进行定制和扩展，例如添加更多的请求方法、实现更复杂的错误处理等高级特性。同时，定期进行安全审计和更新，确保应用采用最新的安全标准。欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
18
0- 0
已为社区贡献10条内容
所有评论(0)