Как создать RESTful API на PHP: полное руководство от основ до практики

/api_project
/src
/Controllers
/Models
/Config
/Middlewares
/Helpers
/public
index.php
/tests
.htaccess
composer.json

{
"name": "your-vendor/api-project",
"description": "RESTful API project",
"require": {
"php": ">=7.4",
"vlucas/phpdotenv": "^5.3",
"firebase/php-jwt": "^5.2"
},
"autoload": {
"psr-4": {
"App\\": "src/"
}
}
}

<?php
require_once __DIR__ . '/../vendor/autoload.php';

// Загрузка переменных окружения
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__ . '/..');
$dotenv->load();

// Настройка обработки ошибок
error_reporting(E_ALL);
ini_set('display_errors', $_ENV['APP_DEBUG'] ? '1' : '0');

// CORS-заголовки для API
header("Access-Control-Allow-Origin: *");
header("Content-Type: application/json; charset=UTF-8");
header("Access-Control-Allow-Methods: OPTIONS,GET,POST,PUT,DELETE");
header("Access-Control-Max-Age: 3600");
header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");

// Определение маршрута
$uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$uri = explode('/', $uri);

// Маршрутизация запроса к соответствующему контроллеру
// ...код маршрутизации

// Формирование и отправка ответа

// Получение HTTP-метода
$requestMethod = $_SERVER["REQUEST_METHOD"];

// Простая маршрутизация
if ($uri[1] == 'api' && $uri[2] == 'users') {
$controller = new App\Controllers\UserController();

switch($requestMethod) {
case 'GET':
if (isset($uri[3])) {
$response = $controller->get($uri[3]);
} else {
$response = $controller->getAll();
}
break;
case 'POST':
$response = $controller->create();
break;
// другие методы...
}
} else {
header("HTTP/1.1 404 Not Found");
exit();
}

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [QSA,L]

<?php
namespace App\Controllers;

class UserController {
private $db;
private $requestMethod;
private $userId;

public function __construct($db, $requestMethod, $userId = null) {
$this->db = $db;
$this->requestMethod = $requestMethod;
$this->userId = $userId;
}

public function processRequest() {
switch ($this->requestMethod) {
case 'GET':
if ($this->userId) {
$response = $this->getUser($this->userId);
} else {
$response = $this->getAllUsers();
}
break;
case 'POST':
$response = $this->createUser();
break;
case 'PUT':
$response = $this->updateUser($this->userId);
break;
case 'DELETE':
$response = $this->deleteUser($this->userId);
break;
default:
$response = $this->notFoundResponse();
break;
}

header($response['status_code_header']);
if ($response['body']) {
echo $response['body'];
}
}

private function getAllUsers() {
$query = "SELECT id, username, email, status FROM users";
$statement = $this->db->query($query);
$result = $statement->fetchAll(\PDO::FETCH_ASSOC);

$response['status_code_header'] = 'HTTP/1.1 200 OK';
$response['body'] = json_encode($result);
return $response;
}

private function getUser($id) {
$result = $this->findUser($id);
if (! $result) {
return $this->notFoundResponse();
}

$response['status_code_header'] = 'HTTP/1.1 200 OK';
$response['body'] = json_encode($result);
return $response;
}

private function createUser() {
$input = (array) json_decode(file_get_contents('php://input'), true);

// Валидация входных данных
if (! $this->validateUser($input)) {
return $this->unprocessableEntityResponse();
}

// Хеширование пароля
$input['password'] = password_hash($input['password'], PASSWORD_BCRYPT);

$query = "INSERT INTO users (username, email, password, status) 
VALUES (:username, :email, :password, :status)";
$statement = $this->db->prepare($query);
$statement->execute([
'username' => $input['username'],
'email' => $input['email'],
'password' => $input['password'],
'status' => $input['status'] ?? 'active'
]);
$input['id'] = $this->db->lastInsertId();

// Убираем пароль из ответа
unset($input['password']);

$response['status_code_header'] = 'HTTP/1.1 201 Created';
$response['body'] = json_encode($input);
return $response;
}

private function updateUser($id) {
$result = $this->findUser($id);
if (! $result) {
return $this->notFoundResponse();
}

$input = (array) json_decode(file_get_contents('php://input'), true);
// Код обновления...

$response['status_code_header'] = 'HTTP/1.1 200 OK';
$response['body'] = json_encode($result);
return $response;
}

private function deleteUser($id) {
$result = $this->findUser($id);
if (! $result) {
return $this->notFoundResponse();
}

$query = "DELETE FROM users WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute(['id' => $id]);

$response['status_code_header'] = 'HTTP/1.1 204 No Content';
$response['body'] = null;
return $response;
}

private function findUser($id) {
$query = "SELECT id, username, email, status FROM users WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute(['id' => $id]);
$result = $statement->fetch(\PDO::FETCH_ASSOC);
return $result;
}

private function validateUser($input) {
// Проверка наличия обязательных полей
if (! isset($input['username']) || ! isset($input['email']) || ! isset($input['password'])) {
return false;
}
// Дополнительные проверки...
return true;
}

private function unprocessableEntityResponse() {
$response['status_code_header'] = 'HTTP/1.1 422 Unprocessable Entity';
$response['body'] = json_encode([
'error' => 'Invalid input data'
]);
return $response;
}

private function notFoundResponse() {
$response['status_code_header'] = 'HTTP/1.1 404 Not Found';
$response['body'] = json_encode([
'error' => 'User not found'
]);
return $response;
}
}

{
"status": "success",
"data": {
// Основные данные ответа
},
"meta": {
"page": 1,
"per_page": 20,
"total": 100
}
}

{
"status": "error",
"error": {
"code": 404,
"message": "User not found",
"details": "The requested user with ID 123 does not exist"
}
}

private function getAllUsers() {
$page = isset($_GET['page']) ? (int)$_GET['page'] : 1;
$perPage = isset($_GET['per_page']) ? (int)$_GET['per_page'] : 20;

// Валидация параметров
if ($perPage > 100) $perPage = 100; // Ограничение максимального количества
if ($page < 1) $page = 1;

$offset = ($page – 1) * $perPage;

// Получение общего количества
$countQuery = "SELECT COUNT(*) FROM users";
$total = (int)$this->db->query($countQuery)->fetchColumn();

// Получение данных с пагинацией
$query = "SELECT id, username, email, status FROM users LIMIT :offset, :limit";
$statement = $this->db->prepare($query);
$statement->bindParam(':offset', $offset, \PDO::PARAM_INT);
$statement->bindParam(':limit', $perPage, \PDO::PARAM_INT);
$statement->execute();
$result = $statement->fetchAll(\PDO::FETCH_ASSOC);

// Формирование ответа с метаданными
$response = [
'status' => 'success',
'data' => $result,
'meta' => [
'page' => $page,
'per_page' => $perPage,
'total' => $total,
'total_pages' => ceil($total / $perPage)
]
];

return [
'status_code_header' => 'HTTP/1.1 200 OK',
'body' => json_encode($response)
];
}

public function handleGetRequest($id = null) {
if ($id) {
// Получение конкретного ресурса
$query = "SELECT * FROM products WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute(['id' => $id]);
$result = $statement->fetch(PDO::FETCH_ASSOC);

if (!$result) {
return [
'status_code_header' => 'HTTP/1.1 404 Not Found',
'body' => json_encode(['error' => 'Product not found'])
];
}

return [
'status_code_header' => 'HTTP/1.1 200 OK',
'body' => json_encode(['data' => $result])
];
} else {
// Получение списка ресурсов с опциональной фильтрацией
$filters = [];
$params = [];

if (isset($_GET['category'])) {
$filters[] = "category = :category";
$params['category'] = $_GET['category'];
}

if (isset($_GET['min_price'])) {
$filters[] = "price >= :min_price";
$params['min_price'] = (float)$_GET['min_price'];
}

$whereClause = count($filters) > 0 ? "WHERE " . implode(' AND ', $filters) : "";

$query = "SELECT * FROM products $whereClause";
$statement = $this->db->prepare($query);
$statement->execute($params);
$result = $statement->fetchAll(PDO::FETCH_ASSOC);

return [
'status_code_header' => 'HTTP/1.1 200 OK',
'body' => json_encode(['data' => $result])
];
}
}

public function handlePostRequest() {
$data = json_decode(file_get_contents('php://input'), true);

// Валидация входных данных
$errors = $this->validateProductData($data);
if (count($errors) > 0) {
return [
'status_code_header' => 'HTTP/1.1 422 Unprocessable Entity',
'body' => json_encode(['errors' => $errors])
];
}

// Создание нового ресурса
$query = "INSERT INTO products (name, description, price, category, stock) 
VALUES (:name, :description, :price, :category, :stock)";

$statement = $this->db->prepare($query);
$statement->execute([
'name' => $data['name'],
'description' => $data['description'],
'price' => $data['price'],
'category' => $data['category'],
'stock' => $data['stock'] ?? 0
]);

$id = $this->db->lastInsertId();

// Возвращаем созданный ресурс с кодом 201 Created
$data['id'] = $id;
return [
'status_code_header' => 'HTTP/1.1 201 Created',
'body' => json_encode(['data' => $data])
];
}

public function handlePutRequest($id) {
// Проверяем существование ресурса
$query = "SELECT id FROM products WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute(['id' => $id]);

if (!$statement->fetch()) {
return [
'status_code_header' => 'HTTP/1.1 404 Not Found',
'body' => json_encode(['error' => 'Product not found'])
];
}

// Получаем и валидируем данные
$data = json_decode(file_get_contents('php://input'), true);
$errors = $this->validateProductData($data, true); // true означает, что все поля обязательны

if (count($errors) > 0) {
return [
'status_code_header' => 'HTTP/1.1 422 Unprocessable Entity',
'body' => json_encode(['errors' => $errors])
];
}

// Обновляем ресурс
$query = "UPDATE products 
SET name = :name, description = :description, price = :price, 
category = :category, stock = :stock
WHERE id = :id";

$statement = $this->db->prepare($query);
$statement->execute([
'id' => $id,
'name' => $data['name'],
'description' => $data['description'],
'price' => $data['price'],
'category' => $data['category'],
'stock' => $data['stock']
]);

// Возвращаем обновленный ресурс
$data['id'] = $id;
return [
'status_code_header' => 'HTTP/1.1 200 OK',
'body' => json_encode(['data' => $data])
];
}

public function handlePatchRequest($id) {
// Проверяем существование ресурса
$query = "SELECT * FROM products WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute(['id' => $id]);
$product = $statement->fetch(PDO::FETCH_ASSOC);

if (!$product) {
return [
'status_code_header' => 'HTTP/1.1 404 Not Found',
'body' => json_encode(['error' => 'Product not found'])
];
}

// Получаем данные для обновления
$data = json_decode(file_get_contents('php://input'), true);

// Формируем запрос только для указанных полей
$updateFields = [];
$params = ['id' => $id];

// Проходим по всем полученным полям
foreach ($data as $key => $value) {
if (array_key_exists($key, $product)) { // Проверяем, что поле существует
$updateFields[] = "$key = :$key";
$params[$key] = $value;
}
}

if (count($updateFields) === 0) {
return [
'status_code_header' => 'HTTP/1.1 400 Bad Request',
'body' => json_encode(['error' => 'No valid fields to update'])
];
}

// Обновляем только указанные поля
$query = "UPDATE products SET " . implode(', ', $updateFields) . " WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute($params);

// Получаем и возвращаем обновленный ресурс
$query = "SELECT * FROM products WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute(['id' => $id]);
$updatedProduct = $statement->fetch(PDO::FETCH_ASSOC);

return [
'status_code_header' => 'HTTP/1.1 200 OK',
'body' => json_encode(['data' => $updatedProduct])
];
}

public function handleDeleteRequest($id) {
// Проверяем существование ресурса (опционально)
$query = "SELECT id FROM products WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute(['id' => $id]);

if (!$statement->fetch()) {
return [
'status_code_header' => 'HTTP/1.1 404 Not Found',
'body' => json_encode(['error' => 'Product not found'])
];
}

// Удаляем ресурс
$query = "DELETE FROM products WHERE id = :id";
$statement = $this->db->prepare($query);
$statement->execute(['id' => $id]);

// Возвращаем 204 No Content без тела ответа
return [
'status_code_header' => 'HTTP/1.1 204 No Content',
'body' => null
];
}

try {
// Код обработки запроса
} catch (PDOException $e) {
// Логирование ошибки
error_log($e->getMessage());

// Возвращаем ошибку клиенту (без раскрытия деталей базы данных)
return [
'status_code_header' => 'HTTP/1.1 500 Internal Server Error',
'body' => json_encode([
'error' => 'A database error occurred',
'code' => 'DB_ERROR'
])
];
} catch (Exception $e) {
// Логирование общих ошибок
error_log($e->getMessage());

return [
'status_code_header' => 'HTTP/1.1 500 Internal Server Error',
'body' => json_encode([
'error' => 'An unexpected error occurred',
'code' => 'GENERAL_ERROR'
])
];
}

// Класс для работы с JWT-токенами
class JwtAuth {
private $secretKey;
private $algorithm;
private $issuer;

public function __construct($secretKey, $algorithm = 'HS256', $issuer = 'api.example.com') {
$this->secretKey = $secretKey;
$this->algorithm = $algorithm;
$this->issuer = $issuer;
}

public function generateToken($userId, $expireMinutes = 60) {
$issuedAt = time();
$expire = $issuedAt + $expireMinutes * 60;

$payload = [
'iss' => $this->issuer, // Издатель
'iat' => $issuedAt, // Время создания
'exp' => $expire, // Время истечения
'user_id' => $userId, // Идентификатор пользователя
];

return \Firebase\JWT\JWT::encode($payload, $this->secretKey, $this->algorithm);
}

public function validateToken($token) {
try {
$decoded = \Firebase\JWT\JWT::decode($token, $this->secretKey, [$this->algorithm]);
return $decoded;
} catch (\Exception $e) {
return false;
}
}
}

// Middleware для защиты маршрутов
function authMiddleware($request, $response, $next) {
$authHeader = $request->getHeaderLine('Authorization');

if (empty($authHeader) || !preg_match('/Bearer\s+(.*)$/i', $authHeader, $matches)) {
return $response->withStatus(401)->withJson([
'error' => 'Authentication required',
'code' => 'AUTH_REQUIRED'
]);
}

$token = $matches[1];
$jwt = new JwtAuth($_ENV['JWT_SECRET']);
$payload = $jwt->validateToken($token);

if (!$payload) {
return $response->withStatus(401)->withJson([
'error' => 'Invalid token',
'code' => 'INVALID_TOKEN'
]);
}

// Токен валиден, добавляем данные пользователя в запрос
$request = $request->withAttribute('user_id', $payload->user_id);

// Продолжаем выполнение цепочки middleware
return $next($request, $response);
}

// Эндпоинт для получения токена
$app->post('/auth/login', function ($request, $response) {
$data = $request->getParsedBody();

// Валидация входных данных
if (empty($data['username']) || empty($data['password'])) {
return $response->withStatus(422)->withJson([
'error' => 'Username and password are required',
'code' => 'VALIDATION_ERROR'
]);
}

// Проверка учетных данных
$user = $this->db->getUserByUsername($data['username']);

if (!$user || !password_verify($data['password'], $user['password'])) {
return $response->withStatus(401)->withJson([
'error' => 'Invalid credentials',
'code' => 'INVALID_CREDENTIALS'
]);
}

// Генерация токена
$jwt = new JwtAuth($_ENV['JWT_SECRET']);
$token = $jwt->generateToken($user['id']);

return $response->withJson([
'access_token' => $token,
'token_type' => 'bearer',
'expires_in' => 3600 // 60 минут
]);
});

// Защищенный маршрут
$app->get('/users/me', function ($request, $response) {
$userId = $request->getAttribute('user_id');
$user = $this->db->getUserById($userId);

// Удаляем чувствительные данные
unset($user['password']);

return $response->withJson(['data' => $user]);
})->add('authMiddleware');

function validateInput($data, $rules) {
$errors = [];

foreach ($rules as $field => $rule) {
// Проверка обязательных полей
if (strpos($rule, 'required') !== false && (!isset($data[$field]) || trim($data[$field]) === '')) {
$errors[$field][] = "Field is required";
continue;
}

// Пропускаем дальнейшие проверки, если поле не указано и оно не обязательное
if (!isset($data[$field])) continue;

// Валидация по типу
if (strpos($rule, 'email') !== false && !filter_var($data[$field], FILTER_VALIDATE_EMAIL)) {
$errors[$field][] = "Invalid email format";
}

if (strpos($rule, 'numeric') !== false && !is_numeric($data[$field])) {
$errors[$field][] = "Must be a number";
}

// Проверка минимальной длины
if (preg_match('/min:(\d+)/', $rule, $matches) && strlen($data[$field]) < $matches[1]) {
$errors[$field][] = "Minimum length is {$matches[1]} characters";
}

// Проверка максимальной длины
if (preg_match('/max:(\d+)/', $rule, $matches) && strlen($data[$field]) > $matches[1]) {
$errors[$field][] = "Maximum length is {$matches[1]} characters";
}
}

return $errors;
}

// Пример использования
$data = json_decode(file_get_contents('php://input'), true);
$rules = [
'username' => 'required|min:3|max:50',
'email' => 'required|email',
'age' => 'numeric'
];

$errors = validateInput($data, $rules);
if (count($errors) > 0) {
return $response->withStatus(422)->withJson(['errors' => $errors]);
}

function rateLimitMiddleware($request, $response, $next) {
$ipAddress = $request->getServerParam('REMOTE_ADDR');
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

// Ключ для Redis, уникальный для IP-адреса
$key = "rate_limit:{$ipAddress}";

// Количество разрешенных запросов в минуту
$maxRequests = 60;

// Получаем текущее количество запросов
$current = $redis->get($key);

if ($current !== false && $current >= $maxRequests) {
// Превышен лимит запросов
return $response->withStatus(429)->withJson([
'error' => 'Too many requests',
'code' => 'RATE_LIMIT_EXCEEDED'
]);
}

// Увеличиваем счетчик или создаем новый
if ($current === false) {
$redis->set($key, 1);
$redis->expire($key, 60); // Истекает через 60 секунд
} else {
$redis->incr($key);
}

// Добавляем заголовки с информацией о лимитах
$remaining = $maxRequests – ($current === false ? 1 : $current + 1);
$response = $response->withHeader('X-RateLimit-Limit', $maxRequests);
$response = $response->withHeader('X-RateLimit-Remaining', max(0, $remaining));

// Продолжаем выполнение запроса
return $next($request, $response);
}

// Применяем middleware ко всем маршрутам
$app->add('rateLimitMiddleware');

// tests/UserApiTest.php
class UserApiTest extends PHPUnit\Framework\TestCase {
private $client;
private $authToken;

protected function setUp(): void {
// Создаем HTTP-клиент для тестирования
$this->client = new GuzzleHttp\Client([
'base_uri' => 'http://localhost:8000',
'http_errors' => false
]);

// Авторизуемся и получаем токен
$response = $this->client->post('/auth/login', [
'json' => [
'username' => 'testuser',
'password' => 'testpassword'
]
]);

$this->assertEquals(200, $response->getStatusCode());
$data = json_decode($response->getBody(), true);
$this->authToken = $data['access_token'];
}

public function testGetUsers() {
$response = $this->client->get('/users', [
'headers' => [
'Authorization' => 'Bearer ' . $this->authToken
]
]);

$this->assertEquals(200, $response->getStatusCode());
$data = json_decode($response->getBody(), true);
$this->assertIsArray($data['data']);
}

public function testCreateUser() {
$userData = [
'username' => 'newuser_' . time(),
'email' => 'newuser_' . time() . '@example.com',
'password' => 'securepassword',
'name' => 'Test User'
];

$response = $this->client->post('/users', [
'headers' => [
'Authorization' => 'Bearer ' . $this->authToken
],
'json' => $userData
]);

$this->assertEquals(201, $response->getStatusCode());
$data = json_decode($response->getBody(), true);

// Проверяем, что пользователь создан с указанными данными
$this->assertEquals($userData['username'], $data['data']['username']);
$this->assertEquals($userData['email'], $data['data']['email']);
$this->assertEquals($userData['name'], $data['data']['name']);

// Проверяем, что пароль не возвращается
$this->assertArrayNotHasKey('password', $data['data']);

return $data['data']['id']; // Возвращаем ID для других тестов
}

/**
* @depends testCreateUser
*/
public function testGetUser($userId) {
$response = $this->client->get("/users/{$userId}", [
'headers' => [
'Autho

**Читайте также**
- [Валидация данных в PHP: безопасные методы и инструменты защиты](/html/validaciya-dannyh-v-php/)
- [PHP против JavaScript, Python и Ruby: как выбрать язык программирования](/javascript/sravnenie-php-s-drugimi-yazykami-veb-razrabotki/)
- [7 критических уязвимостей PHP: защита кода от хакерских атак](/sql/osnovnye-ugrozy-bezopasnosti-v-php/)
- [Эффективная работа с базами данных в Laravel: приемы и методы](/sql/rabota-s-bazami-dannyh-v-laravel/)
- [Безопасная обработка данных в PHP: защита форм от уязвимостей](/html/obrabotka-polzovatelskih-dannyh-v-php/)
- [CI/CD для PHP-приложений: автоматизация развертывания в 2023](/html/avtomatizaciya-razvertyvaniya-php-prilozhenij/)
- [Юнит-тестирование в PHP: защита кода от регрессии и ошибок](/profession/napisanie-yunit-testov-v-php/)
- [Ускоряем PHP-сайты на 80%: техники кэширования с файлами и Redis](/javascript/keshirovanie-v-php/)
- [SQL-инъекции в PHP: защита данных с подготовленными запросами](/sql/zashita-ot-sql-inuekcij-v-php/)
- [Как настроить идеальное PHP-окружение для эффективной разработки](/sql/nastrojka-okruzheniya-dlya-razrabotki-na-php/)