Symfony to enterprise'owy framework PHP. Dowiedz się, jak dodać SMS-y do swojej aplikacji — z użyciem HttpClient, Messenger i dependency injection.
Symfony to jeden z najpopularniejszych frameworków PHP w Europie — szczególnie w projektach enterprise. Jeśli budujesz aplikację w Symfony 7 i chcesz wysyłać SMS-y, ten artykuł pokaże Ci, jak to zrobić zgodnie z najlepszymi praktykami: dependency injection, HttpClient, Messenger (kolejki).
Wymagania
- Symfony 7.x (PHP 8.2+)
- Konto SMSIK z kluczem API
- Opcjonalnie: Symfony Messenger + Redis/RabbitMQ
Krok 1: Konfiguracja klucza API
W .env:
SMSIK_API_KEY=sk_live_TWOJ_KLUCZ
SMSIK_API_URL=https://smsik.pl/api/v1
W config/services.yaml:
parameters:
smsik.api_key: '%env(SMSIK_API_KEY)%'
smsik.api_url: '%env(default:smsik_default_url:SMSIK_API_URL)%'
smsik_default_url: 'https://smsik.pl/api/v1'
Krok 2: DTO dla żądania SMS
Utwórz src/Dto/SmsRequest.php:
<?php
declare(strict_types=1);
namespace App\Dto;
final readonly class SmsRequest
{
public function __construct(
public string $toNumber,
public string $message,
public ?string $idempotencyKey = null,
) {}
public function toArray(): array
{
$payload = [
'to_number' => $this->toNumber,
'message' => $this->message,
];
if ($this->idempotencyKey !== null) {
$payload['idempotency_key'] = $this->idempotencyKey;
}
return $payload;
}
}
Krok 3: Serwis SMS
Utwórz src/Service/SmsikClient.php:
<?php
declare(strict_types=1);
namespace App\Service;
use App\Dto\SmsRequest;
use Psr\Log\LoggerInterface;
use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;
final class SmsikClient
{
public function __construct(
private readonly HttpClientInterface $httpClient,
private readonly LoggerInterface $logger,
private readonly string $apiKey,
private readonly string $apiUrl,
) {}
/**
* Wysyła SMS-a przez SMSIK API.
*
* @return array{id: int, status: string, to_number: string, price_grosze: int}
*
* @throws SmsikException
*/
public function send(SmsRequest $request): array
{
try {
$response = $this->httpClient->request(
'POST',
$this->apiUrl . '/sms/send',
[
'headers' => [
'X-API-Key' => $this->apiKey,
'Content-Type' => 'application/json',
],
'json' => $request->toArray(),
'timeout' => 30,
]
);
$statusCode = $response->getStatusCode();
if ($statusCode === 200) {
return $response->toArray();
}
$body = $response->getContent(false);
$this->logger->error('SMSIK API error', [
'status' => $statusCode,
'body' => $body,
'to_number' => $request->toNumber,
]);
throw new SmsikException(
sprintf('SMSIK API error %d: %s', $statusCode, $body)
);
} catch (TransportExceptionInterface $e) {
$this->logger->error('SMSIK transport error', [
'error' => $e->getMessage(),
]);
throw new SmsikException('Błąd połączenia z SMSIK: ' . $e->getMessage(), 0, $e);
}
}
}
I wyjątek src/Service/SmsikException.php:
<?php
declare(strict_types=1);
namespace App\Service;
final class SmsikException extends \RuntimeException
{
}
Krok 4: Rejestracja serwisu
W config/services.yaml:
services:
App\Service\SmsikClient:
arguments:
$apiKey: '%smsik.api_key%'
$apiUrl: '%smsik.api_url%'
Krok 5: Message + Handler (Messenger)
Wysyłka SMS-a to operacja sieciowa — nie blokuj requestu HTTP. Użyj Symfony Messenger.
Utwórz src/Message/SendSmsMessage.php:
<?php
declare(strict_types=1);
namespace App\Message;
final readonly class SendSmsMessage
{
public function __construct(
public string $toNumber,
public string $message,
public ?string $idempotencyKey = null,
) {}
}
I handler src/MessageHandler/SendSmsMessageHandler.php:
<?php
declare(strict_types=1);
namespace App\MessageHandler;
use App\Dto\SmsRequest;
use App\Message\SendSmsMessage;
use App\Service\SmsikClient;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
#[AsMessageHandler]
final class SendSmsMessageHandler
{
public function __construct(
private readonly SmsikClient $smsikClient,
) {}
public function __invoke(SendSmsMessage $message): void
{
$this->smsikClient->send(new SmsRequest(
toNumber: $message->toNumber,
message: $message->message,
idempotencyKey: $message->idempotencyKey,
));
}
}
Krok 6: Użycie w kontrolerze
<?php
declare(strict_types=1);
namespace App\Controller;
use App\Entity\Order;
use App\Message\SendSmsMessage;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Routing\Attribute\Route;
final class OrderController extends AbstractController
{
public function __construct(
private readonly MessageBusInterface $bus,
) {}
#[Route('/api/orders', methods: ['POST'])]
public function create(Request $request, EntityManagerInterface $em): JsonResponse
{
$data = json_decode($request->getContent(), true);
$order = new Order();
$order->setPhone($data['phone']);
$order->setProduct($data['product']);
$em->persist($order);
$em->flush();
// Wyślij SMS w tle (Messenger)
$this->bus->dispatch(new SendSmsMessage(
toNumber: $order->getPhone(),
message: "Zamowienie #{$order->getId()} przyjete. Dziekujemy!",
idempotencyKey: "order-{$order->getId()}-confirmation",
));
return $this->json(['order_id' => $order->getId()]);
}
}
Krok 7: Konfiguracja Messenger
W config/packages/messenger.yaml:
framework:
messenger:
transports:
async:
dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
retry_strategy:
max_retries: 3
delay: 1000
multiplier: 2
max_delay: 60000
routing:
App\Message\SendSmsMessage: async
Uruchom worker:
php bin/console messenger:consume async
Krok 8: Testy
W tests/Service/SmsikClientTest.php:
<?php
declare(strict_types=1);
namespace App\Tests\Service;
use App\Dto\SmsRequest;
use App\Service\SmsikClient;
use PHPUnit\Framework\TestCase;
use Psr\Log\NullLogger;
use Symfony\Component\HttpClient\MockHttpClient;
use Symfony\Component\HttpClient\Response\MockResponse;
final class SmsikClientTest extends TestCase
{
public function test_send_sms_success(): void
{
$mockResponse = new MockResponse(json_encode([
'id' => 123,
'status' => 'queued',
'to_number' => '+48512017029',
'price_grosze' => 1,
]), ['http_code' => 200]);
$httpClient = new MockHttpClient($mockResponse);
$client = new SmsikClient(
$httpClient,
new NullLogger(),
'sk_live_test',
'https://smsik.pl/api/v1',
);
$result = $client->send(new SmsRequest('+48512017029', 'Test'));
self::assertSame(123, $result['id']);
self::assertSame('queued', $result['status']);
}
}
Podsumowanie
- ✅ Serwis
SmsikClient— reużywalny klient HTTP - ✅ DTO
SmsRequest— typowane żądanie (PHP 8.2) - ✅ Messenger — wysyłka w tle, retry z backoffem
- ✅ Dependency injection — zgodnie z filozofią Symfony
- ✅ Testy —
MockHttpClient - ✅ Readonly properties — czysta architektura
Zarejestruj się bezpłatnie — 5 groszy na start.