# jtttool

**Repository Path**: lorne19/jtttool

## Basic Information

- **Project Name**: jtttool
- **Description**: jtt仓库
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-01-26
- **Last Updated**: 2026-01-26

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Server类 - WebSocket和TCP服务器支持

这个项目提供了一个增强的 `Server` 类，支持同时运行 WebSocket 和 TCP 服务器。

## 功能特性

- ✅ 支持 WebSocket 服务器 (使用 `websockets.serve`)
- ✅ 支持 TCP 服务器
- ✅ 异步消息处理
- ✅ 自定义消息处理器
- ✅ 错误处理和恢复
- ✅ 多服务器并发运行
- ✅ 连接状态管理
- ✅ 优雅关闭

## 安装依赖

```bash
pip install -r requirements.txt
```

## 快速开始

### 1. 创建WebSocket服务器

```python
from models.server import Server
import asyncio

async def message_handler(websocket, message):
    print(f"收到消息: {message}")
    await websocket.send(f"服务器回复: {message}")

# 创建WebSocket服务器
server = Server(
    id=1,
    name="我的WebSocket服务器",
    ip="localhost",
    port=8765,
    protocol="websocket"
)

# 添加消息处理器
server.add_message_handler("default", message_handler)

# 启动服务器
await server.start_websocket_server()
```

### 2. 创建TCP服务器

```python
from models.server import Server

def message_handler(client_socket, message):
    print(f"收到消息: {message}")
    response = f"服务器回复: {message}"
    client_socket.send(response.encode('utf-8'))

# 创建TCP服务器
server = Server(
    id=2,
    name="我的TCP服务器",
    ip="localhost",
    port=8888,
    protocol="tcp"
)

# 添加消息处理器
server.add_message_handler("default", message_handler)

# 启动服务器
server.start_tcp_server()

# 保持服务器运行
import time
while server.is_running:
    time.sleep(1)
```

### 3. 同时运行多个服务器

```python
from models.server import Server, ServerType
import asyncio

# 创建多个服务器
servers = [
    Server(1, "WebSocket服务器", "localhost", 8765, "websocket"),
    Server(2, "TCP服务器", "localhost", 8888, "tcp")
]

# 为每个服务器添加处理器
for server in servers:
    if server.server_type == ServerType.WEBSOCKET:
        server.add_message_handler("default", websocket_handler)
    else:
        server.add_message_handler("default", tcp_handler)

# 启动所有服务器
tasks = []
for server in servers:
    if server.server_type == ServerType.WEBSOCKET:
        task = asyncio.create_task(server.start_websocket_server())
        tasks.append(task)
    else:
        server.start_tcp_server()

# 等待所有WebSocket服务器
await asyncio.gather(*tasks)
```

## 运行示例

### 启动服务器

```bash
# WebSocket服务器
python examples/server_usage.py websocket

# TCP服务器
python examples/server_usage.py tcp

# 多服务器
python examples/server_usage.py multiple
```

### 测试客户端

```bash
# WebSocket客户端
python examples/test_client.py websocket

# TCP客户端
python examples/test_client.py tcp

# 多连接测试
python examples/test_client.py multiple
```

## API 参考

### Server 类

#### 构造函数

```python
Server(id: int, name: str, ip: str, port: int, protocol: str, status: str = "offline")
```

#### 主要方法

- `start_websocket_server(message_handler=None)` - 启动WebSocket服务器
- `start_tcp_server(message_handler=None)` - 启动TCP服务器
- `stop_server()` - 停止服务器
- `add_message_handler(handler_name: str, handler: Callable)` - 添加消息处理器
- `add_error_handler(handler_name: str, handler: Callable)` - 添加错误处理器
- `send_message(message: str) -> bool` - 发送消息到客户端
- `get_connection_info() -> Dict[str, Any]` - 获取连接信息

#### 属性

- `server_type` - 服务器类型 (ServerType.WEBSOCKET 或 ServerType.TCP)
- `status` - 服务器状态 (offline, online, connecting, error)
- `is_running` - 服务器是否正在运行
- `connection` - 当前连接对象

### 枚举类型

#### ServerType

```python
class ServerType(Enum):
    WEBSOCKET = "websocket"
    TCP = "tcp"
```

#### ServerStatus

```python
class ServerStatus(Enum):
    OFFLINE = "offline"
    ONLINE = "online"
    CONNECTING = "connecting"
    ERROR = "error"
```

## 消息处理器

### WebSocket消息处理器

```python
async def websocket_handler(websocket, message):
    # 处理接收到的消息
    print(f"收到WebSocket消息: {message}")
    
    # 发送响应
    await websocket.send("响应消息")
```

### TCP消息处理器

```python
def tcp_handler(client_socket, message):
    # 处理接收到的消息
    print(f"收到TCP消息: {message}")
    
    # 发送响应
    response = "响应消息"
    client_socket.send(response.encode('utf-8'))
```

## 错误处理

```python
async def websocket_error_handler(websocket, error):
    print(f"WebSocket错误: {error}")

def tcp_error_handler(client_socket, error):
    print(f"TCP错误: {error}")

# 添加错误处理器
server.add_error_handler("error", websocket_error_handler)
```

## 注意事项

1. **端口冲突**: 确保使用的端口没有被其他程序占用
2. **防火墙设置**: 如果要从外部访问，请确保防火墙允许相应端口
3. **异步处理**: WebSocket服务器使用异步处理，TCP服务器使用线程处理
4. **资源清理**: 使用 `stop_server()` 方法优雅地停止服务器
5. **错误恢复**: 服务器会自动处理连接错误并尝试恢复

## ServersManager 类

`ServersManager` 类提供了对多个服务器的统一管理功能。

### 主要功能

- **服务器管理**: 添加、移除、查找服务器
- **生命周期管理**: 启动、停止、重启服务器
- **状态监控**: 实时监控服务器状态
- **消息处理**: 统一的消息处理器管理
- **批量操作**: 批量启动、停止、重启服务器
- **资源管理**: 自动清理和资源管理

### 使用示例

```python
from services.servers_manager import ServersManager
from models.server import Server

# 创建管理器
manager = ServersManager()

# 添加服务器
ws_server = Server(1, "WebSocket服务器", "localhost", 8765, "websocket")
tcp_server = Server(2, "TCP服务器", "localhost", 8888, "tcp")

manager.add_server(ws_server)
manager.add_server(tcp_server)

# 启动所有服务器
await manager.start_all_servers()

# 获取服务器状态
status = manager.get_server_status(1)

# 停止所有服务器
manager.stop_all_servers()
```

### 主要方法

- `add_server(server)` - 添加服务器
- `remove_server(server)` - 移除服务器
- `start_server(server_id)` - 启动指定服务器
- `stop_server(server_id)` - 停止指定服务器
- `start_all_servers()` - 启动所有服务器
- `stop_all_servers()` - 停止所有服务器
- `get_server_status(server_id)` - 获取服务器状态
- `broadcast_message(message)` - 广播消息
- `get_server_count()` - 获取服务器统计信息

## 许可证

MIT License