Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerhandbuch: Protokoll

Wichtig: Dies ist eine alte Version dieser Seite. Die neueste 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 aufrufen und aktualisieren.

Mit der Blogger Data API können Sie in Ihrer Clientanwendung neue Blogbeiträge erstellen, vorhandene Blogbeiträge bearbeiten oder löschen und nach Blogbeiträgen suchen, die bestimmten Kriterien entsprechen.

Dieses Dokument enthält nicht nur einige Hintergrundinformationen zu den Funktionen der Blogger Data API, sondern auch Beispiele für grundlegende Data API-Interaktionen mithilfe von Roh-XML und HTTP. Wenn Sie nach dem Lesen dieses Dokuments mehr über die Interaktion mit der API über unsere Clientbibliotheken erfahren möchten, lesen Sie die sprachspezifischen Abschnitte dieses Entwicklerhandbuchs.

Inhalt

Zielgruppe

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

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Konzepten des Google Data APIs-Protokolls vertraut sind.

Wenn Sie ein UNIX-System verwenden und die Beispiele in diesem Dokument ausprobieren möchten, ohne Code zu schreiben, können Sie die UNIX-Befehlszeilenprogramme curl oder wget verwenden. Weitere Informationen finden Sie in den Manual Pages für diese Programme.

Referenzinformationen zur Blogger Data API finden Sie im Referenzhandbuch für Protokolle.

Erste Schritte

Blogger-Konto erstellen

Sie können sich für Testzwecke für ein Blogger-Konto registrieren. Für Blogger werden Google-Konten verwendet. Wenn Sie also bereits ein Google-Konto haben, können Sie sofort loslegen.

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 aber nur lesbar. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor er private Feeds anfordert. Es kann mit einem der beiden folgenden Ansätze authentifiziert werden: AuthSub-Proxy-Authentifizierung oder ClientLogin-Nutzername/Passwort-Authentifizierung.

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

In den meisten Beispielen in den folgenden Abschnitten dieses Dokuments wird davon ausgegangen, dass Sie die entsprechende Authentifizierung bereitstellen.

AuthSub-Proxy-Authentifizierung

Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer in Google-Konten authentifizieren müssen. Der Website-Betreiber 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 er 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 müssen Sie einige Informationen und einen Link anzeigen, über den der Nutzer zu einer Google-Seite weitergeleitet wird, um Ihre Anfrage auf Zugriff auf seine Blogs zu authentifizieren.

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).
sicher: Gibt an, ob der Client ein sicheres Token anfordert.
Sitzung: Gibt an, ob das zurückgegebene Token gegen ein wiederverwendbares Sitzungstoken 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 in 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 dieser URL ein Authentifizierungstoken als Wert des Abfrageparameters token an. Beispiel:

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

Dieser Tokenwert stellt ein AuthSub-Token zur einmaligen Verwendung dar. Da in diesem Beispiel session=1 angegeben wurde, kann dieses Token gegen ein AuthSub-Sitzungstoken eingetauscht werden. Dazu wird der Dienst AuthSubSessionToken mit dem Einmaltoken in einem Autorisierungsheader 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 AuthSubSessionToken-Dienstantwort enthält einen Token-Header mit dem Sitzungstoken und einen Expiration-Header, der angibt, wie lange das Token gültig bleibt.

Ihre Anwendung kann dann den Sitzungstokenwert im Authorization-Header nachfolgender Interaktionen mit Blogger verwenden.

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

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-Nutzername/Passwort-Authentifizierung

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

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

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

E-Mail: Die E-Mail-Adresse des Nutzers.
Passwd: Das Passwort des Nutzers.
Dienst: Der Name des Blogger-Dienstes lautet blogger. Eine Liste anderer Dienstnamen finden Sie in der Liste der Dienstnamen.
accountType: Dieser Wert sollte bei der Verwendung der Blogger API immer auf GOOGLE festgelegt sein. Wenn Sie diesen Parameter nicht festlegen, wird der Zugriff für Nutzer verhindert, die auch ein G Suite-Konto haben.
source: Identifiziert Ihre Clientanwendung. 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.

Wenn der Vorgang erfolgreich war, gibt der Server den HTTP-Statuscode 200 OK sowie drei lange alphanumerische Codes im Antworttext 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. Die Werte für SID und LSID können ignoriert werden.

Da alle Anfragen an private Feeds authentifiziert werden müssen, musst du den Autorisierungsheader bei allen nachfolgenden Interaktionen mit Blogger im folgenden Format festlegen:

Authorization: GoogleLogin auth=yourAuthToken

Dabei ist yourAuthToken der Auth-String, der von der ClientLogin-Anfrage zurückgegeben wird.

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

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

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, kann die Authentifizierungsanfrage fehlschlagen und ein CAPTCHA-Test angefordert werden. Wenn Google die CAPTCHA-Herausforderung stellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter (nicht an die in der ClientLogin-Dokumentation angegebene URL für die CAPTCHA-Verarbeitung).

Liste der Blogs abrufen

Die Blogger Data API stellt einen Feed bereit, in dem die Blogs eines bestimmten Nutzers aufgeführt sind. Dieser Feed wird als „Metafeed“ bezeichnet.

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

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

Hinweis: Sie können auch default anstelle der Nutzer-ID angeben. In diesem Fall gibt Blogger die Liste der Blogs für den Nutzer zurück, dessen Anmeldedaten mit der Anfrage gesendet wurden.

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 im Dokument Google Data APIs Protocol Reference 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 finden Sie auch im Dokument Google Data APIs Protocol Reference (Referenz zum Google Data APIs-Protokoll).

Beiträge erstellen

Mit der Blogger Data API können Sie neue Blogbeiträge erstellen und veröffentlichen sowie Beitragsentwürfe erstellen.

Blogpost veröffentlichen

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

Erstelle zuerst eine XML-Darstellung des zu veröffentlichenden Beitrags. Diese XML-Datei muss in Form eines Atom-<entry>-Elements vorliegen. Das könnte so aussehen:

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

Wenn Sie diesen Eintrag veröffentlichen möchten, senden Sie ihn wie unten beschrieben an die Post-URL des Blogs. Platzieren Sie zuerst das Atom-Element <entry> im Textkörper einer neuen POST-Anfrage und verwenden Sie den Inhaltstyp application/atom+xml. Suche dann im Metafeed nach der Beitrags-URL des Blogs. Sie findest sie im <link>-Element, in dem das rel-Attribut auf #post endet. Die URL des Blogposts wird als href-Attribut dieses Elements angegeben. Sie hat folgendes Format:

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

Hinweis: Diese URL stimmt mit der URL im <link rel="service.post">-Tag überein, die im Bereich <head> der visuell lesbaren Version des Blogs angezeigt wird.

Blogger erstellt einen Blogpost mit dem von Ihnen gesendeten Eintrag und gibt dann einen HTTP-201 CREATED-Statuscode sowie eine Kopie des neuen Beitrags in Form eines <entry>-Elements zurück. Der zurückgegebene Eintrag ist derselbe, den Sie gesendet haben, 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.

Einen Blogpost-Entwurf erstellen

Entwurfsposts werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Dem Eintrag wird jedoch 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 den String yes enthalten, damit der Beitrag als Entwurf erkannt wird.

Sie können einen vorhandenen Blogpost-Entwurf in einen veröffentlichten Beitrag umwandeln, indem Sie den Entwurf abrufen, die Daten des Elements <app:draft> auf den String no festlegen und den Beitrag dann aktualisieren. Das Abrufen und Aktualisieren von Beiträgen wird in den nächsten beiden Abschnitten behandelt.

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

Beiträge abrufen

In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogbeiträgen 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 Blogbeiträge aus einem öffentlichen Blog abrufen.

Alle Blogbeiträge abrufen

Um die Beiträge des Nutzers abzurufen, 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 der Blogbeiträge für liz@gmail.com abrufen möchtest, sende die folgende HTTP-Anfrage an Blogger (natürlich mit dem entsprechenden Wert anstelle von blogID):

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

Blogger gibt dann einen HTTP-Statuscode 200 OK und einen Standard-Atom 1.0-Feed mit den Blogbeiträgen zurück.

Im folgenden Beispiel wird ein Feed für einen Blog mit nur einem Beitrag gezeigt. Beachten Sie, dass wir dieses Beispiel leicht bearbeitet haben, damit es für Menschen leichter lesbar ist. Ein echter Blogger-Feed enthält insbesondere 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 Abfrageparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen. So können Sie beispielsweise Blogbeiträge anfordern, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden.

Wenn Sie beispielsweise eine Abfrage für einen bestimmten Zeitraum senden möchten, fügen Sie der Anfrage-URL die Parameter published-min und published-max hinzu. Wenn Sie alle Blogeinträge abrufen möchten, die zwischen dem 16. März 2008 und dem 24. März 2008 erstellt wurden, 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 Blogbeiträgen zurück, die im angegebenen Zeitraum erstellt wurden.

Mit den Parametern updated-min und updated-max können Sie auch alle Blogbeiträge abrufen, die in einem bestimmten Zeitraum aktualisiert wurden. Beachten Sie jedoch, dass diese Parameter ignoriert werden, es sei denn, der Parameter orderby ist ebenfalls auf updated gesetzt.

Die Blogger Data API unterstützt die folgenden Abfrageparameter:

alt: Der Typ des zurückzugebenden Feeds, z. B. atom (Standard) oder rss.
/category: Gibt Kategorien (auch als Labels bezeichnet) an, um die Feedergebnisse zu filtern. Beispiel: http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt Einträge mit den Labels Fritz und Laurie zurück.
max-results: Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
orderby: Die Reihenfolge, in der Einträge zurückgegeben werden sollen, z. B. lastmodified (Standardeinstellung), starttime oder updated.
published-min, published-max: Die Grenzen für die Veröffentlichungsdaten von Einträgen.
start-index: Der Index (ab 1) des ersten Ergebnisses, das abgerufen werden soll (für die Paginierung).
updated-min, updated-max: Die Grenzen für die Datumsangaben der Eintragsaktualisierungen. Diese Abfrageparameter werden ignoriert, es sei denn, der Parameter orderby ist auf updated gesetzt.

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

Beiträge aktualisieren

Wenn du einen vorhandenen Blogpost aktualisieren möchtest, musst du zuerst den Eintrag abrufen, den du aktualisieren möchtest, dann ändern und dann eine PUT-Anfrage mit dem aktualisierten Eintrag im Nachrichtentext an die Bearbeitungs-URL des Beitrags senden. Der Wert für <id> im Eintrag, den Sie PUT, muss genau mit dem <id> des vorhandenen Eintrags übereinstimmen.

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: Damit der Eintrag auch in Zukunft verwendet werden kann, müssen Sie beim PUT eines aktualisierten Eintrags alle XML-Daten beibehalten, die beim Abrufen des Eintrags aus Blogger vorhanden waren. Andernfalls, wenn wir neue Elemente implementieren und <new-awesome-feature>-Elemente in den Feed aufnehmen, gibt Ihr Kunde sie nicht zurück und Ihre Nutzer gehen leer aus. Die Clientbibliotheken der Google Data API verarbeiten das korrekt. Wenn Sie also eine der Bibliotheken verwenden, ist alles in Ordnung.

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

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-PUT-Nachrichten. Sie können dieses 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 löschen

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

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-DELETE-Nachrichten. Um dies zu umgehen, können 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 Kommentare erstellt, abgerufen und gelöscht werden. Das Aktualisieren von Kommentaren wird nicht unterstützt und ist auch nicht in der Weboberfläche verfügbar.

Kommentare erstellen

Wenn du einen Kommentar posten möchtest, erstelle 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 im Text einer neuen POST-Anfrage und verwende 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 worden.

Kommentare abrufen

Du kannst die Kommentare zu einem bestimmten Beitrag abrufen, indem du eine GET an die Kommentarfeed-URL dieses Beitrags sendest:

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

Alternativ kannst du die Kommentare zu allen Beiträgen über die Kommentarfeed-URL des Blogs abrufen:

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

Diese Anfragen geben einen Kommentarfeed zurück, der 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 hervorgehoben.

Exportformat

Mit Blogger können Nutzer ihre Blogs mit einer Blogger-Exportdatei exportieren und importieren. Diese Exportdatei enthält alle Beiträge und Kommentare für einen Blog. Das Format der Exportdatei ist genau das 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 des Blogs auf. Wenn du die Exportdatei für einen Blog mit der Data API abrufen möchtest, verwende die folgende URL:

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

Wenn Sie die Exportdatei importieren möchten, erstellen Sie eine POST-Anfrage an die folgende URL. Verwenden Sie den 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 Abfrageparameter. Beide Anfragen müssen außerdem Authentifizierungsinformationen enthalten. Nur Blogadministratoren können den Blog mithilfe dieser Feed-URLs importieren/exportieren.

Hinweis: Wenn Sie Ihre eigene Blogger-Exportdatei erstellen, gibt es derzeit eine Einschränkung bei der Reihenfolge der Beitrags- und Kommentareinträge. In der Blogger-Exportdatei werden zuerst alle Beiträge und dann alle Kommentare aufgeführt. Es ist erlaubt, Beiträge und Kommentare zu vermischen, solange der Kommentar nach dem Beitrag gepostet wird, auf den er sich bezieht.

Weitere Informationen dazu, wie Blogger das Atom-Format in der Exportdatei verwendet, finden Sie im Referenzhandbuch für Protokolle.

Nach oben