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 Client-Anwendungen Blogger-Inhalte aufrufen und aktualisieren. in Form von Google Data API-Feeds.

Ihre Client-Anwendung kann mithilfe der Blogger Data API einen neuen Blog erstellen. Posts bearbeiten oder löschen und Blogposts abfragen, die mit der Suchanfrage übereinstimmen. Kriterien erfüllen.

Zusätzlich zu einigen Hintergrundinformationen zu den Funktionen von Blogger Data API enthält, enthält dieses Dokument Beispiele für grundlegende Data API-Interaktionen mithilfe von XML- und HTTP-Rohdaten. 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, Anwendungen, die über XML und HTTP mit Blogger 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 ohne Code schreiben zu müssen, finden Sie die Befehlszeilendienstprogramme von UNIX curl oder wget nützlich; finden Sie in der Seiten für diese Dienstprogramme.

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

Erste Schritte

Erstellen eines Blogger-Kontos

Sie können sich für ein Blogger-Konto zu Testzwecken. Blogger verwendet Google-Konten. Wenn Sie also bereits ein Google-Konto haben, sind Sie 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 nur lesbar. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor er private Feeds anfordert. Die Authentifizierung kann mit einem der beiden folgenden Ansätze erfolgen: AuthSub-Proxy-Authentifizierung oder ClientLogin-Nutzername/Passwort-Authentifizierung.

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

Bei den meisten Beispielen in den nachfolgenden Abschnitten dieses Dokuments wird davon ausgegangen, mit der entsprechenden Authentifizierung.

AuthSub-Proxy-Authentifizierung

Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer bei Google-Konten zu authentifizieren. 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 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 in seinem Google-Konto.

Nach der Authentifizierung des Nutzers leitet das AuthSub-System ihn an die URL weiter. den Sie im Abfrageparameter next der AuthSubRequest angegeben haben URL 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-Einweg-Token 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 Antwort des AuthSubSessionToken-Dienstes enthält einen Token-Header die das Sitzungstoken und einen Expiration-Header enthält, gibt an, wie lange das Token gültig ist.

Ihre Anwendung kann dann den Wert des Sitzungstokens im Authorization-Header nachfolgender Interaktionen mit Blogger.

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

Verwenden Sie die ClientLogin-Authentifizierung, wenn es sich bei Ihrem Client um einen eigenständigen, für einen einzelnen Nutzer installierten Client handelt (z. B. eine Desktopanwendung). So fordern Sie eine Authentifizierungstoken mithilfe des ClientLogin-Mechanismus ein, POST an die folgende URL senden:

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

Schlägt die Authentifizierungsanfrage fehl, gibt der Server eine HTTP- 403 Forbidden-Statuscode.

Ist dies erfolgreich, gibt der Server den HTTP-Status 200 OK zurück. sowie drei lange alphanumerische Codes im Text der Antwort: SID, LSID, und Auth. Der Auth-Wert ist das Autorisierungstoken, das Sie an Blogger senden. mit jeder nachfolgenden Anfrage zu verknüpfen. 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, müssen Sie Authorization-Header bei allen nachfolgenden Interaktionen mit Blogger unter Verwendung des folgendes Format:

Authorization: GoogleLogin auth=yourAuthToken

Dabei ist yourAuthToken der Auth-String, der vom ClientLogin-Anfrage.

Weitere Informationen zur ClientLogin-Authentifizierung, einschließlich Beispiel -Anfragen und -Antworten, siehe Authentifizierung für installierte Dokumentation zu Anwendungen.

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

Hinweis: Wie auf der Seite „ClientLogin“ kann die Authentifizierungsanfrage fehlschlagen und ein CAPTCHA anfordern. Herausforderung. Wenn Google die CAPTCHA-Abfrage ausführen und verarbeiten soll, den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (anstatt der CAPTCHA-URL, die im ClientLogin angegeben wird, Dokumentation.

Liste mit Blogs abrufen

Das Blogger Data API bietet einen Feed, in dem die Blogs für eine bestimmte user; wird dieser Feed 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 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 erhalten Sie in den Google- Data API Protocol Reference (Referenzdokument für das Data API-Protokoll) oder im Atom-Dokument“ 1.0-Spezifikation.

Wenn Ihre Anfrage aus irgendeinem Grund fehlschlägt, gibt Blogger möglicherweise einen anderen Status zurück Code. Weitere Informationen zu HTTP-Statuscodes finden Sie auch im Dokument Google Data APIs Protocol Reference (Referenz zum Google Data APIs-Protokoll).

Beiträge werden erstellt

Mit der Blogger Data API können Sie neue Blog-Einträge erstellen und veröffentlichen, sowie Entwürfe von Einträgen zu erstellen.

Blogposts veröffentlichen

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

Erstellen Sie 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 ist wird derzeit nicht unterstützt. Alle neuen Beiträge werden so angezeigt, als wären sie von den aktuell authentifizierten Nutzer.

Wenn Sie diesen Eintrag veröffentlichen möchten, senden Sie ihn wie unten beschrieben an die Post-URL des Blogs. Erstens: platzieren Sie Ihr Atom-Element <entry> im Textkörper eines neuen POST-Anfrage mit dem Inhalt „application/atom+xml“ Typ. 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 ist mit der URL im <link rel="service.post">-Tag im <head> der visuell lesbaren Version des -Blog.

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 Status zurück Code. Informationen zu den Statuscodes finden Sie im Artikel Google-Daten Referenzdokument zum API-Protokoll.

Entwurf eines Blogposts wird erstellt

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 nur <app:draft>-Element als untergeordnetes Element:

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

Bei den im <app:draft>-Element enthaltenen Daten muss es sich um Folgendes handeln: yes eingeben, damit der Beitrag als Entwurf erkannt wird.

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

Hinweis: Weitere Informationen zum Atom- Veröffentlichungsprotokoll, einschließlich <app:control> und <app:draft>-Namespaces, siehe RFC 5023.

Beiträge abrufen

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

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher sehen Sie brauchen Sie den Autorisierungsparameter nicht festzulegen, wenn Sie Blog-Posts von öffentlich zugänglichen Blog.

Alle Blogposts werden abgerufen

Um die Beiträge des Nutzers abzurufen, sende eine HTTP-GET-Anfrage an den Feed-URL des Blogs an. Blogger gibt dann einen Feed zurück, der den entsprechenden Blog enthält. Einträge. Um beispielsweise eine Liste mit Blogposts für liz@gmail.com zu erhalten, senden Sie den HTTP-Anfrage an Blogger (mit dem entsprechenden Wert anstelle 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 mit den Blogposts

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 Suchparametern 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 Zeitraumabfrage senden möchten, fügen Sie den Parameter published-min hinzu. und published-max an die Anfrage-URL an. 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 du diese GET-Anfrage sendest, gibt Blogger eine HTTP- 200 OK-Statuscode und einem Feed mit Blogposts, die zuvor 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. 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 für die Datumsangaben der Eintragsaktualisierungen. Diese Suchparameter werden ignoriert, sofern der Parameter orderby nicht auf updated festgelegt ist.

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

Um einen vorhandenen Blogpost zu aktualisieren, rufen Sie zuerst den Eintrag ab, den Sie aktualisieren, ändern Sie sie und senden dann eine PUT-Anfrage mit den aktualisierten Eintrag im Nachrichtentext an die Bearbeitungs-URL des Beitrags an. Achten Sie darauf, dass der <id>-Wert in dem Eintrag, mit dem Sie PUT genau übereinstimmen Den <id> des vorhandenen Eintrags.

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, dass bei PUTaktualisierten Einträgen alle Die XML-Datei, die beim Abrufen des Eintrags aus Blogger vorhanden war. Andernfalls wenn wir neue Elemente implementieren und <new-awesome-feature> -Elemente im Feed enthält, gibt Ihr Kunde sie nicht zurück und die Nutzer aus. Die Google Data API-Clientbibliotheken verarbeiten dies alle korrekt. Wenn Sie einer der fertigen Bibliotheken.

Hinweis: Wenn Sie die Autorendaten ändern, die mit Posts werden derzeit nicht unterstützt.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-PUT-Nachrichten. Um dies zu umgehen, können Sie X-HTTP-Method-Override: PUT-Header in einer POST-Anfrage. 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. Um dies zu umgehen, können Sie einen X-HTTP-Method-Override: DELETE-Header in eine POST-Anfrage einfügen. Einzelheiten finden Sie unter Google Data API Dokument zu den Protokollgrundlagen.

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 im Web verfügbar .

Kommentare erstellen

Um einen Kommentar zu posten, erstelle ein Atom-<entry>-Element wie das Folgendes:

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

Platziere dein Atom-Element <entry>, um diesen Kommentar zu veröffentlichen im Text einer neuen POST-Anfrage mithilfe der Methode Inhaltstyp application/atom+xml. Sende dann die POST an die entsprechende Blogger-URL senden:

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

Hinweis: Derzeit können Sie nur Kommentare in einem Blog posten, dessen Inhaber der authentifizierte Nutzer ist.

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

Kommentare abrufen

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

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

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

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 werden gelöscht

Wenn du einen Kommentar löschen möchtest, sende eine DELETE-Anfrage zur Änderung des Kommentars URL Diese URL wird im Kommentarfeed oben hervorgehoben.

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 der Exportdatei ist genau das Atom-Format, das in den Abschnitten zum Abrufen von Beiträgen und Kommentaren beschrieben wird. Diese Exportdatei enthält die Inhalte des Beitragsfeeds und die Inhalte des Kommentarfeeds zusammen in einem Dokument zusammen.

Um Blogdaten mit dem Exportformat zu exportieren oder zu importieren, besuchen Sie die Seite Einstellungen für den Blog. Um die Exportdatei für eine Blog mit der Data API verwenden, verwenden Sie die folgende URL:

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

Um die Exportdatei zu importieren, erstellen Sie eine POST-Anfrage an den folgenden 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 Abfrageparameter. Beide Anfragen müssen enthalten ebenfalls authentication-Informationen und Blog-Administratoren können den Blog mithilfe dieser Feeds importieren/exportieren. URLs.

Hinweis: Wenn Sie Ihren eigenen Blogger erstellen Exportdatei gibt es derzeit eine Einschränkung bezüglich der Reihenfolge der Posts. und Kommentare hinzufügen. 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 im Export verwendet -Datei enthält, siehe die Protokolldatei Leitfaden.

Nach oben