[php] Einführung in Advanced Templating mit Smarty

1.0 Beschreibung

Smarty ist eine Template-Engine welche dazu dient
Logik von Design bzw. der Ausgabe zu trennen.
Der Einsatz von Smarty bringt viele Vorteile mit sich
neben der Trennung von der Logik uund dem Design,
Anwendungen mit Smarty sind von der Ausführung und der Performance
in der Regel schneller als gewöhnliche Anwendungen in denen
direkt HTML mit PHP-Code eingebettet wird.
Dies macht sich allein beispielsweise daran bemerkbar, dass
mit Smarty entwickelte Templates und Anwendungen zwischen gecached werden
können und bei Bedarf aus dem Cache neu geladen werden können.
Neben dessen wird mittels Smarty simple und elegant eine wirkliche
Übersich im Code geschaffen.
Außerdem sofern man eines Tages ein anderes Frontend nutzen möchte,
kann man auf simple Art und Weise ein neues Template hinterlegen und
in das System einpflegen. Einzige Bedingung ist, man muss die entsprechenden
Variablen natürlich auch im neuen Template vergeben.

2.0 Vorbereitung zum Einbinden von Smarty in die eigene Anwendung

Möchte man Smarty für seine Anwendung nutzen, sollte man sich gedanken
um die Verzeichnisstruktur machen, bevor man das Projekt angeht.

Dazu wäre es sinnvoll im vorhinein sich Überlegungen zu machen, wie man
am besten die Logik und das Design verzeichnistechnisch von einander trennen
kann.

Eine Beispielstruktur könnte in etwa so aussehen:

-root-verzeichnis
– css
-templatename
– js
-templatename
– includes
– templates
-templatename
– templates_c
-templatename
– cache
– pages
– global.php
– index.php

Kurze Erläuterung:
Im Ordner CSS und dem entsprechenden Unterordner vom Design landen die CSS files.
Im ordner JS und dem entsprechenden Unterordner vom Design landen die Javascript-Files.
Im Ordner templates und templates_c werden ebenso 2 Ordner hinterlegt mit dem Namen
des Templates.
In Templates/templatename werden die Templates für das Design hinterlegt.
Templates_c/templanename bleibt leer, da dort die kompilierten Templates automatisch
hinterlegt werden. Kompiliert werden die Templates sobald Smarty im Produktionsmodus
läuft und die Anwendung aufgerufen wird.
Im Cache Verzeichnis landen die zwischen gecachten Templates, sobald die Anwendung
über den Webbrowser aufgerufen wird.

In den Ordnern templates, templates_c, cache, includes und pages sollte sofern der Webserver
htaccess files unterstützt eine Htaccess-File hinterlegt werden mit dem Eintrag
“deny from all”, damit auf die Files in den Ordnern nicht direkt über den Webbrowser
zugegriffen werden kann.

(In den nachfolgenden Punkten werde ich mich nach dieser Struktur richten)

3.0 Einbinden von Smarty in die eigene Anwendung.

Die Einbindung von Smarty in das eigene Projekt ist relativ simpel.
In der global.php sollte der Code zur Herstellung der Datenbankverbindung,
sowie der Code zur Erzeugung von Smarty-Objekt hinterlegt werden, sowie alle
anderen notwendingen Initialisierungen wie z.B. das Setzen der entsprechenden
Ordner für Smarty hinterlegt werden.

<?php

	if(defined('NO_DIRECT')){

		session_start();

		define('SMARTY_DIR','./libs/');
		define('BASEDIR', dirname(__FILE__));

		require_once(BASEDIR."/includes/config.inc.php");
		require(SMARTY_DIR.'Smarty.class.php');
		require_once(BASEDIR."/includes/functions.inc.php");
		define('PREFIX', $sql_prefix);

		//Connect to MySQL
		try{
			$pdo = new PDO("mysql:host=$sqldbhost;port=$sqldbport;dbname=$sqldbname;",$sqldbuser, $sqldbpass);
		}catch(PDOException $err){
			die("Connection to the DBMS is not possible");
		}

		//initialize smarty config
		$smarty = new Smarty();
		$smarty->template_dir = "./templates/".$templated."/";
		$smarty->compile_dir = "./templates_c/".$templated."/";
		$smarty->config_dir = "./includes/".$templated."/";
		$smarty->cache_dir = "./cache/".$templated."/";
		$smarty->assign('app_name', $app_name);
		$smarty->assign('app_version', $version);
		//init end

		//Debug on/off
		if($debug == false){
			error_reporting(0);
			$smarty->debugging = false;
		}else{
			$smarty->debugging = true;
		}
		//debug end
	}

?>

Kurze Erläuterung:
In dem obigen Beispiel setzen wir auf Prepared-Statements. Damit vom vorhinein ausgeschlossen
werden kann das SQL-Injection über irgendwelche Parameter in unsere SQL-Statements eingeschlossen werden kann.
Die Attribute template_dir, compile_dir, config_dir und cache_dir werden mit den entsprechenden Pfaden
initialisiert.
Mit der IF-Verzweigung geben wir an wann wir im Produktionsmodus laufen möchten und wann wir
im Debug-Modus laufen möchten.

Mit der Überprüfung in der ersten IF-Verzweigung stellen wir sicher, dass dieses Script
falls eine htaccess-File nicht angelegt wurde, auch wirklich nicht direkt ausgeführt werden kann,
zuvor muss nämlich die Konstante “NO_DIRECT” auch definiert worden sein, dies tun wir in unserer
index.php.
Die Variable $templated beinhaltet den Namen des Designs.

Dessen code in etwa so aussehen könnte:

<?php 	
  define("NO_DIRECT", true); 	
  require_once("./global.php"); 	 	


  [...]

 	
  $smarty->assign("templatename", $templated);
  $smarty->display('index.tpl');

?>

Mit der Methode display vom Objekt Smarty nennen wir den Einsprungspunkt für die Ausgabe des
Templates. In diesem Falle ist dies die index.tpl die sich im Ordner /template/templatename
befindet.

Mit der Methode asssign werden variablen an das Template übergeben.
Die Ausführung des Logikteils geschieht vor dem Anzeigen des Templates.
Damit wäre schon einmal die Grundstruktur für die Nutzung von Smarty geschaffen.

4.0 Aufbau von Templates

Die Index-Template-File könnte man aufteilen in Header, Content und Footer als
Beispiel. Würden wir dazu eine Struktur bauen wollen müssten wir im Verzeichnis
templates_c/templatename die Dateien “header.tpl, content.tpl und footer.tpl” hinterlegen.

Schließlich muss man auch in der index.tpl hinterlegen welche Template-Dateien included werden
sollen.

{include file="header.tpl"}
{include file="content.tpl"}
{include file="footer.tpl"}

Nun kann man relativ geschickt sein Template in den einzelnen Files verpacken.
Im übrigen, Variablen die an ein Template übergeben worden sind, können im Template durch geschweifte
Klammern aufgerufen werden.

Eine Beispielausgabe der Variable templatename die wir in der index.php initialisiert haben
könnte wie folgt aussehen:

<div class="xyz">
	<p>Name des Templates: {$templatename}</p>
</div>

Haben wir nun beispielsweise assoziative Arrays die wir an eine Variablen übergebe,
könnten wir diese mit einer Schleife im Template wiedergeben:

<div class="xyz">
	{foreach from=$arrayname item="items"}
		{$item.eintrag1}
		{$item.eintrag2}
	{/foreach}
</div>

Damit wären alle Grundlagen für ein Template realisiert mit Smarty gegeben.

Leave a Reply