Das Zend Framework

      Das Zend Framework

      Da es im netz noch recht wenig Tutorials zum ZEND Framework [1] gibt, habe ich mir gedacht, dass ich hier mal die wichtigsten Sachen kurz zusammenfasse.

      Part I | Wie ist Zend aufgebaut ?
      Das Zend Framework ist ja nach dem MVC [2] Prinzip entwickelt worden. Das schlägt sich auch schon in der Ordnerstrucktur nieder.
      Die folgende Strucktur ist die am weitesten verbreitete [S1]. Man kann das aber auch so umarbeiten, wie man es für sich am liebsten hat. Die hier vorgestellte Bootstrap- Datei ist jedoch auf diese Strucktur ausgelegt.

      Brainfuck-Quellcode

      1. /htdocs
      2. ->index.php ( Bootstrap Datei )
      3. ->.htaccess
      4. ->/application
      5. ->->/models
      6. ->->->noch leer
      7. ->->/modules
      8. ->->->/default
      9. ->->->->/controllers
      10. ->->->->->indexController.php
      11. ->->->->/views
      12. ->->->->->/scripts
      13. ->->->->->->/index
      14. ->->->->->->->index.phtml
      15. ->/library
      16. ->->.htaccess
      Die Ordnerstrucktur + Datein für Einstieg



      Inhalt der .htaccess im htdocs Ordner :

      Quellcode

      1. RewriteEngine On
      2. RewriteCond %{REQUEST_FILENAME} -s [OR]
      3. RewriteCond %{REQUEST_FILENAME} -l [OR]
      4. RewriteCond %{REQUEST_FILENAME} -d
      5. RewriteRule ^.*$ - [NC,L]
      6. RewriteRule ^.*$ /index.php [NC,L]

      mod_rewrite [3] MUSS aktiviert sein

      [S1] = Wenn du Ordner außerhalb des Rootverzeichnises anlegen kannst, so wird empfohlen den Application- und den Librarayordner dort zu platzieren.


      Last Update : 25.09
      greetings,
      Moritz

      Follow me on twitter !

      Part II | Bootstrap Datei

      Die in Part I erstellte .htaccess Datei leitet ja nun alle Anfragen an die index.php weiter. Und diese Datei muss dann ja folglich alle Anfragen bearbeiten. Dazu müssen wir ein paar Sachen im Kopf behalten :

      Wir wollen unsere Anwendung immer erweitern können ohne die Bootstrap großartig umschreiben zu müssen.
      Nicht nur wir, sondern auch PHP arbeitet von oben nach unten. D.h. wir können nicht erst die Usererkennung machen und dort eine Datenbankverbindung benutzen und erst danach die Datenbankverbindung herstellen.

      Also als Schema sollte das ganze so aussehen :
      1. Included Path von PHP erweitern
      2. ZEND Klassen laden
      3. Configurationen machen
      4. Datenbankverbindung herstellen
      5. Userauthentifizierung
      6. Layout
      7. Zend Front Controller statklar machen & starten
        [/list=1]

        Included Path :

        PHP-Quellcode

        1. set_include_path('.' . PATH_SEPARATOR . 'library'
        2. . PATH_SEPARATOR . get_include_path());

        Da der komplette Zend Library Ordner ja im libraray Ordner liegt und wir nicht alle Klassen extra über require_once einfügen möchten fügen wir diesen Ordner zum include_path von PHP hinzu.
        Später werden hier noch einige Sachen folgen.
        Wenn z.B. eigene Plugins geschrieben werden, oder Datenbank"models" folgen.
        Doch dazu später mehr.

        ZEND Klassen laden :

        PHP-Quellcode

        1. require_once "Zend/Loader.php";
        2. Zend_Loader::registerAutoload();

        Die Klasse Zend_Loader kann mithilfe der Funktion registerAutoload alle benötigten Klassen includen ohne das wir auch nur eine weitere Zeile schreiben müssen
        Magic ;)

        Configurationen machen :

        PHP-Quellcode

        1. $cfg = new Zend_Config_Ini('application/etc/app.ini', 'dev');

        Dieser Abschnitt ist besonders interessant für alle Leute die lokal auf Ihrem PC entwickeln und das ganze dann nur noch hochladen wenns fertig ist.
        Die lokale Datenbank hat aber andre Logindaten als die Onlinedatenbank Ihres Hosts.
        Was tun ?
        Zend schafft Abhilfe. Mit Zend Config lässt sich der Aufwand auf ein minimum redizieren.
        Wir erstellen also folgende Datein und Ordner

        Quellcode

        1. /htdocs
        2. -/application
        3. --/etc
        4. ---app.ini
        5. [...]

        Inhalt der app.ini :

        Quellcode

        1. database.adapter = "pdo_mysql"
        2. database.params.username = "onlineusername"
        3. database.params.password = "onlinepasswort"
        4. database.params.dbname = "datenbankname"
        5. [dev : live]
        6. database.params.username = "lokalerusername"
        7. database.params.password = "lokalespasswort"


        Datenbankverbindung herstellen :

        PHP-Quellcode

        1. $db = Zend_Db::factory($cfg->database);
        2. Zend_Db_Table_Abstract::setDefaultAdapter($db);
        3. $db->getConnection();

        Nun können wir eine Instanz von Zend_Db ganz einfach erstellen.
        Wir übergeben einfach die Logindaten der Datenbank aus unserer Konfiguartionsdate an die function factory.
        Nun setzten wir diese Datenbankverbindung noch als Standart für spätere Models etc. und schließlich stellen wir eine öffnen wir eine Verbindung mit getConnection().

        Userauthentifizierung :

        PHP-Quellcode

        1. $auth = Zend_Auth::getInstance();
        2. $acl = new MyWork_myacl($auth);

        Dazu ein extra Part später ;)

        Layout :

        PHP-Quellcode

        1. Zend_Layout::startMvc(array(
        2. 'layoutPath' => 'application/layouts',
        3. 'layout' => 'frontend'));
        4. $view = Zend_Layout::getMvcInstance()->getView();
        5. $view->doctype('XHTML1_TRANSITIONAL');

        Auch hierzu folgt später noch eine genauere Beschreibung.
        Nur soviel :
        Wir erstellen einen neuen Ordner namens layout und dort eine Datei namens frontend.phtml
        In dieser Datei können wir dann das Design coden ohne viel PHP Code im Weg zu haben.

        Front Controller :

        PHP-Quellcode

        1. try{
        2. $front = Zend_Controller_Front::getInstance();
        3. $front->addModuleDirectory('application/modules')
        4. // Folgendes Plugin hat mit der Userauthentifizierung zusammen und wird später genauer beleuchtet
        5. ->registerPlugin(new MyWork_myauth($auth, $acl))
        6. ->dispatch();
        7. }catch(Zend_Controller_Exception $e){
        8. echo"ControllerError<br />".$e;
        9. }catch(Exception $e){
        10. echo"Error<br />".$e;
        11. }

        Vorab eine kleiner Hinweis :
        Vom Frontcontroller hängt die ganze Seite ab. Dieser steuert das Routing ( also welche Seite im Endeffekt aufgerufen wird ) Dementsprechend gibt es hier ein vielzahl von Kongurationsmöglichkeiten.
        Ich empfehle also einen Blick ins Manual [de] zu werfen.

        Eine Instanz der Klasse erhalten wir mit dem Aufruf von getInstance(). Nun definieren wir nun den Pfad zu dem Modules und mit dem Aufruf von dispatch() wird die ganze Sache gestartet.
        Wenn ich Zeit und Lust hab folgt evtl. später noch eine Part nur zum Frontcontroller ;)

        Ich hab nochmal die komplette Datei so wie sie nun aussehen sollte hochgeladen.
        So wie die datei nun ist, so ist das noch lange nicht perfekt.
        Später werden noch sinnvolle Erweiterungen gemacht.
        In den späteren Parts wird dann eine neue Version der Bootstrap Datei hochgeladen !


        Last Update : 26.09
      Dateien
      • index.zip

        (679 Byte, 438 mal heruntergeladen, zuletzt: )
      greetings,
      Moritz

      Follow me on twitter !

      Part III | Erste Seite(n)

      Was brauchen wir ?

      Folgende Datein :
      IndexController.php ( aus application/modules/default )
      index.phtml ( aus application/modules/default/views/scripts/index )

      Inhalt IndexController.php

      PHP-Quellcode

      1. class IndexController extends Zend_Controller_Action {
      2. public function indexAction()
      3. {
      4. // Programmlogik hier
      5. $this->view->neuevariable = 'Inhalt von IndexController.php';
      6. }
      7. }


      Inhalt von index.phtml

      PHP-Quellcode

      1. <h1>Startseite</h1>
      2. <?php echo $this->neuevariable ?>


      Dann sollte die Ausgabe so sein :

      Startseite
      Inhalt von IndexController.php

      -----------------------------------
      That´s it ;)


      Was lernen wir ?
      Um eine neue Seite auf unserer Webseite brauchen wir nur :
      1a) Neuen Controller anlegen
      ODER
      1b) Eine neue Action im Controller hinzufügen
      2) Wir brauchen einen neuen Ordner (wenn wir auch nen neuen Controller erstellt haben sonst sollte der ordner schon da sein ;) ) im Verzeichnis application/modules/default/views/script/{name des Controllers}/{name der action}.phtml

      Im Controller könnt Ihr auch einfach fröhlich Sachen Ausgeben, doch das bitte nur zu debugg Zwecken, denn schließlich besagt das MVC Prinzip das im Controller nur Programmlogik sein soll.

      Das wärs auch schon ;)
      greetings,
      Moritz

      Follow me on twitter !

      Part III b | Erweiteretes Seitenmanagement

      Für komplexere Internetauftritte

      Jeder der eine mehr, oder minder komplexe Webbaplication schreiben will, der wird nach kurzer Zeit bemerken, dass er mit einem Module nicht weit kommt. Zumindest nicht wenn er keine bescheuerten Controllernamen einführen will, oder einige Controller mit 20 Funktionen bestückt.
      Um genau sowas zu verhindern ist eine modulare Strucktur gut.
      In unserem Verzeichnis modules befindet sich bis dato nur ein Ordner : default.
      Hier fügen wir nun einen neuen Ordner hinzu den wir special nennen.
      In diesem Verzeichnis erstellen wir nun wieder einen IndexController und die dazugehörigen Viewscripts ( siehe Part III -> Was lernen wir).
      nun sollten wir im Ordner Modules folgende Ordnerstrucktur haben :

      Brainfuck-Quellcode

      1. /modules
      2. ->/default
      3. ->->/controllers
      4. ->->->[..]
      5. ->->/views
      6. ->->->/[..]
      7. ->/special
      8. ->->/controllers
      9. ->->->[..]
      10. ->->/views
      11. ->->->/[..]


      Achtung :
      Die Klasse im Controller darf hier nun nicht nur IndexControler heißen, sondern muss den Modulnamen als Präfix haben. Also :

      PHP-Quellcode

      1. class special_IndexController extends Zend_Controller_Action {
      2. public function IndexAction()
      3. {
      4. // Programmlogik hier
      5. }
      6. }


      Das Standart Routing ist :
      /{modul}/{controller}/{action}
      Also in unserem Fall : special/index/index. Es wird immer zuerst überprüft ob der erste Parameter in der URL ein Modul ist.
      /{controller}/{action}
      Hier wird alsModul 'default' benutzt.
      greetings,
      Moritz

      Follow me on twitter !

      Part IV | Userauthentifizierung

      Für eine komplette Userauthentifizierung benötigen wir 4 Sachen :
      • Eine eigene Klasse die von Zend_Acl abgeleitet wird
      • Ein Zend_auth Adapter
      • und ein Front Controller Plugin der die User bei jedem Seitenaufruf authentifiziert
      • dann noch ein Loginformular


      Also erstmal legen wir einen neuen Ordner im Verzeichnis library an den ich hier MyWork nennen werde.
      In diesem Ordner legen wir nun 3 Datein an :
      • myacl.php
      • myauth.php
      • myauthadapter.php


      Arbeiten wir uns nun mal von oben nach unten dutch die Datein.
      Inhalt von myacl.php

      PHP-Quellcode

      1. <?php
      2. class MyWork_myacl extends Zend_Acl
      3. {
      4. public function __construct(Zend_Auth $auth)
      5. {
      6. $this->add(new Zend_Acl_Resource('index'));
      7. $this->addRole(new Zend_Acl_Role('gast'))
      8. ->addRole(new Zend_Acl_Role('admin'),'gast');
      9. $this->allow('gast','index','index');
      10. ->allow('admin','index',array('neuenuser','userlöschen'));
      11. }
      12. }


      Die Klasse muss so benannt werden damit sie von Zend_Auoload im Unterordner gefunden wird ( wer sich also bis jetzt gewundert hat warum alle Zend Klassen mit dem Präfix 'Zend_' beginnen, dem geht jetzt wohl ein Licht auf ;)

      Was passiert in dieser Date ?
      Erst definieren wir Resourcen. Wir können mit Zend_Acl nur den Zugriff von Usern auf Resourcen kontrollieren. Es macht daher sinn diese Resourcen sinnig zu bennenen. Ich benutze hier den Controllernamen.
      Den Actionnamen sollten wir nicht nehmen, da man später die Action als zusätzlich behandeln kann.

      Dann müssen wir Rollen ( Benutzergruppen ) anlegen.
      Eine Rolle sollte immer 'gast' o.ä. heißen. Schließlich brauchen wir eine Klasse die alle nicht angemeldeten User bekommen.
      Zusätzlich definiere ich nun noch eine Admingruppe.
      Durch den 2. Parameter 'gast' lasse ich der Admingruppe alle Erlaubnisse von der Gruppe gast erben.
      Also wenn Gast nun Zugriff auf xyz hat, dann hat die Admingruppe automatisch auch Zugriff auf jene Resource.

      Als nächstes sagen wir der Klasse welche Usergruppen auf welche Resource Zugriff hat.

      PHP-Quellcode

      1. allow('gast','index','index')

      Gast hat nun Zugriff auf die Resource 'index' und dort auf die Action 'index'.
      Admin hat nun automatisch durch die Vererbung auch Zugriff auf diese Action.

      PHP-Quellcode

      1. allow('admin','index',array('neuenuser','userlöschen')

      Admin hat nun Zugriff auf die Resource 'index' und dort auf die beiden Action´s 'neuenuser' und 'userlöschen'.

      Inhalt von myauth.php

      PHP-Quellcode

      1. <?php
      2. class MyWork_myauth extends Zend_Controller_Plugin_Abstract
      3. {
      4. private $_auth;
      5. private $_acl;
      6. private $_noauth = array('module' => 'default',
      7. 'controller' => 'user',
      8. 'action' => 'nouser');
      9. private $_noacl = array('module' => 'default',
      10. 'controller' => 'error',
      11. 'action' => 'noaccess');
      12. public function __construct($auth, $acl) {
      13. $this->_auth = $auth;
      14. $this->_acl = $acl;
      15. }
      16. public function preDispatch(Zend_Controller_Request_Abstract $request) {
      17. $controller = $request->getControllerName();
      18. $action = $request->getActionName();
      19. $module = $request->getModuleName();
      20. $resource = $controller;
      21. if ($this->_auth->hasIdentity()) {
      22. $role = $this->_auth->getIdentity()->role;
      23. } else {
      24. $role = 'gast';
      25. }
      26. if (!$this->_acl->has($resource)) {
      27. $resource = null;
      28. }
      29. if (!$this->_acl->isAllowed($role, $resource, $action)) {
      30. if (!$this->_auth->hasIdentity()) {
      31. $module = $this->_noauth['module'];
      32. $controller = $this->_noauth['controller'];
      33. $action = $this->_noauth['action'];
      34. } else {
      35. $module = $this->_noacl['module'];
      36. $controller = $this->_noacl['controller'];
      37. $action = $this->_noacl['action'];
      38. }
      39. }
      40. $request->setModuleName($module);
      41. $request->setControllerName($controller);
      42. $request->setActionName($action);
      43. }
      44. }

      Was passiert in dieser Datei ?

      Die ersten Zeilen sollten sich von selbst erklären . OOP in PHP möchte ich hier nicht näher erlätern.
      Die Funktion preDispatch wird vor dem Abarbeiten des Controllers gestartet. Als parameter wird hier das Request-Objekt übergeben. Aus diesem können wir nun auslesen auf welche Seite der User gerade zugreifen möchte :

      PHP-Quellcode

      1. $controller = $request->getControllerName();
      2. $action = $request->getActionName();
      3. $module = $request->getModuleName();

      Nun müssen wir noch prüfen ob der User eingeloggt ist, und festlegen das unsere Resource aus Acl hier gleichzusetzten ist mit dem Controller, welcher aufgerufen werden soll.

      PHP-Quellcode

      1. $resource = $controller;
      2. if ($this->_auth->hasIdentity()) {
      3. $role = $this->_auth->getIdentity()->role;
      4. } else {
      5. $role = 'gast';
      6. }

      Wenn der User nicht eingeloggt ist, so wird ihm die Rolle 'gast' gegeben.

      Die wichtigsten Zeilen :

      PHP-Quellcode

      1. if (!$this->_acl->isAllowed($role, $resource, $action)) {
      2. if (!$this->_auth->hasIdentity()) {
      3. $module = $this->_noauth['module'];
      4. $controller = $this->_noauth['controller'];
      5. $action = $this->_noauth['action'];
      6. } else {
      7. $module = $this->_noacl['module'];
      8. $controller = $this->_noacl['controller'];
      9. $action = $this->_noacl['action'];
      10. }
      11. }

      Hier wird geprüft ob der User mit der Rolle $role auf die Resource $resource und dort auf die Action $action keinen Zugriff hat.
      Wenn dies der Fall ist wird entschieden ob er auf die Loginseite weitergeleitet werden sollte, oder ob ihm eine Seite angezeigt werden soll, die ihm sagt, dass er keinen Zugriff auf diese Seite hat.

      Schließlich werden noch die eventuell neuen Angaben an den Request weitergegeben.

      So einfach ist der Hauptteil ;)

      Nun der Inhalt von myauthadapter.php

      PHP-Quellcode

      1. <?php
      2. require_once 'Zend/Auth/Adapter/DbTable.php';
      3. class MyWork_myauthadapter extends Zend_Auth_Adapter_DbTable
      4. {
      5. public $authAdapter;
      6. public function __construct() {
      7. $db = Zend_Registry::get('db');
      8. parent::__construct($db);
      9. $this->setTableName('tabelle_mit_userdaten');
      10. $this->setIdentityColumn('spalte_mit_username');
      11. /* Passwörter sollten verschlüsselt sein */
      12. $this->setCredentialColumn('spalte_mit_passwort');
      13. /* Falls verschlüsselt dann hier sagen wie */
      14. $this->setCredentialTreatment('MD5(?)'');
      15. }
      16. }

      Es gibt auch andere Adapterklassen. Wer also nicht MySQL nutzt kann sich mal in dem Teil des Manuals umsehen [1]

      So das wären auch schon alle wichtigen Sachen.
      Als letztes noch das Loginformular. Wir bauen das Formular am besten so ein das in der selben Funktion auch der tatsächliche Loginvorgang abläuft.

      PHP-Quellcode

      1. // Klasse usw. hier erstellen
      2. private function loginForm()
      3. {
      4. $login = new Zend_Form();
      5. $login->setAction('/user/login')
      6. ->setMethod('post');
      7. $username = $login->createElement('text', 'username')
      8. ->setRequired(true)
      9. ->addValidator('regex', false, array('/^[a-z0-9]*$/i'))
      10. ->addValidator('stringLength', false, array(4,15));
      11. $password = $login->createElement('password', 'password')
      12. ->setRequired(true)
      13. ->addValidator('regex', false, array('/^[a-z0-9*]*$/i'))
      14. ->addValidator('stringLength', false, array(5,10));
      15. $login->addElement($username)
      16. ->addElement($password)
      17. ->addElement('submit', 'login', array('label' => 'Login'));
      18. return $login;
      19. }
      20. public function indexAction()
      21. {
      22. echo $this->loginForm();
      23. }
      24. public function loginAction()
      25. {
      26. if($this->getRequest()->isPost()){
      27. $form = $this->loginForm();
      28. if (!$form->isValid($_POST)) {
      29. $this->view->message = "<font style=\"color:red; font-weight:bold;\">Invalid Input</font><br />";
      30. $this->view->badlogin=$form;
      31. }else{
      32. $erg=$form->getValues();
      33. $authAdapter = new MyWork_myauthadapter();
      34. $authAdapter->setIdentity($erg['username']);
      35. $authAdapter->setCredential($erg['password']);
      36. $auth = Zend_Auth::getInstance();
      37. $result = $auth->authenticate($authAdapter);
      38. if ($result->isValid()) {
      39. $storage = $auth->getStorage();
      40. $storage->write($authAdapter->getResultRowObject(array('spalte_mit_username','spalte_mit_rolle'),'spalte_mit_passwort'));
      41. $this->view->message = 'Login success.';
      42. } else {
      43. switch ($result->getCode()){
      44. case Zend_Auth_Result::FAILURE_IDENTITY_NOT_FOUND:
      45. $this->view->message = '<b>Anmeldung fehlgeschlagen.</b><br />
      46. <br />
      47. Benutzername und/oder Passwort falsch.';
      48. break;
      49. case Zend_Auth_Result::FAILURE_CREDENTIAL_INVALID:
      50. $this->view->message = '<b>Anmeldung fehlgeschlagen.</b><br />
      51. <br />
      52. Inaktiv oder gebannt.';
      53. break;
      54. default:
      55. $this->view->message = '<b>Anmeldung fehlgeschlagen.</b><br />
      56. <br />
      57. Es ist ein Fehler aufgetreten.';
      58. break;
      59. }
      60. }
      61. }
      62. }else{
      63. return $this->_forward('index');
      64. }


      Alle Fragen zum Formular an sich sollten hier geklärt werden können.
      Ich werde hier nur kurz sagen, was folgende Zeilen bedeuten :

      PHP-Quellcode

      1. $authAdapter = new MyWork_myauthadapter();
      2. $authAdapter->setIdentity($erg['username']);
      3. $authAdapter->setCredential($erg['password']);
      4. $auth = Zend_Auth::getInstance();
      5. $result = $auth->authenticate($authAdapter);
      6. if ($result->isValid()) {
      7. $storage = $auth->getStorage();
      8. $storage->write($authAdapter->getResultRowObject(array('spalte_mit_username',
      9. 'spalte_mit_rolle'),'spalte_mit_passwort'));

      Also erstmal hohlen wir uns unsere Adapterklasse und übergeben dieser die Benutzereingaben. Dann lassen wir prüfen ob diese Eingaben korrekt sind. Wenn ja, dann werden die beiden Spalten spalte_mit_username und i]spalte_mit_rolle[/i] noch gespeichert, damit unser Plugin auch bei jedem Seitenaufruf die Indentität wiederfindet.

      Fertig ist das komplette Usermanagement

      Letztes Update : 27.09.2008
      greetings,
      Moritz

      Follow me on twitter !
      Hi

      sieht echt gut aus - hab nur leider noch keine Zeit gehabt mir das ganze genau anzuschaun.
      Vielleicht ists ja auch möglich, dass du irgendwo eine Demo Version online stellst.

      Mfg
      Write this on my gravestone, write this right on my grave, "To whisky and women, here lies a poor slave".



      Computer- und Mediensicherheit - FH Hagenberg
      Hagenberger Kreis zur Förderung der digitalen Sicherheit
      Security Forum
      So und nun melden wir uns wieder nach dieser kleinen Werbeunterbrechung :D

      Part V | Daten auslesen aus Datenbank ( MySQL )

      Alles was in diesem Part beschrieben wird gehört dem M aus MVC an.
      Ich werde manchmal andre Ausdrücke als Model für hier gezeigte Möglichekuten nennen, doch trotzdem ist es der Modelkomponente zuzuordnen.
      Es gibt mehrere Möglichkeiten Daten aus der Datenbank auszulesen.

      [bTabellen-Models :[/b]
      Im Ordner Models legen wir eine neue Datei nach folgendem Muster an :
      {tabellenname}Models.php
      in dieser Datei legen wir eine neue Klasse an

      PHP-Quellcode

      1. class tabelle extends Zend_Db_Table_Abstract{
      2. protected $_name = 'tabelle';
      3. protected $_primary = 'primary_key';
      4. }

      Nun können wir in jedem Controller einfach eine Instanz dieser Klasse erzeugen und dann können wir beispielsweise ganz einfach Datensätze in dieser Tabelle anlegen.

      PHP-Quellcode

      1. $tabelle = new tabelle();
      2. $insertwerte = array('col' => 'value');
      3. $tabelle->insert($insertwerte);

      Auf änliche Art und Weise kann man auch Datensätze auslesen und aktualisieren.
      Mehr dazu im Manual [LINK]

      Eine andre Möglichkeit ist es einfach den in der Index.php ( Bootstrap ! ) erzeugten MySQL Adapter in der Zend Registry zu speichern und nun wieder auszulesen.

      Bootsrapr

      PHP-Quellcode

      1. Zend_Registry::set('db',$dbadapter);

      Controller

      PHP-Quellcode

      1. $db = Zend_Registry::get('db');
      2. $getrow=$db->select();
      3. $temp=$getrow->from('tabelle',array('col1','col2'))
      4. ->order('primary ASC');
      5. $tmp=$getdetails->query();
      6. $res=$tmp->fetchAll();

      Diese Anfrage würde Beispielsweise alle Werte aus den Spalten col1 und col2 auslesen. Sortiert würden die Wertepaare nach dem Wer der in der Spalte primary steht ( wahrscheinlich der Primärschlüssel ;) ). Das Ergebnis wird in der Variable $res gespeichert.
      $res ist ein verschachteltes Array

      PHP-Quellcode

      1. echo $res[0]['col1'];

      Dies würde den Wert aus col1 aus der ersten Reihe ausgeben.

      MySQL ist natürlich ein großes Thema und es gibt auch eine Vielzahl von Möglichkeiten Daten aus einer Datenbank auszulesen.
      Das Framework stellt dementsprechend auch viele Möglichkeiten bereit mit der Datenbank zu kommunizieren.
      Ein Blick ins Manual zu Zend_db ist daher für jeden Zend Framework Benutzer Pflicht.
      greetings,
      Moritz

      Follow me on twitter !