Erstellung eines PHP5-Frameworks

German (Deutsch) translation by Władysław Łucyszyn (you can also view the original English article)

Mit der Grundstruktur für unser Framework sind wir fertig, Funktionen hinzuzufügen. In diesem Tutorial erstellen wir einen Templatemanager und einen Datenbankhandler, die uns einem leistungsstarken Framework einen Schritt näher bringen, das für fast jedes Projekt geeignet ist. Wenn Sie es noch nicht getan haben, lesen Sie zuerst Teil 1 dieser Serie!

MVC: Passen Sie die Struktur an

Im ersten Teil dieses Tutorials haben wir einen Ordner namens controllers erstellt, in dem die Geschäftslogik für unsere Anwendungen gespeichert wird. Wie daok in einem Kommentar betonte, ist dies nicht der beste Ort für die gesamte Geschäftslogik, und es sollte ein Modell zum Speichern dieser Logik verwendet werden. Bisher habe ich in den meisten meiner Anwendungen immer die Datenbank selbst als Modell verwendet. Wenn Sie dies jedoch etwas weiter trennen, wird unser Framework noch leistungsfähiger und einfacher zu erweitern.

Was ist MVC? MVC ist ein Entwurfsmuster (wie auch die Singleton- und Registrierungsmuster, die wir in Teil 1 betrachtet haben) und steht für Model View Controller. Das Ziel dieses Musters ist die Geschäftslogik, Benutzeroberflächenaktionen und die Benutzeroberfläche von zu trennen einander. Obwohl wir noch nichts mit unseren Modellen und Controllern tun werden, aktualisieren wir unsere Frameworks-Ordnerstruktur, um den Ordner "models" einzuschließen. Das Modell enthält die Hauptgeschäftslogik, und der Controller befasst sich mit der Benutzerinteraktion (z.B. Übermitteln von Daten, z.B. eines Kommentars). NB: Unsere __autoload-Funktion muss nicht geändert werden.

Datenbankhandler

Die meisten Websites und Webanwendungen, die PHP verwenden, verwenden auch eine Datenbank-Engine wie MySQL. Wenn wir alle usere datenbankbezogenen Funktionen am selben Ort behalten, können wir (theoretisch) das von uns verwendete Datenbankmodul leicht ändern. Wir können auch bestimmte Vorgänge vereinfachen, z.B. das Einfügen von Datensätzen, das Aktualisieren von Datensätzen oder das Löschen von Datensätzen aus der Datenbank. Dies kann auch den Umgang mit mehreren Datenbankverbindungen erleichtern.

Also... was soll unser Datenbank-Handler tun:

Verwalten Sie Verbindungen zur Datenbank
Versuchen Sie, eine gewisse Abstraktionsebene von der Datenbank bereitzustellen
Cache-Abfragen, damit wir sie später verwenden können
Erleichtern Sie allgemeine Datenbankoperationen

Schauen wir uns den Code für unseren Datenbank-Handler an und diskutieren ihn anschließend.


<?php

/**
 * Database management and access class
 * This is a very basic level of abstraction
 */
class database {
	
	/**
	 * Allows multiple database connections
	 * probably not used very often by many applications, but still useful
	 */
	private $connections = array();
	
	/**
	 * Tells the DB object which connection to use
	 * setActiveConnection($id) allows us to change this
	 */
	private $activeConnection = 0;
	
	/**
	 * Queries which have been executed and then "saved for later"
	 */
	private $queryCache = array();
	
	/**
	 * Data which has been prepared and then "saved for later"
	 */
	private $dataCache = array();
	
	/**
	 * Record of the last query
	 */
	private $last;
	
	
	/**
	 * Hello
	 */
    public function __construct()
    {
    	
    }
    
    /**
     * Create a new database connection
     * @param String database hostname
     * @param String database username
     * @param String database password
     * @param String database we are using
     * @return int the id of the new connection
     */
    public function newConnection( $host, $user, $password, $database )
    {
    	$this->connections[] = new mysqli( $host, $user, $password, $database );
    	$connection_id = count( $this->connections )-1;
    	if( mysqli_connect_errno() )
    	{
    		trigger_error('Error connecting to host. '.$this->connections[$connection_id]->error, E_USER_ERROR);
		} 	
    	
    	return $connection_id;
    }
    
    /**
     * Close the active connection
     * @return void
     */
    public function closeConnection()
    {
    	$this->connections[$this->activeConnection]->close();
    }
    
    /**
     * Change which database connection is actively used for the next operation
     * @param int the new connection id
     * @return void
     */
    public function setActiveConnection( int $new )
    {
    	$this->activeConnection = $new;
    }
    
    /**
     * Store a query in the query cache for processing later
     * @param String the query string
     * @return the pointed to the query in the cache
     */
    public function cacheQuery( $queryStr )
    {
    	if( !$result = $this->connections[$this->activeConnection]->query( $queryStr ) )
    	{
		    trigger_error('Error executing and caching query: '.$this->connections[$this->activeConnection]->error, E_USER_ERROR);
		    return -1;
		}
		else
		{
			$this->queryCache[] = $result;
			return count($this->queryCache)-1;
		}
    }
    
    /**
     * Get the number of rows from the cache
     * @param int the query cache pointer
     * @return int the number of rows
     */
    public function numRowsFromCache( $cache_id )
    {
    	return $this->queryCache[$cache_id]->num_rows;	
    }
    
    /**
     * Get the rows from a cached query
     * @param int the query cache pointer
     * @return array the row
     */
    public function resultsFromCache( $cache_id )
    {
    	return $this->queryCache[$cache_id]->fetch_array(MYSQLI_ASSOC);
    }
    
    /**
     * Store some data in a cache for later
     * @param array the data
     * @return int the pointed to the array in the data cache
     */
    public function cacheData( $data )
    {
    	$this->dataCache[] = $data;
    	return count( $this->dataCache )-1;
    }
    
    /**
     * Get data from the data cache
     * @param int data cache pointed
     * @return array the data
     */
    public function dataFromCache( $cache_id )
    {
    	return $this->dataCache[$cache_id];
    }
    
    /**
     * Delete records from the database
     * @param String the table to remove rows from
     * @param String the condition for which rows are to be removed
     * @param int the number of rows to be removed
     * @return void
     */
    public function deleteRecords( $table, $condition, $limit )
    {
    	$limit = ( $limit == '' ) ? '' : ' LIMIT ' . $limit;
    	$delete = "DELETE FROM {$table} WHERE {$condition} {$limit}";
    	$this->executeQuery( $delete );
    }
    
    /**
     * Update records in the database
     * @param String the table
     * @param array of changes field => value
     * @param String the condition
     * @return bool
     */
    public function updateRecords( $table, $changes, $condition )
    {
    	$update = "UPDATE " . $table . " SET ";
    	foreach( $changes as $field => $value )
    	{
    		$update .= "`" . $field . "`='{$value}',";
    	}
    	   	
    	// remove our trailing ,
    	$update = substr($update, 0, -1);
    	if( $condition != '' )
    	{
    		$update .= "WHERE " . $condition;
    	}
    	
    	$this->executeQuery( $update );
    	
    	return true;
    	
    }
    
    /**
     * Insert records into the database
     * @param String the database table
     * @param array data to insert field => value
     * @return bool
     */
    public function insertRecords( $table, $data )
    {
    	// setup some variables for fields and values
    	$fields  = "";
		$values = "";
		
		// populate them
		foreach ($data as $f => $v)
		{
			
			$fields  .= "`$f`,";
			$values .= ( is_numeric( $v ) && ( intval( $v ) == $v ) ) ? $v."," : "'$v',";
		
		}
		
		// remove our trailing ,
    	$fields = substr($fields, 0, -1);
    	// remove our trailing ,
    	$values = substr($values, 0, -1);
    	
		$insert = "INSERT INTO $table ({$fields}) VALUES({$values})";
		$this->executeQuery( $insert );
		return true;
    }
    
    /**
     * Execute a query string
     * @param String the query
     * @return void
     */
    public function executeQuery( $queryStr )
    {
    	if( !$result = $this->connections[$this->activeConnection]->query( $queryStr ) )
    	{
		    trigger_error('Error executing query: '.$this->connections[$this->activeConnection]->error, E_USER_ERROR);
		}
		else
		{
			$this->last = $result;
		}
		
    }
    
    /**
     * Get the rows from the most recently executed query, excluding cached queries
     * @return array 
     */
    public function getRows()
    {
    	return $this->last->fetch_array(MYSQLI_ASSOC);
    }
    
    /**
     * Gets the number of affected rows from the previous query
     * @return int the number of affected rows
     */
    public function affectedRows()
    {
    	return $this->$this->connections[$this->activeConnection]->affected_rows;
    }
    
    /**
     * Sanitize data
     * @param String the data to be sanitized
     * @return String the sanitized data
     */
    public function sanitizeData( $data )
    {
    	return $this->connections[$this->activeConnection]->real_escape_string( $data );
    }
    
    /**
     * Deconstruct the object
     * close all of the database connections
     */
    public function __deconstruct()
    {
    	foreach( $this->connections as $connection )
    	{
    		$connection->close();
    	}
    }
}
?>

Bevor ich den Code bespreche, möchte ich darauf hinweisen, dass dieser Datenbankhandler sehr einfach ist. Wir könnten eine vollständige Abstraktion bereitstellen, indem wir Abfragen nicht direkt ausführen, sondern Abfragen basierend auf Parametern für eine Abfragefunktion erstellen und dann ausführen.

Unsere Methoden zum Löschen, Einfügen und Aktualisieren von Datensätzen erleichtern die Ausführung einiger gängiger Aufgaben (wie oben erwähnt, können wir diese erweitern, um noch viel mehr zu tun), indem nur Informationen wie der Tabellenname, ein Array von Feldern und entsprechende Werte bereitgestellt werden. Grenzwerte und Bedingungen. Abfragen können auch "zwischengespeichert" werden, damit wir sie später bearbeiten können. Ich finde, dass diese Funktion (sowie die Möglichkeit, Datenfelder zwischenzuspeichern) in Kombination mit einem Vorlagenmanager sehr praktisch ist, da wir Datenzeilen problemlos durchlaufen und sie mit wenig Aufwand in unsere Vorlagen einfügen können, wie Sie möchten Sehen Sie, wenn wir uns den Vorlagen-Manager ansehen.


// insert record
$registry->getObject('db')->insertRecords( 'testTable', array('name'=>'Michael' ) );
// update a record
$registry->getObject('db')->updateRecords( 'testTable', array('name'=>'MichaelP' ), 'ID=2' );
// delete a record (well, upto 5 in this case)
$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );

Wir können auch relativ einfach mit mehreren Datenbankverbindungen arbeiten, solange wir bei Bedarf zwischen den entsprechenden Verbindungen wechseln (obwohl dies beim Zwischenspeichern von Abfragen und Abrufen über unseren Vorlagenmanager ohne weitere Arbeit nicht funktioniert), z.B. mit dem folgenden Code-Snippet können wir Datensätze aus zwei Datenbanken löschen.


// our second database connection (let's assume we already have a connection to our main DB)
$newConnection = $registry->getObject('db')->newConnection('localhost', 'root', 'password', 'secondDB');
// delete from the primary db connection
$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );
// change our active db connection, to allow future queries to be on the second connection
$registry->getObject('db')->setActiveConnection( $newConnection );
// delete from the secondary db connection
$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );
// revert the active connection so future queries are on the primary db connection
$registry->getObject('db')->setActiveConnection( 0 );

Wie möchten wir diese Klasse erweitern?

Volle Abstraktion
Nutzen Sie die Vererbung, erstellen Sie eine Schnittstelle und lassen Sie Datenbankklassen von dieser erben, jeweis für verschiedene Datenbankmodule
Speichern Sie die Verbindungs-IDs zusammen mit der Abfrage, wenn Sie Abfragen zwischenspeichern
Verbessern Sie die Datenbereinigung, abhängig von der Art der Daten, die wir bereinigen möchten

Vorlagen-Manager

Der Vorlagenmanager verarbeitet die gesamte Ausgabe. Er muss in der Lage sein, mit verschiedenen Vorlagendateien zu arbeiten, Platzhalter (ich nenne sie Tags) durch Daten zu ersetzen und Teile der Vorlage mit mehreren Datenzeilen aus der Datenbank zu durchlaufen.

Zur Vereinfachung verwenden wir eine Seitenklasse, um den Inhalt der Seite zu enthalten. Das erleichtert es uns auch, diese zu erweitern und später Funktionen hinzuzufügen. Der Vorlagenmanager verwaltet dieses Objekt.


<?php

// prevent this file being called directly
if ( ! defined( 'PCAFW' ) ) 
{
	echo 'This file can only be called via the main index.php file, and not directly';
	exit();
}

/**
 * Template manager class
 */
class template {

	private $page;
	
	/**
	 * Hello!
	 */
    public function __construct() 
    {
	    include( APP_PATH . '/PCARegistry/objects/page.class.php');
	    $this->page = new Page();

    }
    
    /**
     * Add a template bit onto our page
     * @param String $tag the tag where we insert the template e.g. {hello}
     * @param String $bit the template bit (path to file, or just the filename)
     * @return void
     */
    public function addTemplateBit( $tag, $bit )
    {
		if( strpos( $bit, 'skins/' ) === false )
		{
		    $bit = 'skins/' . PCARegistry::getSetting('skin') . '/templates/' . $bit;
		}
		$this->page->addTemplateBit( $tag, $bit );
    }
    
    /**
     * Put the template bits into our page content
     * Updates the pages content
     * @return void
     */
    private function replaceBits()
    {
	    $bits = $this->page->getBits();
	    foreach( $bits as $tag => $template )
	    {
		    $templateContent = file_get_contents( $bit );
		    $newContent = str_replace( '{' . $tag . '}', $templateContent, $this->page->getContent() );
		    $this->page->setContent( $newContent );
	    }
    }
    
    /**
     * Replace tags in our page with content
     * @return void
     */
    private function replaceTags()
    {
	    // get the tags
	    $tags = $this->page->getTags();
	    // go through them all
	    foreach( $tags as $tag => $data )
	    {
		    if( is_array( $data ) )
		    {
			  
			    if( $data[0] == 'SQL' )
			    {
				    // it is a cached query...replace DB tags
				    $this->replaceDBTags( $tag, $data[1] );
			    }
			    elseif( $data[0] == 'DATA' )
			    {
				     // it is some cached data...replace data tags
				    $this->replaceDataTags( $tag, $data[1] );
			    }
	    	}
	    	else
	    	{	
		    	// replace the content	    	
		    	$newContent = str_replace( '{' . $tag . '}', $data, $this->page->getContent() );
		    	// update the pages content
		    	$this->page->setContent( $newContent );
	    	}
	    }
    }
    
    /**
     * Replace content on the page with data from the DB
     * @param String $tag the tag defining the area of content
     * @param int $cacheId the queries ID in the query cache
     * @return void
     */
    private function replaceDBTags( $tag, $cacheId )
    {
	    $block = '';
		$blockOld = $this->page->getBlock( $tag );
		
		// foreach record relating to the query...
		while ($tags = PCARegistry::getObject('db')->resultsFromCache( $cacheId ) )
		{
			$blockNew = $blockOld;
			// create a new block of content with the results replaced into it
			foreach ($tags as $ntag => $data) 
	       	{
	        	$blockNew = str_replace("{" . $ntag . "}", $data, $blockNew); 
	        }
	        $block .= $blockNew;
		}
		$pageContent = $this->page->getContent();
		// remove the seperator in the template, cleaner HTML
		$newContent = str_replace( '<!-- START ' . $tag . ' -->' . $blockOld . '<!-- END ' . $tag . ' -->', $block, $pageContent );
		// update the page content
		$this->page->setContent( $newContent );
	}
    
	/**
     * Replace content on the page with data from the cache
     * @param String $tag the tag defining the area of content
     * @param int $cacheId the datas ID in the data cache
     * @return void
     */
    private function replaceDataTags( $tag, $cacheId )
    {
	    $block = $this->page->getBlock( $tag );
		$blockOld = $block;
		while ($tags = PCARegistry::getObject('db')->dataFromCache( $cacheId ) )
		{
			foreach ($tags as $tag => $data) 
	       	{
		       	$blockNew = $blockOld;
	        	$blockNew = str_replace("{" . $tag . "}", $data, $blockNew); 
	        }
	        $block .= $blockNew;
		}
		$pageContent = $this->page->getContent();
		$newContent = str_replace( $blockOld, $block, $pageContent );
		$this->page->setContent( $newContent );
    }
    
    /**
     * Get the page object
     * @return Object 
     */
    public function getPage()
    {
	    return $this->page;
    }
    
    /**
     * Set the content of the page based on a number of templates
     * pass template file locations as individual arguments
     * @return void
     */
    public function buildFromTemplates()
    {
	    $bits = func_get_args();
	    $content = "";
	    foreach( $bits as $bit )
	    {
		    
		    if( strpos( $bit, 'skins/' ) === false )
		    {
			    $bit = 'skins/' . PCARegistry::getSetting('skin') . '/templates/' . $bit;
		    }
		    if( file_exists( $bit ) == true )
		    {
			    $content .= file_get_contents( $bit );
		    }
		    
	    }
	    $this->page->setContent( $content );
    }
    
    /**
     * Convert an array of data (i.e. a db row?) to some tags
     * @param array the data 
     * @param string a prefix which is added to field name to create the tag name
     * @return void
     */
    public function dataToTags( $data, $prefix )
    {
	    foreach( $data as $key => $content )
	    {
		    $this->page->addTag( $key.$prefix, $content);
	    }
    }
    
    public function parseTitle()
    {
	    $newContent = str_replace('<title>', '<title>'. $page->getTitle(), $this->page->getContent() );
	    $this->page->setContent( $newContent );
    }
    
    /**
     * Parse the page object into some output
     * @return void
     */
    public function parseOutput()
    {
	    $this->replaceBits();
	    $this->replaceTags();
	    $this->parseTitle();
    }
    
    
    
}
?>

Was genau macht diese Klasse?

Erstellt unser Seitenobjekt und basiert es auf Vorlagendateien. Das Seitenobjekt hat den Inhalt und die Informationen, die zum Erstellen des HTML-Codes der Seite erforderlich sind. Anschließend erstellen wir buildFromTemplate ('templatefile.tpl.php', 'templatefile2.tpl.php'), um den ursprünglichen Inhalt für unsere Seite zu erhalten. Diese Methode verwendet eine beliebige Anzahl von Vorlagendateien als Argumente und setzt sie in der für sie nützlichen Reihenfolge zusammen Vorlagen für Kopf-, Inhalts- und Fußzeilen.

Managt den mit der Seite verknüpften Inhalt, indem das Seitenobjekt einen Datensatz mit Daten verwaltet, die auf der Seite ersetzt werden sollen, sowie zusätzliche Vorlagenbits, die in die Seite integriert werden müssen (addTemplateBit('userbar', 'usertoolsbar.tpl.php)')).

Fügt der Seite Daten und Inhalte hinzu, indem verschiedene Ersetzungsvorgänge für den Seiteninhalt ausgeführt werden, einschließlich des Abrufs von Ergebnissen aus einer zwischengespeicherten Abfrage und des Hinzufügens zu der Seite.

Die Vorlagendatei muss in sich selbst markieren, wo eine zwischengespeicherte Abfrage abgerufen und die Daten aus der Abfrage ersetzt werden müssen. Wenn der Vorlagenmanager auf ein zu ersetzendes Tag stößt, bei dem es sich um eine Abfrage handelt, erhält er den Teil der Seite, durch den er iterieren muss, indem er getBlock('block') für das Seitenobjekt aufruft. Dieser Inhaltsblock wird dann für jeden Datensatz in der Abfrage kopiert und enthält Tags, die durch die Ergebnisse der Abfrage ersetzt werden. Wir werden uns später in diesem Tutorial ansehen, wie dies in der Vorlage aussieht.

Vorlagen-Manager: Seite

Das Seitenobjekt wird vom Vorlagenmanager verwaltet und enthält alle Details zur Seite. Dadurch kann der Vorlagenmanager frei verwaltet werden, und wir können die Funktionalität zu einem späteren Zeitpunkt leichter erweitern.


<?php

/**
 * This is our page object
 * It is a seperate object to allow some interesting extra functionality to be added
 * Some ideas: passwording pages, adding page specific css/js files, etc
 */
class page {

	// room to grow later?
	private $css = array();
	private $js = array();
	private $bodyTag = '';
	private $bodyTagInsert = '';
	
	// future functionality?
	private $authorised = true;
	private $password = '';
	
	// page elements
	private $title = '';
	private $tags = array();
	private $postParseTags = array();
	private $bits = array();
	private $content = "";
	
	/**
	 * Constructor...
	 */
    function __construct() { }
    
    public function getTitle()
    {
    	return $this->title;
    }
    
    public function setPassword( $password )
    {
    	$this->password = $password;
    } 
    
    public function setTitle( $title )
    {
	    $this->title = $title;
    }
    
    public function setContent( $content )
    {
	    $this->content = $content;
    }
    
    public function addTag( $key, $data )
    {
	    $this->tags[$key] = $data;
    }
    
    public function getTags()
    {
	    return $this->tags;
    }
    
    public function addPPTag( $key, $data )
    {
	    $this->postParseTags[$key] = $data;
    }
    
    /**
     * Get tags to be parsed after the first batch have been parsed
     * @return array
     */
    public function getPPTags()
    {
	    return $this->postParseTags;
    }
    
    /**
     * Add a template bit to the page, doesnt actually add the content just yet
     * @param String the tag where the template is added
     * @param String the template file name
     * @return void
     */
    public function addTemplateBit( $tag, $bit )
    {
	    $this->bits[ $tag ] = $bit;
    }
    
    /**
     * Get the template bits to be entered into the page
     * @return array the array of template tags and template file names
     */
    public function getBits()
    {
	    return $this->bits;
    }
    
    /**
     * Gets a chunk of page content
     * @param String the tag wrapping the block ( <!-- START tag --> block <!-- END tag --> )
     * @return String the block of content
     */
    public function getBlock( $tag )
    {
		preg_match ('#<!-- START '. $tag . ' -->(.+?)<!-- END '. $tag . ' -->#si', $this->content, $tor);
		
		$tor = str_replace ('<!-- START '. $tag . ' -->', "", $tor[0]);
		$tor = str_replace ('<!-- END '  . $tag . ' -->', "", $tor);
		
		return $tor;
    }
    
    public function getContent()
    {
	    return $this->content;
    }
  
}
?>

Wie kann diese Klasse erweitert und verbessert werden?

PostParseTags: Möglicherweise möchten Sie Tags ersetzen lassen, nachdem der größte Teil der Seite analysiert wurde. Möglicherweise enthält der Inhalt der Datenbank Tags, die analysiert werden müssen.
Kennwortseiten: Weisen Sie einer Seite ein Kennwort zu. Überprüfen Sie, ob der Benutzer das Kennwort in einem Cookie oder einer Sitzung hat, damit er die Seite sehen kann.
Eingeschränkte Seiten (obwohl wir zuerst unsere Authentifizierungskomponenten benötigen!)
Änderung
Dynamisches Hinzufügen von Verweisen auf Javascript- und CSS-Dateien basierend auf der Seite oder Anwendung.

Kernobjekte laden

Nachdem wir nun einige Objekte haben, die unsere Registrierung für uns speichern wird, müssen wir der Registrierung mitteilen, um welche Objekte es sich handelt. Ich habe im PCARegistry-Objekt eine Methode namens loadCoreObjects erstellt, die (wie es heißt) die Kernobjekte lädt. Dies bedeutet, dass Sie dies einfach aus unserer index.php-Datei aufrufen können, um die Registrierung mit diesen Objekten zu laden.


public function storeCoreObjects()
{
	$this->storeObject('database', 'db' );
	$this->storeObject('template', 'template' );
}

Diese Methode kann später geändert werden, um die anderen Kernobjekte einzubeziehen, die von der Registrierung geladen werden sollen. Natürlich kann es Objekte geben, die von unserer Registrierung verwaltet werden sollen, jedoch nur abhängig von der Anwendung, für die das Framework verwendet wird. Diese Objekte würden außerhalb dieser Methode geladen.

Daten

Damit wir die neuen Funktionen demonstrieren können, die unserem Framework hinzugefügt wurden, benötigen wir eine Datenbank, um den Datenbankhandler zu verwenden, und einige der Vorlagenverwaltungsfunktionen (bei denen wir einen Inhaltsblock durch die Zeilen in der Datenbank ersetzen).

Die Demonstrationssite, die wir am Ende dieser Reihe von Tutorials mit unserem Framework erstellen werden, ist eine Website mit einem Mitgliederverzeichnis. Erstellen wir daher eine sehr einfache Datenbanktabelle für Mitgliederprofile, die eine ID, einen Namen und eine E-Mail-Adresse enthält.

Natürlich brauchen wir ein paar Datenzeilen in dieser Tabelle!

Eine schnelle Vorlage

Damit etwas angezeigt werden kann, benötigen wir eine Basisvorlage, in der wir die Daten aus unserer Mitgliedertabelle auflisten.


<html>
<head>
	<title> Powered by PCA Framework</title>
</head>
<body>
<h1>Our Members</h1>
<p>Below is a list of our members:</p>
<ul>
<!-- START members -->
<li>{name} {email}</li>
<!-- END members -->
</ul>
</body>
</html>

Die HTML-Kommentare der START-Mitglieder und END-Mitglieder bezeichnen den Mitgliederblock (der über die Methode getBlock() auf der Seite abgerufen wird). Hier durchläuft der Vorlagenmanager die Datensätze in der Datenbank und zeigt sie an.

Framework im Einsatz

Jetzt müssen wir dies alles mit unserer index.php-Datei zusammenführen:


// require our registry
require_once('PCARegistry/pcaregistry.class.php');
$registry = PCARegistry::singleton();

// store those core objects
$registry->storeCoreObjects();

// create a database connection
$registry->getObject('db')->newConnection('localhost', 'root', '', 'pcaframework');

// set the default skin setting (we will store these in the database later...)
$registry->storeSetting('default', 'skin');

// populate our page object from a template file
$registry->getObject('template')->buildFromTemplates('main.tpl.php');

// cache a query of our members table
$cache = $registry->getObject('db')->cacheQuery('SELECT * FROM members');

// assign this to the members tag
$registry->getObject('template')->getPage()->addTag('members', array('SQL', $cache) );

// set the page title
$registry->getObject('template')->getPage()->setTitle('Our members');

// parse it all, and spit it out
$registry->getObject('template')->parseOutput();
print $registry->getObject('template')->getPage()->getContent();

Wenn wir diese Seite jetzt in unserem Webbrowser anzeigen, werden die Ergebnisse der Abfrage auf der Seite angezeigt:

Kommen in Teil 3...

In Teil 3 werden wir einen kleinen Umweg von der Entwicklungsseite unseres Frameworks machen und uns ansehen, wie wir mit Blick auf unser Framework entwerfen und wie wir HTML-Vorlagen so aufteilen, dass sie für unser Framework geeignet sind. Wenn wir beginnen, unsere erste Anwendung mit unserem Framework zu erstellen, werden wir uns einige Funktionen dieser Klassen genauer ansehen. Zum Schluss vielen Dank für Ihre Kommentare beim letzten Mal!

Abonnieren Sie den NETTUTS RSS Feed für weitere tägliche Webentwicklungs-Tuts und Artikel.

1
2	<?php
3
4	/**
5	* This is our page object
6	* It is a seperate object to allow some interesting extra functionality to be added
7	* Some ideas: passwording pages, adding page specific css/js files, etc
8	*/
9	class page {
10
11	// room to grow later?
12	private $css = array();
13	private $js = array();
14	private $bodyTag = '';
15	private $bodyTagInsert = '';
16
17	// future functionality?
18	private $authorised = true;
19	private $password = '';
20
21	// page elements
22	private $title = '';
23	private $tags = array();
24	private $postParseTags = array();
25	private $bits = array();
26	private $content = "";
27
28	/**
29	* Constructor...
30	*/
31	function __construct() { }
32
33	public function getTitle()
34	{
35	return $this->title;
36	}
37
38	public function setPassword( $password )
39	{
40	$this->password = $password;
41	}
42
43	public function setTitle( $title )
44	{
45	$this->title = $title;
46	}
47
48	public function setContent( $content )
49	{
50	$this->content = $content;
51	}
52
53	public function addTag( $key, $data )
54	{
55	$this->tags[$key] = $data;
56	}
57
58	public function getTags()
59	{
60	return $this->tags;
61	}
62
63	public function addPPTag( $key, $data )
64	{
65	$this->postParseTags[$key] = $data;
66	}
67
68	/**
69	* Get tags to be parsed after the first batch have been parsed
70	* @return array
71	*/
72	public function getPPTags()
73	{
74	return $this->postParseTags;
75	}
76
77	/**
78	* Add a template bit to the page, doesnt actually add the content just yet
79	* @param String the tag where the template is added
80	* @param String the template file name
81	* @return void
82	*/
83	public function addTemplateBit( $tag, $bit )
84	{
85	$this->bits[ $tag ] = $bit;
86	}
87
88	/**
89	* Get the template bits to be entered into the page
90	* @return array the array of template tags and template file names
91	*/
92	public function getBits()
93	{
94	return $this->bits;
95	}
96
97	/**
98	* Gets a chunk of page content
99	* @param String the tag wrapping the block ( <!-- START tag --> block <!-- END tag --> )
100	* @return String the block of content
101	*/
102	public function getBlock( $tag )
103	{
104	preg_match ('#<!-- START '. $tag . ' -->(.+?)<!-- END '. $tag . ' -->#si', $this->content, $tor);
105
106	$tor = str_replace ('<!-- START '. $tag . ' -->', "", $tor[0]);
107	$tor = str_replace ('<!-- END ' . $tag . ' -->', "", $tor);
108
109	return $tor;
110	}
111
112	public function getContent()
113	{
114	return $this->content;
115	}
116
117	}
118	?>

Erstellung eines PHP5-Frameworks - Teil 2