Zend_Feed_Reader ist eine Komponente die verwendet wird um RSS und Atom Feeds jeder Version zu konsumieren, inklusive RDF/RSS 1.0, RSS 2.0, Atom 0.3 und Atom 1.0. Die API für das Empfangen von Feed Daten ist relativ einfach da Zend_Feed_Reader in der Lage ist jeden Feed eines jeden Typs mit Hilfe der API nach den angefragten Informationen zu durchsuchen. Wenn die typischen Elemente die diese Informationen enthalten nicht vorhanden sind, werden diese adaptiert und statt dessen auf eine Vielzahl von alternativen Elementen zurück gegriffen. Diese Fähigkeit, von Alternativen auszuwählen, verhindert das Benutzer Ihren eigenen astrakten Layer über die Komponente legen müssen damit Sie nützlich ist, oder beliebig tiefes Wissen des zugrundeliegenden Standard, aktueller alternativen und namespaces Erweiterungen haben müssen.

Intern arbeitet Zend_Feed_Reader fast komplett auf Basis der Erstellung von XPath Abfragen gegen das Dokument Objekt Modell des Feed XML's. Das DOM wird nicht durch eine gekettete Eigenschaften API wie bei Zend_Feed bekannt gegeben und durch die darunterliegenden DOMDocument, DOMElement und DOMXPath Objekte für eine externe Manipulation bekannt gegeben. Dieser Singular Weg des Parsens ist konsistent und die Komponente bietet ein Plugin System um dem Feed hinzuzufügen und eine Eintrags Level API durch das Schreiben von Erweiterungen auf einer ähnlichen Basis.

Geschwindigkeit wird auf drei Wegen bereitgestellt. Erstens unterstützt Zend_Feed_Reader das Cachen durch Verwendung von Zend_Cache um eine Kopie des Originalen Feed XML zu halten. Das erlaubt es Netzwerk Anfragen für eine Feed URI zu überspringen wenn der Cache gültig ist. Zweitens wird die Feed und Eintrag- Level API durch einen internen Cache gesichert (nicht persistent) damit wiederholte API Aufrufe für den gleichen Feed eine zusätzliche Verwendung von DOM oder XPath verhindert. Drittens erlaubt das Importieren von Feeds von einer URI den Vorteil von konditionellen HTTP GET Anfragen welche es Servern erlauben eine leere 304 Anfrage auszulösen wenn der angefragte Feed seit der Zeit zu der er das letzte Mal angefragt wurde, nicht verändert wurde. Im letzten Fall hält eine Instanz von Zend_Cache den zuletzt empfangenen Feed zusammen mit dem ETag und dem Last-Modified Header Werten die in der HTTP Antwort gesendet wurde.

Relativ zu Zend_Feed wurde Zend_Feed_Reader als frei stehender Ersatz für Zend_Feed formuliert der aber nicht mit Zend_Feed rückwärts kompatibel ist. Aber es ist eine Alternative die einer anderen Ideologie folgt die darin fokusiert ist einfach verwendbar zu sein, flexibel, konsistent und durch das Plugin System erweiterbar. Zend_Feed_Reader ist auch nicht dazu fähig Feeds zu erstellen, delegiert diese Aufgabe aber an Zend_Feed_Writer, seinen Bruder.

Das importieren eines Feeds mit Zend_Feed_Reader ist zu Zend_Feed nicht sehr unterschiedlich. Feeds können von einem String, einer Datei, URI oder einer Instanz des Typs Zend_Feed_Abstract importiert werden. Das importieren von einer URI kann zusätzlich eine konditionelle HTTP GET Anfrage benützen. Wenn das importieren fehlschlägt, wird eine Exception geworfen. Das Endergebnis wird ein Objekt des Typs Zend_Feed_Reader_FeedInterface sein, die Core Implementation von Zend_Feed_Reader_Feed_Rss und Zend_Feed_Reader_Feed_Atom (Zend_Feed hat alle kurzen Namen genommen!). Beide Objekte unterstützen mehrere (alle existierenden) Versionen dieser breiten Feed Typen.

Im folgenden Beispiel importieren wir einen RDF/RSS 1.0 Feed und extrahieren einige grundsätzliche Information die dann in einer Datenbank oder wo anders gespeichert werden können.

$feed = Zend_Feed_Reader::import('http://www.planet-php.net/rdf/');
$data = array(
    'title'        => $feed->getTitle(),
    'link'         => $feed->getLink(),
    'dateModified' => $feed->getDateModified(),
    'description'  => $feed->getDescription(),
    'language'     => $feed->getLanguage(),
    'entries'      => array(),
);

foreach ($feed as $entry) {
    $edata = array(
        'title'        => $entry->getTitle(),
        'description'  => $entry->getDescription(),
        'dateModified' => $entry->getDateModified(),
        'authors'      => $entry->getAuthors(),
        'link'         => $entry->getLink(),
        'content'      => $entry->getContent()
    );
    $data['entries'][] = $edata;
}

Das obige Beispiel demonstriert die API von Zend_Feed_Reader und es demonstriert auch einige seiner internen Operationen. In Wirklichkeit hat der ausgewählte RDF Feed keine nativen Daten oder Author Elemente, trotzdem verwendet er das Dublin Core 1.1 Modul welches Namespaced Ersteller und Datums Elemente anbietet. Zend_Feed_Reader fällt auf diese und ähnliche Operationen zurück wenn keine relativ nativen Elemente existieren. Wenn es absolut keine alternative finden kann wird es NULL zurückgeben, was anzeigt das die Informationen nicht im Feed gefunden werden können. Man sollte beachten das Klassen die Zend_Feed_Reader_FeedInterface implementieren auch die SPL Interfaces Iterator und Countable implementieren.

Feeds können auch von Strings, Dateien und sogar Objekten des Typs Zend_Feed_Abstract importiert werden.

// von einer URI
$feed = Zend_Feed_Reader::import('http://www.planet-php.net/rdf/');

// von einem String
$feed = Zend_Feed_Reader::importString($feedXmlString);

// von einer Datei
$feed = Zend_Feed_Reader::importFile('./feed.xml');

// von einem abstrakten Zend_Feed_Abstract Objekt
$zfeed = Zend_Feed::import('http://www.planet-php.net/atom/');
$feed  = Zend_Feed_Reader::importFeed($zfeed);

Zend_Feed_Reader macht sein bestes um Ihnen die Details abzunehmen. Wenn man an einem Feed ausserhalb von Zend_Feed_Reader arbeiten muß, kann man das grundsätzliche DOMDocument oder DOMElement von jeder Klasse extrahieren, oder sogar einen XML String der sie enthält. Es werden auch Methoden angeboten um das aktuelle DOMXPath Objekt (mit allen registrierten Kern und Erweiterungs Namespaces) zu extrahieren, und den richtigen Präfix der in allen XPath Anfragen für den aktuellen Feed oder Eintrag verwendet wird. Die grundsätzlich zu verwenden Methoden (für jedes Objekt) sind saveXml(), getDomDocument(), getElement(), getXpath() und getXpathPrefix(). Diese erlauben es sich von Zend_Feed_Reader zu lösen und das zu tun was man selbst machen will.

Hier ist ein Beispiel bei dem ein Feed eine RSS Erweiterung enthalten können die von Zend_Feed_Reader nicht out of the Box unterstützt wird. Beachtenswert ist, das man eine Erweiterungen schreiben und registrieren könnte (wird später behandelt) um das zu bewerkstelligen, aber das ist nicht immer eine Garantie für einen schnellen Check. Man muß jeden neuen Namespace beim DOMXPath Objekt registrieren bevor es verwendet wird ausser Sie werden vorab von Zend_Feed_Reader oder einer Erweiterung registriert.

$feed        = Zend_Feed_Reader::import('http://www.planet-php.net/rdf/');
$xpathPrefix = $feed->getXpathPrefix();
$xpath       = $feed->getXpath();
$xpath->registerNamespace('admin', 'http://webns.net/mvcb/');
$reportErrorsTo = $xpath->evaluate('string('
                                 . $xpathPrefix
                                 . '/admin:errorReportsTo)');

Dieser Tage ist vielen Webseiten bekannt das der Ort Ihrer XML Feeds nicht immer eindeutig ist. Eine kleine RDF, RSS oder Atom Grafik hilft wenn der Benutzer die Seite liest, aber was wenn eine Maschine kommt und versucht herauszufinden So die Feed sind? Um hierbei zu helfen, zeigen viele Webseiten zu Ihren Feeds indem <link> Tags in der <head> Sektion Ihres HTMLs verwendet werden. Um diesen Vorteil zu nutzen, kann man Zend_Feed_Reader verwenden diese Feeds zu erkennen, indem die statische findFeedLinks() Methode verwendet wird.

Diese Methode ruft irgendeine URI auf und sucht nach dem Ort der RSS, RDF und Atom Feeds mit der Annahme dass das HTML der Webseite nur die relevanten Links enthält. Sie gibt dann ein Wert Objekt zurück indem man die Existenz einer RSS, RDF oder Atom Feed URI prüfen kann.

Das zurückgegebene Objekt ist eine Unterklasse von ArrayObject welche Zend_Feed_Reader_Collection_FeedLink heisst, damit es in ein Array gecastet werden kann, oder damit man es iterieren kann um auf alle erkannten Links zuzugreifen. Trotzdem kann man, als einfache Abkürzung, den ersten RSS, RDF oder Atom Link holen indem dessen öffentliche Eigenschaft wie im beiliegenden Beispiel verwendet wird. Andernfalls ist jedes Element von ArrayObject ein einfaches Array mit den Schlüsseln "type" und "uri" wobei der Typ "rdf", "rss" oder "atom" sein kann.

$links = Zend_Feed_Reader::findFeedLinks('http://www.planet-php.net');

if(isset($links->rdf)) {
    echo $links->rdf, "\n"; // http://www.planet-php.org/rdf/
}
if(isset($links->rss)) {
    echo $links->rss, "\n"; // http://www.planet-php.org/rss/
}
if(isset($links->atom)) {
    echo $links->atom, "\n"; // http://www.planet-php.org/atom/
}

Basierend auf diesen Links kann man dann, von welchen Quellen man auch immer will, importieren indem die übliche Vorgehensweise verwendet wird.

Diese schnelle Methode gibt nur einen Link für jeden Feed Typ zurück, aber Webseiten können viele Links von jedem Typ enthalten. Möglicherweise ist es eine News Site mit einem RSS Feed für jede News Kategorie. Man kann durch alle Links iterieren indem der ArrayObject Iterator verwendet wird.

$links = Zend_Feed_Reader::findFeedLinks('http://www.planet-php.net');

foreach ($links as $link) {
    echo $link['uri'], "\n";
}

In einem Versuch die Rückgabetypen zu vereinfachen, können Rückgabetypen für die verschiedenen Feed und Entry Level Methoden ab Zend Framework 1.10 ein Objekt vom Typ Zend_Feed_Reader_Collection_CollectionAbstract enthalten. Abgesehen vom speziellen Klassennamen der anbei erklärt wird, ist es nur eine einfache Subklasse von SPL's ArrayObject.

Der Hauptzweck hierbei besteht darin, die Präsentation von so vielen Daten wie möglich von den angefragten Elementen zu erlauben, während trotzdem der Zugriff auf die meisten relevanten Daten über ein einfaches Array erlaubt wird. Das erzwingt auch einen Standardweg um solche Daten zurückzugeben, was vorher zwischen Arrays und Objekten gewandert ist.

Der neue Klassentyp arbeitet identisch zu ArrayObject, mit der gleichen kleinen Änderung dass eine neue Methode getValues() existiert welche ein einfaches flaches Array zurückgibt dass die meisten relevanten Informationen enthält.

Ein einfaches Beispiel hiervon ist Zend_Feed_Reader_FeedInterface::getCategories(). Wenn es in irgendeinem RSS oder Atom Feed verwendet wird, gibt diese Methode Daten der Kategorie als Container Objekt zurück welches Zend_Feed_Reader_Collection_Category genannt wird. Das Container Objekt wird, für jede Kategorie, drei Felder an Daten enthalten: term, schema und label. "term" ist der grundsätzliche Name der Kategorie, oft Maschinen lesbar (normalerweise ein URI Identifikator) und in RSS 2.0 auch bekannt als "domain". "label" ist ein menschlich lesbarer Kategorie Name welcher HTML Entities unterstützt. In RSS 2.0 gibt es kein Label Attribut deshalb wird es der Bequemlichkeit halber immer auf den selben Wert gesetzt wie der Ausdruck.

Um auf die Label der Kategorie selbst als einfache Array Werte zuzugreifen könnte man das folgende verwenden:

$feed = Zend_Feed_Reader::import('http://www.example.com/atom.xml');
$categories = $feed->getCategories();
$labels = array();
foreach ($categories as $cat) {
    $labels[] = $cat['label']
}

Es ist ein erfundenes Beispiel, aber der Punkt ist, dass Label zusammen mit anderen Informationen gebunden sind.

Trotzdem erlaubt die Container Klasse den Zugriff auf die "relevantesten" Daten als einfaches Array indem die Methode getValues() verwendet wird. Das Konzept der "relevantesten" Daten ist offensichtlich ein beurteilter Aufruf. Für Kategorien bedeutet es die Label der Kategorien (nicht die Typen oder Schemata) während es für Autoren der Name des Autors wäre (nicht deren Email Adressen oder die URIs). Das einfache Array ist flach (nur Werte) und durchläuft array_unique um doppelte Werte zu entfernen.

$feed = Zend_Feed_Reader::import('http://www.example.com/atom.xml');
$categories = $feed->getCategories();
$labels = $categories->getValues();

Das obige Beispiel zeigt wie nur die Label und sonst nichts extrahiert wird. Das gibt einen einfachen Zugriff auf die Label der Kategorie ohne zusätzliche Arbeit die Daten selbst zu extrahieren.

Das Empfangen von Informationen von einem Feed (wir reden über Einträge und Elemente in der nächsten Sektion da Sie identischen Prinzipien folgen) verwendet eine klar definierte API welche exakt die gleiche ist, unabhängig davon ob der angefragte Feed RSS, RDF oder Atom ist. Das selbe gilt für Sub-Versionen dieser Standards da wir jede einzelne RSS und Atom Version getestet haben. Wärend sich der darunterliegende XML Feed substantiell unterscheiden kann, im Sinne von Tags und Elementen die vorhanden sind, versuchen trotzdem alle ähnliche Informationen zu geben und um das alles zu reflektieren werden unterschiede und das Hanteln durch alternative Tags intern von Zend_Feed_Reader behandelt welche einem ein identisches Interface für jeden anzeigt. Idealerweise sollte man sich nicht darum kümmern ob ein Feed RSS oder Atom ist, solange man die Informationen extrahieren kann die man benötigt.

Natürlich leben wir nicht in einer idealen Welt sodas es Zeiten gibt in denen die API einfach nicht das bietet wonach man sucht. Um hierbei zu helfen bietet Zend_Feed_Reader ein Plugin System an das es erlaubt Erweiterungen zu schreiben und die Kern API zu erweitern sowie alle zusätzliche Daten abzudecken die man von Feeds extrahieren will. Wenn das schreiben einer weiteren Erweiterung zu problematisch ist, kann man einfach das darunterliegende DOM oder die XPath Objekte holen und das von Hand in der Anwendung machen. Natürlich sollte wirklich eine Erweiterung geschrieben werden, einfach um es portabler und wiederverwendbarer zu machen. Und nützliche Erweiterungen können für den Framework vorgeschlagen werden um Sie formal hinzuzufügen.

Hier ist eine Zusammenfassung der Kern API für Feeds. Man sollte beachten das es nicht nur die grundsätzlichen RSS und Atom Standard abdeckt, sondern das es auch eine Anzahl von mitgelieferten Erweiterungen gibt die mit Zend_Feed_Reader gebündelt sind. Die Benennung dieser Methoden von Erweiterungen ist recht generisch - alle erweiterten Methoden arbeiten auf dem gleichen Level wie die Kern API da wir es erlauben alle spefizischen Erweiterungs Objekte separat zu empfangen wenn das notwendig ist.

Angehend von der Vielzahl von Feeds in der Wildnis, werden einige dieser Methoden erwartungsgemäßg NULL zurückgeben, was anzeigt das die relevanten Informationen nicht gefunden wurden. Wo es möglich ist wird Zend_Feed_Reader während der Suche auf alternative Elemente zurück greifen. Zum Beispiel ist das Durchsuchen eines RSS Feeds nach einem Modifikations Datum komplizierter als es aussieht. RSS Feeds sollten ein <lastBuildDate> Tag und (oder) ein <pubDate> Element enthalten. Aber was wenn Sie es nicht tun, weil es z.B. ein RSS 1.0 Feed ist? Vielleicht ist stattdessen ein <atom:updated> Element mit identischen Informationen vorhanden (Atom kann verwendet werden um die RSS Syntax anzubieten)? Bei einem Fehlschlag können wir einfach auf die Einträge sehen, den aktuellsten herausholen, und sein <pubDate> Element verwenden. In der Annahme das es existiert... viele Feeds verwenden auch Dublin Core 1.0 oder 1.1 <dc:date> Elemente für Feeds und Einträge. Oder wir können wieder ein Atom finden das herumliegt.

Der Punkt ist, das Zend_Feed_Reader entwickelt wurde um das zu wissen. Wenn man nach dem Änderungsdatum fragt (oder irgendwas anderes), wird er starten und alle diese Alternativen suchen bis er entweder aufgibt und NULL zurückgibt, oder eine Alternative findet welche die richtige Antwort hat.

Zusätzlich zu den obigen Methoden, implementieren alle Feed Objekte Methoden für das empfangen der DOM und XPath Objekte für die aktuellen Feeds wie vorher beschrieben. Feed Objekte implementieren auch die Interfaces für SPL Iterator und Countable. Die erweiterte API wird anbei zusammengefasst.

Das Empfangen von Informationen für spezifische Einträge oder Elemente (abhängig davon ob man Atom oder RSS spricht) ist identisch wie bei den Daten auf Feed Level. Der Zugriff auf Einträge ist einfach ein Fall von Iteration über ein Feed Objekt oder durch Verwendung des SPL Interfaces Iterator welches Feed Objekte implementieren und durch Aufruf der betreffenden Methoden auf Ihnen.

Die erweiterte API für Einträge ist identisch zu der für die Feed mit der Aufnahme der Iterator Methoden die hier nicht benötigt werden.

Die Erweiterung von Zend_Feed_Reader erlaubt es Methoden sowohl auf Level von Feeds als auch auf Level von Einträgen hinzuzufügen, welche das Empfangen von Informationen abdecken die nicht bereits von Zend_Feed_Reader unterstützt werden. Bei der Anzahl an RSS und Atom Erweiterungen die existieren, ist das ein guter Weg da Zend_Feed_Reader einfach nicht alles hinzufügen kann.

Es gibt zwei Typen von Erweiterungen, jene welche Informationen von Elementen empfangen die unmittelbare Kunder des Root Elements sind (z.B. <channel> für RSS oder <feed> für Atom), und jene die Informationen von Kind-Elementen eines Eintrags empfangen (z.B. <item> für RSS oder <entry> für Atom). Auf dem Filesystem sind Sie als Klassen in einem Namespace gruppiert, basierend auf dem Standardnamen der Erweiterung. Zum Beispiel haben wir intern Zend_Feed_Reader_Extension_DublinCore_Feed und Zend_Feed_Reader_Extension_DublinCore_Entry Klassen welche zwei Klassen sind welche die Unterstützung für Dublin Core 1.0/1.1 implementieren.

Erweiterungen werden in Zend_Feed_Reader durch Verwendung von Zend_Loader_PluginLoader geladen, sodas dessen Operationen ähnlich denen anderer Zend Framework Komponenten ist. Zend_Feed_Reader kommt bereits mit einer Anzahl dieser Erweiterungen. Trotzdem müssen jene, die nicht intern verwendet und standardmäßig registriert werden (sogenannte Core Erweiterungen), bei Zend_Feed_Reader registriert werden bevor Sie verwendet werden. Die gebündelten Erweiterungen sind:

Die Core Erweiterungen sind irgendwie speziell da Sie extrem allgemein sind und viele Facetten haben. Zum Beispiel haben wir eine Core Erweiterung für Atom. Atom ist als Erweiterung (und nicht nur als Basis Klasse) implementiert weil es ein gültiges RSS Modul dupliziert - so kann man Atom Elemente in RSS Feeds einfügen. Wir haben sogar RDF Feeds gesehen die viel von Atom verwenden statt den üblicheren Erweiterungen wie Dublin Core.

Die zusätzlichen nicht-Core Erweiterungen werden angeboten aber standardmäßig bei Zend_Feed_Reader nicht registriert. Wenn man Sie verwenden will, muß man Zend_Feed_Reader sagen dass Sie diese zusätzlich zum Importieren eines Feeds laden soll. Zusätzliche nicht-Core Erweiterungen werden in zukünftigen Releases dieser Komponente enthalten sein.

Das Registrieren einer Erweiterung bei Zend_Feed_Reader, so dass diese geladen wird und dessen API für Feed und Entry Objekte zur Verfügung steht, ist eine einfache Sache wenn der Zend_Loader_PluginLoader verwendet wird. Hier registrieren wir die optionale Slash Erweiterung und finden heraus das Sie direkt von der Entry Level API heraus aufgerufen werden kann, ohne große Dinge notwendig sind. Es ist zu beachten das die Namen der Erweiterungen von der Schreibweise abhängig sind und Camel Casing für mehrere Ausdrücke verwenden.

Zend_Feed_Reader::registerExtension('Syndication');
$feed = Zend_Feed_Reader::import('http://rss.slashdot.org/Slashdot/slashdot');
$updatePeriod = $feed->current()->getUpdatePeriod();

Im obigen Beispiel haben wir geprüft wie oft ein Feed aktualisiert wurde indem wir die getUpdatePeriod() Methode verwendet haben. Da das nicht Teil der Kern API von Zend_Feed_Reader ist, kann es nur eine Methode sein die von der neu registrieren Syndication Erweiterung unterstützt wird.

Wie man auch sieht, kann man auf die neuen Methoden vlon Erweiterungen aus der Haupt API heraus zugreifen indem PHP's magische Methoden verwendet werden. Als Alternative kann man, für ein ähnliches Ergebnis, auf jedes Erweiterungs Objekt auch direkt zugreifen, wie anbei gezeigt.

Zend_Feed_Reader::registerExtension('Syndication');
$feed = Zend_Feed_Reader::import('http://rss.slashdot.org/Slashdot/slashdot');
$syndication = $feed->getExtension('Syndication');
$updatePeriod = $syndication->getUpdatePeriod();

JungleBooks 1.0:
http://example.com/junglebooks/rss/module/1.0/

<?xml version="1.0" encoding="utf-8" ?>
<rss version="2.0"
   xmlns:content="http://purl.org/rss/1.0/modules/content/"
   xmlns:jungle="http://example.com/junglebooks/rss/module/1.0/">
<channel>
    <title>Jungle Books Customer Reviews</title>
    <link>http://example.com/junglebooks</link>
    <description>Many book reviews!</description>
    <pubDate>Fri, 26 Jun 2009 19:15:10 GMT</pubDate>
    <jungle:dayPopular>
        http://example.com/junglebooks/book/938
    </jungle:dayPopular>
    <item>
        <title>Review Of Flatland: A Romance of Many Dimensions</title>
        <link>http://example.com/junglebooks/review/987</link>
        <author>Confused Physics Student</author>
        <content:encoded>
        A romantic square?!
        </content:encoded>
        <pubDate>Thu, 25 Jun 2009 20:03:28 -0700</pubDate>
        <jungle:isbn>048627263X</jungle:isbn>
    </item>
</channel>
</rss>

class My_FeedReader_Extension_JungleBooks_Entry
    extends Zend_Feed_Reader_Extension_EntryAbstract
{
    public function getIsbn()
    {
        if (isset($this->_data['isbn'])) {
            return $this->_data['isbn'];
        }
        $isbn = $this->_xpath->evaluate(
            'string(' . $this->getXpathPrefix() . '/jungle:isbn)'
        );
        if (!$isbn) {
            $isbn = null;
        }
        $this->_data['isbn'] = $isbn;
        return $this->_data['isbn'];
    }

    protected function _registerNamespaces()
    {
        $this->_xpath->registerNamespace(
            'jungle', 'http://example.com/junglebooks/rss/module/1.0/'
        );
    }
}

if(!Zend_Feed_Reader::isRegistered('JungleBooks')) {
    Zend_Feed_Reader::addPrefixPath(
        'My_FeedReader_Extension', '/path/to/My/FeedReader/Extension'
    );
    Zend_Feed_Reader::registerExtension('JungleBooks');
}
$feed = Zend_Feed_Reader::import('http://example.com/junglebooks/rss');

// ISBN für irgendein Buch dem der erste Eintrag im Feed gewidmet war
$firstIsbn = $feed->current()->getIsbn();

class My_FeedReader_Extension_JungleBooks_Feed
    extends Zend_Feed_Reader_Extension_FeedAbstract
{
    public function getDaysPopularBookLink()
    {
        if (isset($this->_data['dayPopular'])) {
            return $this->_data['dayPopular'];
        }
        $dayPopular = $this->_xpath->evaluate(
            'string(' . $this->getXpathPrefix() . '/jungle:dayPopular)'
        );
        if (!$dayPopular) {
            $dayPopular = null;
        }
        $this->_data['dayPopular'] = $dayPopular;
        return $this->_data['dayPopular'];
    }

    protected function _registerNamespaces()
    {
        $this->_xpath->registerNamespace(
            'jungle', 'http://example.com/junglebooks/rss/module/1.0/'
        );
    }
}

if(!Zend_Feed_Reader::isRegistered('JungleBooks')) {
    Zend_Feed_Reader::addPrefixPath(
        'My_FeedReader_Extension', '/path/to/My/FeedReader/Extension'
    );
    Zend_Feed_Reader::registerExtension('JungleBooks');
}
$feed = Zend_Feed_Reader::import('http://example.com/junglebooks/rss');

// URI zur Informations Seite des populärsten Buchs des Tages mit Besuchern
$daysPopularBookLink = $feed->getDaysPopularBookLink();

// ISBN für irgendein Buch dem der erste Eintrag im Feed gewidmet war
$firstIsbn = $feed->current()->getIsbn();