Schnelleinstieg ins CodeIgniter-Framework
Was ist CodeIgniter? Bei CodeIgniter handelt es sich um ein in PHP geschriebenes quelloffenes Webframework (Open-Software License 3.0), welches sich großer Beliebtheit insbesondere im amerikanischen Raum erfreut.
Entwickelt wurde dieses von der im US-Bundesstaat Oregon liegenden Softwareentwicklungsfirma EllisLab. Das erste öffentliche Release des Frameworks wurde am 28. Februar 2006 herausgegeben.
CodeIgniter wirbt vor allem damit, im Vergleich mit anderen Webframeworks wesentlich schneller und effizienter zu sein. Die Entwicklungszeiten von neuer Software und Web-Anwendungen verkürzen sich dadurch erheblich.
In einer kritischen Sicht auf PHP-Frameworks im Allgemeinen erwähnte der PHP-Schöpfer Rasmus Nerdorf auf der FrOSCon im August 2008, dass ihm CodeIgniter gefalle, da es „schneller, schlanker und am wenigsten wie ein Framework ist“ (Originaltext: „[…] because it is faster, lighter and the least like a framework […]“).
Allerdings konnte es das Entwicklerteam von EllisLab in der letzten Zeit nicht mehr die notwendigen Ressourcen aufbringen, welche für eine Weiterentwicklung notwendig gewesen wären. Am 9. Juli 2013 schließlich veröffentlichte EllisLab einen Blogartikel, in dem sie bekanntgeben, dass ab nun ein neues „Zuhause“ für das CodeIgniter-Framework gesucht werde.
Das letzte Stable-Release (Version 2.2.0) wurde am 5. Juni 2014 herausgegeben. Diese Version ist momentan auch die aktuellste.
Am 6. Oktober 2014 wurde schließlich bekannt, dass das „British Columbia Institute of Technology“, kurz „BCIT“, aus Vancouver (Kanada) das Projekt vollständig übernommen hat.
Der Quellcode steht auf GitHub unter der MIT-Lizenz zur Verfügung, wo aktuell tatkräftig an der Version 3.0 gearbeitet wird.
Aufbau und Struktur
Dadurch, dass CodeIgniter bewusst möglichst schlank gehalten wurde, zeichnet sich das Framework im Vergleich zu anderen vor allem durch eine hohe Performance, und analog dazu einer verhältnismäßig kurzen Einarbeitungszeit aus.
Um den Code übersichtlich und leicht wartbar zu machen, macht sich CodeIgniter die Model-View-Controller-Architektur, kurz „MVC“, zu Nutze.
Der Grundgedanke hinter MVC ist jener, dass man Programmcode und Design strikt voneinander trennen möchte, sodass die Software im Allgemeinen modularer wird. So können beispielsweise Backend-Entwickler sich um die programmiertechnische Logik und Frontend-Designer sich um das Layout und die einzelnen grafischen Komponenten kümmern. Diese parallele Arbeitsweise trägt auch maßgeblich an der raschen Entwicklungszeit der Software bei.
CodeIgniter hat standardmäßig ein umfangreiches Paket von Bibliotheken und diversen Hilfsfunktionen an Board, um dem Entwickler häufig genutzte Funktionen, angefangen bei der Datenbankkommunikation, über die Eingabevalidierung bis hin zur Implementierung eines Warenkorb-Systems, abzunehmen.
Besonders hervorzuheben ist hierbei auch die einfache Konfiguration. In den meisten Fällen reicht es vollkommen aus, nur eine Datenbankverbindung und ggf. eine Basis-URL zu hinterlegen.
Von der Theorie zur Praxis – ein Beispiel
Um euch einen kleinen Einblick in die Softwareentwicklung auf Basis des CodeIgniter-Frameworks zu geben, werde ich euch die Basisfunktionen anhand eines kleinen und stark vereinfachten Beispielprojekts zeigen.
Ich werde hierfür eine kleine Jobbörse nachbauen, wo man Stellenangebote eintragen kann, und diese dann in einer Liste angezeigt bekommt. Mit einem Klick auf das Angebot gelangt man dann zur Detailansicht. Bei Bedarf kann dieses dann auch wieder gelöscht werden.
Als erstes müssen wir uns das Framework von der Homepage oder direkt von GitHub herunterladen. Ich verwende hier die aktuelle Stable-Version 2.2.0 (hier „CodeIgniter-2.2.0.tar.gz“).
Anschließend entpacken wir den Inhalt und kopieren alle Verzeichnisse und Dateien in einen neuen Ordner auf dem Entwicklungsserver (z.B. XAMPP, WAMP, LAMP…). Ich nenne diesen Ordner hier einfach „ci-demo“.
Nun können wir auch sofort testen, ob die CodeIgniter-Installation funktioniert – dafür rufen wir unser Demo-Setup via http://localhost/ci-demo auf. Es sollte nun die Willkommensseite zu sehen sein („Welcome to CodeIgniter“).
Theoretisch könnten wir auch sofort mit dem Entwickeln loslegen, allerdings empfehle ich, vorher noch die offizielle Layout-Bibliothek zu integrieren. Diese wird uns später einiges an Arbeit ersparen und gleichzeitig den Code noch übersichtlicher gestalten.
Dazu gehen wir wie folgt vor: auf der GitHub-Wiki-Seite befindet sich bereits der notwendige PHP-Code. Wir erstellen hierfür eine neue Datei namens „layout.php“ und kopieren den Sourcecode hinein. Diese speichern wir dann unter /application/libraries ab.
Als nächsten Schritt konfigurieren wir CodeIgniter so, dass diese Bibliothek standardmäßig immer geladen werden soll. Dazu öffnen wir die Datei /application/config/autoload.php und suchen nach folgendem Ausdruck:
$autoload['libraries'] = array();
Diesem Array fügen wir nun die Bibliotheken für das Layout und die Datenbank hinzu, sodass es schließlich wie folgt aussieht:
$autoload['libraries'] = array('database', 'layout');
Damit wir später auch einige Hilfsfunktionen nutzen können, laden wir auch den URL- und den Form-Helper:
$autoload['helper'] = array('url', 'form');
Unter /application/views erstellen wir eine neue Datei „layout_main.php“ (dies ist das Standard-Layout, welches von der Layout-Bibliothek initialisiert wird). Hier hinein schreiben wir unser HTML-Grundgerüst. Wichtig ist hier, dass wir an jener Stelle, wo wir die View-spezifischen Inhalte anzeigen möchten die PHP-Variable $content_for_layout ausgeben!
<html> <head> <title>CodeIgniter Demo</title> </head> <body> <div id="header"> <h1>CodeIgniter Demo</h1> <hr /> </div> <div id="main"> <?php echo $content_for_layout; ?> </div> <div id="footer"> <hr /> Footer... </div> </body> </html>
Damit wir schöne „Speaking-URLs“ ohne dem „index.php“ dazwischen haben, erstellen wir uns im Root-Verzeichnis von CodeIgniter eine neue Datei „.htaccess“ (Apache als Webserver vorausgesetzt!) und schreiben hier Folgendes hinein:
RewriteEngine on RewriteRule .* index.php
Jetzt haben wir uns alle Grundvoraussetzungen geschaffen, damit es mit dem eigentlichen Entwickeln losgehen kann.
Da wir hier eine Art „Jobbörse“ nachbauen wollen, müssen wir als erstes einen neuen Controller anlegen. Ich nenne diesen hier „Jobs“, und lege dementsprechend eine neue Datei „jobs.php“ unter /application/controllers an.
class Jobs extends CI_Controller {
public function index()
{
$this->load->view('/jobs/index');
}
}
Da wir hier unsere Layout-Bibliothek verwenden möchten, muss das Laden der View geringfügig angepasst werden. Dazu ändern wir die folgende Zeile von
$this->load->view('/jobs/index');
auf
$this->layout->view('/jobs/index');
um. Dadurch haben wir den Vorteil, dass wir nicht in jeder Action des Controllers immer zuerst das Layout des Headers, dann den eigentlichen Inhalt, und schließlich das Layout für den Footer laden müssen – diese Arbeit übernimmt nun die Layout-Bibliothek für uns, sodass wir uns voll und ganz auf den eigentlichen Inhalt konzentrieren können.
Als nächstes legen wir unsere View an. Dazu erstellen wir unter /application/views einen neuen Ordner „jobs“ und legen in diesem die Datei „index.php“ an. Dies ist nicht zwingend erforderlich, fördert aber die Übersichtlichkeit bei mehreren Controllern.
Die Index-Action werden wir später für die Auflistung der Jobs verwenden. Damit wir auch Stellenangebote anlegen, ansehen und löschen können, erstellen wir uns nach dem gleichen Prinzip noch den Actions „add“, „view“ und „delete“ (hier keine View notwendig).
Der Jobs-Controller sieht nun also folgendermaßen aus:
class Jobs extends CI_Controller {
public function index()
{
$this->layout->view('/jobs/index');
}
public function add()
{
$this->layout->view('/jobs/add');
}
public function delete(){ }
public function view()
{
$this->layout->view('/jobs/view');
}
}
Da wir nun mit der Grundstruktur fertig sind, wird es Zeit eine Verbindung zur Datenbank herzustellen. Dafür erstellen wir uns eine neue MySQL-Tabelle namens „jobs“:
CREATE TABLE IF NOT EXISTS `jobs` ( `id` int(11) NOT NULL AUTO_INCREMENT PRIMARY KEY, `title` varchar(255) NOT NULL, `company` varchar(255) NOT NULL, `description` text NOT NULL );
In der Konfigurationsdatei des Datenbank-Treibers unter /application/config/database.php tragen wir nun die Zugangsdaten des MySQL-Servers und den Namen der Datenbank ein.
Damit wir nun vom Controller aus auf die Datenbank zugreifen können, brauchen wir ein sogenanntes „Model“. Dieses wird uns Methoden zur Verfügung stellen, welche wir vom Controller später aufrufen werden, um so an Daten der Datenbank zu gelangen.
Das ORM von CodeIgniter folgt dem typischen „ActiveRecord“-Muster. Anstatt die SQL-Statements direkt zu schreiben, verwenden wir hier fertige Funktionen, die wir aufrufen. Wir erhalten dadurch eine Abstraktion und sind so unabhängig vom Datenbanktreiber. Das ORM generiert die Statements dann dynamisch und liefert die Antworten der Datenbank als Objekt wieder retour.
Für unser Jobbörse-Model erstellen wir unter /application/models eine neue Datei „jobs_model.php“ und definieren hier unsere Methoden. Eine soll alle Einträge der Tabelle zurückliefern, eine andere nur einen einzelnen (über die ID), und schließlich jeweils eine zum Hinzufügen und Löschen eines Eintrags.
class Jobs_model extends CI_Model {
protected $table = 'jobs';
// returns all job offers
public function getAll()
{
$result = $this->db->get( $this->table )->result_object();
return $result;
}
// looks for job offer by id
public function getById($id)
{
$this->db->select('*')
->from( $this->table )
->where('id', (int) $id);
$result = $this->db->get()->row_object();
return $result;
}
// add job offer
public function add(array $data)
{
return $this->db->insert( $this->table, $data);
}
// deletes job offer
public function delete($id)
{
$this->db->delete( $this->table, array('id' => (int) $id));
}
}
Info: result_object() liefert ein Array mit mehreren Datensätzen (als Objekte), row_object() hingegen nur das geforderte Objekt. Alternativ zur Objekt-Ausgabe stehen auch die Array-Ausgaben via result_array() und row_array() zur Verfügung.
Im Jobs-Controller laden wir nun dieses Model, indem wir die Initialisierung gleich über den Konstruktor erfolgen lassen. Dafür ergänzen wir den Controller um Folgendes:
public function __construct()
{
parent::__construct();
$this->load->model('jobs_model');
}
Das Jobs-Model steht uns ab sofort via $this->jobs_model zur Verfügung.
Damit die Index-Action die Job-Angebote auflistet, rufen wir die Model-Methode „getAll()“ auf, und übergeben den Rückgabewert der View.
public function index()
{
$data = array(
'jobs' => $this->jobs_model->getAll(),
);
$this->layout->view('/jobs/index', $data);
}
In der View können wir nun mit der Variable $jobs die Stellenangebote ausgeben:
<h2>Übersicht</h2> <a href="<?php echo base_url(); ?>jobs/add">Neu anlegen</a> <table> <thead> <th>Bezeichnung</th> <th>Unternehmen</th> <th>Aktion</th> </thead> <tbody> <?php foreach($jobs as $job): ?> <tr> <td><?php echo $job->title; ?></td> <td><?php echo $job->company; ?></td> <td> <a href="<?php echo base_url() . 'jobs/view/'. $job->id; ?>">Ansehen</a> <a href="<?php echo base_url() . 'jobs/delete/'. $job->id; ?>">Löschen</a> </td> </tr> <?php endforeach; ?> </tbody> </table>
Damit wir ein Jobangebot erstellen können, bearbeiten wir unsere Add-View folgendermaßen (zur Vereinfachung wurden hier die Form-Elemente nicht über den Form-Helper erstellt!):
<a href="<?php echo base_url(); ?>jobs">« Zurück</a> <h2>Neues Jobangebot erstellen</h2> <?php echo form_open(); ?> <table> <tr> <td>Bezeichnung:</td> <td><input type="text" name="title" /></td> </tr> <tr> <td>Unternehmen:</td> <td><input type="text" name="company" /></td> </tr> <tr> <td>Beschreibung:</td> <td><textarea name="description"></textarea></td> </tr> <tr> <td></td> <td><input type="submit" value="Speichern" /></td> </tr> </table> <?php echo form_close(); ?>
Die zugehörige Action sieht dann folgendermaßen aus:
public function add()
{
$post = $this->input->post(NULL, TRUE);
if($post) {
$data = array(
'title' => $post['title'],
'company' => $post['company'],
'description' => $post['description'],
);
$this->jobs_model->add($data);
redirect('jobs');
} else {
$this->layout->view('/jobs/add');
}
}
Wenn ein POST-Request erfolgt ist, wird ein neuer Eintrag gespeichert, sonst wird das Formular angezeigt.
Bei der Action zum Löschen verzichten wir der Einfachheit halber auf jegliche Bestätigung seitens des Benutzers – wir löschen den Eintrag direkt.
public function delete($id)
{
$this->jobs_model->delete($id);
redirect('jobs');
}
In der Praxis jedoch empfehle ich solche Aktionen unbedingt via POST zu realisieren, da dies sicherer ist! Eine serverseitige Validierung sollte auch nicht fehlen (z.B. ob der Benutzer dazu berechtigt ist…)!
Für die Detailansicht muss der Controller nur den entsprechenden Eintrag aus der Datenbank holen und an die View übergeben:
public function view($id)
{
$data = array(
'job' => $this->jobs_model->getById($id),
);
$this->layout->view('/jobs/view', $data);
}
Die View ist im Prinzip gleich wie jene der Add-Action, nur dass hier anstatt der Eingabefelder die Daten aus der Datenbank angezeigt werden:
<a href="<?php echo base_url(); ?>jobs">« Zurück</a> <h2>Details: <?php echo $job->title; ?></h2> <table> <tr> <td>Bezeichnung:</td> <td><?php echo $job->title; ?></td> </tr> <tr> <td>Unternehmen:</td> <td><?php echo $job->company; ?></td> </tr> <tr> <td>Beschreibung:</td> <td><?php echo nl2br($job->description); ?></td> </tr> </table>
Somit sind wir das Demoprojekt fertig und haben nebenbei auch die relevantesten Grundfunktionen kennengelernt.
Wer möchte, kann auch noch den Standard-Controller ändern, sodass beim Aufruf von http://localhost/ci-demo nicht die CodeIgniter-Willkommensseite, sondern gleich die Jobbörse angezeigt wird.
Dazu ändern wir in der Datei routes.php unter /application/config die folgende Zeile von
$route['default_controller'] = "welcome";
auf
$route['default_controller'] = "jobs";
Fazit
Das CodeIgniter-Framework zeichnet sich im Vergleich zu anderen PHP-Frameworks durch eine sehr hohe Performance und Leichtigkeit aus.
Dadurch, dass es von den Funktionen relativ schlank gehalten wurde, eröffnet es dem Entwickler alle Tore, da dieser hier seiner Kreativität freien Lauf lassen kann. Analog dazu, wird er unbewusst auf eine konsequente Art dazu bewegt, sich an Strukturen zu halten.
Diese Art der Softwareentwicklung ermöglicht dem Entwickler also maximale Freiheiten, schafft es aber, den Code jederzeit gut lesbar und dadurch auch leicht wartbar zu halten.
Wichtig zu erwähnen sind vor allem die große, hinter dem Framework stehende Community, sowie eine gute und umfangreiche Dokumentation mit zahlreichen kleineren Anwendungsbeispielen.
Meiner Meinung nach eignet sich CodeIgniter insbesondere zur Umsetzung von kleinen Projekten bis hin zu Projekten mittlerer Größenordnung.
Offizielle Homepage: http://www.codeigniter.com