仓颉编程语言入门 -- Socket 编程与HTTP 编程概述

仓颉的 Socket 编程概述

在网络通信的广阔天地中，仓颉的Socket编程如同一座桥梁，连接着不同的计算设备，实现了基于传输层协议的数据传输。无论是追求稳定可靠的TCP，还是偏好轻量级、无连接的UDP，Socket都扮演着不可或缺的角色。

可靠传输：TCP

在TCP的舞台上，客户端与服务端精心编排着一场连接与通信的舞蹈。服务端首先优雅地登台，创建并绑定一个监听特定端口的Socket，然后静待有缘人的连接请求。客户端则怀揣着明确的目标地址与端口，创建Socket并发起连接请求。一旦双方牵手成功，这场舞蹈便正式拉开序幕，数据报文的收发变得如丝般顺滑。

TCP服务端示例：

// 假设我们有一个伪代码环境  
let serverPort = 8080  
  
function startTcpServer() {  
    // 创建并绑定服务端Socket  
    let serverSocket = createTcpServerSocket(serverPort)  
    serverSocket.bind()  
  
    // 等待并接受客户端连接  
    let clientSocket = serverSocket.accept()  
  
    // 读取并处理数据  
    let buffer = allocateBuffer(10)  
    let bytesRead = clientSocket.read(buffer)  
    print("Server received: ", buffer.slice(0, bytesRead))  
  
    // 后续可以继续与客户端通信或关闭连接  
}  
  
// 调用函数启动服务器  
startTcpServer()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

TCP客户端示例：

let serverIp = "127.0.0.1"  
let serverPort = 8080  
  
function connectToTcpServer() {  
    // 创建客户端Socket并连接到服务器  
    let clientSocket = createTcpSocket(serverIp, serverPort)  
    clientSocket.connect()  
  
    // 发送数据  
    let dataToSend = [1, 2, 3]  
    clientSocket.write(dataToSend)  
  
    // 关闭连接（在实际应用中，根据需求决定是否立即关闭）  
    // clientSocket.close()  
}  
  
// 调用函数连接到服务器  
connectToTcpServer()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

不可靠传输：UDP

相比之下，UDP的通信方式则显得更为随性不羁。无需建立连接，数据报文的发送与接收都更加直接且高效，但代价是牺牲了可靠性。在UDP的世界里，服务端与客户端的角色不再那么泾渭分明，每个套接字都是独立的舞者，自由地发送与接收来自四面八方的数据。

UDP服务端示例：

let serverPort = 8080  
  
function startUdpServer() {  
    // 创建并绑定UDP Socket  
    let serverSocket = createUdpSocket(serverPort)  
    serverSocket.bind()  
  
    // 接收数据  
    let buffer = allocateBuffer(3)  
    let (senderAddress, bytesRead) = serverSocket.receiveFrom(buffer)  
    print("Received from ", senderAddress, ": ", buffer.slice(0, bytesRead))  
}  
  
// 异步启动UDP服务器  
asyncStart(startUdpServer)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

UDP客户端示例：

let serverIp = "127.0.0.1"  
let serverPort = 8080  
  
function sendUdpData() {  
    // 创建UDP Socket并绑定（有时可以省略绑定步骤）  
    let clientSocket = createUdpSocket()  
    // 客户端通常不需要显式绑定，除非有特定需求  
    // clientSocket.bind(anyLocalPort)  
  
    // 发送数据到服务器  
    let dataToSend = [1, 2, 3]  
    clientSocket.sendTo(serverIp, serverPort, dataToSend)  
  
    // 无需关闭连接，UDP是无连接的  
}  
  
// 调用函数发送数据  
sendUdpData()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

HTTP 编程

HTTP 协议，作为互联网上的通用语言，通过请求与响应的交互模式，在客户端与服务端之间架起了一座数据传输的桥梁。每当用户通过浏览器或其他客户端软件访问网络资源时，都会发送一个HTTP请求给服务器，而服务器则根据请求的内容返回相应的HTTP响应。这些请求和响应都遵循着固定的格式，包括报文头和报文体，确保了数据传输的准确性和完整性。

在HTTP的请求类型中，GET和POST是最为常用的两种。GET请求主要用于从服务器请求数据，其特点是在请求行中直接包含要访问的资源路径，且请求体中不包含数据（尽管实际上GET请求也可能带有查询字符串，但这通常不被视为请求体的一部分）。而POST请求则用于向服务器提交数据，这些数据被放置在请求体中，并通过一个空行与请求头分隔开。

仓颉框架，作为一款强大的网络开发工具，支持HTTP 1.0、1.1及2.0等多个协议版本，让开发者能够轻松构建高性能的客户端和服务端应用。通过利用仓颉提供的HttpRequestBuilder和HttpResponseBuilder类，开发者可以灵活地构造符合RFC 9110、9112、9113、9218、7541等标准规范的HTTP请求和响应报文。

下面是一个使用仓颉框架进行客户端和服务端编程的示例。在这个示例中，服务端将监听本地8080端口，并注册了一个处理"/hello"路径的请求处理器。当客户端发送GET请求到"/hello"时，服务端将返回"Hello Cangjie!"作为响应体。

服务端代码：

import 'net.http.dart';  
import 'std.time.dart';  
import 'std.sync.dart';  
  
void startServer() {  
    // 1. 初始化并配置Server实例  
    var server = ServerBuilder()  
                    .address("127.0.0.1")  
                    .port(8080)  
                    .build();  
      
    // 2. 注册路由处理函数  
    server.router.addRoute("/hello", (HttpContext httpContext) {  
        httpContext.response.body = "Hello Cangjie!";  
    });  
      
    // 3. 启动服务器监听  
    server.listen();  
}  
  
void main() {  
    spawn(startServer);  
    sleep(Duration.seconds(1));  
    startClient(); // 假设startClient在后续调用，实际中可能需要其他方式触发  
}  
  
// 注意：这里假设了startClient函数已经定义，并且会在服务端启动后适当时间被调用  
// 实际情况下，你可能需要在另一个脚本或程序中启动客户端，或者使用某种形式的同步/异步机制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28