Archivo Explosivo: Slim PHP Framework

Slim 3 – Sekelton App gefunden

Ein simples Skelett bestehend aus Slim3, Twig und Monolog: GitHub

Archivo Explosivo: Slim PHP Framework
Constructr CMS V1.04.4

Constructr Version 1.04.4 ist da

ConstructrCMS (http://constructr-cms.org) based on Slim-PHP5-Framework, Twitter Bootstrap, MySQL/PDO, jQuery/Javascript and Passion!

That’s it for now (Version 1.04.4 / 2015-02-17):

  • Page-Management
  • Create, edit, re-order/order, delete Pages
  • Page specific CSS- and JS-Content
  • Automatic sitemap.xml generation
  • Content-Management
  • Create, edit, re-order/order, delete, recover Content-Elements
  • Content-Element History
  • Template-Management
  • EASY PHP-Templates
  • Create, edit, delete a Template-File
  • Asset-Management (Uploads)
  • Upload, edit, delete, recover Uploads
  • Media information (Title, Copyright, Description, Keywords)
  • 2 Factor Authentication-Login (2FA)
  • User Management
  • Create, edit, delete, active/de-activate User-Accounts
  • User Rights-Management
  • User Password resetting via CONSTRUCTR_CONF-Option for all User-Accounts
  • Generate a dynamic Website
  • Generating Domain specific static Websites
  • Included FTP-Transfer of your Website to your Domain
  • Full-Stack backend Searchengine
  • Constructr-Postmaster for Contact-Form-Handling on your Website
  • File based Website-Caching
  • Easy Plugin-System (beta feature)

Download via GitHub

Archivo Explosivo: Slim PHP Framework
PHP PDO

PDO in Slim

Schreibt doch keiner mehr pures MySQL mit den entsprechenden PHP-Funktionen… Deshalb eine Anbindung im PHP PDO Style in Slim:

In der index.php im Root-Level wird PDO eingebunden und instanziert:



    $HOSTNAME = "DATENBANK_HOST";
    $DATABASE = "DATENBANK";
    $USERNAME = "BENUTZERNAME";
    $PASSWORD = "PASSWORD";

    try
    {
        $DBCON = new PDO("mysql:host=" . $HOSTNAME . ";dbname=" . $DATABASE,$USERNAME,$PASSWORD,
            array
            (
                PDO::ATTR_PERSISTENT => true
            )
        );

        $DBCON -> setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
    }
    catch (PDOException $e)
    {
        die();
    }

Danach kann PDO in den gewünschten Routen benutzt werden:


    ...
    try {
        $ORDERS = $DBCON -> prepare('SELECT * FROM ...;');
        $ORDERS -> execute();
    } catch (PDOException $e) {
        echo $e -> getMessage();
        die();
    }
Archivo Explosivo: Slim PHP Framework
Idiorm & Paris

Slim Framework und Datenbanken

Wie wahrscheinlich bei jedem andern Framework, gibt es auch bei Slim mehrere Möglichkeiten eine Datenbankanbindung herzustellen.

Natives SQL, Anbindung per PDO, oder eine Anbindung durch ein ORM der Wahl. Wenn es um ORMs geht, kann ich nur eine Empfehlung für die Kombination Idiorm & Paris von Jamie Matthews aussprechen. Wobei Idiorm die Rolle des objekt-relationalen-Mapping’s und Query-Builder’s übernimmt und Paris das „Active Record“-Pattern implementiert. Beide sehr klein und äußerst flink ;-)

Um dieses dynamische Duo mit Slim zu verbinden, müssen die entsprechenden Dateien von Paris & Idiorm heruntergeladen werden und in der Verzeichnisstruktur des Projekts abgelegt werden. In der Index-Datei des Projekts können diese Klassen dann inkludiert und konfiguriert werden:


    ...
    require 'Helper/idiorm.php';
    require 'Helper/paris.php';
    ...

    ORM::configure('mysql:host=MEIN_DATENBANK_HOST;dbname=MEINE_DATENBANK');
    ORM::configure('username','BENUTZERNAME');
    ORM::configure('password','PASSSWORT');
    ORM::configure('logging','false');

    // Primärschlüssel der eingebundenen Tabellen definieren
    ORM::configure('id_column_overrides', array
        (
            'logs' => 'lg_id',
            'tabelle2' => 'primary_id2',
            ...
        )
    );
    ...

Wenn dies ohne Fehlermeldungen im Browser abgeschlossen ist, kann man das Duo in den gewünschten Routen verwenden und seine Abfragen damit gestalten:


    ...
    $LOG = Model::factory('Logs')->create();
    if($LOG instanceof Logs){
        $LOG -> log_timestamp = date('Y-m-d H:i:s');
        $LOG -> log_user_id = $_USERID;
        $LOG -> log_username = $_USERNAME;
        $LOG -> log_txt = 'Logging...';
        $LOG->save();
    }
    ...

Paris und Idiorm auf GitHub.

Archivo Explosivo: Slim PHP Framework
Slim PHP-Micro-Framework

$_GET und $_POST-Parameter in Slim

Wie bringe ich Slim dazu, $_GET-/$_POST-Parameter zu erhalten?

Nehmen wir an, in unserer Anwendung gibt es eine Ansicht http://domain.tld/formular. Hier gibt es ein kleines Kontaktformular mit den Feldern Name, eMail-Adresse und Nachricht.



Dieses Formular kann ich per Formular-Action an die URL http://domain.tld/formular-verarbeiten senden. Die Formular Methode GET :



    $app -> get('/formular-verarbeiten', function () use ($app)
    ...

Die entsprechende Ansicht in der POST-Variante:



    $app -> post('/formular-verarbeiten', function () use ($app)
    ...

Hier werden noch keine Formular-Werte übergeben, verarbeitet, oder zugewiesen... das erledigen wir nun innerhalb der Route formular-verarbeiten



    $app -> get/post('/formular-verarbeiten', function () use ($app)
        {
            //GET variable
            $GET_NAME = $app -> request -> get('name');

            //POST variable
            $POST_NAME = $app -> request -> post('name');
            ...
        }
    );

Ab den Zeilen $GET_NAME/$POST_NAME = $app -> request -> get/post('name');, steht mir die Variable $GET_NAME/$POST_NAME mit dem aus dem Formular übergebenem Wert zur Verfügung.

Archivo Explosivo: Slim PHP Framework
Slim PHP-Micro-Framework

Parameter-Übergabe mit Slim

Das absolut Wichtigste in einer programmierten Anwendung ist häufig die Fragestellung: „Wie komme ich an meine Variablen?“

In Slim, wie auch in vielen anderen PHP-Frameworks, kann ich schon bei Aufruf der Route einer Variablen einen Wert zuweisen:



    $app -> get('/hello/:name', function ($name) use ($app)
        {
            echo 'Hello ' . $name . '!';
        }
    );

Mit der Route „/hello/:name“ bereite ich Slim darauf vor, das diese Route aus einem statischen Teil (/hello) und einem variablen Teil (/:name) besteht. Der Wert, der als „:name“ übergeben wird, wird der Variablen „$name“ zugewiesen. In der Ausgabe dieser Route, kann ich diese Variable direkt weiter verarbeiten… zum Beispiel einfach ausgeben: echo ‚Hello ‚ . $name . ‚!‘;

Rufe ich im Browser meine Route auf und übergebe meinen Namen als Variable :name/$name (http://www.domain.tld/hello/Christian), erhalte ich die folgende Ausgabe:

Hello Christian!

Einfacher geht es kaum, oder?

Bin ich mir nicht sicher, ob ich in meiner Anwendung eine Variable auch wirklich bekomme, kann ich diese in der Routen-Definition einfach in Klammern schreiben. Das zeigt Slim: Es könnte dieser Variablen ein Wert zugewiesen werden, dies ist aber nicht zwingend notwendig und bringt meine Anwendung nicht gleich komplett zum Abbruch mit lauter PHP-Fehlermeldungen:



    $app -> get('/hello(/:name)', function ($name = '') use ($app)
        {
            if($name == '')
            {
                echo 'Hello!';
            }
            else
            {
                echo 'Hello ' . $name . '!';
            }
        }
    );

Jetzt kann ich meine Anwendung über zwei URLs im Browser aufrufen:

  • http://www.domain.tld/hello/Christian
  • http://www.domain.tld/hello

Bei Aufruf No. 1 mit meinem Namen als Wert für die Variable :name/$name erhalte ich die gewohnte Ausgabe „Hello Christian!“. Bei Aufruf No. 2 erhalte ich lediglich die Ausgabe „Hello!“, eben weil der Variablen in diesem Fall kein Wert zugewiesen wurde und der vordefinierte Wert zugewiesen wird.

Hier gibt es eine kleine Demo-Installation

Archivo Explosivo: Slim PHP Framework
Slim PHP-Micro-Framework

Slim micro PHP-Framework

Ich kann nur bestätigen, was einem als erstes auf der Internetseite von Slim ins Auge fällt: „Slim is a PHP micro framework that helps you quickly write simple yet powerful web applications and APIs.“.

Klein, übersichtlich, einfach in der Handhabung und in Benchmarks immer unter den schnellsten Frameworks. Einige der Vorteile sind:

  • Eine ordentliche Dokumentation
  • Composer Unterstützung
  • Ein mächtiger Router für saubere URLs im Browser
  • Unterstützung aller Standard HTTP-Methoden (GET, POST, PUT, …)
  • Parametern in URLs über Konditionen , oder sogar Wildcards
  • Beeinflussung des Programmablaufs während der Ausführung (Umleitungen, Weiterleitungen, Stop, …)
  • „Middleware“ für Erweiterung der Grundfunktionalität (Templates, Logging, …)
  • Benachrichtigungssystem (Flash-Messages)Unterstützung für sichere Cookies (AES 256)
  • HTTP-Caching über eTag-Parameter (einfach erweiterbar über ein statischen Document-Cache)
  • Fehlerbehandlung mit Debug-Informationen
  • Einfachste Konfiguration
  • Keine besonderen Ansprüche an die Hosting-Umgebung (PHP Version >= 5.3.0, mcrypt-Extensionfür sichere Cookies)

Da hat Josh Lockhart ein ordentliches Framework auf die Beine gestellt.

Eine einfache „Hello World“-Anwendung mit Slim kann so einfach aussehen:



    require 'Slim/Slim.php';
    \Slim\Slim::registerAutoloader();

    $app = new \Slim\Slim();

    $app->get('/', function () use ($app)
        {
            echo "Hello World";
        }
    );

    $app -> run();


Slim wird inkludiert, eine Instanz wird gebildet, eine Anweisung für die Route/URL ‚/‘ erstellt (http://domain.tld) und schließlich wird die Slim-Applikation gestartet und ausgeführt.

Micro-Framework VS. Fullstack… Was bedeutet Micro? Eignet sich Slim auch für größere Projekte? Ich gebe ein klares „Jo“ von mir.

Mein eigenes Content Mangement System ConstructrCMS basiert auf Slim. Viele Jahre setze ich bei privaten Vergnügen, aber auch bei geschäftskritischen Anwendungen auf Slim als Unterbau. An die Grenzen gestoßen bin ich damit noch nie. Alles eine Frage der Organisation.

Wird zum Beispiel ein ORM benötigt, inkludiere ich das gewünschte System. Wird in einer speziellen Route eine Erweiterung benötigt, kann ich diese global instanzieren und bei Bedarf an Slim übergeben, oder nur in der speziellen Route einbinden. Routen, Templates und Models können in Unterverzeichnissen ausgelagert werden – die Übersicht leidet dadurch auch bei großen Anwendungen nicht.

Ich kann Slim jedem nur wärmstens empfehlen – es muss nicht immer ein Symphony, Yii oder Zend sein!

Hiermit startet meine kleine Beitragsreihe über das Slim-PHP-Framework.