Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerhandbuch: Protokoll

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

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

Ihre Client-Anwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und Blogposts abzufragen, die bestimmten Kriterien entsprechen.

Zusätzlich zu einigen Hintergrundinformationen zu den Funktionen der Blogger Data API enthält dieses Dokument Beispiele für grundlegende Data API-Interaktionen mit Roh-XML und HTTP. Nachdem Sie dieses Dokument gelesen haben, können Sie in den Abschnitten zu Programmiersprachen in diesem Entwicklerhandbuch mehr über die Interaktion mit der API über unsere Clientbibliotheken erfahren.

Inhalt

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die Client-Anwendungen schreiben möchten, die über XML und HTTP mit Blogger interagieren können.

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Konzepten 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 Seiten zu diesen Dienstprogrammen.

Referenzinformationen zur Blogger Data API finden Sie im Leitfaden zu Protokollen.

Erste Schritte

Erstellen eines Blogger-Kontos

Du kannst dich zu Testzwecken für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn du also bereits ein Google-Konto hast, bist du startklar.

Beim Blogger-Dienst authentifizieren

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 jedoch schreibgeschützt. Wenn du Blogs ändern möchtest, muss sich dein Kunde vor dem Anfordern von privaten Feeds authentifizieren. Für die Authentifizierung gibt es zwei Möglichkeiten: die AuthSub-Proxy-Authentifizierung oder die ClientLogin-Authentifizierung mit Nutzername/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 von einer entsprechenden Authentifizierung ausgegangen.

AuthSub-Proxy-Authentifizierung

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

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

Die folgenden Abfrageparameter sind in der AuthSubRequest-URL enthalten:

Weiter: Die URL der Seite, zu der 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).
sicher: Gibt an, ob der Client ein sicheres Token anfordert.
session: Gibt an, ob das zurückgegebene Token gegen ein Mehrfachnutzungstoken (Sitzungstoken) ausgetauscht werden kann.

Die AuthSubRequest-URL könnte wie folgt 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 leitet das AuthSub-System ihn an die URL weiter, die Sie im Abfrageparameter next der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt ein Authentifizierungstoken als Wert des Abfrageparameters token an diese URL an. Beispiel:

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

Dieser Tokenwert stellt ein AuthSub-Einweg-Token dar. Da in diesem Beispiel session=1 angegeben wurde, kann dieses Token gegen ein AuthSub-Sitzungstoken ausgetauscht werden. Dazu wird der AuthSubSessionToken-Dienst mit dem Einmal-Token in einem Autorisierungsheader so aufgerufen:

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 Antwort des AuthSubSessionToken-Dienstes enthält einen Token-Header, der das Sitzungstoken enthält, und einen Expiration-Header, der angibt, wie lange das Token gültig ist.

Deine Anwendung kann dann den Wert des Sitzungstokens im Authorization-Header bei nachfolgenden Interaktionen mit Blogger verwenden.

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

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

ClientLogin-Authentifizierung mit Nutzername/Passwort

Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger Client ist, der für einen einzelnen Nutzer "installiert" ist (z. B. eine Desktopanwendung). Wenn Sie ein Authentifizierungstoken mit dem ClientLogin-Mechanismus anfordern möchten, senden Sie eine POST-Anfrage an die folgende URL:

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

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

E-Mail: E-Mail-Adresse des Nutzers
Passwd: Das Passwort des Nutzers.
Dienst: Der Name des Blogger-Dienstes lautet blogger. Weitere Dienstnamen finden Sie in der Liste der Dienstnamen.
accountType: Bei Verwendung der Blogger API sollte dieser Wert immer auf GOOGLE festgelegt sein. Andernfalls können Nutzer mit einem G Suite-Konto nicht mehr darauf zugreifen.
source: Damit wird Ihre Clientanwendung gekennzeichnet. Muss das Format companyName-applicationName-versionID haben. In den Beispielen wird der Name 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.

Ist dies erfolgreich, gibt der Server den HTTP-Statuscode 200 OK sowie drei lange alphanumerische Codes im Text der Antwort zurück: SID, LSID und Auth. Der Auth-Wert ist das Autorisierungstoken, das Sie bei jeder nachfolgenden Anfrage an Blogger senden. Bewahren Sie daher eine Kopie dieses Werts auf. Sie können die SID- und LSID-Werte ignorieren.

Da alle Anfragen an private Feeds eine Authentifizierung erfordern, musst du 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 Auth-String.

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

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

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, kann die Authentifizierungsanfrage fehlschlagen und eine CAPTCHA-Abfrage auslösen. Wenn Google die CAPTCHA-Abfrage ausführen und verarbeiten soll, leiten Sie den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter und nicht an die CAPTCHA-Bearbeitungs-URL, die in der ClientLogin-Dokumentation angegeben ist.

Liste mit Blogs abrufen

Die Blogger Data API stellt einen Feed bereit, in dem die Blogs für einen bestimmten Nutzer aufgelistet werden. Dieser Feed wird als „Metafeed“ bezeichnet.

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

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

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

Ein Eintrag im Metafeed könnte wie folgt 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 Referenzdokument zum Google Data APIs-Protokoll oder in der Atom 1.0-Spezifikation.

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

Beiträge werden erstellt

Mit der Blogger Data API können Sie neue Blogeinträge und Entwurfseinträge erstellen und veröffentlichen.

Blogposts veröffentlichen

Nach der Authentifizierung kannst du neue Blogeinträge veröffentlichen.

Erstellen Sie zuerst eine XML-Darstellung des zu veröffentlichenden Beitrags. Diese XML-Datei muss das Format eines Atom-<entry>-Elements haben, das so aussehen könnte:

<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 werden so angezeigt, als wären sie vom aktuell authentifizierten Nutzer erstellt.

Wenn Sie diesen Eintrag veröffentlichen möchten, senden Sie ihn wie folgt an die Post-URL des Blogs. Fügen Sie zuerst das Atom-Element <entry> in den Text einer neuen POST-Anfrage ein. Verwenden Sie dabei den Inhaltstyp application/atom+xml. Suchen Sie dann die Post-URL des Blogs im Metafeed nach dem <link>-Element, bei dem das Attribut rel auf #post endet. Die Post-URL des Blogs wird als href-Attribut dieses Elements angegeben und hat folgendes Format:

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

Hinweis: Diese URL ist mit der URL im <link rel="service.post">-Tag identisch, das im Abschnitt <head> der visuell lesbaren Version des Blogs angezeigt wird.

Blogger erstellt anhand des von Ihnen gesendeten Eintrags einen Blogpost und gibt dann einen HTTP-201 CREATED-Statuscode sowie eine Kopie des neuen Posts im Format 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 im Referenzdokument zum Google Data API-Protokoll.

Entwurf eines Blogposts wird erstellt

Beitragsentwü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 im Element <app:draft> enthaltenen Daten müssen der String yes sein, damit der Beitrag als Entwurf erkannt wird.

Sie können einen vorhandenen Blogpost-Entwurf in einen veröffentlichten Post umwandeln. Dazu rufen Sie den Postentwurf ab, setzen die Daten des <app:draft>-Elements auf den String no und aktualisieren den Post. Wie Sie Beiträge abrufen und aktualisieren, wird in den nächsten beiden Abschnitten erläutert.

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 Abfrageparameter abrufen.

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

Alle Blogposts werden abgerufen

Wenn du die Beiträge des Nutzers abrufen möchtest, sende eine HTTP-GET-Anfrage an die Feed-URL des Blogs. Blogger gibt dann einen Feed mit den entsprechenden Blogeinträgen zurück. Wenn Sie beispielsweise eine Liste mit Blogposts für liz@gmail.com erhalten möchten, senden Sie die folgende HTTP-Anfrage an Blogger (mit dem entsprechenden 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 Post. Beachten Sie, dass wir dieses Beispiel leicht bearbeitet haben, um es für Menschen besser lesbar zu machen. Insbesondere enthält ein echter Blogger-Feed tatsächliche 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 mithilfe von Suchparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. 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. Um alle zwischen dem 16. März 2008 und dem 24. März 2008 erstellten Blogeinträge abzurufen, 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 du diese GET-Anfrage sendest, gibt Blogger einen HTTP-200 OK-Statuscode und einen Feed zurück, der alle Blogposts enthält, die im angegebenen Zeitraum erstellt wurden.

Die Parameter updated-min und updated-max können auch verwendet werden, um alle Blogeinträge abzurufen, die innerhalb eines bestimmten Bereichs aktualisiert wurden. Diese Parameter werden jedoch ignoriert, es sei denn, der Parameter orderby ist auch auf updated gesetzt.

Die Blogger Data API unterstützt die folgenden Abfrageparameter:

alt: Der Feedtyp, der zurückgegeben werden soll, z. B. atom (Standardeinstellung) oder rss.
/category: Damit werden Kategorien (auch Labels genannt) zum Filtern der Feedergebnisse angegeben. Beispielsweise gibt http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie Einträge mit den beiden Labels Fritz und Laurie zurück.
max-results: Die maximale Anzahl der zurückzugebenden Einträge.
Orderby: Die Reihenfolge, in der Einträge zurückgegeben werden sollen, z. B. lastmodified (Standardeinstellung), starttime oder updated.
Publish-Min., Publish-Max.: Die Grenzen der Veröffentlichungsdaten des Eintrags.
start-index: Der 1-basierte Index des ersten abzurufenden Ergebnisses (für die Seitenordnung).
updated-min., updated-max.: Die Grenzen bei Datumsangaben für die Aktualisierung von Einträgen. Diese Suchparameter werden ignoriert, sofern der Parameter orderby nicht auf updated festgelegt ist.

Weitere Informationen zu Abfrageparametern finden Sie im Blogger Data API-Referenzhandbuch und im Referenzhandbuch für Google Data APIs.

Beiträge werden aktualisiert

Wenn Sie einen vorhandenen Blogpost aktualisieren möchten, rufen Sie zuerst den zu aktualisierenden Eintrag ab. Anschließend ändern Sie ihn und senden dann eine PUT-Anfrage mit dem aktualisierten Eintrag im Nachrichtentext an die Bearbeitungs-URL des Posts. Achten Sie darauf, dass der <id>-Wert in Ihrem Eintrag PUT genau mit dem <id> des vorhandenen Eintrags übereinstimmt.

Die Bearbeitungs-URL wird 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 Aufwärtskompatibilität sicherzustellen, musst du beim PUT eines aktualisierten Eintrags alles XML beibehalten, das beim Abrufen des Eintrags aus Blogger vorhanden war. Andernfalls gibt dein Client sie nicht zurück, wenn wir neue Elemente implementieren und <new-awesome-feature>-Elemente in den Feed aufnehmen, und deine Nutzer werden nichts tun. Die Google Data API-Clientbibliotheken verarbeiten dies alle ordnungsgemäß. Wenn Sie also eine der Bibliotheken verwenden, sind keine weiteren Schritte erforderlich.

Hinweis: Die mit Beiträgen verknüpften Autorendaten können derzeit nicht geändert werden.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-PUT-Nachrichten. Sie können das Problem umgehen, indem Sie einen X-HTTP-Method-Override: PUT-Header in eine POST-Anfrage einfügen. Weitere Informationen finden Sie im Dokument Grundlagen des Google Data API-Protokolls.

Beiträge werden gelöscht

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

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-DELETE-Nachrichten. Sie können das Problem umgehen, indem Sie einen X-HTTP-Method-Override: DELETE-Header in eine POST-Anfrage einfügen. Weitere Informationen finden Sie 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 nicht unterstützt und ist auch nicht über die Weboberfläche verfügbar.

Kommentare erstellen

Wenn Sie einen Kommentar posten möchten, erstellen Sie ein Atom-<entry>-Element wie das folgende:

  <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>

Wenn du diesen Kommentar veröffentlichen möchtest, platziere dein Atom-<entry>-Element in den Text einer neuen POST-Anfrage. Verwende dazu den Inhaltstyp application/atom+xml. Sende dann die POST-Anfrage an die entsprechende Blogger-URL:

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

Hinweis: Derzeit können Sie nur Kommentare in einem Blog posten, der dem authentifizierten Nutzer gehört.

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 aktuell authentifizierten Nutzer erstellt.

Kommentare werden abgerufen

Sie können die Kommentare für einen bestimmten Beitrag abrufen, indem Sie eine GET an die Kommentarfeed-URL dieses Beitrags senden:

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

Sie können auch die Kommentare zu allen Posts über die Kommentarfeed-URL des Blogs abrufen:

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

Bei diesen Anfragen wird ein Kommentarfeed zurückgegeben, der wie folgt 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 werden gelöscht

Wenn Sie einen Kommentar löschen möchten, senden Sie eine DELETE-Anfrage an die Bearbeitungs-URL des Kommentars. Diese URL wird im Kommentarfeed oben hervorgehoben.

Exportformat

Mit Blogger können Nutzer ihre Blogs mithilfe 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 Post-Feeds und den Inhalt des Kommentarfeeds in einem Dokument.

Um Blogdaten mit dem Exportformat zu exportieren oder zu importieren, rufen Sie die Seite Einstellungen des Blogs 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 mit dem Inhalt der Exportdatei als Anfragedaten und application/atom+xml als Inhaltstyp:

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

Keine der oben genannten URLs unterstützt Suchparameter. Beide Anfragen müssen außerdem Authentifizierungsinformationen enthalten und nur Blogadministratoren können den Blog mithilfe dieser Feed-URLs importieren/exportieren.

Hinweis: Wenn Sie eine eigene Blogger-Exportdatei erstellen, gibt es derzeit eine Einschränkung bezüglich der Reihenfolge von Post- und Kommentareinträgen. In der Blogger-Exportdatei werden zuerst alle Posts und dann alle Kommentare aufgelistet. Das Verschachteln von Beitrags- und Kommentareinträgen ist zulässig, solange der Kommentareintrag nach dem Post folgt, auf den sich der Kommentar bezieht.

Weitere Informationen dazu, wie Blogger das Atom-Format in der Exportdatei verwendet, finden Sie im Leitfaden zu Protokollen.

Nach oben