Previous Next

Theorie der Funktionsweise

Um eine MVC Anwendung zu konfigurieren und bereit zur Auslieferung zu bekommen wird ein immer größerer Anteil an Code benötigt sobald mehr Features verfügbar sind: Setzen der Datenbank, Konfiguration der View und View Helfer, Konfiguration der Layouts, Registrierung der Plugins, Registrierung der Aktion Helfer, und andere.

Zusätzlich will man oft den gleichen Code wiederverwenden um Tests zu bootstrappen, einen Cronjob, oder ein Service Skript zu haben. Wärend es sehr einfach ist sein Bootstrap Skript einzubauen, gibt es oft Initialisierungen die abhängig sind von der Umgebung - man könnte kein MVC für einen Cronjob benötigen, oder nur den DB Layer für ein Service Skript.

Zend_Application zielt darauf ab das alles einfacher zu machen und bietet Wiederwervendbarkeit durch die Kapselung vom Bootstrapping in OOP Paradigmen.

Zend_Application ist in drei Bereiche geteilt:

  • Zend_Application: Lädt die PHP Umgebung, inklusive Inklude-Pfade und Autoloading, und instanziiert die benötigte Bootstrap Klasse.

  • Zend_Application_Bootstrap: Bietet Interfaces für Bootstrap Klassen. Zend_Application_Bootstrap_Bootstrap bietet übliche Funktionalitäten für die meisten Notwendigkeiten des Bootstrappings, inklusive Angorithmen um Abhängigkeiten zu prüfen und die Möglichkeit Bootstrap Ressourcen bei Bedarf zu laden.

  • Zend_Application_Resource bietet ein Interface für Standard Bootstrap Ressourcen die bei Bedarf von einer Bootstrap Instanz geladen werden können, sowie verschiedene standardmäßige Ressource Implementationen.

Entwickler erstellen eine Bootstrap Klasse für Ihre Anwendung und erweitern Zend_Application_Bootstrap_Bootstrap oder implementieren (mindestens) Zend_Application_Bootstrap_BootstrapAbstract. Der Einstiegspunkt (z.B. public/index.php) lädt Zend_Application und initialisiert Sie, indem folgendes übergeben wird:

  • Die aktuelle Umgebung

  • Optionen für das Bootstrapping

Die Bootstrap Optionen enthalten den Pfad zur Datei die die Bootstrap Klasse enthält und optional:

  • Jeden include_path der extra zu setzen ist

  • Jeden Autoloader Namespace der zusätzlich zu registrieren ist

  • Jede php.ini Einstellung die zu initialisieren ist

  • Den Klassennamen für die Bootstrap Klasse (wenn diese nicht "Bootstrap" ist)

  • Ressourcen Präfix zu Pfad Paare die zu verwenden sind

  • Jede Ressource die zu verwenden ist (durch Name der Klasse oder Kurzname)

  • Zusätzliche Pfade zu einer Konfigurationsdatei die zu laden ist

  • Zusätzliche Konfigurations Optionen

Optionen können, ein Array, ein Zend_Config Objekt, oder der Pfad zu einer Konfigurationsdatei sein.

Bootstrapping

Zend_Application's zweites Feld der Arbeit ist die Ausführung des Bootstraps der Anwendung. Bootstraps müssen mindestens Zend_Application_Bootstrap_Bootstrapper implementieren, welches die folgende API definiert:

interface Zend_Application_Bootstrap_Bootstrapper
{
    public function __construct($application);
    public function setOptions(array $options);
    public function getApplication();
    public function getEnvironment();
    public function getClassResources();
    public function getClassResourceNames();
    public function bootstrap($resource = null);
    public function run();
}

Diese API erlaubt es dem Bootstrap die Umgebung und die Konfiguration vom Objekt der Anwendung zu akzeptieren, die Ressourcen die für das Bootstrapping verantwortlich sind zu melden, und dann das Bootstrappen ausführen und die Anwendung zu starten.

Man kann dieses Interface selbst implementieren, Zend_Application_Bootstrap_BootstrapAbstract erweitern, oder Zend_Application_Bootstrap_Bootstrap verwenden.

Neben dieser Funktionalität gibt es eine Anzahl anderer Gebiete von Interesse mit denen man vertraut sein sollte.

Methoden für Ressourcen

Die Implementation von Zend_Application_Bootstrap_BootstrapAbstract bietet eine einfache Konvention für die Definition von Methoden für Ressourcen Klassen. Jede geschützte Methode (protected), deren Name mit _init beginnt wird als Ressourcemethode angenommen.

Um eine einzelne Ressource Methode zu bootstrappen, muß die bootstrap() Methode verwendet, und der Name der Ressource übergeben werden. Der Name ist der Name der Methode ohne den _init Präfix.

Um mehrere Ressourcen Methoden zu bootstrappen, muß ein Array von Namen übergeben werden. Um alle Ressourcen Methoden zu bootstrappen, darf nichts übergeben werden.

Nehmen wir die folgende Bootstrap Klasse an:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initFoo()
    {
        // ...
    }

    protected function _initBar()
    {
        // ...
    }

    protected function _initBaz()
    {
        // ...
    }
}

Um nur die _initFoo() Methode zu bootstrappen, machen wir das folgende:

$bootstrap->bootstrap('foo');

Um die Methoden _initFoo() und _initBar() zu bootstrappen, machen wir das folgende:

$bootstrap->bootstrap(array('foo', 'bar'));

Um alle Ressourcen Methoden zu bootstrappen, rufen wir bootstrap() ohne Argumente auf:

$bootstrap->bootstrap();

Bootstraps die Ressourcen Plugins benutzen

Um Bootstraps wiederverwendbarer zu machen wurde die Fähigkeit zur Verfügung gestellt Ressourcen in Ressource Plugin Klassen zu geben. Das erlaubt es Ressourcen einfach über die Konfiguration zu mischen und zu sehen ob Sie passen. Wir behandeln später wie Ressourcen erstellt werden; in diesem Abschnitt zeigen wir nur wie Sie angepasst werden können.

Wenn die Bootstrap dazu in der Lage sein soll Ressource Plugins zu verwenden muß man ein zusätzliches Interface implementieren, Zend_Application_Bootstrap_ResourceBootstrapper. Dieses Interface definiert eine API für das Erkennen, Registrieren und Laden von Ressource Plugins:

interface Zend_Application_Bootstrap_ResourceBootstrapper
{
    public function registerPluginResource($resource, $options = null);
    public function unregisterPluginResource($resource);
    public function hasPluginResource($resource);
    public function getPluginResource($resource);
    public function getPluginResources();
    public function getPluginResourceNames();
    public function setPluginLoader(Zend_Loader_PluginLoader_Interface $loader);
    public function getPluginLoader();
}

Ressource Plugins bieten grundsätzlich die Fähigkeit Ressource Initialisierer zu Erstellen die zwischen Anwendungen wiederverwendet werden können. Das erlaubt es die aktuelle Bootstrap relativ klein zu halten, und neue Ressourcen einzuführen ohne Sie in der Bootstrap selbst anzugreifen.

Zend_Application_Bootstrap_BootstrapAbstract (und bei Erweiterung Zend_Application_Bootstrap_Bootstrap) implementiert dieses Interface genauso, und erlaubt es Ressource Plugins zu verwenden.

Um Ressource Plugins zu verwenden müssen diese in den Optionen spezifiziert werden, die dem Anwendungs Objekt und-oder der Bootstrap übergeben werden. Diese Optionen können von einer Konfigurationsdatei kommen, oder manuell übergeben werden. Optionen sind Paare von Schlüssel zu Optionspaaren, wobei der Schlüssel den Namen der Ressource repräsentiert. Der Ressourcename ist das Segment das dem Klassenpräfix folgt. Die Ressourcen, die zum Beispiel mit Zend Framework ausgeliefert werden, haben den Klassenpräfix "Zend_Application_Resource_"; alles was folgt würde der Name der Ressource sein. Als Beispiel:

$application = new Zend_Application(APPLICATION_ENV, array(
    'resources' => array(
        'FrontController' => array(
            'controllerDirectory' => APPLICATION_PATH . '/controllers',
        ),
    ),
));

Das zeigt das die "FrontController" verwendet werden sollte, mit den spezifizierten Optionen.

Wenn man beginnt eigene Ressource Plugins zu schreiben, oder Ressource Plugins von dritten anzupassen, muß man der eigenen Bootstrap mitteilen wo nach Ihnen zu suchen ist. Intern verwendet die Bootstrap Zend_Loader_PluginLoader so dass man nur die üblichen Klassenpräfix und Pfadpaare angeben muß.

Als Beispiel nehmen wir an das wir eigene Ressource Plugins in APPLICATION_PATH/resources/ haben, und das sie den gemeinsamen Klassenpräfix My_Resource teilen. Man würde diese Information de Anwendungsobjekt wie folgt übergeben:

$application = new Zend_Application(APPLICATION_ENV, array(
    'pluginPaths' => array(
        'My_Resource' => APPLICATION_PATH . '/resources/',
    ),
    'resources' => array(
        'FrontController' => array(
            'controllerDirectory' => APPLICATION_PATH . '/controllers',
        ),
    ),
));

Man ist jetzt in der Lage Ressource von diesem Verzeichnis zu verwenden.

Wie Ressource Methoden kann die bootstrap() Methode verwendet werden um Ressource Plugins zu verwenden. Wie bei Ressource Methoden kann man entweder einzelne Ressource Plugins spezifizieren, mehrere Plugins (über ein Array), oder alle Plugins. Zusätzlich kann man mischen und entsprechende Ressource Methoden genauso ausführen.

// Eine ausführen:
$bootstrap->bootstrap('FrontController');

// Mehrere ausführen:
$bootstrap->bootstrap(array('FrontController', 'Foo'));

// Alle Ressource Methoden und Plugins ausführen:
$bootstrap->bootstrap();

Ressource Registry

Viele, wenn nicht sogar alle, der eigenen Ressource Methoden oder Plugins initialisieren Objekte, und in vielen Fällen werden diese Objekte an anderen Orten der Anwendung benötigt. Wie man man auf Sie zugreifen?

Zend_Application_Bootstrap_BootstrapAbstract bietet eine locale Registry für diese Objekte. Um eigene Objekte in Ihr zu Speichern müssen diese einfach von den eigenen Ressourcen zurückgegeben werden.

Für maximale Flexibilität wird diese Registry intern als "Container" bezeichnet; die einzige Voraussetzung ist das es ein Objekt ist. Ressourcen werden dann als Eigenschaften registriert die nach dem Namen der Ressource benannt sind. Standardmäßig wird eine Instanz von Zend_Registry verwendet, man kann aber jedes andere Objekt spezifizieren wenn man das will. Die Methoden setContainer() und getContainer() können verwendet werden um den Container selber zu manipulieren. getResource($resource) kann verwendet werden um eine angegebene Ressource vom Container zu holen, und hasResource($resource) um zu prüfen ob die Ressource aktuell schon registriert wurde.

Als Beispiel nehmen wir eine grundsätzliche View Ressource an:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initView()
    {
        $view = new Zend_View();
        // weitere Initialisierungen...

        return $view;
    }
}

Man kann Sie prüfen und-oder Sie wie folgt holen:

// Verwendung der has- und getResource() Paare:
if ($bootstrap->hasResource('view')) {
    $view = $bootstrap->getResource('view');
}

// Über den Container:
$container = $bootstrap->getContainer();
if (isset($container->view)) {
    $view = $container->view;
}

Es ist zu beachten das die Registry und auch der Container nicht global sind. Das bedeutet das man auf die Bootstrap zugreifen muß um Ressourcen zu holen. Zend_Application_Bootstrap_Bootstrap bietet einige Bequemlichkeiten hierfür: wärend der Ausführung von run(), registriert Sie sich als Front Controller Parameter "bootstrap", was es erlaubt Sie von Routern, Dispatchern, Plugins, und Action Controllern zu holen.

Wenn man, als Beispiel, auf die View Ressource von oben im eigenen Action Controller zugreifen will, kann man das wie folgt tun:

class FooController extends Zend_Controller_Action
{
    public function init()
    {
        $bootstrap = $this->getInvokeArg('bootstrap');
        $view = $bootstrap->getResource('view');
        // ...
    }
}

Erkennen von Abhängigkeiten

Zusätzlich zur Ausführung von Ressource Methoden und Plugins, ist es notwendig sicherzustellen das diese einmal und wirklich nur einmal ausgeführt werden; Sie sollen eine Anwendung bootstrappen, und die mehrfache Ausführung von Ihnen kann zu einem Overhead von Ressourcen führen.

Zur gleichen Zeit können Ressourcen von anderen ausgeführten Ressourcen abhängen. Um diese zwei Fälle zu lösen bietet Zend_Application_Bootstrap_BootstrapAbstract einen einfachen und effektiven Mechanismus für die Erkennung von Abhängigkeiten.

Wie vorher erwähnt werden alle Ressourcen -- ob Methoden oder Plugins -- durch den Aufruf von bootstrap($resource) gebootstrappt, wobei $resource der Name einer Ressource ist, ein Array von Ressourcen oder leer gelassen wird, was zeigt das alle Ressourcen ausgeführt werden sollen.

Wenn eine Ressource von anderen Ressourcen abhängig ist, sollte Sie in Ihrem Code bootstrap() aufrufen um sicherzustellen das die Ressource ausgeführt wurde. Weitere Aufrufe von Ihr werden dann ignoriert.

In einer Ressource Methode würde so ein Aufruf wie folgt aussehen:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initRequest()
    {
        // Sicherstellen der der Front Controlle initialisiert wird
        $this->bootstrap('FrontController');

        // Den Front Controller von der Bootstrap Registry erhalten
        $front = $this->getResource('FrontController');

        $request = new Zend_Controller_Request_Http();
        $request->setBaseUrl('/foo');
        $front->setRequest($request);

        // Sicherstellen das die Anfrage in der Bootstrap Registry gespeichert ist
        return $request;
    }
}

Ressource Plugins

Wie vorher erwähnt ist die Verwendung von Ressource Plugins ein guter Weg um wiederverwendbare Bootstrap Ressourcen zu erstellen und um so viel wie möglich vom eigenen Code in diskrete Klassen auszulagern. Wärend Zend Framework mit einer Anzahl von standardmäßigen Ressource Plugins geliefert wird, besteht das Ziel darin das der Entwickler eigene schreiben sollte um seine eigenen Notwendigkeiten der Initialisierung zu kapseln.

Ressourcen müssen nur Zend_Application_Resource_Resource implementieren, oder einfach Zend_Application_Resource_ResourceAbstract erweitern. Das grundsätzliche Interface ist folgendes:

interface Zend_Application_Resource_Resource
{
    public function __construct($options = null);
    public function setBootstrap(
        Zend_Application_Bootstrap_Bootstrapper $bootstrap
    );
    public function getBootstrap();
    public function setOptions(array $options);
    public function getOptions();
    public function init();
}

Das Interface definiert einfach das eine Ressouce Optionen im Konstruktor akzeptieren sollte, Mechanismen für das Setzen und Empfangen von Optionen, Mechanismen für das Setzen und Empfangen des Bootstrap Objekts, und eine Initialisierungs-Methode hat.

Als Beispiel nehmen wir an das wir eine normale View Initialisierung haben die in der eigenen Anwendung verwendet wird. Man hat normale Doctype, CSS und Javascript, und will in der Lage sein diese in einem basis Dokumententitel über die Konfiguration zu übergeben. So eine Ressource könnte wie folgt aussehen:

class My_Resource_View extends Zend_Application_Resource_ResourceAbstract
{
    protected $_view;

    public function init()
    {
        // Die View zurückgeben damit die Bootstrap Sie in der Registry speichert
        return $this->getView();
    }

    public function getView()
    {
        if (null === $this->_view) {
            $options = $this->getOptions();
            $title   = '';
            if (array_key_exists('title', $options)) {
                $title = $options['title'];
                unset($options['title']);
            }

            $view = new Zend_View($options);
            $view->doctype('XHTML1_STRICT');
            $view->headTitle($title);
            $view->headLink()->appendStylesheet('/css/site.css');
            $view->headScript()->appendfile('/js/analytics.js');

            $viewRenderer =
                Zend_Controller_Action_HelperBroker::getStaticHelper(
                    'ViewRenderer'
                );
            $viewRenderer->setView($view);

            $this->_view = $view;
        }
        return $this->_view;
    }
}

Solange man den Präfix Pfad für dieses Ressource Plugin registriert, kann es in der eigenen Anwendung verwendet werden. Besser, weil der Plugin Loader verwendet wird, ist es die gelieferten "View" Ressource Plugin zu überschreiben, und sicherzustellen das man stattdessen die eigene verwendet.

Previous Next
Introduction to Zend Framework
Übersicht
Installation
Zend_Acl
Einführung
Verfeinern der Zugriffskontrolle
Fortgeschrittene Verwendung
Zend_Amf
Einführung
Zend_Amf_Server
Zend_Application
Einführung
Zend_Application Quick Start
Theorie der Funktionsweise
Beispiele
Kern Funktionalität
Vorhandene Ressource Plugins
Zend_Auth
Einführung
Datenbanktabellen Authentifizierung
Digest Authentication
HTTP Authentication Adapter
LDAP Authentifizierung
Open ID Authentifikation
Zend_Cache
Einführung
Die Theorie des Cachens
Zend_Cache Frontends
Zend_Cache Backends
Zend_Captcha
Einführung
Captcha Anwendung
CAPTCHA Adapter
Zend_CodeGenerator
Einführung
Zend_CodeGenerator Beispiele
Zend_CodeGenerator Referenz
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Einführung
Definieren von Getopt Regeln
Holen von Optionen und Argumenten
Konfigurieren von Zend_Console_Getopt
Zend_Controller
Zend_Controller Schnellstart
Zend_Controller Grundlagen
Der Front Controller
Das Request Objekt
Der Standard Router
Der Dispatcher
Action Controller
Action Helfer
Das Response Objekt
Plugins
Eine konventionelle modulare Verzeichnis Struktur verwenden
MVC Ausnahmen
Migration von vorhergehenden Versionen
Zend_Currency
Einführung in Zend_Currency
Arbeiten mit Währungen
Migration von vorhergehenden Versionen
Zend_Date
Einführung
Theorie der Arbeitsweise
Basis Methoden
Zend_Date API Übersicht
Erstellen von Datumswerten
Konstanten für generelle Datums Funktionen
Funktionierende Beispiele
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Zend_Db_Table Relationships
Zend_Db_Table_Definition
Zend_Debug
Variablen ausgeben
Zend_Dojo
Einführung
Zend_Dojo_Data: dojo.data Envelopes
Dojo View Helfer
Formular Elemente und Dekoratore für Dojo
Zend_Dojo build layer support
Zend_Dom
Einführung
Zend_Dom_Query
Zend_Exception
Verwenden von Ausnahmen
Zend_Feed
Einführung
Feeds importieren
Feeds von Websites abrufen
Einen RSS Feed konsumieren
Einen Atom Feed konsumieren
Einen einzelnen Atom Eintrag konsumieren
Verändern der Feed- und Eintragsstruktur
Eigene Klassen für Feeds und Einträge
Zend_Feed_Reader
Zend_File
Zend_File_Transfer
Prüfungen für Zend_File_Transfer
Filter für Zend_File_Transfer
Migration von vorhergehenden Versionen
Zend_Filter
Einführung
Standard Filter Klassen
Filter Ketten
Filter schreiben
Zend_Filter_Input
Zend_Filter_Inflector
Migration von vorhergehenden Versionen
Zend_Form
Zend_Form
Schnellstart mit Zend_Form
Erstellen von Form Elementen mit Hilfe von Zend_Form_Element
Erstellen von Form durch Verwendung von Zend_Form
Erstellen von eigenem Form Markup durch Zend_Form_Decorator
Standard Form Elemente die mit dem With Zend Framework ausgeliefert werden
Standard Formular Dekoratoren die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung
Authentifizierung mit AuthSub
Die Buchsuche Daten API verwenden
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Verwenden von Google Health
Google Tabellenkalkulation verwenden
Google Apps Provisionierung verwenden
Google Base verwenden
Picasa Web Alben verwenden
Verwenden der YouTube Daten API
Gdata Ausnahmen auffangen
Zend_Http
Einführung
Zend_Http_Client - Fortgeschrittende Nutzung
Zend_Http_Client - Verbindungsadapter
Migration von vorhergehenden Versionen
Zend_Http_Cookie und Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Einführung
Zend_Json
Einführung
Grundlegende Verwendung
Fortgeschrittene Verwendung von Zend_Json
XML zu JSON Konvertierung
Zend_Json_Server - JSON-RPC server
Zend_Layout
Einführung
Zend_Layout Schnellstart
Zend_Layout Konfigurations Optionen
Erweiterte Verwendung von Zend_Layout
Zend_Ldap
Einführung
API Übersicht
Usage Scenarios
Tools
Objektorientierter Zugriff auf den LDAP Baum durch Verwendung von Zend_Ldap_Node
Informationen vom LDAP Server erhalten
Serialisieren von LDAP Daten von und zu LDIF
Zend_Loader
Dynamisches Laden von Dateien und Klassen
Der Autoloader
Ressource Autoloader
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte Gebietsschemata
Migrieren von vorhergehenden Versionen
Zend_Log
Übersicht
Writer
Formatter
Filter
Zend_Mail
Einführung
Versand über SMTP
Versand von mehreren E-Mails über eine SMTP Verbindung
Verwendung von unterschiedlichen Versandwegen
HTML E-Mail
Anhänge
Empfänger hinzufügen
Die MIME Abgrenzung kontrollieren
Zusätzliche Kopfzeilen
Zeichensätze
Kodierung
SMTP Authentifizierung
SMTP Übertragungen sichern
Lesen von Mail Nachrichten
Zend_Measure
Einführung
Erstellung einer Maßeinheit
Ausgabe von Maßeinheiten
Manipulation von Maßeinheiten
Arten von Maßeinheiten
Zend_Memory
Übersicht
Memory Manager
Memory Objekte
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_Navigation
Einführung
Seiten
Container
Migration von vorhergehenden Versionen
Zend_OpenId
Einführung
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Provider
Zend_Paginator
Einführung
Verwendung
Konfiguration
Advanced usage
Zend_Pdf
Einführung
Erstellen und Laden von PDF Dokumenten
Änderungen an PDF Dokumenten speichern
Arbeiten mit Seiten
Zeichnen
Interactive Features
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Queue
Einführung
Beispiel der Verwendung
Framework
Adapter
Anpassen von Zend_Queue
Stomp
Zend_Reflection
Einführung
Zend_Reflection Beispiele
Zend_Reflection Referenz
Zend_Registry
Die Registry verwenden
Zend_Rest
Einführung
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Überblick
Indexerstellung
Einen Index durchsuchen
Abfragesprache
Abfrage Erzeugungs API
Zeichensätze
Erweiterbarkeit
Zusammenarbeit Mit Java Lucene
Erweitert
Die besten Anwendungen
Zend_Server
Einführung
Zend_Server_Reflection
Zend_Service
Einführung
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Amazon_Ec2
Zend_Service_Amazon_Ec2: Instanzen
Zend_Service_Amazon_Ec2: Windows Instanzen
Zend_Service_Amazon_Ec2: Reservierte Instanzen
Zend_Service_Amazon_Ec2: CloudWatch Monitoring
Zend_Service_Amazon_Ec2: Amazon Maschinen Images (AMI)
Zend_Service_Amazon_Ec2: Elastischer Block Speicher (EBS)
Zend_Service_Amazon_Ec2: Elastische IP Adressen
Zend_Service_Amazon_Ec2: Schlüsselpaare
Zend_Service_Amazon_Ec2: Regionen und Availability Zones
Zend_Service_Amazon_Ec2: Sicherheitsgruppen
Zend_Service_Amazon_S3
Zend_Service_Amazon_Sqs
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Einführung
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Mitgelieferte Services
Zend_Service_StrikeIron: Erweiterte Verwendung
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_Yahoo
Zend_Session
Einführung
Grundsätzliche Verwendung
Fortgeschrittene Benutzung
Globales Session Management
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL Zugriffsmethoden
AutoDiscovery
Zend_Tag
Einführung
Zend_Tag_Cloud
Zend_Test
Einführung
Zend_Test_PHPUnit
Zend_Test_PHPUnit_Db
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Tool_Framework
Einführung
Verwenden des CLI Tools
Architektur
Erstellen von Providern für die Verwendung mit Zend_Tool_Framework
Mitgelieferte System Provider
Extending and Configuring Zend_Tool_Framework
Zend_Tool_Project
Einführung
Ein Projekt erstellen
Project Provider für Zend Tool
Zend_Translate
Einführung
Adapter für Zend_Translate
Benutzen von Übersetzungs Adaptoren
Erstellen von Quelldateien
Zusätzliche Features für Übersetzungen
Plurale Schreibweisen für Übersetzungen
Migration von vorhergehenden Versionen
Zend_Uri
Zend_Uri
Zend_Validate
Einführung
Standard Prüfklassen
Kettenprüfungen
Schreiben von Prüfern
Prüfungsmeldungen
Zend_Version
Die Version des Zend Frameworks erhalten
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Migration von vorhergehenden Versionen
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Zend Framework Voraussetzungen
Einführung
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Zend Framework Dokumentations Standard
Übersicht
Formatierung von Dokumentationsdateien
Empfehlungen
Recommended Project Structure for Zend Framework MVC Applications
Overview
Recommended Project Directory Structure
Module Structure
Rewrite Configuration Guide
Zend Framework Performance Guide
Einführung
Laden von Klassen
Zend_Db Performance
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen