Frameworki

Symfony SMS Integration — jak wysyłać SMS-y w Symfony 7

Tomasz Lewandowski - Lead Developer, SMSIK 11 min czytania

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.

Wyprobuj SMSIK bezplatnie

Rejestracja zajmuje 2 minuty. Otrzymasz 5 groszy na start.

Utworz darmowe konto