Tworzenie i uruchamianie projektu Symfony

ServBay to lokalne środowisko programistyczne przeznaczone specjalnie dla macOS, integrujące wiele środowisk uruchomieniowych, takich jak PHP, Node.js, Python, Go, Java, a także bazy danych MySQL, PostgreSQL, MongoDB, Redis itp. oraz serwery WWW Apache i Caddy. W tym przewodniku szczegółowo opisano, jak szybko skonfigurować i uruchomić projekt Symfony na macOS z wykorzystaniem ServBay.

Czym jest Symfony?

Symfony to otwarty framework PHP dla aplikacji WWW stworzony przez SensioLabs, stworzony z myślą o zapewnieniu programistom wydajnego, elastycznego i bogatego w funkcje narzędzia do budowy nowoczesnych aplikacji internetowych i API. Symfony przestrzega najlepszych praktyk webowych i oferuje bogaty zestaw komponentów — takich jak routing, silnik szablonów (Twig), obsługa formularzy, uwierzytelnianie, wstrzykiwanie zależności itp. — znacznie upraszczających typowe zadania w programowaniu webowym.

Główne zalety i cechy Symfony

Modułowa architektura: Rdzeniem Symfony jest zestaw wielokrotnie używanych komponentów. Możesz dowolnie je wybierać, by zbudować lekką lub rozbudowaną aplikację.
Wysoka wydajność: Dzięki zoptymalizowanej architekturze, skutecznym mechanizmom cache i wsparciu najnowszych możliwości PHP, Symfony zapewnia dużą wydajność działania.
Silne wsparcie społeczności: Rozwijane przez dużą społeczność deweloperów, z szerokim dostępem do pluginów (Bundle) i dokumentacji — łatwo znaleźć rozwiązanie napotkanych problemów.
Elastyczność: Możliwość łatwej integracji z wieloma bibliotekami i rozszerzeniami zewnętrznymi, odpowiednie dla projektów różnej wielkości i złożoności.
Stabilność i łatwa konserwacja: Dobry styl kodowania i wzorce projektowe pomagają w testowaniu, utrzymaniu i rozbudowie aplikacji.

Symfony sprawdzi się zarówno przy małych API, jak i rozbudowanych systemach klasy enterprise.

Tworzenie i uruchamianie projektu Symfony z ServBay

ServBay zapewnia kompletne środowisko do pracy z Symfony, w tym wymagane wersje PHP, Composer, serwery WWW i szeroki wybór baz danych oraz rozwiązań cache. Ta sekcja przeprowadzi Cię krok po kroku przez stworzenie i konfigurację nowego projektu Symfony w ServBay.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że masz:

Zainstalowany ServBay: ServBay został pomyślnie zainstalowany i uruchomiony na Twoim macOS. Jeżeli nie, skorzystaj z przewodnika instalacji ServBay.
Działający ServBay: Upewnij się, że serwisy kluczowe (Caddy lub Apache oraz bazy danych) są aktywne.
Podstawowa wiedza: Znasz podstawy PHP, Composer oraz ogólne pojęcia dotyczące Symfony.

Tworzenie projektu Symfony

Zalecane jest przechowywanie wszystkich stron w katalogu /Applications/ServBay/www, co pozwala ServBay łatwo je zarządzać i rozpoznawać.

Sprawdzenie dostępności Composer
Composer jest domyślnie zainstalowany wraz z ServBay i poprawnie skonfigurowany. Nie musisz go instalować osobno. Sprawdź jego dostępność poleceniem composer --version w terminalu.
Utworzenie katalogu projektu
W katalogu głównym stron utwórz nowy folder na projekt Symfony:
bash
```
cd /Applications/ServBay/www
mkdir servbay-symfony-app
```
1
2
Utworzenie projektu Symfony przez Composer
Wejdź do swojego katalogu projektu i użyj Composer do zainicjowania szkielety projektu na bazie website-skeleton — bazowego szablonu do klasycznych aplikacji webowych:
bash
```
cd /Applications/ServBay/www/servbay-symfony-app
composer create-project symfony/website-skeleton .
```
1
2
Composer pobierze pliki rdzeniowe Symfony wraz z zależnościami.

Konfiguracja początkowa

Kluczowa konfiguracja projektu Symfony zarządzana jest za pomocą zmiennych środowiskowych, które przechowywane są w pliku .env w głównym katalogu projektu.

Edycja pliku .env (zmienne środowiskowe)
Otwórz plik .env w katalogu głównym projektu. Znajdziesz w nim konfigurację środowiskową (dane do bazy, klucz aplikacji itp.). Edytuj lub dodaj konfiguracje zgodnie z własnymi potrzebami.
Upewnij się, że ustawienia są adekwatne do środowiska ServBay:
dotenv
```
# Przykład pliku .env
APP_ENV=dev # środowisko developerskie
APP_SECRET=your_secret_key # zamień na unikalny losowy ciąg znaków do celów bezpieczeństwa

# Przykłady połączeń do baz danych (więcej poniżej)
# DATABASE_URL="mysql://db_user:[email protected]:3306/db_name?serverVersion=8.0&charset=utf8mb4"
# DATABASE_URL="postgresql://db_user:[email protected]:5432/db_name?serverVersion=13&charset=utf8"
# DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"
```
1
2
3
4
5
6
7
8
Zastąp your_secret_key bezpiecznym losowym ciągiem. Domyślny użytkownik to zazwyczaj root, a hasło password (w środowisku produkcyjnym zawsze zmień te dane!). W przykładzie nazwę bazy użyjemy servbay_symfony_app.

Konfiguracja serwera WWW (strona w ServBay)

Aby móc wyświetlać aplikację w przeglądarce, skonfiguruj lokalny wirtualny host przez funkcję „Strony” w ServBay. Katalogiem publicznym Symfony jest public/ w katalogu projektu.

W panelu ServBay przejdź do ustawień „Strony” (lub „Hosts” w starszych wersjach) i dodaj nową stronę:

Nazwa (Name): Wybierz rozpoznawalną nazwę, np. My Symfony Dev Site.
Domena (Domain): Wprowadź lokalną domenę, np. servbay-symfony-test.local. ServBay skonfiguruje ją automatycznie.
Typ strony (Website Type): Wybierz PHP.
Wersja PHP (PHP Version): Wybierz wersję PHP zgodną z Twoim projektem (najlepiej najnowszą dostępną, np. 8.3).
Katalog publiczny strony (Website Root): Ustaw na /Applications/ServBay/www/servbay-symfony-app/public.

Po zapisaniu ServBay zaktualizuje ustawienia serwera. Domyślnie wykorzystywany jest Caddy lub Apache, a także automatycznie generowany jest zaufany certyfikat SSL – możesz korzystać bezpośrednio z HTTPS.

Szczegóły konfiguracji: Dodawanie pierwszej strony w ServBay.

Dodanie przykładowego kodu

Aby sprawdzić poprawność konfiguracji strony, dodamy prostą trasę i kontroler wyświetlający tekst przy wejściu na główną ścieżkę.

Dodanie trasy (config/routes.yaml)
Otwórz plik config/routes.yaml i dodaj trasę dla /, wskazującą na metodę kontrolera index:
yaml
```
# config/routes.yaml
index:
    path: /
    controller: App\Controller\DefaultController::index
```
1
2
3
4

Tworzenie kontrolera (src/Controller/DefaultController.php)

Stwórz plik DefaultController.php w katalogu src/Controller/ z następującą treścią:

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!');
    }
}

Tworzysz tym samym prosty kontroler o nazwie DefaultController i metodzie index, powiązanej dzięki @Route("/") z główną ścieżką. Przy wejściu na główną stronę zwracany jest tekst "Hello ServBay and Symfony!".

Dostęp do strony

Otwórz przeglądarkę internetową i przejdź na skonfigurowaną domenę, np. https://servbay-symfony-test.local. Jeżeli wszystko zostało poprawnie skonfigurowane, zobaczysz na stronie:

Hello ServBay and Symfony!

Oznacza to, że Twój projekt Symfony został pomyślnie uruchomiony w środowisku ServBay. Ponieważ certyfikat SSL jest wygenerowany automatycznie, zaleca się korzystanie z adresu https://.

Przykłady integracji bazy danych i cache

Dzięki Doctrine ORM Symfony radzi sobie ze standardowymi bazami danych relacyjnymi, a komponent Symfony Cache umożliwia wygodną pracę z cache i bazami NoSQL. ServBay zapewnia pełną integrację z wieloma bazami danych i obsługę odpowiednich rozszerzeń PHP.

Przykład integracji z relacyjną bazą danych (Doctrine ORM)

ServBay obsługuje MySQL i PostgreSQL. Oto jak skonfigurować Symfony do pracy z tymi bazami.

Konfiguracja połączenia z bazą
W pliku .env odkomentuj i zmodyfikuj ustawienia DATABASE_URL zgodnie z wybraną bazą.
- Dla MySQL: Domyślny użytkownik: root, hasło: password, port: 3306.
  dotenv
```
# .env
DATABASE_URL="mysql://root:[email protected]:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"
```
  1
  2
- Dla PostgreSQL: Domyślny użytkownik: root, hasło: password, port: 5432.
  dotenv
```
# .env
DATABASE_URL="postgresql://root:[email protected]:5432/servbay_symfony_app?serverVersion=13&charset=utf8"
```
  1
  2
Pamiętaj, aby wybrana usługa bazy była uruchomiona w panelu ServBay.
Tworzenie bazy danych
Jeśli baza servbay_symfony_app nie istnieje, stwórz ją ręcznie np. przez phpMyAdmin/pgAdmin w ServBay lub poleceniem:
bash
```
php bin/console doctrine:database:create
```
1
Tworzenie Entity oraz plików migracji
W Symfony każda tabela odzwierciedlona jest jako klasa Entity. Do generowania szkieletów pomocny jest Maker Bundle.
- Stwórz Entity (np. encja User):
  bash
```
php bin/console make:entity User
```
  1
  Dodaj np. pola name (string) i email (string, unique=yes).
- Wygeneruj plik migracji:
  bash
```
php bin/console make:migration
```
  1
  To utworzy plik migracji SQL dla tabeli users w katalogu src/Migrations.
Wykonanie migracji
Zastosuj strukturę bazy danych poprzez:
bash
```
php bin/console doctrine:migrations:migrate
```
1

Dodanie przykładowych operacji na bazie

Zmień src/Controller/DefaultController.php tak, aby używał EntityManagera do zapisu i odczytu danych.

Upewnij się, że konstruktor DefaultController przyjmuje 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; // Importuj EntityManagerInterface
use App\Entity\User; // Import klasy User
use Symfony\Component\HttpFoundation\JsonResponse; // Obsługa JSON

class DefaultController
{
    private $entityManager;

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

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

    // ... inne metody ...
}

Dodaj nowe trasy w config/routes.yaml:

yaml

# config/routes.yaml
# ... inne trasy ...
mysql_add_user:
    path: /mysql-add-user # lub /pgsql-add-user w zależności od użytej bazy
    controller: App\Controller\DefaultController::addUser
mysql_get_users:
    path: /mysql-users # lub /pgsql-users
    controller: App\Controller\DefaultController::getUsers

W src/Controller/DefaultController.php dodaj odpowiednie metody:

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; // Import JSON

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 nazwą ServBay
        $user->setName('ServBay Demo User');
        $user->setEmail('[email protected]');

        $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 wszystkich użytkowników z bazy
        $users = $this->entityManager->getRepository(User::class)->findAll();

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

        return new JsonResponse($usersArray);
    }
}

Sprawdzenie działania
- Odwiedź https://servbay-symfony-test.local/add-user, by dodać przykładowego użytkownika.
- Przejdź do https://servbay-symfony-test.local/get-users, by zobaczyć listę użytkowników (format JSON).

Przykład cache i bazy NoSQL (Symfony Cache)

ServBay ma wbudowane usługi Redis i Memcached z odpowiednimi rozszerzeniami PHP. W Symfony możesz łatwo korzystać z Symfony Cache, by współpracować z tymi serwisami.

Konfiguracja połączenia cache
W pliku .env ustaw kanał cache w zależności od wybranej usługi.
- Dla Memcached: Domyślny port Memcached to 11211.
  dotenv
```
# .env
# ... pozostałe konfiguracje ...
CACHE_DSN=memcached://127.0.0.1:11211
```
  1
  2
  3
  Upewnij się, że usługa jest aktywna w panelu ServBay.
- Dla Redis: Domyślny port Redis to 6379.
  dotenv
```
# .env
# ... pozostałe konfiguracje ...
CACHE_DSN=redis://127.0.0.1:6379
# Jeśli Redis wymaga hasła (domyślnie w ServBay nie), ustaw tak:
# CACHE_DSN=redis://:[email protected]:6379
```
  1
  2
  3
  4
  5
  Upewnij się, że serwis Redis jest uruchomiony w ServBay.

Przykład użycia cache

Rozszerz klasę DefaultController o obsługę cache (cache przez CacheInterface w konstruktorze):

Najpierw uzupełnij konstruktor o parametr CacheInterface:

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; // Import CacheInterface

class DefaultController
{
    private $entityManager;
    private $cache; // Pole cache

    // Konstruktor z wstrzyknięciem 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ę 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;
use Symfony\Component\Cache\Item\ItemInterface; // Import 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 je wygeneruj
        $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
            // Jeśli brak cache, wykonaj operację i zapisz do cache
            $item->expiresAfter(3600); // ważność cache: 1 godzina

            // Symuluj ciężką operację np. pobranie danych z bazy
            $data = "Data generated at " . date('Y-m-d H:i:s');

            // Dane do zakodowania
            return $data;
        });

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

        return new Response($output);
    }
}

Test działania
- Odwiedź https://servbay-symfony-test.local/cache-example. Przy pierwszym wejściu zwrócona będzie nowa wygenerowana wartość, przy kolejnych cachowana (dopóki nie wygaśnie).

Najczęstsze pytania (FAQ)

Q: Po wejściu na https://servbay-symfony-test.local widzę błąd 404 lub 500. Co robić?

A: Sprawdź:

Czy ServBay działa, a serwis (Caddy lub Apache) jest uruchomiony.
Czy konfiguracja strony w ServBay jest poprawna — szczególnie domena i katalog publiczny /Applications/ServBay/www/servbay-symfony-app/public.
Zajrzyj do logów Symfony (var/log/dev.log), by znaleźć szczegóły błędów.
W katalogu projektu uruchom composer install, by pobrać zależności.
Sprawdź, czy wybrana wersja PHP jest zgodna z wymogami Twojego projektu Symfony.

Q: Nie mogę połączyć się z bazą danych. Jak rozwiązać problem?

A: Sprawdź:

Czy usługa MySQL lub PostgreSQL w ServBay jest uruchomiona.
Konfigurację DATABASE_URL w .env — sprawdź użytkownika (root), hasło (password), host (127.0.0.1), port (MySQL: 3306, PostgreSQL: 5432), nazwę bazy.
Czy dane logowania do bazy są aktualne.
Czy baza servbay_symfony_app istnieje.

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

A: Upewnij się, że bieżący katalog w terminalu to /Applications/ServBay/www/servbay-symfony-app oraz, że wersja PHP używana w systemie to ta dostarczana przez ServBay (sprawdź przez which php). ServBay zwykle ustawia odpowiednio zmienne środowiskowe podczas instalacji.

Podsumowanie

Dzięki temu przewodnikowi utworzyłeś, skonfigurowałeś i uruchomiłeś projekt Symfony na macOS z wykorzystaniem ServBay. ServBay udostępnia wszystkie niezbędne komponenty (PHP, Composer, serwer WWW, bazy danych, cache) i upraszcza konfigurację środowiska — możesz skupić się na pracy programistycznej. Możesz na tej bazie rozwijać kolejne obszary projektu oraz korzystać z innych pakietów udostępnianych przez ServBay.

Tworzenie i uruchamianie projektu Symfony ​

Czym jest Symfony? ​

Główne zalety i cechy Symfony ​

Tworzenie i uruchamianie projektu Symfony z ServBay ​

Wymagania wstępne ​

Tworzenie projektu Symfony ​

Konfiguracja początkowa ​

Konfiguracja serwera WWW (strona w ServBay) ​

Dodanie przykładowego kodu ​

Dostęp do strony ​

Przykłady integracji bazy danych i cache ​

Przykład integracji z relacyjną bazą danych (Doctrine ORM) ​

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

Najczęstsze pytania (FAQ) ​

Podsumowanie ​