Ein CodeIgniter-Projekt erstellen und ausführen

Was ist CodeIgniter?

CodeIgniter ist ein leichtgewichtiges und performantes PHP-Web-Anwendungsframework. Es folgt dem Model-View-Controller (MVC)-Entwurfsmuster und wurde entwickelt, um Entwicklern beim schnellen Aufbau funktionsreicher Webanwendungen zu helfen. Mit seiner klaren Struktur, herausragenden Performance und der einfachen Lernkurve ist CodeIgniter die bevorzugte Wahl vieler PHP-Entwickler.

Hauptmerkmale und Vorteile von CodeIgniter

• Leichter Kern: Das Core-System von CodeIgniter ist äußerst schlank und enthält nur die notwendigsten Komponenten – was für besonders schnelle Ladezeiten sorgt.
• Exzellente Performance: Das Framework ist auf Effizienz getrimmt und kann hohe Anfragenlasten problemlos verarbeiten, was großartige Performance für Anwendungen bedeutet.
• Einfache Einstiegsmöglichkeiten: Dank klarer Dokumentation und einer intuitiven API ist der Einstieg einfach und die Lernkurve niedrig.
• Hohe Flexibilität: Entwickler können je nach Projektbedarf beliebig Drittanbieter-Bibliotheken integrieren, was eine unkomplizierte Erweiterung und Individualisierung ermöglicht.
• Aktive Community: Eine große und hilfsbereite Entwickler-Community bietet zahlreiche Ressourcen und Support.

CodeIgniter eignet sich für kleine bis hin zu großen Enterprise-Projekten und unterstützt Sie bei der effizienten Umsetzung qualitativ hochwertiger Weblösungen.

CodeIgniter-Entwicklungsumgebung mit ServBay einrichten

ServBay ist ein für macOS entwickeltes lokales Webentwicklungstool. Es vereint PHP, Datenbanken (MySQL, PostgreSQL, MongoDB), Caching-Lösungen (Redis, Memcached), Webserver (Caddy, Nginx, Apache) und vieles mehr in einer zentralen Anwendung mit komfortabler Benutzeroberfläche. Mit ServBay können Sie ganz einfach die benötigte Entwicklungsumgebung für CodeIgniter-Projekte aufbauen und verwalten.

In diesem Leitfaden zeigen wir Ihnen, wie Sie mit der PHP-Umgebung und der Webseiten-Funktion von ServBay ein CodeIgniter-Projekt erstellen, konfigurieren und starten – einschließlich der Integration verschiedener Datenbanken und Cache-Dienste.

Voraussetzungen

Stellen Sie vor dem Start bitte sicher, dass folgende Bedingungen erfüllt sind:

• ServBay ist auf Ihrem macOS-System erfolgreich installiert und läuft.
• Die gewünschte PHP-Version (z. B. PHP 8.3) ist in ServBay aktiviert.
• Die von Ihnen benötigten Datenbank- und Cache-Komponenten (z. B. MySQL, PostgreSQL, Redis, Memcached) sind in ServBay aktiviert.

CodeIgniter-Projekt erstellen

ServBay empfiehlt, Ihre Website-Projekte einheitlich unter /Applications/ServBay/www abzulegen. Das erleichtert die lokale Verwaltung der Webseiten durch ServBay.

1. Composer installieren

   ServBay bringt Composer bereits vorinstalliert mit, eine manuelle Installation ist in der Regel nicht nötig. Sie können den Befehl composer direkt im Terminal verwenden.

2. Wechseln Sie ins Webverzeichnis

   Öffnen Sie das Terminal und gehen Sie in das von ServBay empfohlene Webverzeichnis:

   cd /Applications/ServBay/www

3. CodeIgniter-Projekt erstellen

   Nutzen Sie Composer, um ein neues CodeIgniter-4-Projekt anzulegen. Das Projektverzeichnis nennen wir servbay-codeigniter-app:

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

   Composer lädt das CodeIgniter-Grundgerüst sowie alle Abhängigkeiten in das Verzeichnis servbay-codeigniter-app.

4. Wechseln Sie ins Projektverzeichnis

   Navigieren Sie ins frisch angelegte CodeIgniter-Projektverzeichnis:

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

Initialkonfiguration

Datenbankverbindung konfigurieren

Die Konfiguration für die Datenbank befindet sich in der Datei app/Config/Database.php. Bevor Sie eine Datenbank nutzen können, müssen Sie in dieser Datei die Zugangsdaten anpassen.

Legen Sie zunächst über das Datenbank-Tool von ServBay (z. B. Adminer oder phpMyAdmin, erreichbar über die ServBay-Oberfläche) eine Datenbank namens servbay_codeigniter_app an.

Bearbeiten Sie nun die Datei app/Config/Database.php. Suchen Sie das Array $default und tragen Sie basierend auf der in ServBay aktivierten Datenbank (z. B. MySQL oder PostgreSQL) die korrekten Zugangsdaten ein. Standardmäßig sind Benutzername und Passwort bei ServBay meist root und password.

Ein Beispiel für MySQL:

public $default = [
    'DSN'      => '',
    'hostname' => '127.0.0.1', // ServBay-Datenbank läuft in der Regel auf 127.0.0.1
    'username' => 'root',      // Standard-Benutzername bei ServBay
    'password' => 'password',  // Standard-Passwort bei ServBay
    'database' => 'servbay_codeigniter_app', // Name Ihrer Datenbank
    'DBDriver' => 'MySQLi',    // Je nach genutzter Datenbank: MySQLi oder Pdo für MySQL
    'DBPrefix' => '',
    'pConnect' => false,
    'DBDebug'  => (ENVIRONMENT !== 'production'),
    'charset'  => 'utf8mb4',
    'DBCollat' => 'utf8mb4_general_ci',
    'swapPre'  => '',
    'encrypt'  => false,
    'compress' => false,
    'strictOn' => false,
    'failover' => [],
    'port'     => 3306,        // Standard-Port für MySQL
];

Für PostgreSQL muss DBDriver auf 'Postgre' gesetzt werden; der Port ist normalerweise 5432. Ggf. müssen Sie auch zeichenbezogene Einstellungen anpassen.

Cache-Verbindung konfigurieren (Memcached/Redis)

Wenn Sie Memcached oder Redis als Cache einsetzen möchten, erfolgt die Konfiguration in der Datei app/Config/Cache.php.

Bearbeiten Sie app/Config/Cache.php und suchen Sie den zugehörigen Abschnitt. ServBay nutzt standardmäßig Port 11211 für Memcached und Port 6379 für Redis; meist ist kein Passwort nötig.

Beispiel für Memcached:

public $memcached = [
    'host'   => '127.0.0.1', // Memcached läuft bei ServBay meist auf 127.0.0.1
    'port'   => 11211,       // Standardport Memcached
    'weight' => 1,
];

Beispiel für Redis:

public string $handler = 'redis'; // Setzt Redis als Standard-Cache-Handler

public $default = [ // Redis-Konfiguration meist im default-Array
    'host'     => '127.0.0.1', // Redis läuft bei ServBay meist auf 127.0.0.1
    'password' => null,        // Standardmäßig kein Passwort für Redis bei ServBay
    'port'     => 6379,        // Standardport Redis
    'timeout'  => 0,
    'database' => 0,
];

Passen Sie die entsprechenden Abschnitte Ihrer Konfiguration gemäß den aktivierten Caching-Services an.

Webserver konfigurieren (ServBay-Webseitenfunktion)

Nutzen Sie die Webseiten-Funktion von ServBay, um den Webserver für Ihr CodeIgniter-Projekt einzurichten.

1. Öffnen Sie die ServBay-Anwendung.
2. Wechseln Sie zum Tab Webseiten.
3. Klicken Sie unten links auf das +, um eine neue Website hinzuzufügen.
4. Tragen Sie die Websitedaten ein:
   • Name: Wählen Sie einen erkennbaren Namen wie z. B. My First CodeIgniter Dev Site.
   • Domain: Eine gewünschte lokale Domain, z. B. servbay-codeigniter-test.local. ServBay löst .local-Domains automatisch auf die lokale Maschine auf.
   • Website-Typ: Wählen Sie PHP.
   • PHP-Version: Wählen Sie z. B. 8.3 als gewünschte PHP-Version.
   • Document Root: Sehr wichtig! Die Einstiegspunkt-Datei von CodeIgniter (index.php) befindet sich im public-Ordner Ihres Projekts. Daher muss das Document Root unbedingt auf den public-Ordner Ihres Projekts zeigen, z. B.: /Applications/ServBay/www/servbay-codeigniter-app/public.
5. Klicken Sie auf Hinzufügen (Add), um die Einstellungen zu speichern.
6. ServBay fordert Sie ggf. auf, die Änderungen anzuwenden – bestätigen Sie dies.

Detaillierte Anweisungen finden Sie unter Erste Website hinzufügen.

Beispielcode hinzufügen

Um zu prüfen, ob Ihr Projekt korrekt funktioniert und die Verbindung zu Datenbank sowie Cache klappt, modifizieren wir den Standard-Controller Home von CodeIgniter und ergänzen einige Beispielmethoden.

Editieren Sie die Datei app/Controllers/Home.php und ersetzen Sie deren Inhalt durch folgenden Code:

<?php

namespace App\Controllers;

use CodeIgniter\Controller;
use CodeIgniter\Database\Exceptions\DatabaseException; // Datenbank-Ausnahme-Klasse einbinden
use CodeIgniter\Cache\Exceptions\CacheException; // Cache-Ausnahme-Klasse einbinden

class Home extends Controller
{
    /**
     * Standard-Homepage-Methode
     */
    public function index(): string
    {
        // Gibt eine einfache Willkommensnachricht aus
        return '<h1>Hello ServBay and CodeIgniter!</h1><p>Your CodeIgniter project is running on ServBay.</p>';
    }

    /**
     * Memcached-Beispielmethode
     */
    public function memcached(): string
    {
        try {
            $cache = \Config\Services::cache();

            // Versucht, einen Cache-Wert zu speichern
            $success = $cache->save('servbay_memcached_key', 'Hello Memcached from CodeIgniter!', 60); // 60 Sekunden cachen

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

            // Versucht, den Wert wieder zu lesen
            $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) {
            // Behandlung von Cache-bezogenen Ausnahmen
            return 'Cache Error: ' . $e->getMessage() . '. Ensure Memcached service is running and configured correctly.';
        } catch (\Exception $e) {
            // Behandlung sonstiger unerwarteter Fehler
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Redis-Beispielmethode
     */
    public function redis(): string
    {
        try {
            $cache = \Config\Services::cache();

            // Versucht, einen Wert in Redis zu speichern
            $success = $cache->save('servbay_redis_key', 'Hello Redis from CodeIgniter!', 60); // 60 Sekunden cachen

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

            // Versucht, den Wert wieder zu lesen
            $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) {
             // Behandlung von Cache-bezogenen Ausnahmen
            return 'Cache Error: ' . $e->getMessage() . '. Ensure Redis service is running and configured correctly.';
        } catch (\Exception $e) {
            // Behandlung sonstiger unerwarteter Fehler
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Benutzer-Datensatz zur Datenbank hinzufügen (MySQL/PostgreSQL)
     */
    public function addUser(): string
    {
        try {
            $db = \Config\Database::connect();

            // Prüft, ob die Tabelle 'users' existiert (einfache Sicherheitsmaßnahme)
            if (!$db->tableExists('users')) {
                 return 'Error: "users" table does not exist. Please run database migrations first.';
            }

            // Daten einfügen
            $data = [
                'name' => 'ServBay Demo User',
                'email' => 'user_' . time() . '@servbay.demo', // Für eindeutige Emails wird time() genutzt
            ];

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

            // Prüfen, ob das Einfügen erfolgreich war (optional, insert() gibt meist true zurück)
            // if ($db->affectedRows() > 0) {
                 return 'User added successfully: ' . $data['email'];
            // } else {
            //      return 'Error: Failed to add user.';
            // }

        } catch (DatabaseException $e) {
            // Behandlung von Datenbank-bezogenen Ausnahmen
            return 'Database Error: ' . $e->getMessage() . '. Check database connection and table structure.';
        } catch (\Exception $e) {
             // Behandlung sonstiger unerwarteter Fehler
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }

    /**
     * Benutzerdaten aus der Datenbank abrufen (MySQL/PostgreSQL)
     */
    public function listUsers(): string
    {
         try {
            $db = \Config\Database::connect();

             // Prüft, ob die Tabelle 'users' existiert
            if (!$db->tableExists('users')) {
                 return 'Error: "users" table does not exist. Please run database migrations first.';
            }

            // Alle Benutzer abfragen
            $users = $db->table('users')->get()->getResult();

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

            // Gibt die Benutzerdaten als JSON-Array zurück
            return json_encode($users);

        } catch (DatabaseException $e) {
             // Behandlung von Datenbank-bezogenen Ausnahmen
            return 'Database Error: ' . $e->getMessage() . '. Check database connection and table structure.';
        } catch (\Exception $e) {
            // Behandlung sonstiger unerwarteter Fehler
            return 'An unexpected error occurred: ' . $e->getMessage();
        }
    }
}

Dieser überarbeitete Controller enthält übersichtliche Ausgaben und grundlegendes Fehler-Handling zur einfacheren Problemdiagnose.

Routing konfigurieren

Damit Sie die im Home-Controller hinzugefügten Beispielmethoden auch über die URL aufrufen können, müssen entsprechende Routen in der Routing-Datei von CodeIgniter definiert werden.

Bearbeiten Sie die Datei app/Config/Routes.php. Suchen Sie den Block mit $routes und ergänzen Sie darin die folgenden Regeln:

// ... weitere Routen-Regeln ...

// Beispielroute für Memcached
$routes->get('/memcached', 'Home::memcached');

// Beispielroute für Redis
$routes->get('/redis', 'Home::redis');

// Datenbank-Beispielrouten
$routes->get('/add-user', 'Home::addUser');
$routes->get('/list-users', 'Home::listUsers');

// ... weitere Routen-Regeln ...

Achten Sie darauf, diese neuen Routen zu den bestehenden $routes-Definitionen hinzuzufügen, ohne vorhandene Einträge zu überschreiben.

Website aufrufen

Ihr CodeIgniter-Projekt sollte nun in ServBay eingerichtet und lauffähig sein. Öffnen Sie einen Webbrowser und greifen Sie via der zuvor eingestellten lokalen Domain darauf zu:

• Startseite öffnen: https://servbay-codeigniter-test.local Sie sollten auf der Seite die Ausgabe Hello ServBay and CodeIgniter! sehen. Das zeigt, dass Ihr Projekt erfolgreich über ServBay läuft.

• Memcached-Beispiel: https://servbay-codeigniter-test.local/memcached Wenn Memcached korrekt eingerichtet ist, erscheint eine Nachricht wie Memcached Test Success: Hello Memcached from CodeIgniter!.

• Redis-Beispiel: https://servbay-codeigniter-test.local/redis Falls Redis ordnungsgemäß funktioniert, erhalten Sie eine Ausgabe wie Redis Test Success: Hello Redis from CodeIgniter!.

Datenbank-Beispiele (MySQL/PostgreSQL)

Bevor Sie die Datenbankbeispiele nutzen, müssen Sie mittels CodeIgniter-Migrationen die Tabelle users anlegen.

Datenbank-Struktur erstellen (Migration ausführen)

1. Öffnen Sie das Terminal und navigieren Sie ins CodeIgniter-Projektverzeichnis:

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

2. Migrationsdatei erstellen: Nutzen Sie das CLI-Tool von CodeIgniter, um eine Migrationsdatei für die Tabelle users zu erstellen:

   php spark make:migration create_users_table

   Dies legt eine neue PHP-Datei im Verzeichnis app/Database/Migrations an.

3. Migrationsdatei bearbeiten: Öffnen Sie die neu erstellte Datei (Name ähnlich wie YYYY-MM-DD-HHMMSS_CreateUsersTable.php) und ergänzen Sie im up()-Abschnitt die Definition der Spalten und Indizes. Beachten Sie, dass MySQL und PostgreSQL unterschiedliche Standardsyntax für automatische Zeitstempelspalten haben (CURRENT_TIMESTAMP versus NOW()). Die Klasse RawSql von CodeIgniter hilft dabei. Beispiel:

   <?php
   
   namespace App\Database\Migrations;
   
   use CodeIgniter\Database\Migration;
   use CodeIgniter\Database\RawSql; // Stellen Sie sicher, dass RawSql eingebunden ist
   
   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, // E-Mail-Feld ist eindeutig
               ],
               'created_at' => [
                   'type'    => 'TIMESTAMP',
                   // Passende Default-Ausdruck je Datenbank-Typ wählen
                   // MySQL: 'default' => new RawSql('CURRENT_TIMESTAMP'),
                   // PostgreSQL: 'default' => new RawSql('NOW()'),
                   'default' => new RawSql($this->db->getPlatform() === 'MySQLi' ? 'CURRENT_TIMESTAMP' : 'NOW()'), // Dynamische Auswahl
               ],
               '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()'), // Dynamische Auswahl
               ],
           ]);
           $this->forge->addKey('id', true); // id als Primärschlüssel definieren
           $this->forge->createTable('users'); // users-Tabelle anlegen
       }
   
       public function down()
       {
           // Zum Zurücksetzen der Migration: users-Tabelle löschen
           $this->forge->dropTable('users');
       }
   }

   Hinweis: Das obige Beispiel verwendet eine einfache Logik, um je nach Datenbankplattform den passenden Standardwert für Zeitstempelspalten zu wählen. Für reale Projekte sollten Sie ggf. migrationsspezifische Anpassungen oder separate Dateien für verschiedene Datenbanken pflegen.

4. Migrationen ausführen: Mit folgendem Befehl legen Sie die Tabelle users an:

   php spark migrate

   Bei Erfolg sehen Sie eine entsprechende Bestätigung im Terminal. Über das Datenbank-Tool (z. B. Adminer) in ServBay können Sie die Tabelle users in Ihrer Datenbank servbay_codeigniter_app überprüfen.

Datenbank-Beispiele aufrufen

Vergewissern Sie sich, dass die Datenbankzugangsdaten in app/Config/Database.php korrekt konfiguriert und die Migration erfolgreich ausgeführt wurde.

• Benutzer zur Datenbank hinzufügen: Rufen Sie https://servbay-codeigniter-test.local/add-user auf. Jeder Aufruf dieser URL fügt einen neuen Benutzer in die Tabelle ein. Eine Ausgabe wie User added successfully: [email protected] bestätigt den Erfolg.

• Benutzer ausgeben: Besuchen Sie https://servbay-codeigniter-test.local/list-users Hier werden alle Benutzereinträge als JSON-Array ausgegeben.

Zusammenfassung

Mit den obigen Schritten haben Sie erfolgreich ein CodeIgniter-Projekt unter macOS in ServBay erstellt, konfiguriert und gestartet. Sie haben gelernt, wie Sie mit Composer ein Projekt anlegen, die Webseiten-Funktion in ServBay korrekt konfigurieren, Datenbank- und Cache-Anbindungen im CodeIgniter-Projekt vornehmen und anhand von einfacher Beispielcodes die Integration testen können. ServBay erleichtert Ihnen das Setup und die Verwaltung der lokalen Entwicklungsumgebung, sodass Sie sich ganz auf die Entwicklung Ihrer CodeIgniter-Anwendung konzentrieren können.