Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerleitfaden: Protokoll

Wichtig: Dies ist eine alte Version dieser Seite. Die aktuelle Version finden Sie über die Links in der linken Navigationsleiste.

Mit der Blogger Data API können Clientanwendungen Blogger-Inhalte in Form von Google Data API-Feeds abrufen und aktualisieren.

Ihre Clientanwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und nach Blogposts zu suchen, die bestimmten Kriterien entsprechen.

Neben Informationen zu den Möglichkeiten der Blogger Data API enthält dieses Dokument auch Beispiele für grundlegende Data API-Interaktionen mit Roh-XML und HTTP. Nachdem Sie dieses Dokument gelesen haben, können Sie mehr über die Interaktion mit der API mithilfe unserer Clientbibliotheken erfahren. Lesen Sie dazu die Abschnitte zu den Programmiersprachen dieses Entwicklerhandbuchs.

Inhalt

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die Clientanwendungen schreiben möchten, die über XML und HTTP mit Blogger interagieren.

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Ideen hinter dem Google Data APIs-Protokoll vertraut sind.

Wenn Sie ein UNIX-System verwenden und die Beispiele in diesem Dokument ausprobieren möchten, ohne Code zu schreiben, könnten die UNIX-Befehlszeilendienstprogramme curl oder wget hilfreich sein. Weitere Informationen finden Sie auf den entsprechenden Seiten zu diesen Dienstprogrammen.

Referenzinformationen zur Blogger Data API finden Sie im Referenzleitfaden zum Protokoll.

Erste Schritte

Blogger-Konto erstellen

Du kannst dich auch für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn Sie also bereits ein Google-Konto haben, müssen Sie nichts weiter tun.

Authentifizierung beim Blogger-Dienst

Mit der Blogger Data API können Sie sowohl auf öffentliche als auch auf private Feeds zugreifen. Für öffentliche Feeds ist keine Authentifizierung erforderlich, sie sind aber schreibgeschützt. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor du private Feeds anfordern kannst. Für die Authentifizierung gibt es zwei Möglichkeiten: die AuthSub-Proxyauthentifizierung oder die ClientLogin-Authentifizierung mit Nutzername und Passwort.

Weitere Informationen zur Authentifizierung mit Google Data APIs im Allgemeinen finden Sie in der Authentifizierungsdokumentation.

Bei den meisten Beispielen in den nachfolgenden Abschnitten dieses Dokuments wird davon ausgegangen, dass Sie die entsprechende Authentifizierung durchführen.

AuthSub-Proxy-Authentifizierung

Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer bei Google-Konten authentifizieren müssen. Der Websitebetreiber und der Clientcode haben keinen Zugriff auf den Nutzernamen und das Passwort für den Blogger-Nutzer. Stattdessen erhält der Client spezielle AuthSub-Tokens, die es dem Client ermöglichen, im Namen eines bestimmten Nutzers zu handeln. Weitere Informationen finden Sie in der AuthSub-Dokumentation.

Wenn ein Nutzer Ihre Anwendung zum ersten Mal aufruft, wurde er noch nicht authentifiziert. In diesem Fall musst du einige Informationen und einen Link anzeigen, der den Nutzer zu einer Google-Seite weiterleitet, damit deine Zugriffsanfrage für seine Blogs authentifiziert werden kann.

Die folgenden Abfrageparameter sind in der AuthSubRequest-URL enthalten:

Weiter: Die URL der Seite, auf die Google den Nutzer nach der Authentifizierung weiterleiten soll.
Bereich: Gibt an, dass die Anwendung ein Token für den Zugriff auf Blogger-Feeds anfordert. Der zu verwendende Bereichsstring ist http://www.blogger.com/feeds/ (natürlich URL-codiert).
geschützt?: Gibt an, ob der Client ein sicheres Token anfordert.
session: Gibt an, ob das zurückgegebene Token gegen ein Mehrzwecktoken (Sitzungsversion) eingetauscht werden kann.

Die AuthSubRequest-URL könnte so aussehen:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fwww.blogger.com%2Ffeeds%2F&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fwelcome.html

Der Nutzer folgt dem Link zur Google-Website und authentifiziert sich bei seinem Google-Konto.

Nach der Authentifizierung des Nutzers werden sie vom AuthSub-System an die URL weitergeleitet, die Sie im Abfrageparameter next der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt als Wert des Abfrageparameters token ein Authentifizierungstoken an diese URL an. Beispiel:

http://www.example.com/welcome.html?token=yourAuthToken

Dieser Tokenwert stellt ein Einweg-Token für die einmalige Verwendung dar. Da in diesem Beispiel session=1 angegeben wurde, kann dieses Token gegen ein AuthSub-Sitzungstoken eingetauscht werden. Rufen Sie dazu den Dienst AuthSubSessionToken mit dem Einweg-Token in einem Autorisierungsheader so auf:

GET /accounts/AuthSubSessionToken HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourAuthToken"
User-Agent: Java/1.5.0_06
Host: www.google.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

Die Dienstantwort AuthSubSessionToken enthält einen Token-Header mit dem Sitzungstoken und einen Expiration-Header, der angibt, wie lange das Token gültig bleibt.

Die Anwendung kann dann den Wert des Sitzungstokens im Header Authorization nachfolgender Interaktionen mit Blogger verwenden.

Hier ein Beispiel für eine HTTP-Anfrage mit einem nicht sicheren Token, das Sie an Blogger senden können:

GET /feeds/blogID/blogs/posts/defaults HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourSessionToken"
User-Agent: Java/1.5.0_06
Host: www.blogger.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

Authentifizierung mit Nutzername/Passwort für ClientLogin

Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger, einzelner Nutzerclient ist, z. B. eine Desktopanwendung. Wenn Sie mit dem ClientLogin-Mechanismus ein Authentifizierungstoken anfordern möchten, senden Sie eine POST-Anfrage an die folgende URL:

https://www.google.com/accounts/ClientLogin

Der POST-Text sollte eine Reihe von Suchparametern enthalten, die wie Parameter aussehen, die von einem HTML-Formular mit dem Inhaltstyp application/x-www-form-urlencoded übergeben werden. Diese Parameter sind:

E-Mail-Adresse: E-Mail-Adresse des Nutzers
Passwd: Das Passwort des Nutzers.
Dienst: Der Name des Blogger-Dienstes lautet blogger. Informationen zu anderen Dienstnamen finden Sie in der Liste der Dienstnamen.
accountType: Sollte bei der Nutzung der Blogger API immer auf GOOGLE gesetzt werden. Andernfalls wird der Zugriff von Nutzern verhindert, die ein G Suite-Konto haben.
source: Identifiziert Ihre Clientanwendung. Muss das Format companyName-applicationName-versionID haben. In den Beispielen wird exampleCo-exampleApp-1 verwendet.

Weitere Informationen zu den Parametern finden Sie im Dokument Authentifizierung für installierte Anwendungen.

Wenn die Authentifizierungsanfrage fehlschlägt, gibt der Server den HTTP-Statuscode 403 Forbidden zurück.

Wenn der Vorgang erfolgreich ist, gibt der Server den HTTP-Statuscode 200 OK sowie drei lange alphanumerische Codes im Text der Antwort zurück: SID, LSID und Auth. Der Authentifizierungswert ist das Autorisierungstoken, das Sie zusammen mit Ihren nachfolgenden Anfragen an Blogger senden. Legen Sie deshalb eine Kopie dieses Werts auf. Sie können die SID- und LSID-Werte ignorieren.

Da für alle Anfragen an private Feeds eine Authentifizierung erforderlich ist, müssen Sie den Autorisierungsheader bei allen nachfolgenden Interaktionen mit Blogger im folgenden Format festlegen:

Authorization: GoogleLogin auth=yourAuthToken

Dabei ist yourAuthToken der von der ClientLogin-Anfrage zurückgegebene Authentifizierungsstring.

Weitere Informationen zur ClientLogin-Authentifizierung, einschließlich Beispielanfragen und -antworten, finden Sie in der Dokumentation Authentifizierung für installierte Anwendungen.

Hinweis: Verwenden Sie für alle Anfragen in einer bestimmten Sitzung dasselbe Token. Erhalten Sie nicht für jede Blogger-Anfrage ein neues Token.

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, schlägt die Authentifizierungsanfrage möglicherweise fehl und fordert ein CAPTCHA an. Wenn Google die CAPTCHA-Abfrage ausstellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter anstatt zur in der ClientLogin-Dokumentation angegebenen CAPTCHA-Verarbeitungs-URL.

Liste von Blogs abrufen

Die Blogger Data API bietet einen Feed, in dem die Blogs eines bestimmten Nutzers aufgelistet werden. Dieser Feed wird als Metametafeed bezeichnet.

Senden Sie eine HTTP-GET an die folgende URL, um die Liste der Blogs abzurufen:

http://www.blogger.com/feeds/userID/blogs

Hinweis: Sie können default auch durch die Nutzer-ID ersetzen. Dadurch wird Blogger angewiesen, die Liste der Blogs für den Nutzer zurückzugeben, dessen Anmeldedaten die Anfrage enthalten.

Ein Eintrag im Metafeed könnte so aussehen:

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-08-02T18:44:43.089-07:00</published>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <summary type='html'>Being the journal of Elizabeth Bennet</summary>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='http://schemas.google.com/g/2005#post'
    type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

Informationen zur Bedeutung der einzelnen Elemente finden Sie in der Protokolldokumentation zum Google Data APIs oder in der Spezifikation von Atom 1.0.

Wenn Ihre Anfrage aus irgendeinem Grund fehlschlägt, gibt Blogger möglicherweise einen anderen Statuscode zurück. Weitere Informationen zu HTTP-Statuscodes finden Sie auch in der Referenz zum Protokoll der Google Data APIs.

Beiträge erstellen

Mit der Blogger Data API können Sie sowohl neue Blogeinträge als auch Entwürfe erstellen und veröffentlichen.

Blogpost veröffentlichen

Nach der Authentifizierung können Sie neue Blogeinträge veröffentlichen.

Erstellen Sie zuerst eine XML-Darstellung des zu veröffentlichenden Posts. Diese XML muss in Form eines Atom-<entry>-Elements vorliegen, das in etwa so aussehen kann:

<entry xmlns='http://www.w3.org/2005/Atom'>
  <title type='text'>Marriage!</title>
  <content type='xhtml'>
    <div xmlns="http://www.w3.org/1999/xhtml">
      <p>Mr. Darcy has <em>proposed marriage</em> to me!</p>
      <p>He is the last man on earth I would ever desire to marry.</p>
      <p>Whatever shall I do?</p>
    </div>
  </content>
  <category scheme="http://www.blogger.com/atom/ns#" term="marriage" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
</entry>

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Beiträge wird derzeit nicht unterstützt. Alle neuen Beiträge sehen so aus, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.

Wenn Sie diesen Eintrag veröffentlichen möchten, senden Sie ihn folgendermaßen an die Beitrags-URL des Blogs: Platzieren Sie zuerst das Atom-Element <entry> im Textbereich einer neuen POST-Anfrage mit dem Inhaltstyp application/atom+xml. Suchen Sie dann im Post die URL des Blogposts. Suchen Sie dazu das Element <link> dort, wo das Attribut rel mit #post endet. Die Beitrags-URL des Blogs wird als href-Attribut des Elements in folgendem Format angegeben:

http://www.blogger.com/feeds/blogID/posts/default

Hinweis: Diese URL ist mit der URL im Tag <link rel="service.post"> identisch, die im Abschnitt <head> der für Menschen lesbaren Version des Blogs angezeigt wird.

Blogger erstellt einen Blogpost mit dem von Ihnen gesendeten Eintrag und gibt dann den HTTP-Statuscode 201 CREATED zusammen mit einer Kopie des neuen Beitrags in Form eines <entry>-Elements zurück. Der zurückgegebene Eintrag ist derselbe, den Sie gesendet haben, er enthält aber auch verschiedene von Blogger hinzugefügte Elemente, z. B. ein <id>-Element.

Wenn Ihre Anfrage aus irgendeinem Grund fehlschlägt, gibt Blogger möglicherweise einen anderen Statuscode zurück. Informationen zu den Statuscodes finden Sie in der Referenzdokumentation zum Google Data API-Protokoll.

Blogpostentwurf erstellen

Entwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt, allerdings wird dem Eintrag ein <app:control>-Element hinzugefügt, das angibt, dass der Beitrag (noch) nicht veröffentlicht werden soll.

Dieses <app:control>-Element sollte ein einzelnes <app:draft>-Element als untergeordnetes Element enthalten:

<app:control xmlns:app='http://purl.org/atom/app#'>
  <app:draft>yes</app:draft>
</app:control>

Die Daten im Element <app:draft> müssen den String yes enthalten, damit der Beitrag als Entwurf erkannt wird.

Du kannst einen vorhandenen Blogpost in einen veröffentlichten Beitrag umwandeln. Rufe dazu den Entwurfsbeitrag ab, setze die Daten des <app:draft>-Elements auf den String no und aktualisiere dann den Beitrag. Wie Sie Beiträge abrufen und aktualisieren, erfahren Sie in den nächsten beiden Abschnitten.

Hinweis: Weitere Informationen zum Atom Publishing Protocol, einschließlich der Namespaces <app:control> und <app:draft>, finden Sie unter RFC 5023.

Beiträge werden abgerufen

In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogposts mit und ohne Suchparameter abrufen.

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher müssen Sie den Autorisierungsparameter nicht festlegen, wenn Sie Blogposts aus einem öffentlichen Blog abrufen.

Alle Blogposts werden abgerufen

Wenn Sie die Beiträge des Nutzers abrufen möchten, senden Sie eine HTTP-GET-Anfrage an die Feed-URL des Blogs. Blogger gibt dann einen Feed mit den entsprechenden Blogeinträgen zurück. Wenn du beispielsweise eine Liste mit Blogposts für marie@gmail.com erhalten möchtest, musst du die folgende HTTP-Anfrage an Blogger senden (natürlich mit dem richtigen Wert anstelle von blogID):

GET http://www.blogger.com/feeds/blogID/posts/default

Blogger gibt dann den HTTP-Statuscode 200 OK und einen Standard-Atom 1.0-Feed zurück, der die Blogposts enthält.

Im Folgenden finden Sie ein Beispiel für einen Feed für einen Blog mit nur einem Beitrag. Beachten Sie, dass wir dieses Beispiel leicht bearbeitet haben, damit es für Menschen besser lesbar ist. Ein echter Blogger-Feed enthält die tatsächlichen IDs und URLs.

<feed xmlns='http://www.w3.org/2005/Atom'>
  <id>tag:blogger.com,1999:blog-blogID</id>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/index.html'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
  <generator version='7.00' uri='http://www2.blogger.com'>Blogger</generator>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
    <published>2006-11-08T18:10:00.000-08:00</published>
    <updated>2006-11-08T18:10:14.954-08:00</updated>
    <title type='text'>Quite disagreeable</title>
    <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
      this evening. I found him quite disagreeable.&lt;/p&gt;</content>
    <link rel='alternate' type='text/html'
      href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
    </link>
    <link rel='self' type='application/atom+xml'
      href='http://blogName.blogspot.com/feeds/posts/default/postID'>
    </link>
    <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
    </link>
    <author>
      <name>Elizabeth Bennet</name>
      <email>noreply@blogger.com</email>
      <uri>http://www.blogger.com/profile/profileID</uri>
    </author>
  </entry>
</feed>

Beiträge mit Suchparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. das Anfordern von Blogposts, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden.

Wenn Sie beispielsweise eine Zeitraumabfrage senden möchten, fügen Sie der Anfrage-URL die Parameter published-min und published-max hinzu. Wenn Sie alle zwischen dem 16. März 2008 und dem 24. März 2008 erstellten Blogeinträge abrufen möchten, senden Sie eine HTTP-Anfrage an die Feed-URL des Blogs:

GET http://www.blogger.com/feeds/blogID/posts/default?published-min=2008-03-16T00:00:00&published-max=2008-03-24T23:59:59

Wenn Sie diese GET-Anfrage senden, gibt Blogger einen HTTP-200 OK-Statuscode und einen Feed mit allen Blogposts zurück, die im angegebenen Zeitraum erstellt wurden.

Die Parameter updated-min und updated-max können auch verwendet werden, um alle Blogeinträge innerhalb eines bestimmten Bereichs zu aktualisieren. Diese Parameter werden jedoch ignoriert, sofern der Parameter orderby nicht auf updated gesetzt ist.

Die Blogger Data API unterstützt die folgenden Abfrageparameter:

alt: Der Feedtyp, der zurückgegeben werden soll, z. B. atom (Standardeinstellung) oder rss.
/category: Gibt Kategorien an (auch Labels genannt), um die Feedergebnisse zu filtern. http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt beispielsweise Einträge mit den Labels Fritz und Laurie zurück.
Max. Ergebnisse: Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
Orderby: Die Reihenfolge, in der Einträge zurückgegeben werden, z. B. lastmodified (Standardeinstellung), starttime oder updated.
Veröffentlicht-Min., veröffentlicht-max: Die Grenzen des Veröffentlichungsdatums des Eintrags.
Startindex: Der 1-basierte Index des ersten abzurufenden Ergebnisses (für die Seitenordnung).
updated-min, updated-max: Die Grenzen für die Datumsaktualisierung. Diese Suchparameter werden ignoriert, sofern der Parameter orderby nicht auf updated gesetzt ist.

Weitere Informationen zu Suchparametern findest du im Referenzleitfaden für die Blogger Data API und im Referenzhandbuch für Google Data APIs.

Beiträge werden aktualisiert

Zum Aktualisieren eines vorhandenen Blogposts rufen Sie zuerst den zu aktualisierenden Eintrag ab, ändern ihn und senden dann eine PUT-Anfrage mit dem aktualisierten Eintrag im Nachrichtentext an die Bearbeitungs-URL des Beitrags. Achten Sie darauf, dass der <id>-Wert im Eintrag PUT genau mit dem <id> des vorhandenen Eintrags übereinstimmt.

Die Bearbeitungs-URL ist im folgenden Eintrag hervorgehoben:

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-11-08T18:10:00.000-08:00</published>
  <updated>2006-11-08T18:10:14.954-08:00</updated>
  <title type='text'>Quite disagreeable</title>
  <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
    this evening. I found him quite disagreeable.&lt;/p&gt;</content>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default/postID'>
  </link>
  <link rel='edit' type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
  </link>
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Bingley" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

WICHTIG: Um die Kompatibilität zu gewährleisten, achte darauf, dass beim PUT-Aktualisieren eines Eintrags alle XML-Inhalte beibehalten werden, die beim Abrufen des Eintrags aus Blogger vorhanden waren. Wenn wir neue Inhalte implementieren und <new-awesome-feature>-Elemente in den Feed aufnehmen, werden diese von Ihrem Client nicht zurückgegeben und Ihre Nutzer versäumen es. In den Google Data API-Clientbibliotheken wird dies alles korrekt verarbeitet. Wenn Sie also eine der Bibliotheken verwenden, sind keine weiteren Schritte nötig.

Hinweis: Das Ändern von mit Beiträgen verknüpften Autorendaten wird derzeit nicht unterstützt.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-PUT-Nachrichten. Dies lässt sich umgehen, indem Sie einen X-HTTP-Method-Override: PUT-Header in eine POST-Anfrage einfügen. Weitere Informationen findest du im Dokument Grundlagen des Google Data API-Protokolls.

Beiträge löschen

Wenn Sie einen Beitrag löschen möchten, senden Sie eine DELETE-Anfrage an die Bearbeitungs-URL des Beitrags. Dies ist dieselbe URL, die auch zum Aktualisieren von Beiträgen verwendet wird.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-DELETE-Nachrichten. Dies lässt sich umgehen, indem Sie einen X-HTTP-Method-Override: DELETE-Header in eine POST-Anfrage einfügen. Weitere Informationen findest du im Dokument Grundlagen des Google Data API-Protokolls.

Kommentare

Mit der Blogger Data API können Sie Kommentare erstellen, abrufen und löschen. Das Aktualisieren von Kommentaren wird weder unterstützt noch in der Weboberfläche verfügbar.

Kommentare erstellen

Erstellen Sie zum Posten eines Kommentars ein Atom-Element vom Typ <entry>. Beispiel:

  <entry xmlns='http://www.w3.org/2005/Atom'>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
  </entry>

Zum Veröffentlichen dieses Kommentars platzieren Sie das Atom-Element <entry> im Textbereich einer neuen POST-Anfrage mit dem Inhaltstyp application/atom+xml. Senden Sie dann die POST-Anfrage an die entsprechende Blogger-URL:

POST http://www.blogger.com/feeds/blogID/postID/comments/default

Hinweis: Derzeit können Sie in einem Blog nur Kommentare veröffentlichen, deren Inhaber der authentifizierte Nutzer ist.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Kommentare wird derzeit nicht unterstützt. Alle neuen Kommentare werden so angezeigt, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.

Kommentare werden abgerufen

Du kannst die Kommentare für einen bestimmten Beitrag abrufen, indem du GET an die URL des Kommentarfeeds dieses Beitrags sendest:

GET http://www.blogger.com/feeds/blogID/postID/comments/default

Du kannst auch die Kommentare zu allen Beiträgen über die Kommentar-Feed-URL des Blogs abrufen:

GET http://www.blogger.com/feeds/blogID/comments/default

Bei diesen Anfragen wird ein Kommentarfeed zurückgegeben, der in etwa so aussieht:

<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
         xmlns:thr="http://purl.org/syndication/thread/1.0">
  <id>tag:blogger.com,1999:blog-blogID.post-postID.comment-commentID</id>
  <updated>2007-04-04T21:56:29.803-07:00</updated>
  <title type="text">My Blog : Time to relax</title>
  <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html"/>
  <link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default"/>
  <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default"/>
  <author>
    <name>Blog Author name</name>
  </author>
  <generator version="7.00" uri="http://www2.blogger.com">Blogger</generator>
  <openSearch:totalResults>1</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-commentID</id>
    <published>2007-04-04T21:56:00.000-07:00</published>
    <updated>2007-04-04T21:56:29.803-07:00</updated>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
    <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html#commentID"/>
    <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default/commentID"/>
    <link rel="edit" type="application/atom+xml" href="http://www.blogger.com/feeds/blogID/postID/comments/default/commentID"/>
    <thr:in-reply-to href="http://blogName.blogspot.com/2007/04/first-post.html" 
                     ref="tag:blogger.com,1999:blog-blogID.post-postID" 
                     source="http://www.blogger.com/feeds/posts/default/blogID"
                     type="text/html"/>
    <author>
      <name>Blog Author name</name>
      <email>blog_author@gmail.com</email>
      <uri>http://www.blogger.com/profile/userID</uri>
    </author>
    <thr:in-reply-to xmlns:thr='http://purl.org/syndication/thread/1.0' 
         href='http://blogName.blogspot.com/2007/04/first-post.html' 
         ref='tag:blogger.com,1999:blog-blogID.post-postID' 
         source='http://blogName.blogspot.com/feeds/posts/default/postID'
         type='text/html' />
  </entry>
</feed>

Kommentare löschen

Wenn du einen Kommentar löschen möchtest, sende eine DELETE-Anfrage an die Bearbeitungs-URL des Kommentars. Diese URL ist im Kommentarfeed oben markiert.

Exportformat

Mit Blogger können Nutzer ihre Blogs mit einer Blogger-Exportdatei exportieren und importieren. Diese Exportdatei enthält alle Posts und Kommentare für einen Blog. Das Format für die Exportdatei entspricht genau dem Atom-Format, das in den Abschnitten zum Abrufen von Beiträgen und Kommentaren beschrieben wird. Diese Exportdatei enthält den Inhalt des Beitragsfeeds und den Inhalt des Kommentarfeeds in einem Dokument.

Wenn Sie Blogdaten im Exportformat exportieren oder importieren möchten, rufen Sie die Seite Einstellungen für den Blog auf. Verwenden Sie die folgende URL, um die Exportdatei für einen Blog mithilfe der Data API abzurufen:

GET http://www.blogger.com/feeds/blogID/archive

Erstellen Sie zum Importieren der Exportdatei eine POST-Anfrage an die folgende URL, die den Inhalt der Exportdatei als Anfragedaten und application/atom+xml als Inhaltstyp enthält:

POST http://www.blogger.com/feeds/blogID/archive/full

Keine der oben genannten URLs unterstützt Suchparameter. Beide Anfragen müssen auch Authentifizierungsinformationen enthalten und nur Blogadministratoren können den Blog mit diesen Feed-URLs importieren/exportieren.

Hinweis: Wenn Sie eine eigene Blogger-Exportdatei erstellen, gibt es derzeit eine Einschränkung für die Sortierung der Beitrags- und Kommentareinträge. Die Blogger-Exportdatei listet zuerst alle Posts und dann alle Kommentare auf. Das Verschränken von Beitrags- und Kommentareinträgen ist zulässig, solange der Kommentareintrag nach dem Beitrag kommt, für den er gedacht ist.

Weitere Informationen dazu, wie Blogger das Atom-Format in der Exportdatei verwendet, finden Sie im Protokoll-Referenzhandbuch.

Nach oben