Tworzenie i uruchamianie projektu CodeIgniter

Czym jest CodeIgniter?

CodeIgniter to lekki i wydajny framework do tworzenia aplikacji webowych w PHP. Opiera się na wzorcu Model-View-Controller (MVC), mając na celu umożliwienie deweloperom szybkiego budowania zaawansowanych aplikacji webowych. Dzięki prostej strukturze, świetnej wydajności i łatwości nauki, CodeIgniter jest często wybieranym frameworkiem wśród programistów PHP.

Najważniejsze cechy i zalety CodeIgniter

• Lekki rdzeń: Sercem CodeIgniter jest skondensowany system zawierający wyłącznie podstawowe komponenty niezbędne do działania, zapewniający bardzo szybkie ładowanie.
• Wysoka wydajność: Konstrukcja frameworka nastawiona jest na efektywność – radzi sobie z obsługą dużej liczby żądań, gwarantując znakomite osiągi aplikacji.
• Łatwość nauki: Czytelna dokumentacja i intuicyjne API pozwalają szybko opanować framework nawet początkującym.
• Duża elastyczność: Programiści mogą dowolnie integrować biblioteki zewnętrzne oraz rozszerzać i dostosowywać funkcje do wymagań projektu.
• Aktywna społeczność: Rozbudowana i pomocna społeczność dostarcza bogactwo zasobów i wsparcia.

CodeIgniter sprawdza się zarówno przy małych projektach, jak i przy rozbudowanych rozwiązaniach korporacyjnych, umożliwiając szybkie tworzenie wysokiej jakości aplikacji webowych.

Konfiguracja środowiska CodeIgniter za pomocą ServBay

ServBay to narzędzie stworzone z myślą o macOS, umożliwiające lokalne tworzenie środowisk webowych. Zawiera ono zintegrowane wersje PHP oraz bazy danych (MySQL, PostgreSQL, MongoDB), usługi cache (Redis, Memcached), serwery WWW (Caddy, Nginx, Apache) oraz wygodny interfejs do zarządzania. Dzięki ServBay z łatwością skonfigurujesz i przeprowadzisz administrację środowiskiem niezbędnym dla CodeIgnitera.

Ten poradnik krok po kroku pokazuje, jak wykorzystać PHP i funkcje „Websites” ServBay do utworzenia, skonfigurowania i uruchomienia projektu CodeIgniter oraz zintegrowania go z bazami danych i usługami cache.

Wymagania wstępne

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

• ServBay jest zainstalowany i uruchomiony na Twoim macOS.
• W ServBay została aktywowana wybrana przez Ciebie wersja PHP (np. PHP 8.3).
• W ServBay zostały włączone wymagane bazy danych oraz usługi cache (np. MySQL, PostgreSQL, Redis, Memcached).

Tworzenie projektu CodeIgniter

Dla wygody zarządzania ServBay zaleca przechowywanie projektów stron WWW w katalogu /Applications/ServBay/www.

1. Instalacja Composera

   Wraz z instalacją ServBay otrzymujesz w pakiecie zintegrowanego Composera, dlatego nie musisz instalować go osobno. Możesz używać komendy composer bezpośrednio w terminalu.

2. Przejście do katalogu root strony

   Otwórz terminal i przejdź do katalogu podstawowego dla stron www zalecanego przez ServBay:

   cd /Applications/ServBay/www

3. Tworzenie projektu CodeIgniter

   Za pomocą Composera utwórz nowy projekt CodeIgniter 4 – katalog projektu nazwijmy servbay-codeigniter-app:

   composer create-project codeigniter4/appstarter servbay-codeigniter-app

   Composer pobierze podstawową strukturę CodeIgnitera i wszystkie zależności do wybranego katalogu.

4. Wejście do katalogu projektu

   Przejdź do nowo utworzonego katalogu projektu:

   cd /Applications/ServBay/www/servbay-codeigniter-app

Wstępna konfiguracja

Konfiguracja połączenia z bazą danych

Konfiguracja bazy danych dla CodeIgniter znajduje się w pliku app/Config/Database.php. Przed rozpoczęciem korzystania z bazy danych należy wprowadzić tam odpowiednie dane dostępowe.

Najpierw, jeśli zamierzasz używać bazy danych, utwórz ją za pomocą narzędzi oferowanych przez ServBay, takich jak Adminer lub phpMyAdmin (dostępne z poziomu aplikacji ServBay). Zalecana nazwa bazy danych: servbay_codeigniter_app.

Następnie edytuj plik app/Config/Database.php, znajdź tablicę $default i wpisz dane odpowiednie do wybranego typu bazy danych (np. MySQL lub PostgreSQL). Domyślna nazwa użytkownika ServBay to root, a hasło: password.

Przykładowa konfiguracja MySQL:

public $default = [
    'DSN'      => '',
    'hostname' => '127.0.0.1', // Baza ServBay zwykle nasłuchuje na 127.0.0.1
    'username' => 'root',     // Domyślny użytkownik ServBay
    'password' => 'password', // Domyślne hasło ServBay
    'database' => 'servbay_codeigniter_app', // Nazwa utworzonej bazy danych
    'DBDriver' => 'MySQLi',   // W zależności od bazy, MySQL używa MySQLi lub Pdo
    'DBPrefix' => '',
    'pConnect' => false,
    'DBDebug'  => (ENVIRONMENT !== 'production'),
    'charset'  => 'utf8mb4',
    'DBCollat' => 'utf8mb4_general_ci',
    'swapPre'  => '',
    'encrypt'  => false,
    'compress' => false,
    'strictOn' => false,
    'failover' => [],
    'port'     => 3306,       // Domyślny port MySQL
];

Dla PostgreSQL ustaw DBDriver na 'Postgre', port zazwyczaj to 5432, a ustawienia dotyczące charsetu mogą wymagać dostosowania.

Konfiguracja połączenia z cache (Memcached/Redis)

Gdy planujesz skorzystać z usług cache – Memcached lub Redis – skonfiguruj je w pliku app/Config/Cache.php.

Edytuj plik app/Config/Cache.php i znajdź odpowiednią sekcję konfiguracji. Domyślny port dla Memcached to 11211, a dla Redis to 6379; najczęściej nie jest wymagane hasło.

Przykład konfiguracji Memcached:

public $memcached = [
    'host'   => '127.0.0.1', // Serwis Memcached ServBay zwykle jest na 127.0.0.1
    'port'   => 11211,      // Domyślny port Memcached
    'weight' => 1,
];

Przykład konfiguracji Redis:

public string $handler = 'redis'; // Ustaw podstawowy handler cache na redis

public $default = [ // Konfiguracja Redis zwykle w tablicy default
    'host'     => '127.0.0.1', // Serwis Redis ServBay zwykle jest na 127.0.0.1
    'password' => null,       // Domyślnie bez hasła
    'port'     => 6379,       // Domyślny port Redis
    'timeout'  => 0,
    'database' => 0,
];

Dostosuj konfigurację do wybranego przez siebie systemu cache i aktywowanych usług w ServBay.

Konfiguracja serwera WWW (strony Serwowane przez ServBay)

Korzystaj z funkcji „Websites” ServBay, by skonfigurować serwer WWW wskazujący katalog projektu CodeIgniter.

1. Otwórz aplikację ServBay.
2. Przejdź do zakładki Websites.
3. Kliknij przycisk + w lewym dolnym rogu, aby dodać nową stronę.
4. Wypełnij dane strony:
   • Nazwa (Name): Wpisz rozpoznawalną nazwę, np. My First CodeIgniter Dev Site.
   • Domena (Domain): Wpisz domenę, pod którą chcesz korzystać lokalnie, np. servbay-codeigniter-test.local. ServBay automatycznie skieruje domenę .local na maszynę lokalną.
   • Typ strony (Site Type): Wybierz PHP.
   • Wersja PHP (PHP Version): Wybierz żądaną wersję PHP, np. 8.3.
   • Katalog główny (Document Root): To ważny krok. Plik wejściowy CodeIgniter (index.php) znajduje się w public w katalogu projektu. Katalog główny musi wskazywać folder public projektu: /Applications/ServBay/www/servbay-codeigniter-app/public.
5. Kliknij Add (Dodaj), by zapisać ustawienia.
6. ServBay może poprosić o zatwierdzenie zmian – kliknij, aby potwierdzić.

Szczegóły konfiguracji znajdziesz w Dodawanie pierwszej strony.

Dodanie przykładowego kodu

Aby przetestować, czy projekt działa prawidłowo i obsługuje połączenia z bazą danych oraz cache, zmodyfikuj kontroler domyślny Home i dodaj kilka przykładowych metod.

Edytuj plik app/Controllers/Home.php i zamień jego treść na poniższą:

<?php

namespace App\Controllers;

use CodeIgniter\Controller;
use CodeIgniter\Database\Exceptions\DatabaseException; // Import klasy wyjątków bazy danych
use CodeIgniter\Cache\Exceptions\CacheException; // Import klasy wyjątków cache

class Home extends Controller
{
    /**
     * Domyślna metoda strony głównej
     */
    public function index(): string
    {
        // Wyświetl proste powitanie
        return '<h1>Hello ServBay and CodeIgniter!</h1><p>Your CodeIgniter project is running on ServBay.</p>';
    }

    /**
     * Przykład użycia Memcached
     */
    public function memcached(): string
    {
        try {
            $cache = \Config\Services::cache();

            // Próba zapisu do cache
            $success = $cache->save('servbay_memcached_key', 'Hello Memcached from CodeIgniter!', 60); // Cache na 60 sekund

            if (!$success) {
                 return 'Error: Failed to save data to Memcached. Check Memcached service and configuration.';
            }

            // Próba odczytu z cache
            $value = $cache->get('servbay_memcached_key');

            if ($value === null) {
                return 'Error: Failed to get data from Memcached. Cache might have expired or service is down.';
            }

            return 'Memcached Test Success: ' . $value;

        } catch (CacheException $e) {
            // Obsługa wyjątków związanych z cache
            return 'Cache Error: ' . $e->getMessage() . '. Ensure Memcached service is running and configured correctly.';
        } catch (\Exception $e) {
            // Obsługa innych nieoczekiwanych wyjątków
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Przykład użycia Redis
     */
    public function redis(): string
    {
        try {
            $cache = \Config\Services::cache();

            // Próba zapisu do cache
            $success = $cache->save('servbay_redis_key', 'Hello Redis from CodeIgniter!', 60); // Cache na 60 sekund

             if (!$success) {
                 return 'Error: Failed to save data to Redis. Check Redis service and configuration.';
            }

            // Próba odczytu z cache
            $value = $cache->get('servbay_redis_key');

             if ($value === null) {
                return 'Error: Failed to get data from Redis. Cache might have expired or service is down.';
            }

            return 'Redis Test Success: ' . $value;

        } catch (CacheException $e) {
             // Obsługa wyjątków związanych z cache
            return 'Cache Error: ' . $e->getMessage() . '. Ensure Redis service is running and configured correctly.';
        } catch (\Exception $e) {
            // Obsługa innych nieoczekiwanych wyjątków
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Dodawanie użytkownika do bazy danych (MySQL/PostgreSQL)
     */
    public function addUser(): string
    {
        try {
            $db = \Config\Database::connect();

            // Sprawdzenie, czy tabela 'users' istnieje (zabezpieczenie)
            if (!$db->tableExists('users')) {
                 return 'Error: "users" table does not exist. Please run database migrations first.';
            }

            // Dodanie rekordu
            $data = [
                'name' => 'ServBay Demo User',
                'email' => 'user_' . time() . '@servbay.demo', // Unikalny email na podstawie time()
            ];

            $db->table('users')->insert($data);

            // Opcjonalnie: sprawdzenie sukcesu (insert() zwykle zwraca true)
            // if ($db->affectedRows() > 0) {
                 return 'User added successfully: ' . $data['email'];
            // } else {
            //      return 'Error: Failed to add user.';
            // }

        } catch (DatabaseException $e) {
            // Obsługa wyjątków bazy danych
            return 'Database Error: ' . $e->getMessage() . '. Check database connection and table structure.';
        } catch (\Exception $e) {
             // Obsługa innych nieoczekiwanych wyjątków
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Pobieranie listy użytkowników z bazy danych (MySQL/PostgreSQL)
     */
    public function listUsers(): string
    {
         try {
            $db = \Config\Database::connect();

             // Sprawdzenie, czy tabela 'users' istnieje
            if (!$db->tableExists('users')) {
                 return 'Error: "users" table does not exist. Please run database migrations first.';
            }

            // Pobranie wszystkich użytkowników
            $users = $db->table('users')->get()->getResult();

            if (empty($users)) {
                return 'No users found in the database.';
            }

            // Zwrócenie listy użytkowników w formacie JSON
            return json_encode($users);

        } catch (DatabaseException $e) {
             // Obsługa wyjątków bazy danych
            return 'Database Error: ' . $e->getMessage() . '. Check database connection and table structure.';
        } catch (\Exception $e) {
            // Obsługa innych nieoczekiwanych wyjątków
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }
}

Zaktualizowany kontroler przedstawia czytelniejszy output i podstawową obsługę błędów, ułatwiającą diagnozowanie.

Konfiguracja routera

Aby umożliwić dostęp do nowych metod kontrolera Home przez adresy URL, uzupełnij plik routingu CodeIgniter – app/Config/Routes.php.

Edytuj plik app/Config/Routes.php. Znajdź sekcję zdefiniowaną przez $routes i dodaj następujące reguły:

// ... inne reguły routingu ...

// Przykładowa trasa Memcached
$routes->get('/memcached', 'Home::memcached');

// Przykładowa trasa Redis
$routes->get('/redis', 'Home::redis');

// Przykładowe trasy bazy danych
$routes->get('/add-user', 'Home::addUser');
$routes->get('/list-users', 'Home::listUsers');

// ... inne reguły routingu ...

Dodaj te reguły do istniejącej sekcji $routes, nie nadpisuj dotychczasowych pozycji.

Odwiedzanie swojej strony

Projekt CodeIgniter jest już skonfigurowany i uruchomiony przez ServBay. Otwórz przeglądarkę i odwiedź adres przypisany podczas dodawania strony:

• Strona główna: https://servbay-codeigniter-test.local
  Powinieneś zobaczyć komunikat: Hello ServBay and CodeIgniter! – to znak, że serwis działa poprawnie.

• Test Memcached: https://servbay-codeigniter-test.local/memcached
  Jeśli usługa Memcached oraz jej konfiguracja są poprawne, zobaczysz komunikat podobny do: Memcached Test Success: Hello Memcached from CodeIgniter!.

• Test Redis: https://servbay-codeigniter-test.local/redis
  Jeśli usługa Redis oraz konfiguracja są w porządku, zobaczysz komunikat podobny do: Redis Test Success: Hello Redis from CodeIgniter!.

Przykłady operacji na bazie danych (MySQL/PostgreSQL)

Zanim przetestujesz przykład użycia bazy danych, wykonaj migrację CodeIgniter, by utworzyć tabelę users.

Tworzenie struktury bazy danych (uruchomienie migracji)

1. Otwórz terminal i przejdź do katalogu projektu:

   cd /Applications/ServBay/www/servbay-codeigniter-app

2. Tworzenie pliku migracji: Skorzystaj z CLI CodeIgniter, by wygenerować migrację definiującą strukturę tabeli users:

   php spark make:migration create_users_table

   Plik migracji zostanie stworzony w app/Database/Migrations.

3. Edytowanie pliku migracji: Otwórz nowo utworzony plik (nazwa w stylu YYYY-MM-DD-HHMMSS_CreateUsersTable.php) i zmodyfikuj metodę up(), by zdefiniować strukturę tabeli users. Zwróć uwagę, że MySQL i PostgreSQL mają nieco odmienne składnie domyślnych wartości dla pól timestamp (CURRENT_TIMESTAMP vs NOW()). Klasa RawSql CodeIgniter umożliwia dynamiczne ich ustawienie. Przykład:

   <?php
   
   namespace App\Database\Migrations;
   
   use CodeIgniter\Database\Migration;
   use CodeIgniter\Database\RawSql; // Import klasy RawSql
   
   class CreateUsersTable extends Migration
   {
       public function up()
       {
           $this->forge->addField([
               'id'          => [
                   'type'           => 'INT',
                   'constraint'     => 5,
                   'unsigned'       => true,
                   'auto_increment' => true,
               ],
               'name'       => [
                   'type'       => 'VARCHAR',
                   'constraint' => '100',
               ],
               'email'      => [
                   'type'       => 'VARCHAR',
                   'constraint' => '100',
                   'unique'     => true, // Email jako pole unikalne
               ],
               'created_at' => [
                   'type'    => 'TIMESTAMP',
                   // Dynamiczny wybór składni domyślnej wartości zależnie od bazy
                   // MySQL: 'default' => new RawSql('CURRENT_TIMESTAMP'),
                   // PostgreSQL: 'default' => new RawSql('NOW()'),
                   'default' => new RawSql($this->db->getPlatform() === 'MySQLi' ? 'CURRENT_TIMESTAMP' : 'NOW()'),
               ],
               'updated_at' => [
                   'type'    => 'TIMESTAMP',
                   // MySQL: 'default' => new RawSql('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'),
                   // PostgreSQL: 'default' => new RawSql('NOW()'),
                    'default' => new RawSql($this->db->getPlatform() === 'MySQLi' ? 'CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP' : 'NOW()'),
               ],
           ]);
           $this->forge->addKey('id', true); // Ustaw główny klucz na 'id'
           $this->forge->createTable('users'); // Utwórz tabelę users
       }
   
       public function down()
       {
           // Rollback migracji – usuń tabelę users
           $this->forge->dropTable('users');
       }
   }

   Uwaga: Powyższy przykład dynamicznie dostosowuje domyślne wartości timestamp do używanej bazy danych. W większych projektach może być konieczne przygotowanie oddzielnych migracji lub stosowania dodatkowych zabezpieczeń.

4. Uruchamianie migracji: W terminalu wykonaj:

   php spark migrate

   Po pomyślnym zakończeniu zobaczysz odpowiedni komunikat w terminalu. Możesz również sprawdzić w bazie (np. przez Adminer), czy tabela users została utworzona w servbay_codeigniter_app.

Testowanie operacji na bazie danych

Upewnij się, że konfiguracja połączenia z bazą danych (app/Config/Database.php) jest poprawna i przeprowadziłeś migrację.

• Dodanie użytkownika: Wejdź na https://servbay-codeigniter-test.local/add-user
  Za każdym razem w tabeli users zostanie umieszczony nowy użytkownik. Zobaczysz komunikat np.: User added successfully: user_XXXXXXXXXX@servbay.demo.

• Wyświetlenie listy użytkowników: Wejdź na https://servbay-codeigniter-test.local/list-users
  Ta trasa pobierze i zwróci JSON z listą użytkowników z tabeli users.

Podsumowanie

Przechodząc przez powyższe kroki, utworzyłeś, skonfigurowałeś i uruchomiłeś projekt CodeIgniter w środowisku ServBay na macOS. Dowiedziałeś się, jak zainicjować projekt za pomocą Composera, skonfigurować stronę w ServBay wskazując odpowiedni katalog, skonfigurować połączenia CodeIgniter z bazą danych i cache oraz jak przetestować je przy użyciu prostego kodu. ServBay znacząco upraszcza zakładanie i zarządzanie lokalnym środowiskiem pracy – możesz skupić się na właściwym rozwoju aplikacji CodeIgniter.