Tworzenie i uruchamianie projektu Symfony

ServBay to lokalne środowisko programistyczne zaprojektowane dla macOS i Windows. Integruje PHP, Node.js, Python, Go, Java i inne runtime'y oraz bazy danych takie jak MySQL, PostgreSQL, MongoDB, Redis. Obsługuje serwery WWW Apache oraz Caddy. Ten przewodnik pokazuje krok po kroku, jak szybko zbudować i uruchomić projekt Symfony na macOS i Windows z pomocą ServBay.

Czym jest Symfony?

Symfony to otwarty framework PHP stworzony przez SensioLabs, zaprojektowany, aby dostarczyć programistom wydajny, elastyczny i rozbudowany zestaw narzędzi do tworzenia nowoczesnych aplikacji webowych oraz API. Realizuje standardowe dobre praktyki w webdevelopmencie i posiada bogaty zestaw komponentów, takich jak routing, silnik szablonów (Twig), obsługa formularzy, autentykacja, dependency injection, co znacząco upraszcza typowe zadania związane z budową aplikacji webowej.

Główne cechy i zalety Symfony

Modułowa architektura: Jądrem Symfony jest biblioteka komponentów wielokrotnego użycia, które programista może dowolnie wybierać, by budować aplikacje od lekkich do rozbudowanych.
Wysoka wydajność: Dzięki zoptymalizowanej architekturze, skutecznym mechanizmom cache i obsłudze najnowszych funkcji PHP, Symfony gwarantuje znakomitą wydajność aplikacji.
Silne wsparcie społeczności: Ogromna społeczność programistów, bogactwo zewnętrznych Bundle (pluginów) oraz kompletna dokumentacja sprawiają, że łatwo znaleźć rozwiązania problemów.
Elastyczność: Łatwa integracja z bibliotekami i rozszerzeniami, sprawdza się w projektach o różnym rozmiarze i poziomie skomplikowania.
Stabilność i łatwość utrzymania: Przestrzeganie dobrych standardów kodowania i wzorców projektowych ułatwia testowanie, rozwijanie i utrzymanie aplikacji.

Symfony nadaje się do budowy zarówno makowych API, jak i rozbudowanych systemów klasy enterprise.

Tworzenie i uruchomienie projektu Symfony z ServBay

ServBay dostarcza kompletnego środowiska do uruchamiania projektów Symfony, zapewniając odpowiednią wersję PHP, Composer, serwer WWW oraz bazy danych i systemy cache. Poniższa sekcja prowadzi krok po kroku przez założenie i konfigurację nowego projektu Symfony.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

Zainstalowałeś ServBay: ServBay został pomyślnie zainstalowany i uruchomiony na macOS. Jeśli nie, skorzystaj z instrukcji instalacji ServBay.
ServBay działa prawidłowo: Serwisy ServBay, takie jak Caddy lub Apache oraz potrzebne bazy danych, są uruchomione.
Podstawowa znajomość: Znasz podstawy PHP, Composera oraz koncept frameworka Symfony.

Tworzenie projektu Symfony

ServBay zaleca przechowywanie projektów stron internetowych w katalogu /Applications/ServBay/www – ułatwia to rozpoznawanie i zarządzanie projektami w ServBay.

Sprawdź dostępność Composera
Composer jest zintegrowany z ServBay i odpowiednio skonfigurowany w zmiennych środowiskowych, więc nie wymaga samodzielnej instalacji. W terminalu możesz sprawdzić jego wersję:
```
composer --version
```
1
Utwórz katalog projektu
W zalecanym katalogu głównym stwórz nowy folder na projekt Symfony:
bash
```
cd /Applications/ServBay/www
mkdir servbay-symfony-app
```
1
2
Stwórz projekt Symfony przez Composer
Wejdź do świeżo utworzonego katalogu i wygeneruj projekt na bazie website-skeleton using Composer. website-skeleton to szkielet z popularnymi zależnościami dla tradycyjnych aplikacji WWW.
bash
```
cd /Applications/ServBay/www/servbay-symfony-app
composer create-project symfony/website-skeleton .
```
1
2
Composer pobierze pliki rdzeniowe Symfony oraz zależności do bieżącego katalogu.

Wstępna konfiguracja

Podstawowa konfiguracja Symfony jest realizowana za pomocą zmiennych środowiskowych w pliku .env w głównym folderze projektu.

Ustawianie zmiennych środowiskowych (.env)

Otwórz plik .env w głównym katalogu projektu. Zawiera on konfigurację środowiska aplikacji, np. połączenie z bazą danych, klucz aplikacji i inne. Dostosuj go według potrzeb.

Kluczowe zmienne do ustawienia lub modyfikacji:

dotenv

# Przykład pliku .env
APP_ENV=dev # środowisko deweloperskie
APP_SECRET=your_secret_key # zamień na unikalny, losowy ciąg znaków dla bezpieczeństwa

# Połączenia z bazą danych (np. MySQL, PostgreSQL – omówione szczegółowo niżej)
# DATABASE_URL="mysql://db_user:db_password@127.0.0.1:3306/db_name?serverVersion=8.0&charset=utf8mb4"
# DATABASE_URL="postgresql://db_user:db_password@127.0.0.1:5432/db_name?serverVersion=13&charset=utf8"
# DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"

Zamień your_secret_key na bezpieczny, losowy ciąg znaków. Domyślnie użytkownik bazy danych w ServBay to root, hasło to password (zdecydowanie zmień w produkcji!). Przyjmujemy jako przykładową nazwę bazy: servbay_symfony_app.

Ustawienia serwera WWW (strona ServBay)

By uzyskać dostęp do projektu przez przeglądarkę, musisz skonfigurować lokalny wirtualny host w panelu ServBay. Główny katalog publiczny Symfony to folder public/.

Otwórz panel ServBay i przejdź do ustawień „Strony” (lub w starszej wersji „Hosty”) i dodaj nową stronę:

Nazwa: Wybierz przyjazną nazwę strony, np. My Symfony Dev Site.
Domena: Ustal domenę dla deweloperskich testów, np. servbay-symfony-test.local. ServBay automatycznie skieruje ją na lokalną maszynę.
Typ strony: Wybierz PHP.
Wersja PHP: Ustaw wersję kompatybilną z projektem, zalecane najnowsze stabilne np. 8.3.
Katalog główny strony: Najważniejsze – wskaż dokładnie na public/, czyli /Applications/ServBay/www/servbay-symfony-app/public.

Zapisz i zaaplikuj zmiany – ServBay automatycznie zaktualizuje konfigurację serwera. Domyślnie używany jest Caddy lub Apache. ServBay automatycznie generuje i ufa certyfikatom SSL dla lokalnych domen, więc możesz śmiało korzystać z HTTPS.

Szczegółowe instrukcje znajdziesz w Dodawanie pierwszej strony w ServBay.

Dodanie przykładowego kodu

Aby zweryfikować konfigurację strony, dodajmy prostą trasę i kontroler, który wyświetli tekst przy wejściu na główną ścieżkę.

Konfiguracja routing'u (config/routes.yaml)
W pliku config/routes.yaml dodaj trasę dla /, wskazując metodę kontrolera index:
yaml
```
# config/routes.yaml
index:
    path: /
    controller: App\Controller\DefaultController::index
```
1
2
3
4

Utwórz kontroler (src/Controller/DefaultController.php)

W katalogu src/Controller/ utwórz plik DefaultController.php:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class DefaultController
{
    /**
     * @Route("/", name="index")
     */
    public function index(): Response
    {
        // Zwraca prostą odpowiedź HTTP
        return new Response('Hello ServBay and Symfony!');
    }
}

Ten kontroler DefaultController definiuje metodę index, powiązaną z trasą /, która zwraca odpowiedź z tekstem "Hello ServBay and Symfony!".

Dostęp do strony

Otwórz teraz przeglądarkę i wejdź na skonfigurowaną domenę: https://servbay-symfony-test.local. Jeśli wszystko działa, zobaczysz:

Hello ServBay and Symfony!

To oznacza, że projekt Symfony jest poprawnie uruchamiany przez serwer WWW ServBay. Zalecamy dostęp przez protokół HTTPS – ServBay sam zadbał o konfigurację certyfikatów SSL.

Przykład bazy danych i cache

Symfony standardowo korzysta z Doctrine ORM do pracy z relacyjnymi bazami oraz z komponentu Symfonowego Cache do obsługi cache i baz NoSQL. ServBay udostępnia szereg usług bazodanowych i odpowiednie rozszerzenia PHP, dzięki czemu łatwo je włączyć do aplikacji.

Przykład relacyjnej bazy danych (Doctrine ORM)

ServBay wspiera MySQL i PostgreSQL. Pokażemy, jak skonfigurować oba typy w Symfony.

Połączenie z bazą
W pliku .env odkomentuj i edytuj odpowiedni DATABASE_URL:
- Dla MySQL: Użytkownik domyślny: root, hasło: password, port: 3306.
  dotenv
```
# .env
DATABASE_URL="mysql://root:password@127.0.0.1:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"
```
  1
  2
- Dla PostgreSQL: Użytkownik domyślny: root, hasło: password, port: 5432.
  dotenv
```
# .env
DATABASE_URL="postgresql://root:password@127.0.0.1:5432/servbay_symfony_app?serverVersion=13&charset=utf8"
```
  1
  2
Upewnij się, że serwis bazy wybranej w ServBay został uruchomiony.
Utworzenie bazy
Jeśli baza servbay_symfony_app nie istnieje, utwórz ją przez panel ServBay (np. phpMyAdmin lub pgAdmin) albo poleceniem:
bash
```
php bin/console doctrine:database:create
```
1
Tworzenie Entity i migracji
Entity w Symfony odpowiada tabeli w bazie. Maker Bundle generuje encje i pliki migracyjne.
- Utwórz encję (np. User):
  bash
```
php bin/console make:entity User
```
  1
  Dodaj pola, np. name (string) i email (string, unique=yes).
- Stwórz plik migracji:
  bash
```
php bin/console make:migration
```
  1
  Plik z SQL utworzy się w src/Migrations.
Wykonaj migrację
Aplikacja struktury bazy:
bash
```
php bin/console doctrine:migrations:migrate
```
1

Dodanie przykładowej operacji na bazie

Zmień src/Controller/DefaultController.php, by pokazać zapis i odczyt przy użyciu Doctrine. Należy wstrzyknąć EntityManagerInterface.

Konstruktor z EntityManagerInterface:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface;
use App\Entity\User;
use Symfony\Component\HttpFoundation\JsonResponse;

class DefaultController
{
    private $entityManager;

    // Wstrzykiwanie EntityManagerInterface
    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }

    /**
     * @Route("/", name="app_index")
     */
    public function index(): Response
    {
        return new Response('Hello ServBay and Symfony!');
    }

    // ... pozostałe metody ...
}

Następnie dodaj nowe trasy w config/routes.yaml:

yaml

# config/routes.yaml
# ... inne trasy ...
mysql_add_user:
    path: /mysql-add-user
    controller: App\Controller\DefaultController::addUser
mysql_get_users:
    path: /mysql-users
    controller: App\Controller\DefaultController::getUsers

Odpowiednie metody w kontrolerze:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface;
use App\Entity\User;
use Symfony\Component\HttpFoundation\JsonResponse;

class DefaultController
{
    private $entityManager;

    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }

    /**
     * @Route("/", name="app_index")
     */
    public function index(): Response
    {
        return new Response('Hello ServBay and Symfony!');
    }

    /**
     * @Route("/add-user", name="app_add_user")
     */
    public function addUser(): Response
    {
        $user = new User();
        // Przykładowe dane z marką ServBay
        $user->setName('ServBay Demo User');
        $user->setEmail('demo-user@servbay.test');

        // Zapis encji do bazy
        $this->entityManager->persist($user);
        $this->entityManager->flush();

        return new Response('User added successfully!');
    }

    /**
     * @Route("/get-users", name="app_get_users")
     */
    public function getUsers(): JsonResponse
    {
        // Pobierz wszystkie encje User
        $users = $this->entityManager->getRepository(User::class)->findAll();

        $usersArray = [];
        foreach ($users as $user) {
            $usersArray[] = [
                'id' => $user->getId(),
                'name' => $user->getName(),
                'email' => $user->getEmail(),
            ];
        }

        // Zwróć jako JSON
        return new JsonResponse($usersArray);
    }
}

Testowanie przykładu
- Wejdź na https://servbay-symfony-test.local/add-user, by dodać użytkownika.
- Wejdź na https://servbay-symfony-test.local/get-users, by podejrzeć listę użytkowników w formacie JSON.

Przykład cache i bazy NoSQL (Symfony Cache)

ServBay zapewnia usługi Redis i Memcached oraz odpowiednie rozszerzenia PHP – możesz od razu użyć komponentu Symfony Cache z tymi serwisami.

Konfiguracja połączenia cache
Dodaj odpowiedni DSN w .env:
- Memcached (port 11211 – domyślnie):
  dotenv
```
# .env
CACHE_DSN=memcached://127.0.0.1:11211
```
  1
  2
  Upewnij się, że Memcached jest uruchomiony w ServBay.
- Redis (port 6379 – domyślnie):
  dotenv
```
# .env
CACHE_DSN=redis://127.0.0.1:6379
# Jeśli Redis wymaga hasła (domyślnie nie), użyj:
# CACHE_DSN=redis://:your_password@127.0.0.1:6379
```
  1
  2
  3
  4
  Upewnij się, że Redis jest uruchomiony.

Dodanie przykładu obsługi cache

Wstrzyknij CacheInterface w konstruktorze kontrolera:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface;
use App\Entity\User;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Contracts\Cache\CacheInterface;

class DefaultController
{
    private $entityManager;
    private $cache;

    // Konstruktor z CacheInterface
    public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
    {
        $this->entityManager = $entityManager;
        $this->cache = $cache;
    }

    // ... inne metody ...
}

Dodaj trasę w config/routes.yaml:

yaml

# config/routes.yaml
# ... inne trasy ...
cache_example:
    path: /cache-example
    controller: App\Controller\DefaultController::cacheExample

Dodaj odpowiednią metodę w kontrolerze:

php

<?php
// src/Controller/DefaultController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Doctrine\ORM\EntityManagerInterface;
use App\Entity\User;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Component\Cache\Item\ItemInterface;

class DefaultController
{
    private $entityManager;
    private $cache;

    public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
    {
        $this->entityManager = $entityManager;
        $this->cache = $cache;
    }

    // ... inne metody ...

    /**
     * @Route("/cache-example", name="app_cache_example")
     */
    public function cacheExample(): Response
    {
        // Pobierz dane z cache (lub wygeneruj, jeśli brak)
        $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
            // Logika przy braku cache
            $item->expiresAfter(3600); // dane ważne godzinę

            // Symulacja kosztownego zapytania
            $data = "Data generated at " . date('Y-m-d H:i:s');

            return $data;
        });

        $output = "From Cache: " . $cacheItem;

        return new Response($output);
    }
}

Test działania cache
- Wejdź na https://servbay-symfony-test.local/cache-example. Pierwsza wizyta wygeneruje i zapisze dane w cache. Kolejne odczyty pobiorą dane bezpośrednio z pamięci Memcached lub Redis, dopóki nie wygasną.

Najczęstsze pytania (FAQ)

Q: Po wejściu na https://servbay-symfony-test.local strona nie działa lub pojawia się błąd 500 – co zrobić?

A: Sprawdź:

Czy ServBay jest uruchomiony, a strona w panelu ServBay aktywna.
Czy domena servbay-symfony-test.local jest poprawnie dodana i katalog root wskazuje dokładnie na /Applications/ServBay/www/servbay-symfony-app/public.
Przejrzyj logi Symfony (var/log/dev.log) – znajdziesz szczegóły błędów.
Uruchom w katalogu projektu composer install, by pobrać zależności.
Sprawdź czy bieżąca wersja PHP jest zgodna z wymaganiami projektu.

Q: Problemy z połączeniem do bazy danych?

A: Upewnij się, że:

Odpowiedni serwis bazy (MySQL lub PostgreSQL) działa w panelu ServBay.
W .env url bazy (DATABASE_URL) jest poprawny – użytkownik, hasło, host (127.0.0.1), port (3306 dla MySQL, 5432 dla PostgreSQL) oraz nazwa bazy.
Dane dostępowe użytkownika bazy zgadzają się z domyślnymi lub ustawionymi przez Ciebie.
Baza danych servbay_symfony_app istnieje i jest dostępna.

Q: Komenda php bin/console nie działa?

A: Upewnij się, że jesteś w katalogu /Applications/ServBay/www/servbay-symfony-app oraz że PHP ServBay jest widoczne w zmiennej PATH systemu (ServBay zwykle dodaje to automatycznie). Sprawdź poleceniem which php, czy używasz właściwego binarnego PHP.

Podsumowanie

Dzięki temu przewodnikowi, stworzyłeś, skonfigurowałeś i uruchomiłeś bazowy projekt Symfony na macOS, korzystając z ServBay. ServBay gwarantuje wszystkie kluczowe komponenty (PHP, Composer, serwer WWW, bazy danych, cache) oraz upraszcza konfigurację środowiska, umożliwiając szybkie rozpoczęcie prac programistycznych. Teraz możesz rozwijać projekt i poznawać dalsze możliwości Symfony oraz korzystać z szerokiego wyboru pakietów i serwisów oferowanych przez ServBay.

Tworzenie i uruchamianie projektu Symfony ​

Czym jest Symfony? ​

Główne cechy i zalety Symfony ​

Tworzenie i uruchomienie projektu Symfony z ServBay ​

Wymagania wstępne ​

Tworzenie projektu Symfony ​

Wstępna konfiguracja ​

Ustawienia serwera WWW (strona ServBay) ​

Dodanie przykładowego kodu ​

Dostęp do strony ​

Przykład bazy danych i cache ​

Przykład relacyjnej bazy danych (Doctrine ORM) ​

Przykład cache i bazy NoSQL (Symfony Cache) ​

Najczęstsze pytania (FAQ) ​

Podsumowanie ​