phaziz.com

Startseite > 25.09.2017 App-Entwicklung mit dem Slim-Framework

25.09.2017 App-Entwicklung mit dem Slim-Framework

Grundsätzliches zum Slim-PHP-Framework - die Projekt-Organisation (https://www.slimframework.com)

Slim Framework

Das Slim-Framework ist meiner Meinung nach eines der flexibelsten und gleichzeitig einfachsten und schnellsten PHP-Frameworks, die es gibt. Das Routing per FastRoute, Pimple als DI-Container, PSR-7, Middleware, Error-Handling, ...

0. Werkzeuge

Wir benötigen einen Webserver mit PHP und Composer (composer.phar) und Zugriff per FTP und SSH. Los geht's!

Composer, Composer, Composer... (https://getcomposer.org)... Es führt eigentlich kein Weg an Composer vorbei.

Für den Fall, dass man nicht über einen eigenen Root-Server verfügt, gibt es die Datei composer.phar. Hat man einen "üblichen" Webspeicherplatz und eine Möglichkeit per SSH zuzugreifen, steht einer Nutzung von Composer nix mehr im Weg.

Man lädt die Datei composer.phar in die Root-Ebene des Webspeicherplatz und erstellt eine composer.json-Datei (auch in der Root-Ebene des Webspeicherplatz).

Der Inhalt der composer.json-Datei könnte dabei wie folgt aussehen:

{
  "require": {
      "slim/slim": "^3.0"
  }
}

Sind die beiden Dateien composer.phar und composer.json auf dem Server (und man hat sich erfolgreich per SSH auf dem Server eingelogged) genügt folgende Eingabe über die SSH-Shell und composer(.phar) erledigt den Rest:

php composer.phar update

Composer lädt das Slim-Framework (und richtet die composer.lock-Datei automatisch ein) in einen neu eingerichteten Ordner Namens vendor und richtet die entsprechenden Autoloader ein.

Um ein neues Projekt mit Slim zu erstellen, genügt jetzt das einbinden der generierten autoload.php-Datei im Verzeichnis vendor.

require_once __DIR__ . '/PFAD_ZUM_VENDOR_VERZEICHNIS/vendor/autoload.php';

Ich empfehle das einrichten eines public-Verzeichnis in der Root-Ebene des Webservers (oder des gerouteten Verzeichnis). Das public-Verzeichnis wird das einzige über die Domain zugreifbare Verzeichnis. So bleibt das vendor-Verzeichnis außerhalb der zugreifbaren Struktur per Browser aus dem Internet, aber dazu später mehr. Für die Organisation mit einem public-Verzeichnis genügt in der Hauptdatei der Anwendung (/public/index.php) die folgende Anweisung um das Slim-Framework einzubinden:

require_once __DIR__ . '/../vendor/autoload.php';

1. Ordnerstruktur

Meine persönliche Empfehlung lautet: Die physische Trennung von Frontend und Backend, wie auch die Einschränkung für Zugriffe aus dem Internet.

Nehmen wir die folgende Verzeichnisstruktur in der Root-Ebene des Webservers als Beispiel:

...
composer.json
composer.lock
composer.phar
/cache/
/database/
/logs/
/public/
  <em>/components/</em>
  <em>.htaccess</em>
  <em>index.php</em>
/vendor/
/views/
...

In der Root-Ebene (das Verzeichnis auf das die eingerichtete Domain zeigt) liegen die Dateien composer.phar, composer.json, composer.lock und alle Unterverzeichnisse.

Die eingerichtete Domain zeigt auf das Unterverzeichnis /public/ - alles andere wird somit unerreichbar aus dem Internet. Das Verzeichnis /public/components/ benutzt man für einzubindende Dateien für die Internetseiten (css, javascript, bilder, ...).

Die Datei /public/index.php wird unsere Slim-Framework-Hauptdatei. Wenn diese index.php-Datei den folgenden Inhalt bekommt:

<?php

  require_once __DIR__ . '/../vendor/autoload.php';

  use \Psr\Http\Message\ServerRequestInterface as Request;
  use \Psr\Http\Message\ResponseInterface as Response;

  $app = new \Slim\App;

  $app -> get('/', function (Request $request, Response $response) use ($app)
    {
        $response->getBody()->write("Hallo Welt!");
        return $response;
    }
  );

  $app -> run();

sollte unser Browser mit der entsprechenden Domain in der Adresszeile ein wunderschönes Hallo Welt! anzeigen. Wer sich ein wenig mit Composer beschäftigt, wird feststellen, dass es noch weitere Wege der Installation gibt, aber der oben beschriebene Weg sollte selbst bei Massen-Hostern funktionieren.

2. Zubehör

Was wäre eine Internetseite ohne Datenbank, ohne einen Logger, ohne... In den meisten Fällen benötigt man also weitere Komponenten um eine Internetseite auf die Beine zu stellen. Ein Logger ist immer ganz interessant - für die Entwicklung, wie auch den späteren Live-Betrieb. Ebenso eine Template-Engine. Erweitern wir also unsere composer.json-Datei einfach mal um die folgenden Einträge:

{
    "require": {
        "slim/slim": "^3.0",
        "monolog/monolog": "*",
        "twig/twig": "*"
    }
}

Dadurch werden zusätzlich zum Slim-Framework auch noch ein Monolog-Logger (https://github.com/Seldaek/monolog) und die Twig-Template-Engine (https://twig.symfony.com) eingebunden.

Aber das erst nach dem bekannten Aufruf über die SSH-Shell in der Root-Ebene des Webservers:

php composer.phar update

Wirft man nach diesem Befehl über die SSH-Shell einen Blick in das Verzeichnis /vendor/ erblickt man die neuen Verzeichnisse /vendor/twig/, /vendor/monolog/. Beides kann nun in unserem Slim-Framework-Projekt verwendet werden. Über diesen Weg (update der composer.json-Datei und danach ein update Befehl per SSH-Shell) können zu jedem Zeitpunkt neue Komponenten zum Projekt hinzugefügt werden.

Jetzt müssen der Monolog-Logger und die Twig-Template-Engine nur noch in der /public/index.php-Datei eingebunden werden. Wir ändern also diese Datei wie folgt:

<?php

  require_once __DIR__ . '/../vendor/autoload.php';

  use Monolog\Logger;
  use Monolog\Handler\StreamHandler;

  use \Psr\Http\Message\ServerRequestInterface as Request;
  use \Psr\Http\Message\ResponseInterface as Response;

  $app = new \Slim\App;

  $container = $app -> getContainer();

  $container['logger'] = function()
  {
    $logger = new \Monolog\Logger('phaziz');
    $file_handler = new \Monolog\Handler\StreamHandler(__DIR__ . '/../logs/' . date('Y-m-d') . '-log.logfile');
    $logger -> pushHandler($file_handler);
    return $logger;
  };

  $container['twig'] = function()
  {
    $loader = new Twig_Loader_Filesystem(__DIR__ . '/../views/');
    $twig = new Twig_Environment($loader, [
      'cache' => __DIR__ . '/../cache/',
      'charset' => 'utf-8'
    ]);

    return $twig;
  };

  $app -> get('/', function (Request $request, Response $response) use ($app)
    {
      return $this -> twig -> render('index.html', [
        'content' => 'Hallo Welt!'
      ]);
    }
  );

  $app -> run();

Was passiert hier?

Über die Zeile $container = $app -> getContainer(); benutzen wir den DI-Container des Slim-Frameworks. Das Zauberwort lautet Dependency Injection (https://de.wikipedia.org/wiki/Dependency_Injection). Slim benutzt Pimple (https://pimple.symfony.com) als DI-Container. Über die Zeile $container = $app -> getContainer(); wird der Slim-Container eingerichtet. Die folgenden Zeilen richten den Monolog-Logger und die Twig-Template-Engine ein:

...
$container['logger'] = function()
{
  $logger = new \Monolog\Logger('phaziz');
  $file_handler = new \Monolog\Handler\StreamHandler(__DIR__ . '/../logs/' . date('Y-m-d') . '-log.logfile');
  $logger -> pushHandler($file_handler);
  return $logger;
};

$container['twig'] = function()
{
  $loader = new Twig_Loader_Filesystem(__DIR__ . '/../views/');
  $twig = new Twig_Environment($loader, [
    'cache' => __DIR__ . '/../cache/',
    'charset' => 'utf-8'
  ]);

  return $twig;
};
...

Dazu noch ein leicht abgewandelter Aufruf für unsere Index-Route (/) für die Darstellung einer Twig-Template-Datei:

$app -> get('/', function (Request $request, Response $response) use ($app)
  {
    return $this -> twig -> render('index.html', [
      'content' => 'Hallo Welt!'
    ]);
  }
);

Und wer jetzt aufgepasst hat, hat die neuen Verzeichnisse /logs/, /views/, /cache/ entdeckt. Diese müssen in der selben Ebene wie das /public/-Verzeichnis eingerichtet werden. Um sich Ärger wegen fehlender Zugriffsrechte zu ersparen, kann man das Verzeichnis /logs/ lieber früher als später per SSH mit dem Befehl chmod auf die Rechte 0755 (oder 0777) setzen.

chmod -R 0777 logs

Es fehlt jetzt nur noch die Datei /views/index.html als Template für unseren neuen Aufruf mit der Twig-Template-Engine:

<!DOCTYPE html>
  <html>
      <head>
          <title>My Webpage</title>
      </head>
      <body>
          &#123;&#123; content &#125;&#125;
      </body>
  </html>

Wenn wir jetzt per Browser auf die entsprechende Domain auf dem Webserver zugreifen, legt der Monolog-Logger beim ersten Aufruf eine neue Log-Datei im Verzeichnis /logs/ an und registriert unseren Zugriff, gleichzeitig sollte uns eine HTML-Datei per Twig-Template-Engine und unserem Inhalt Hallo Welt! begrüßen.

Es können nun weitere Routen in der /public/index.php angelegt werden (https://www.slimframework.com/docs/objects/router.html).

Ich empfehle ein intensives Studium der Dokumentation von Slim und viel Spaß beim spielen ;-)

Meine Slim3-Boilerplate auf GitHub:https://github.com/phaziz/Slim3Dev

 

Suche

Suchbegriffe mit mindestens 3 Zeichen! Suchvorgang mit ENTER-Taste starten.