# SeanNetworkLib

**Repository Path**: ldr123/sean-network-lib

## Basic Information

- **Project Name**: SeanNetworkLib
- **Description**: No description available
- **Primary Language**: C++
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-03-15
- **Last Updated**: 2025-03-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# SeanNetwork - 跨平台网络通信框架

SeanNetwork是一个基于ASIO和KCP的跨平台网络通信框架，支持双通道通信策略，提供高可靠性和高效率的网络传输解决方案。

## 特性

- **双通道传输策略**
  - 主通道使用KCP协议，次通道使用TCP保底
  - 双通道并行监听，按到达顺序处理数据
  - 智能通道切换：当KCP连续丢包超过3次或延迟>500ms时自动切换TCP
  - 通道切换保持原有连接状态

- **二进制消息系统**
  - 高效的二进制消息结构
  - 独立的序列化/反序列化模块
  - 消息池管理
  - 多级消息优先级（0-3级）

- **可靠性机制**
  - 可配置的消息存活时间
  - TCP重传间隔指数退避
  - KCP快速重传模式
  - 双通道独立ACK机制

- **并发控制**
  - IO线程与业务线程分离
  - 使用asio::strand保证线程安全
  - 支持动态工作线程池

- **跨平台兼容**
  - 支持Windows/Linux/Android/iOS
  - 使用C++11标准
  - 无需依赖Boost库

## 项目结构

```
.
├── SeanNetworkLib/         # 核心网络库
│   ├── SeanNetwork.h       # 主头文件，包含所有接口
│   ├── NetworkMessage.h/cpp # 消息定义与实现
│   ├── Serializer.h/cpp    # 序列化/反序列化工具
│   ├── MessagePool.h/cpp   # 消息池实现
│   ├── TimerManager.h/cpp  # 定时器管理
│   ├── INetworkChannel.h   # 通道接口定义
│   ├── TcpChannel.h/cpp    # TCP通道实现
│   ├── KcpChannel.h/cpp    # KCP通道实现
│   ├── NetworkManager.h/cpp # 核心网络管理器
│   ├── NetworkClient.h/cpp # 客户端实现
│   ├── NetworkServer.h/cpp # 服务器实现
│   └── thirdpart/          # 第三方库
│       ├── asio/           # ASIO库
│       └── kcp/            # KCP库
├── ClientTest/             # 客户端测试项目
│   └── client_example.cpp  # 客户端示例代码
├── ServerTest/             # 服务器测试项目
│   └── server_example.cpp  # 服务器示例代码
├── CMakeLists.txt          # CMake构建配置
└── SeanNetwork.sln         # Visual Studio解决方案文件
```

## 特别鸣谢

SeanNetwork库基于以下开源项目：
- [asio](https://think-async.com/Asio/) - 跨平台网络库
- [kcp](https://github.com/skywind3000/kcp) - KCP协议实现

## 快速入门

### 安装

#### 方法一：使用CMake

```bash
git clone https://github.com/username/seannetwork.git
cd seannetwork
mkdir build && cd build
cmake ..
make
make install
```

#### 方法二：使用Visual Studio

```
1. 打开SeanNetwork.sln解决方案文件
2. 选择构建配置（Debug/Release和x86/x64）
3. 右键点击解决方案并选择"生成解决方案"
4. 编译后的库文件将位于bin目录下
```

#### 方法三：直接集成到项目

将`SeanNetworkLib`目录复制到你的项目中，并在你的CMake项目中添加：

```cmake
add_subdirectory(SeanNetworkLib)
target_link_libraries(your_target PRIVATE SeanNetwork)
```

或者在Visual Studio项目中，添加对SeanNetworkLib项目的引用。

### 服务器示例

```cpp
#include "SeanNetwork.h"
#include <iostream>

using namespace SeanNetwork;

class ServerApp {
public:
    bool Initialize() {
        // 创建服务器
        m_Server = std::make_unique<NetworkServer>();
        
        // 配置服务器
        ServerConfig config;
        config.TcpPort = 9000;
        config.KcpPort = 9001;
        config.WorkerThreadCount = 2;
        
        // 初始化
        if (!m_Server->Initialize(config)) {
            std::cerr << "Failed to initialize server" << std::endl;
            return false;
        }
        
        // 注册消息处理回调
        m_Server->RegisterMessageHandler(1, [this](ClientSessionId clientId, std::shared_ptr<NetworkMessage> message) {
            HandleMessage(clientId, message);
        });
        
        // 注册会话状态回调
        m_Server->SetSessionCallback([this](ClientSessionId clientId, ConnectionState state, const std::string& reason) {
            HandleSessionState(clientId, state, reason);
        });
        
        return true;
    }
    
    bool Start() {
        return m_Server->Start();
    }
    
    void Stop() {
        if (m_Server) {
            m_Server->Stop();
        }
    }
    
private:
    void HandleMessage(ClientSessionId clientId, std::shared_ptr<NetworkMessage> message) {
        // 处理接收到的消息
        std::string text(reinterpret_cast<const char*>(message->GetBody()), message->GetBodySize());
        std::cout << "Received from client " << clientId << ": " << text << std::endl;
        
        // 创建回复消息
        auto reply = m_Server->CreateMessage(1);
        std::string replyText = "Server received: " + text;
        reply->SetBody(reinterpret_cast<const uint8_t*>(replyText.data()), replyText.size());
        
        // 发送回复
        m_Server->SendMsg(clientId, reply);
    }
    
    void HandleSessionState(ClientSessionId clientId, ConnectionState state, const std::string& reason) {
        std::cout << "Client " << clientId << " state: " << static_cast<int>(state) << " (" << reason << ")" << std::endl;
    }
    
    std::unique_ptr<NetworkServer> m_Server;
};

int main() {
    ServerApp app;
    
    if (!app.Initialize()) {
        return 1;
    }
    
    if (!app.Start()) {
        std::cerr << "Failed to start server" << std::endl;
        return 1;
    }
    
    std::cout << "Server started, press Enter to exit..." << std::endl;
    std::cin.get();
    
    app.Stop();
    return 0;
}
```

### 客户端示例

```cpp
#include "SeanNetwork.h"
#include <iostream>
#include <thread>

using namespace SeanNetwork;

class ClientApp {
public:
    bool Initialize() {
        // 创建客户端
        m_Client = std::make_unique<NetworkClient>();
        
        // 配置客户端
        NetworkConfig config;
        config.WorkerThreadCount = 1;
        
        // 初始化
        if (!m_Client->Initialize(config)) {
            std::cerr << "Failed to initialize client" << std::endl;
            return false;
        }
        
        // 注册消息处理回调
        m_Client->RegisterMessageHandler(1, [this](std::shared_ptr<NetworkMessage> message) {
            HandleMessage(message);
        });
        
        // 注册连接状态回调
        m_Client->SetConnectionCallback([this](ConnectionState state, const std::string& reason) {
            HandleConnectionState(state, reason);
        });
        
        return true;
    }
    
    bool Connect(const std::string& host, uint16_t port) {
        return m_Client->Connect(host, port);
    }
    
    void Disconnect() {
        if (m_Client) {
            m_Client->Disconnect();
        }
    }
    
    bool SendMessage(const std::string& text) {
        if (!m_Client || m_Client->GetConnectionState() != ConnectionState::Connected) {
            return false;
        }
        
        auto message = m_Client->CreateMessage(1);
        message->SetBody(reinterpret_cast<const uint8_t*>(text.data()), text.size());
        
        return m_Client->SendMsg(message);
    }
    
private:
    void HandleMessage(std::shared_ptr<NetworkMessage> message) {
        // 处理接收到的消息
        std::string text(reinterpret_cast<const char*>(message->GetBody()), message->GetBodySize());
        std::cout << "Received: " << text << std::endl;
    }
    
    void HandleConnectionState(ConnectionState state, const std::string& reason) {
        std::cout << "Connection state: " << static_cast<int>(state) << " (" << reason << ")" << std::endl;
    }
    
    std::unique_ptr<NetworkClient> m_Client;
};

int main() {
    ClientApp app;
    
    if (!app.Initialize()) {
        return 1;
    }
    
    if (!app.Connect("localhost", 9000)) {
        std::cerr << "Failed to connect to server" << std::endl;
        return 1;
    }
    
    // 等待连接建立
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    // 发送消息
    app.SendMessage("Hello, server!");
    
    std::cout << "Message sent, press Enter to exit..." << std::endl;
    std::cin.get();
    
    app.Disconnect();
    return 0;
}
```

## 常见问题

### 如何启用日志输出？

可以在NetworkConfig中设置日志级别：

```cpp
NetworkConfig config;
config.LogLevel = LogLevel::Debug;  // 设置为Debug级别以查看详细日志
```

### 如何处理网络事件？

网络事件通过回调函数处理，常见的回调包括：

1. 消息处理回调 - 处理接收到的消息
2. 连接状态回调 - 处理连接状态变化
3. 错误处理回调 - 处理各种错误情况

示例可参考上面的客户端和服务器示例代码。

### 如何优化性能？

1. 调整KCP参数以平衡延迟和带宽
   ```cpp
   NetworkConfig config;
   config.KcpNodelay = 1;        // 1启用快速模式
   config.KcpInterval = 10;      // 内部更新时钟间隔（毫秒）
   config.KcpFastResend = 2;     // 触发快速重传的丢包阈值
   ```

2. 合理设置工作线程数
   ```cpp
   NetworkConfig config;
   config.WorkerThreadCount = std::thread::hardware_concurrency();  // 使用硬件支持的线程数
   ```

3. 使用消息优先级
   ```cpp
   auto highPriorityMsg = client.CreateMessage(msgId, MessagePriority::High);
   ```

## 许可证

SeanNetwork使用MIT许可证，详情见[LICENSE](LICENSE)文件。