Flutter连接管理插件connectme的使用

ConnectMe 是一个轻量级库，用于在客户端和服务器端处理 WebSocket 或 TCP 连接。它允许你创建连接、管理连接、发送不同数据类型的消息，并且可以与 PackMe 集成实现高效的二进制序列化。

ConnectMe 的功能

• 创建具有不同选项（如 autoReconnect、queryTimeout）的 WebSocket 服务器连接。
• 使用任何 InternetAddress 对象创建 WebSocket 服务器。
• 在服务器端使用默认或自定义 Client 类管理连接。
• 发送不同类型的数据消息：String、Uint8List 或 PackMe 消息。
• 监听任意消息，包括特定客户端的消息。
• 使用 PackMe 消息进行异步查询。
• 广播消息到所有客户端或根据条件指定的一组客户端。

PackMe 集成

PackMe 是一个非常快速的二进制序列化器，提供从简单 JSON 清单文件生成 .dart 类的内置脚本。它提供了一种简便高效的方法将类对象打包为二进制缓冲区，反之亦然。

使用示例

1. 创建 manifest.json 文件

首先，创建一个简单的 manifest.json 文件来描述你的通信协议：

{
    "get_user": [
        {
            "id": "string"
        },
        {
            "first_name": "string",
            "last_name": "string",
            "age": "uint8"
        }
    ]
}

2. 生成 Dart 文件

使用以下命令生成 Dart 文件：

dart run packme <json_manifests_dir> <generated_classes_dir>

例如：

dart run packme packme generated

3. 服务器端代码

下面是一个简单的服务器端示例：

import 'generated/manifest.generated.dart';
import 'package:connectme/connectme.dart';

void main() async {
    final ConnectMeServer server = await ConnectMe.serve(InternetAddress('127.0.0.1'),
        port: 31337,
        onConnect: (ConnectMeClient client) {
            print('${client.headers.host} connected.');
        },
        onDisconnect: (ConnectMeClient client) {
            print('${client.headers.host} disconnected.');
        },
        type: ConnectMeType.ws, // 使用 WebSocket 服务器
    );
    
    // 监听字符串消息并返回反转后的字符串
    server.listen<String>((String message, ConnectMeClient client) {
        client.send(message.split('').reversed.join(''));
    });

    // 注册 PackMe 消息以监听它们
    server.register(manifestMessageFactory);
    
    // 监听 GetUserRequest 消息并回复 GetUserResponse
    server.listen<GetUserRequest>((GetUserRequest request, ConnectMeClient client) {
        final GetUserResponse response = request.$response(
            firstName: 'Alyx',
            lastName: 'Vance',
            age: 19,
        );
        client.send(response);
    });
}

4. 客户端代码

下面是一个简单的客户端示例：

import 'generated/manifest.generated.dart';
import 'package:connectme/connectme.dart';

void main() async {
    final ConnectMeClient client = await ConnectMe.connect('ws://127.0.0.1:31337');
    
    // 注册 PackMe 消息以处理它们
    client.register(manifestMessageFactory);

    // 监听来自服务器的反转字符串消息
    client.listen<String>((String message) {
        print('Here is our reversed string: $message');
    });
    
    // 向服务器发送字符串消息
    client.send('Was it a car or a cat I saw?');
    
    // 查询用户数据
    final GetUserResponse response = await client.query<GetUserResponse>(GetUserRequest(id: 'hl3'));
    print('A person name is ${response.firstName} ${response.lastName} and she is ${response.age} years old.');
}

服务器初始化和选项

你可以使用 ConnectMe.server 或 ConnectMe.serve 方法来初始化服务器。以下是可用选项：

final ConnectMeServer server = await ConnectMe.serve(InternetAddress('127.0.0.1'),
    port: 31337,
    onLog: logMessage,
    onError: logError,
    onConnect: (CustomServerClient client) {
        logMessage('\n[SERVER]: A client from ${client.socket.httpRequest!.headers.host} has connected.');
    },
    onDisconnect: (CustomServerClient client) {
        logMessage('[SERVER]: A client ${client.name} has disconnected.');
        server.close();
    },
    clientFactory: (_) => CustomServerClient(_),
);

客户端初始化和选项

你可以使用 ConnectMe.client 或 ConnectMe.connect 方法来初始化客户端。以下是可用选项：

final ConnectMeClient client = await ConnectMe.connect('ws://127.0.0.1:31337',
    headers: {'custom-header': 'value'},
    autoReconnect: true,
    onLog: logMessage,
    onError: logError,
    onConnect: () {
        print('Connected to the server.');
    },
    onDisconnect: () {
        print('Disconnected from the server.');
    },
);

发送数据

你可以发送不同类型的数据消息：String、Uint8List 和 PackMe 消息。

client.send("Is this what you've been waiting for?");
client.send(Uint8List.fromList([1, 2, 4]));
client.send(GetUserResponse(
    firstName: 'Alyx',
    lastName: 'Vance',
    age: 19,
));

监听消息事件

你可以使用 server.listen<T> 和 client.listen<T> 方法监听特定类型的消息。

void _handleServerStringMessage(String message, ConnectMeClient client) {
    print('Got a message: $message from client ${client.headers.host}');
}

void _handleServerGetUserRequest(GetUserRequest request, ConnectMeClient client) {
    print('A client ${client.headers.host} asked for a user with ID: ${request.id}');
}

void _handleClientGetUserResponse(GetUserResponse response) {
    print('Got a user from server: $response');
}

void main() async {
    server.listen<String>(_handleServerStringMessage);
    server.listen<GetUserRequest>(_handleServerGetUserRequest);
    client.listen<GetUserResponse>(_handleClientGetUserResponse);
}

特定客户端消息监听

有时你需要只为特定客户端添加消息监听器，例如已登录用户。

bool _isAuthorizedToDoSomething(String codePhrase) {
    return codePhrase == "I am Iron Man.";
}

void main() async {
    server.listen<AuthorizeRequest>((AuthorizeRequest request, ConnectMeClient client) {
        if (_isAuthorizedToDoSomething(request.codePhrase)) {
            client.listen<GodModeRequest>(_handleGodModeRequest);
            client.listen<AllWeaponsRequest>(_handleAllWeaponsRequest);
            client.listen<KillEveryoneRequest>(_handleKillEveryoneRequest);
            client.send(request.$response(
                allowed: true,
                reason: 'Welcome on board!',
            ));
        } else {
            client.send(request.$response(
                allowed: false,
                reason: 'You are not Iron Man.',
            ));
            client.close();
        }
    });
}

广播消息

你可以使用 server.broadcast() 方法向所有连接的客户端广播消息。

server.broadcast('Cheese for Everyone!');
server.broadcast('Scratch that! Cheese for no one.', (ConnectMeClient client) {
    return client.headers.host == '127.0.0.1';
});

管理服务器客户端

你可以通过 server.clients 属性访问所有连接的客户端。

List<ConnectMeClient> _clientsToDisconnect = <ConnectMeClient>[];
_clientsToDisconnect.addAll(server.clients.where((ConnectMeClient client) => client.headers.host == '127.0.0.1'));
for (final ConnectMeClient client in _clientsToDisconnect) client.close();