Лучшие практики разработки

Руководство по написанию эффективного и надежного кода на Localzet Server.

Архитектурные паттерны

1. Разделение ответственности

Плохо:

$server->onMessage = function($conn, $req) {
    // Вся логика в одном месте
    $db = new PDO(...);
    $user = $db->query("SELECT * FROM users...");
    $result = processUser($user);
    $conn->send(json_encode($result));
};

Хорошо:

// app/Handlers/UserHandler.php
class UserHandler extends ServerAbstract {
    private UserService $userService;
    
    public function __construct(UserService $userService) {
        $this->userService = $userService;
    }
    
    public function onMessage(ConnectionInterface $connection, mixed $request): void {
        if ($request instanceof Request) {
            $this->handleHttp($connection, $request);
        }
    }
    
    private function handleHttp(TcpConnection $conn, Request $req): void {
        $result = $this->userService->processRequest($req);
        $conn->send($result);
    }
}

// Использование
$handler = new UserHandler(new UserService());
localzet_bind($server, $handler);

2. Dependency Injection

class AppHandler extends ServerAbstract {
    public function __construct(
        private Database $db,
        private Cache $cache,
        private Logger $logger
    ) {}
    
    public function onMessage(ConnectionInterface $conn, mixed $req): void {
        // Использование внедренных зависимостей
    }
}

// Создание с зависимостями
$handler = new AppHandler(
    new Database($config['database']),
    new Cache($config['cache']),
    new Logger($config['logger'])
);
localzet_bind($server, $handler);

3. Обработка ошибок

Централизованная обработка:

class ErrorHandler {
    public static function handle(Throwable $e, TcpConnection $conn): void {
        // Логирование
        Server::log("Error: " . $e->getMessage());
        Server::log($e->getTraceAsString());
        
        // Отправка ошибки клиенту (для разработки)
        if ($_ENV['APP_ENV'] === 'development') {
            $conn->send(new Response(500, [], $e->getMessage()));
        } else {
            $conn->send(new Response(500, [], 'Internal Server Error'));
        }
    }
}

$server->onError = function($conn, $code, $reason) {
    ErrorHandler::handle(new Exception($reason), $conn);
};

Управление ресурсами

1. Подключения к БД

Плохо - создание нового соединения для каждого запроса:

$server->onMessage = function($conn, $req) {
    $db = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
    // Использование...
};

Хорошо - переиспользование соединений:

class DatabaseManager {
    private static ?PDO $connection = null;
    
    public static function getConnection(): PDO {
        if (self::$connection === null) {
            self::$connection = new PDO(
                'mysql:host=localhost;dbname=test',
                $user,
                $pass,
                [
                    PDO::ATTR_PERSISTENT => true,
                    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                ]
            );
        }
        
        // Проверка соединения
        try {
            self::$connection->query('SELECT 1');
        } catch (PDOException $e) {
            self::$connection = null;
            return self::getConnection(); // Переподключение
        }
        
        return self::$connection;
    }
}

$server->onMessage = function($conn, $req) {
    $db = DatabaseManager::getConnection();
    // Использование...
};

2. Кеширование

class CacheManager {
    private static array $cache = [];
    private static array $timestamps = [];
    private const TTL = 300; // 5 минут
    
    public static function get(string $key): mixed {
        if (!isset(self::$cache[$key])) {
            return null;
        }
        
        // Проверка TTL
        if (time() - self::$timestamps[$key] > self::TTL) {
            unset(self::$cache[$key], self::$timestamps[$key]);
            return null;
        }
        
        return self::$cache[$key];
    }
    
    public static function set(string $key, mixed $value): void {
        self::$cache[$key] = $value;
        self::$timestamps[$key] = time();
        
        // Ограничение размера кеша
        if (count(self::$cache) > 1000) {
            // Удаление самых старых записей
            asort(self::$timestamps);
            $oldest = array_keys(self::$timestamps)[0];
            unset(self::$cache[$oldest], self::$timestamps[$oldest]);
        }
    }
}

3. Управление соединениями

// Всегда очищайте соединения при закрытии
$server->onClose = function(TcpConnection $conn) {
    // Очистка таймеров
    if (isset($conn->context->timerId)) {
        Timer::del($conn->context->timerId);
    }
    
    // Очистка из глобальных массивов
    if (isset($globalConnections[$conn->id])) {
        unset($globalConnections[$conn->id]);
    }
    
    // Обнуление ссылок
    $conn->context = null;
};

Безопасность

1. Валидация входных данных

class Validator {
    public static function validateRequest(Request $req): array {
        $errors = [];
        
        // Валидация параметров
        $name = $req->post('name');
        if (empty($name) || strlen($name) > 100) {
            $errors[] = 'Invalid name';
        }
        
        // Валидация email
        $email = $req->post('email');
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $errors[] = 'Invalid email';
        }
        
        // Защита от XSS
        $message = htmlspecialchars($req->post('message'), ENT_QUOTES, 'UTF-8');
        
        return ['errors' => $errors, 'data' => compact('name', 'email', 'message')];
    }
}

$server->onMessage = function($conn, $req) {
    $validation = Validator::validateRequest($req);
    
    if (!empty($validation['errors'])) {
        $conn->send(new Response(400, [], json_encode($validation['errors'])));
        return;
    }
    
    // Обработка валидных данных
};

2. Защита от SQL Injection

// Всегда используйте подготовленные запросы
$stmt = $db->prepare('SELECT * FROM users WHERE id = :id');
$stmt->execute(['id' => $req->get('id')]);
$user = $stmt->fetch();

// НИКОГДА не делайте так:
// $db->query("SELECT * FROM users WHERE id = " . $req->get('id'));

3. Защита сессий

// Генерация безопасного session ID
function generateSessionId(): string {
    return bin2hex(random_bytes(32));
}

// Установка безопасных cookies
$response->cookie('session_id', $sessionId, [
    'httponly' => true,
    'secure' => true,
    'samesite' => 'Strict',
    'max-age' => 3600
]);

Производительность

1. Избегайте блокирующих операций