Kohana: Das Swift PHP-Framework

German (Deutsch) translation by Katharina Grigorovich-Nevolina (you can also view the original English article)

Kohana ist ein PHP 5-Framework, das das Architekturmuster Model View Controller (MVC) verwendet. Es gibt mehrere Gründe, warum Sie sich für Kohana entscheiden sollten, aber die wichtigsten sind Sicherheit, Schwerelosigkeit und Einfachheit. In diesem Tutorial stelle ich die Hauptfunktionen vor und zeige Ihnen anhand einer einfachen Demonstration, wie viel Zeit Kohana Ihnen möglicherweise sparen kann.

Schritt 1: Was ist Kohana?

Kohana ist ein PHP5-Framework, das das Architekturmuster Model View Controller verwendet. MVC hält die Anwendungslogik von der Präsentation getrennt. Auf diese Weise können wir saubereren Code erstellen und Zeit für die Fehlersuche sparen. Mit diesem Muster nicht vertraut:

Ein Modell repräsentiert Daten, mit denen die Anwendung arbeitet. Normalerweise eine Datenbank.
Eine Ansicht enthält Präsentationscode wie HTML, CSS und JavaScript.
Ein Controller interpretiert Eingaben des Benutzers und sendet sie an das Modell und/oder die Ansicht.

Kohana war ursprünglich eine Abzweigung von CodeIgniter (CI), einem Open-Source-Produkt von EllisLab. Es gibt viele Ähnlichkeiten zwischen CI und Kohana, aber der gesamte Code ist entweder neu oder vollständig neu geschrieben. Wie Sie auf der offiziellen Kohana-Website lesen können, sind die Hauptmerkmale:

Sehr sicher
Extrem leicht
Kurze Lernkurve
Verwendet das MVC-Muster
100% UTF-8-kompatibel
Locker gekoppelte Architektur
Extrem einfach zu verlängern

Schritt 2: Kohana herunterladen

Lassen Sie uns anfangen. Besuchen Sie die offizielle Website von Kohana http://kohanaphp.com und klicken Sie auf das grüne Kästchen in der rechten Ecke, um die neueste Version herunterzuladen. Alle Kohana-Bibliotheken, -Hilfen und -Ansichten sind im Standard-Download-Paket enthalten. Sie können jedoch bei Bedarf zusätzliche Module, Hersteller-Tools und Sprachen auswählen. Für dieses Tutorial kann das Standardpaket ausreichen. Klicken Sie auf "Kohana herunterladen!" um den Download zu starten.

Schritt 3: Kohana installieren

Sobald Sie den Download abgeschlossen haben:

Entpacken
Benennen Sie den Ordner "Kohana_vx.x.x" in "kohana" um und laden Sie ihn in das Stammverzeichnis Ihres Webservers hoch
Bearbeiten Sie die globale Konfigurationsdatei application/config/config.php wie folgt

1	$config['site_domain'] = 'localhost/kohana';

Wenn Sie ein Unix-ähnliches System verwenden, haben die Unterverzeichnisse der Installation möglicherweise ihre Berechtigungen während der Zip-Extraktion verloren. Chmod sie alle auf 755 durch Ausführen von find. -type d -exec chmod 755 {} \; von der Wurzel Ihrer Kohana-Installation.
Stellen Sie sicher, dass die Verzeichnisse application/logs und application/cache beschreibbar sind. Chmod bis 666.
Zeigen Sie nun mit Ihrem Browser auf http://localhost/kohana/. Das Framework ruft automatisch das Skript install.php auf und überprüft Ihre Serveranforderungen.

Kohana kann in nahezu jeder Umgebung mit minimaler Konfiguration ausgeführt werden. Es gibt einige Mindestserveranforderungen:

Server mit Unicode-Unterstützung
PHP-Version >= 5.2.3
Ein HTTP-Server. Ich schlage vor, Sie verwenden XAMPP. XAMPP ist ein einfaches All-in-One-Tool zur Installation von MySQL, PHP und Perl.
Datenbank (MsSQL, MySQL, MySQLi, PostgreSQL, PDOSqlite)

Es gibt auch einige erforderliche Erweiterungen.

PCRE
iconv
mcrypt
SPL

Wenn Ihre Installation erfolgreich abgeschlossen wurde, werden Sie zu dieser Testseite weitergeleitet:

Wenn einer der Tests fehlschlägt, müssen Sie ihn korrigieren, bevor Sie fortfahren.

Wenn alle Tests bestanden wurden, wechseln Sie in das Kohana-Verzeichnis und entfernen Sie das Skript install.php oder benennen Sie es um. Aktualisieren Sie, und Sie sehen eine Begrüßungsseite wie diese:

Schritt 4: Kohana konfigurieren

Kohana ist bereit zu gehen. Es ist keine andere Konfiguration erforderlich. Dieser Rahmen ist erstaunlich. Ist es nicht? Lassen Sie uns einen Code überprüfen. Folge mir.

Schritt 5: Ihr erstes Kohana-Projekt

Kanonische Programmier-Tutorials beginnen mit dem Beispiel "Hallo Welt". Ich denke stattdessen, dass eine einfache Anwendung Ihnen eine klare Vorstellung davon geben kann, wie das Framework funktioniert. Also werden wir einen CD-Sammlungsmanager erstellen - nur für eine lustige Demonstration. Bevor wir mit dem Codieren beginnen, ist eine kurze Einführung in das Kohana-Dateisystem erforderlich.

Unsere Anwendung wird im Anwendung-Ordner abgelegt. In diesem Ordner gibt es mehrere Unterordner, aber wir benötigen die folgenden für unser Projekt:

Der Konfiguration-Ordner hostet alle Konfigurationsdateien, die als einfache statische Arrays codiert sind.
Der Controller-Ordner enthält unsere benutzerdefinierte Controller-Klasse
Der Modelle-Ordner enthält unsere benutzerdefinierte Modellklasse
Der Ansichten-Ordner hostet unsere benutzerdefinierten Dateien, die in HTML geschrieben sind (oder eine Markup-Sprache oder ein Skript, die zum Anzeigen von Daten und Schnittstellensteuerelementen für den Benutzer erforderlich sind).

Die verbleibenden Unterordner werden für dieses Tutorial nicht benötigt. Ich lade Sie daher ein, auf der Kohana-Website mehr zu erfahren.

Der System-Ordner enthält den Kohana-Kern und die Kohana-Tools wie Bibliotheken, Helfer und vordefinierte Konfigurationsdateien. In diesem Projekt werden wir einige Bibliotheken und einige Helfer verwenden - gute Werkzeuge, um Ihre Arbeit zu beschleunigen.

Der Assets-Ordner ist kein vordefinierter Kohana-Ordner. Ich habe es für Mediendateien wie CSS, JS und Bilder erstellt. Ich zeige Ihnen, wie Sie diese Dateien in das Projekt aufnehmen können.

Im Moduln-Ordner können wiederverwendbare Sammlungen verwandter Dateien abgelegt werden, die einer Anwendung eine bestimmte Funktionalität hinzufügen. Das vom Kohana-Team bereitgestellte Authentifizierungsmoduln ist ein Beispiel für ein Modul.

Dies ist eine sehr kurze Einführung in das Kohana-Dateisystem, die jedoch für die Zwecke dieses Lernprogramms ausreicht. Ich möchte dich nicht mehr mit Theorie langweilen.

Schritt 6: Projektdatenbank

Ich habe MySQL als mein DBMS gewählt, aber denken Sie daran, dass Kohana auch MsSQL, MySQLi, PostgreSQL, PDOSqlite unterstützt. Erstellen Sie eine Datenbank mit dem Namen "cd_collection" oder wählen Sie den gewünschten Namen und führen Sie die folgende SQL über phpMyAdmin oder ein beliebiges Tool aus, um die Verwaltung von MySQL zu verwalten.

CREATE TABLE `albums` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(50) collate utf8_bin NOT NULL,
  `author` varchar(50) collate utf8_bin NOT NULL,
  `genre_id` int(11) NOT NULL,
  PRIMARY KEY  (`id`),
  KEY `genre_id` (`genre_id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=19 ;

INSERT INTO `albums` (`id`, `name`, `author`, `genre_id`) VALUES
(2, 'Lines, Vines And Trying Times', 'Jonas Brothers', 16),
(3, 'The E.N.D.', 'The Black Eyed Peas', 16),
(4, 'Relapse', 'Eminem', 18),
(5, 'Monuments And Melodies', 'Incubus', 1),
(6, 'Thriller', 'Michael Jackson', 16),
(7, 'Back in Black', 'AC/DC', 4),
(8, 'The Dark Side of the Moon', 'Pink Floyd', 4),
(9, 'Bat out of Hell', 'Meat Loaf', 4),
(10, 'Backstreet Boys', 'Millennium', 16),
(11, 'Rumours', 'Fleetwood Mac', 4),
(12, 'Come on Over', 'Shania Twain', 16),
(13, 'Led Zeppelin IV', 'Led Zeppelin', 4),
(14, 'Jagged Little Pill', 'Alanis Morissette', 4),
(15, 'Sgt. Pepper''s Lonely Hearts Club Band', 'The Beatles', 16),
(16, 'Falling into You', 'C√©line Dion', 16),
(17, 'Music Box', 'Mariah Carey', 16),
(18, 'Born in the U.S.A.', 'Bruce Springsteen', 4);

CREATE TABLE `genres` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(50) collate utf8_bin NOT NULL,
  PRIMARY KEY  (`id`),
  UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=22 ;

INSERT INTO `genres` (`id`, `name`) VALUES
(1, 'Alternative Rock'),
(2, 'Blues'),
(3, 'Classical'),
(4, 'Rock'),
(5, 'Country'),
(6, 'Dance'),
(7, 'Folk'),
(8, 'Metal'),
(9, 'Hawaiian'),
(10, 'Imports'),
(11, 'Indie Music'),
(12, 'Jazz'),
(13, 'Latin'),
(14, 'New Age'),
(15, 'Opera'),
(16, 'Pop'),
(17, 'Soul'),
(18, 'Rap'),
(20, 'Soundtracks'),
(21, 'World Music');

ALTER TABLE `albums`
  ADD CONSTRAINT `genre_inter_relational_constraint` FOREIGN KEY (`genre_id`) REFERENCES `genres` (`id`) ON DELETE CASCADE ON UPDATE CASCADE;

Wie Sie sehen können, erstellt SQL zwei Tabellen, Alben und Genres und füllt sie mit einigen Daten. Die letzte SQL-Anweisung fügt eine Einschränkung für den Fremdschlüssel "genre_id" hinzu.

Die Datenbankstruktur ist sehr einfach und bedarf keiner näheren Erläuterung.

Jetzt müssen Sie Kohana mitteilen, wo sich Ihre Datenbank befindet und wie Sie darauf zugreifen können. Bearbeiten Sie die globale Konfigurationsdatei system/config/database.php wie folgt

$config['default'] = array
(
	'benchmark'     => TRUE,
	'persistent'    => FALSE,
	'connection'    => array
	(
		'type'     => 'mysql',	
		'user'     => 'root',	
		'pass'     => 'root',	
		'host'     => 'localhost',	
		'port'     => FALSE,		
		'socket'   => FALSE,		
		'database' => 'cd_collection'
	),
	'character_set' => 'utf8',
	'table_prefix'  => '',
	'object'        => TRUE,
	'cache'         => FALSE,
	'escape'        => TRUE
);

Dieser Code weist Kohana an, eine Verbindung zu einer MySQL-Datenbank namens "cd_collection" auf localhost mit dem Benutzernamen "root" und dem Kennwort "root" herzustellen. Sie müssen diese Einstellungen entsprechend Ihrer Datenbankserverkonfiguration ändern.

Schritt 7: Erstellen Sie den Controller

Lassen Sie uns nun unseren ersten Controller erstellen. Denken Sie an diese Konventionen.

Der Dateiname des Controllers muss klein geschrieben sein, z. B. album.php
Die Controller-Klasse muss dem Dateinamen zugeordnet und groß geschrieben sein und muss an _Controller angehängt werden, z. B. Album_Controller
muss die Controller-Klasse als (Groß-) Eltern haben

Denken Sie auch daran, wie Kohana seine URLs strukturiert und wie Sie eine Controller-Methode aufrufen können. z. B. http: //hostname/kohana_directory/index.php/controller/function.

Werfen wir einen Blick auf diesen einfachen Controller.

<?php defined('SYSPATH') OR die('No direct access allowed.');

class Album_Controller extends Controller
{ 
	public function __construct()	
 	{ 
		parent::__construct();
	}
 	
	public function index()
 	{
 	  	echo "My first controller";	
	}
}

PHP5 OOP ist Voraussetzung. Wenn Sie sich nicht auskennen, können Sie hier mehr erfahren.

Die Konstruktorfunktion called __construct initialisiert die Klasse und ruft den übergeordneten Konstruktor auf. Die Indexfunktion ist die Standardfunktion, d. h. sie wird aufgerufen, wenn wir den Controller ohne Angabe einer Funktion aufrufen (z. B. http://localhost/index.php/kohana/album. Nach dem Namenscontroller ist keine Funktion vorhanden, es wird die Standard-Indexfunktion aufgerufen).

Konzentrieren wir uns angesichts dieser Grundregeln auf unsere Anwendung. Der Album-Controller implementiert alle Aktionen für die Verwaltung der Alben-Sammlung. Mit diesem Controller können wir ein neues Album erstellen, um die in unserer Datenbank gespeicherten Alben anzuzeigen, um ein Album zu aktualisieren und ein Album zu löschen.

Ändern wir also die Klasse wie folgt.

Erstellen Sie eine Datei mit dem Namen album.php in application/controllers/ und fügen Sie Folgendes ein.

<?php defined('SYSPATH') OR die('No direct access allowed.');
	
class Album_Controller extends Controller
{
	 private $album_model; 
	 private $genre_model;
	 
	 private $list_view;
	 private $create_view;
	 private $update_view;
 
	public function __construct()	
 	{ 
		parent::__construct();
		$this->album_model   = new Album_Model;
		$this->genre_model  	= new Genre_Model;
	  	$this->list_view   	= new View('list');
	  	$this->update_view  	= new View('update');
	  	$this->create_view  	= new View('create');
	}
 
 	public function index()
 	{
  		$this->show_albums_list();
 	}
		
	private function show_albums_list()
	{
		$albums_list = $this->album_model->get_list(); 
		$this->list_view->set('albums_list',$albums_list);
		$this->list_view->render(TRUE); 
	}
	
 	public function show_create_editor()
 	{
 		$this->create_view->set('genres_list',$this->get_genres_list());
  		$this->create_view->render(TRUE);
 	}
 
 	public function show_update_editor($id)
 	{
		$album_data = $this->album_model->read($id);
		$this->update_view->set('album_id',$album_data[0]->id);
		$this->update_view->set('name',$album_data[0]->name);
		$this->update_view->set('author',$album_data[0]->author);
		$this->update_view->set('genre_id',$album_data[0]->genre_id);
		$this->update_view->set('genres_list',$this->get_genres_list());
		$this->update_view->render(TRUE);
 	}
 
 	public function create()
 	{ 
		$album_data=array(
		'name'    	=> $this->input->post('name'),
		'author'  	=> $this->input->post('author'),
		'genre_id'  => $this->input->post('genre_id')
		);
		$this->album_model->create($album_data);
		url::redirect('album');
 	}
 
	public function update()
	{ 
		$album_data = array(
			'name'    	=> $this->input->post('name'),
			'author'  	=> $this->input->post('author'),
			'genre_id'  => $this->input->post('genre_id')
		);
		$this->album_model->update($this->input->post('album_id'),$album_data);
  		url::redirect('album');
 	}
  
  	public function delete($id)
 	{
		$this->album_model->delete($id);
		url::redirect('album');
 	}
 
	private function get_genres_list()
	{
		$db_genres_list  = $this->genre_model->get_list(); 
		$genres_list  = array();
		
		if(sizeof($db_genres_list) >= 1)
		{
			foreach($db_genres_list as $item)
			{
				$genres_list[$item->id] = $item->name;
			}
		}
		return $genres_list;
 	}
}

Lassen Sie mich erklären, was dieser Code bewirkt.

Am Anfang der Klasse werden fünf Mitgliedsvariablen deklariert:

private $album_model; 
private $genre_model;
		 
private $list_view;
private $create_view;
 private $update_view;

Diese Mitglieder sind privat, da ich die Sichtbarkeit nur auf diese Klasse beschränken möchte.

In der Konstruktmethode werden die Modell- und Ansichtsobjekte mit den fünf Elementen erstellt:

$this->album_model   = new Album_Model;
$this->genre_model  	= new Genre_Model;
$this->list_view   	= new View('list');
$this->update_view  	= new View('update');
$this->create_view  	= new View('create');

Verwenden Sie diese Syntax, um ein Modellobjekt zu erstellen:

1	$obj_name = new Name_Model;

Verwenden Sie diese Syntax, um ein Ansichtsobjekt zu erstellen:

1	$obj_name = new View('view_filename_without_extension');

Jetzt gibt es zwei Objekte für den Zugriff auf das Album- und Genre-Modell und drei Objekte für den Zugriff auf die Ansichten, die zum Rendern der Präsentation erforderlich sind.

Die Indexmethode ruft die Methode show_albums_list auf, die alle in der Datenbank gespeicherten Alben auflistet.

1	$albums_list = $this->album_model->get_list();
2	$this->list_view->set('albums_list',$albums_list);
3	$this->list_view->render(TRUE);

In dieser Methode können Sie sehen, wie das Modell und das Ansichtsobjekt für den Zugriff auf relative Methoden verwendet werden. "get_list" ist eine Modellmethode (wir werden sie später sehen), die alle in der Datenbank gespeicherten Alben zurückgibt. Das Ergebnis wird im Array "$album_list" gespeichert. Um das Ergebnisarray vom Controller an die Ansicht zu übergeben, wird die Methode "set" für das Ansichtsobjekt aufgerufen. Diese Methode erfordert zwei Parameter: eine neue leere Variable(album_list), die Daten einer vorhandenen Variablen enthält ($album_list). Jetzt enthält die neue Variable "album_list" das Array $album_list (wir werden später sehen, wie der Inhalt in der Ansicht angezeigt wird). Die Methode "render" mit dem Parameter TRUE ist erforderlich, um Daten an den Browser auszugeben.

Die Methode show_create_editor zeigt die Benutzeroberfläche zum Einfügen eines neuen Albums.

1	$this->create_view->set('genres_list',$this->get_genres_list());
2	$this->create_view->render(TRUE);

Die Liste der Genres wird an die Ansicht übergeben.

Die Methode show_update_editor zeigt die Benutzeroberfläche zum Aktualisieren eines vorhandenen Albums.

$album_data = $this->album_model->read($id);
$this->update_view->set('album_id',$album_data[0]->id);
$this->update_view->set('name',$album_data[0]->name);
$this->update_view->set('author',$album_data[0]->author);
$this->update_view->set('genre_id',$album_data[0]->genre_id);
$this->update_view->set('genres_list',$this->get_genres_list());
$this->update_view->render(TRUE);

"read" ist eine Modellmethode (wir werden sie später sehen), die Daten ($album_data) des Albums mit einer ID gleich $id zurückgibt. Anschließend wird jedes einzelne Element des zurückgegebenen Datenalbums an die Ansicht übergeben.

Die Methode create empfängt Daten für ein neues Album aus der Ansicht und die Daten werden in der Datenbank gespeichert.

		$album_data=array(
		'name'    	=> $this->input->post('name'),
		'author'  	=> $this->input->post('author'),
		'genre_id'  => $this->input->post('genre_id')
		);
		$this->album_model->create($album_data);
		url::redirect('album');

$album_data ist ein Array, das die POST-Daten aus der Ansicht enthält. Um das Album zu speichern, wird das Array an die Methode create model übergeben. Die letzte Zeile ist ein Aufruf einer Hilfsmethode. Helfer sind einfach Funktionen, die Sie bei der Entwicklung unterstützen. Die Hilfsklassen werden automatisch vom Framework geladen. Helfer werden als statische Methoden einer Klasse deklariert, sodass die Klasse nicht instanziiert werden muss. In diesem Fall wird die Methode "Redirect" der Helfer "URL" aufgerufen und weist Kohana an, den Browser zum Album-Controller umzuleiten. Dadurch wird ein neuer Einsatz vermieden (z. B. Drücken von F5).

"Helfer sind einfach Funktionen, die Sie bei der Entwicklung unterstützen."

Die Aktualisierungs- und Löschmethoden funktionieren auf die gleiche Weise wie die oben beschriebene Erstellungsmethode.

Die letzte Methode get_genres_list ruft die Genre-Liste aus dem Modell ab ($db_genres_list) und erstellt ein neues Array ($genres_list) für das Auswahlfeld in den Ansichten.

		$db_genres_list  = $this->genre_model->get_list(); 
		$genres_list  = array();
		
		if(sizeof($db_genres_list) >= 1)
		{
			foreach($db_genres_list as $item)
			{
				$genres_list[$item->id] = $item->name;
			}
		}
		return $genres_list;

Schritt 8: Projektmodell erstellen

Lassen Sie uns nun Modelle für unsere Webanwendung erstellen. Denken Sie an diese Konventionen.

der Dateiname des Modells muss klein geschrieben sein, z. B. album.php
die Modellklasse muss dem Dateinamen zugeordnet und großgeschrieben werden und muss mit _Model, z. B. Album_Model
muss die Modellklasse als (Groß-) Elternteil haben

Hier ist der Modellcode des Albums. Erstellen Sie eine Datei mit dem Namen album.php in application/models/ und fügen Sie den folgenden Code ein.

<?php defined('SYSPATH') OR die('No direct access allowed.');

class Album_Model extends Model
{
 	private $album_table;
 	private $genre_table; 
 
  	public function __construct()
    	{
      		parent::__construct();
  		$this->album_table = 'albums';
		$this->genre_table = 'genres';
  	}
  
  	public function read($id)
  	{
		$this->db->where('id', $id);
		$query = $this->db->get($this->album_table); 
  		return $query->result_array();
 	}
  	
	public function delete($id)
  	{
		$this->db->delete($this->album_table, array('id' => $id));
  	}
  
  	public function update($id,$data)
  	{
		$this->db->update($this->album_table, $data, array('id' => $id));
  	}
  	
	public function create($data)
  	{
   		$this->db->insert($this->album_table, $data);
  	}
 	
	public function get_list()
 	{
  		$this->db->select('albums.id as id,albums.name as name,albums.author as author, genres.name as genre');  
  		$this->db->from($this->album_table);  
  		$this->db->join($this->genre_table,'genres.id','albums.genre_id');
  		$query = $this->db->get();
  		return $query->result_array();
	}
}

Alle Methoden in den Modellen verwenden die Syntax des Abfrage-Generators. Dieses Kohana-Tool beschleunigt die Datenbankentwicklungszeiten und vereinfacht die Erstellung von Abfragen.

Am Anfang der Klasse werden zwei Mitgliedsvariablen deklariert:

1	private $album_table;
2	private $genre_table;

Diese Mitglieder sind privat, da ich die Sichtbarkeit nur auf diese Klasse beschränken möchte. Sie sind die Container für die Namen der Datenbanktabellen.

Die erste Zeile in der Konstruktormethode lädt die Kohana-Datenbankbibliothek in $this->db. In der zweiten und dritten Zeile werden die beiden Klassenmitglieder initialisiert.

1	parent::__construct();
2	$this->album_table = 'albums';
3	$this->genre_table = 'genres';

Die Abfrage in der Lesemethode ruft Albumdatensätze ab, die eine bestimmte Kennung ("$id") haben.

1	$this->db->where('id', $id);
2	$query = $this->db->get($this->album_table);
3	return $query->result_array();

Die Abfrage in der Löschmethode löscht die Albumtabellenzeile mit einem bestimmten Bezeichner ("$id").

1	$this->db->delete($this->album_table, array('id' => $id));

Die Abfrage in der Aktualisierungsmethode aktualisiert die Albumtabellenzeile mit einem bestimmten Bezeichner ("$id") mit neuen Werten aus dem Array "$data".

1	$this->db->update($this->album_table, $data, array('id' => $id));

Das Array "$data" muss Datensatznamen als Schlüssel des Arrays und Werte als Werte des Arrays enthalten. Das Array "$data" muss folgende Form haben:

$data = array(
	'name' 			=> 	'album_name',
	'author'		=>	'author_name',
	'genre_id'		=>	'genre_id'	
	);

Die Abfrage in der Methode create fügt einen neuen Datensatz mit Werten des Arrays "$data" ein.

1	$this->db->insert($this->album_table, $data);

Das Array "$data" muss folgende Form haben:

$data = array(
	'id'			=>	'album_id',
	'name' 			=> 	'album_name',
	'author'		=>	'author_name',
	'genre_id'		=>	'genre_id'	
);

Die Abfrage in der Methode get_list ruft alle Albumzeilen ab.

		$this->db->select('albums.id as id,albums.name as name,albums.author as author, genres.name as genre');  
		$this->db->from($this->album_table);  
		$this->db->join($this->genre_table,'genres.id','albums.genre_id');
		$query = $this->db->get();
		return $query->result_array();

Nun das Genre-Modell. Erstellen Sie eine Datei mit dem Namen genre.php in application/models/ und fügen Sie den Code darunter ein:

	<?php defined('SYSPATH') OR die('No direct access allowed.');

	class Genre_Model extends Model
	{
		private $genre_table;
	
		function __construct()
		{
			parent::__construct();
			$this->genre_table = 'genres';
		}
	
		function get_list()
		{
			$query = $this->db->get($this->genre_table);
			return  $query->result_array();		
		}
	}

Dieses Modell ist sehr einfach, daher werde ich keine Zeit mehr verlieren, um es zu kommentieren. Die Modelle und der Controller sind einsatzbereit. Lassen Sie uns nun an den Ansichten arbeiten.

Schritt 9: Erstellen Sie die Projektansicht

Ansichten sind Dateien, die die Präsentationsebene für Ihre Anwendung enthalten. Der Zweck besteht darin, diese Informationen von Ihrer Anwendungslogik zu trennen, um die Wiederverwendbarkeit und den saubereren Code zu vereinfachen. Für dieses Projekt sind drei Ansichten erforderlich: eine Ansicht zum Auflisten der Albumsammlung, eine Ansicht zum Erstellen eines neuen Albums und eine Ansicht zum Bearbeiten eines vorhandenen Albums.

Erstellen Sie eine Datei mit dem Namen list.php in application/views/ und fügen Sie den folgenden Code ein:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<?php
	echo html::stylesheet(array
		(
		 'assets/css/style'
		),
		array
		(
		 'screen'
		), FALSE);
?>
		<title>CD COLLECTION</title>
		</head>
		<body>
		<?php 
				echo html::image('assets/images/add.png');
				echo html::anchor('album/show_create_editor', 'Add new album'); 
		?>
		<table class="list" cellspacing="0">
		<tr>
			<td colspan="5" class="list_title">CD Collection</td>
		</tr>	
		<tr>
			<td class="headers">Album name</td>
			<td class="headers">Author</td>
			<td colspan='3' class="headers">Genre</td>
		
		</tr>	
		<?php
			foreach($albums_list as $item)
			{
				echo "<tr>";
				echo "<td class='item'>".$item->name."</td>";
				echo "<td class='item'>".$item->author."</td>";
				echo "<td class='item'>".$item->genre."</td>";
				echo "<td class='item'>".html::anchor('album/delete/'.$item->id,html::image('assets/images/delete.png'))."</td>";		
				echo "<td class='item'>".html::anchor('album/show_update_editor/'.$item->id,html::image('assets/images/edit.png'))."</td>";		
				echo "</tr>";
			}
		?>
		</table>
		</body>
		</html>

Diese Ansicht zeigt eine HTML-Seite mit einer Liste aller Alben. Diese Liste wurde mit einer foreach-Schleife erstellt, die die Informationen in einer HTML-Tabelle druckt. Für jede Albumzeile gibt es zwei Bilder: ein "rotes Kreuz" und ein "Taschenbuch". Sie verknüpfen jeweils die Controller-Löschmethode und die Aktualisierungsmethode. Beide übergeben die Album-ID über eine Get-Anfrage an den Album-Controller. Über der Liste befindet sich eine Schaltfläche zum Erstellen neuer Alben. In diesem Code verwenden wir auch einen von Kohana bereitgestellten HTML-Helfer, der den Vorgang zum Schreiben von HTML-Seiten beschleunigt.

Lassen Sie uns nun eine Datei mit dem Namen create.php in application/views/ erstellen.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<?php
	echo html::stylesheet(array
	(
	    'assets/css/style'
	),
	array
	(
	    'screen'
	), FALSE);
?>
<title>CD COLLECTION</title>
</head>
<body>
<?php echo form::open('album/create'); ?>
<table class='editor'>
<tr>
	<td colspan='2' class='editor_title'>Create new album</td>
</tr>
<?php
	echo "<tr>";
	echo "<td>".form::label('name', 'Name: ')."</td>";
	echo "<td>".form::input('name', '')."</td>";
	echo "</tr>";
	
	echo "<tr>";
	echo "<td>".form::label('author', 'Author: ')."</td>";	
	echo "<td>".form::input('author', '')."</td>";	
	echo "<tr/>";
	
	echo "<tr>";
	echo "<td>".form::label('genre', 'Genre: ')."</td>";	
	echo "<td>".form::dropdown('genre_id',$genres_list)."</td>";
	echo "<tr/>";
	
	echo "<tr>";
	echo "<td colspan='2' align='left'>".form::submit('submit', 'Create album')."</td>";
	echo "</tr>";
?>
</table>
<?php echo form::close(); ?>
</body>
</html>

Das letzte aber nicht das letzte ist die Update-Ansicht. Erstellen wir eine Datei mit dem Namen update.php in application/views/.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<?php
	echo html::stylesheet(array
	(
	    'assets/css/style'
	),
	array
	(
	    'screen'
	), FALSE);
?>
<title>CD COLLECTION</title>
</head>
<body>
<?php echo form::open('album/update'); ?>
<table class='editor'>
<tr>
	<td colspan='2' class='editor_title'>Update album</td>
</tr>
<?php
	echo "<tr>";
	echo "<td>".form::label('name', 'Name: ')."</td>";
	echo "<td>".form::input('name', $name)."</td>";
	echo "</tr>";
	
	echo "<tr>";
	echo "<td>".form::label('author', 'Author: ')."</td>";	
	echo "<td>".form::input('author', $author)."</td>";	
	echo "<tr/>";
	
	echo "<tr>";
	echo "<td>".form::label('genre', 'Genre: ')."</td>";	
	echo "<td>".form::dropdown('genre_id',$genres_list, $genre_id)."</td>";
	echo "<tr/>";
	
	echo "<tr>";
	echo "<td colspan='2' align='left'>".form::submit('submit', 'Update album')."</td>";
	echo "</tr>";
	
?>
</table>
<?php 
	echo form::hidden('album_id',$album_id);
	echo form::close(); 
?>
</body>
</html>

Der erste ist ein einfacher Editor, mit dem der Benutzer Informationen zu einem neuen Album einfügen kann. Die Felder wie Autor und Name werden über eine HTML-Eingabe und das Genre über ein Kombinationsfeld eingefügt. Sobald der Benutzer auf die Schaltfläche "Erstellen" klickt, werden alle Informationen als POST-Anfrage an die Methode "Erstellen/Aktualisieren" im Album-Controller übergeben. Wenn die Steuerung diese gebuchten Variablen erhält, ruft sie das Modell auf, das ein neues Album in die Datenbank einfügt. Die Formulare verwenden in beiden Ansichten den Kohana-Formularhelfer.

Erstellen Sie den Assets-Ordner im Kohana-Stammverzeichnis auf derselben Ebene wie der Anwendungsordner, um unserer Anwendung einen gewissen Stil zu verleihen. Öffnen Sie es jetzt und erstellen Sie zwei neue Ordner: CSS und Bilder.

Erstellen Sie im CSS-Ordner eine neue Datei mit dem Namen style.css und fügen Sie diese ein:

a {
	font-family: Verdana, Geneva, Arial, Helvetica, sans-serif ;
	font-weight: normal;
	font-size: 12px;
	color: #00F;
	vertical-align:text-top;
}

img {
	border: 0;
}

label {
	font-family: Verdana, Geneva, Arial, Helvetica, sans-serif ;
	font-weight: normal;
	font-size: 12px;
}

input {
	border: 1px solid #000;
}

select {
	width:185px;
}

table.editor
{
	text-align: center;
	font-family: Verdana, Geneva, Arial, Helvetica, sans-serif ;
	font-weight: normal;
	font-size: 11px;
	color: #fff;
	width: 280px;
	background-color: #666;
	border: 0px;
	border-collapse: collapse;
	border-spacing: 0px;
}

table.editor td.editor_title
{
	background-color: #666;
	color: #fff;
	padding: 4px;
	text-align: left;
	font-weight: bold;
	font-size: 16px;
} 

table.editor td
{
	padding: 4px;
} 

table.list
{
	text-align: center;
	font-family: Verdana, Geneva, Arial, Helvetica, sans-serif ;
	font-weight: normal;
	font-size: 11px;
	color: #fff;
	width: 280px;
	background-color: #666;
	border: 0px;
	border-collapse: collapse;
	border-spacing: 0px;
}

table.list td.item
{
	background-color: #CCC;
	color: #000;
	padding: 4px;
	text-align: left;
	border: 1px #fff solid;
}

table.list td.list_title,table.list td.headers
{
	background-color: #666;
	color: #fff;
	padding: 4px;
	text-align: left;
	border-bottom: 2px #fff solid;
	font-weight: bold;
} 

table.list td.list_title
{
	font-size: 16px;
} 

table.list td.headers
{
	font-size: 12px;
}

Kopieren Sie nun die folgenden Bilder in den Bilder-Ordner:

Das ist alles. Zeigen Sie mit Ihrem Browser auf http://localhost/kohana/index.php/album, und Sie sollten etwas Ähnliches sehen:

Wenn Sie versuchen, ein neues Album zu erstellen oder ein vorhandenes zu bearbeiten, sollten Sie etwas Ähnliches sehen:

Schritt 10: Letzte Gedanken

Natürlich sind für diese Anwendung einige Verbesserungen erforderlich, aber mit einer kleinen Menge Code haben Sie eine kleine Webanwendung erstellt. Jetzt wissen Sie, wie Sie das MVC-Muster mit Kohana verwenden und wie Sie Datenbankbibliotheken und Helfer verwenden. Weitere Informationen finden Sie in der offiziellen Dokumentation.

Dank Kohana ist die Code-Wartung eine einfache Aufgabe, und das Hinzufügen neuer Funktionen ist ein Kinderspiel. Ich hoffe, Ihnen hat dieses Tutorial gefallen. Bleiben Sie dran, um mehr über Kohana zu erfahren.

Folgen Sie uns auf Twitter oder abonnieren Sie den NETTUTS RSS-Feed, um weitere tägliche Tipps und Artikel zur Webentwicklung zu erhalten.