Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerhandbuch: Java

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.

Ihre Clientanwendung kann die Blogger Data API verwenden, um neue Blogbeiträge zu erstellen, vorhandene Blogbeiträge zu bearbeiten oder zu löschen und nach Blogbeiträgen zu 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 mit der Java-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Bibliothek verwendet wird, finden Sie im Abschnitt zum Protokoll dieses Entwicklerhandbuchs.

Inhalt

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die Java-Clientanwendungen schreiben möchten, die mit Blogger interagieren können.

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

Referenzinformationen zu den Klassen und Methoden der Clientbibliothek finden Sie in der API-Referenz der Java-Clientbibliothek. Allgemeine Informationen zur Blogger Data API findest du im Referenzleitfaden zum Protokoll.

Erste Schritte

Informationen zum Einrichten der Clientbibliothek finden Sie im Leitfaden für den Einstieg.

Für die Java-Clientbibliothek ist Java 1.5 erforderlich. Nachdem Sie die Clientbibliothek heruntergeladen haben, finden Sie die benötigten Klassen in der Datei java/lib/gdataclient-1.0.jar.

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.

Codebeispiel ausführen

Ein vollständiger, funktionierender Beispielclient mit dem gesamten in diesem Dokument gezeigten Beispielcode ist in der Java-Clientbibliothek im Verzeichnis gdata/java/sample/blogger/BloggerClient.java verfügbar. Eine Anleitung zum Erstellen und Ausführen finden Sie im selben Verzeichnis in der Datei README.txt.

Der Beispielclient führt mehrere Vorgänge am angegebenen Blog aus, um die Verwendung der Blogger Data API zu demonstrieren.

Um die Beispiele in diesem Dokument in Ihren eigenen Code zu kompilieren, benötigen Sie die folgenden import-Anweisungen:

import com.google.gdata.client.*;
import com.google.gdata.data.*;
import com.google.gdata.util.*;
import java.io.IOException;
import java.net.URL;

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 ein authentifiziertes GoogleService-Objekt haben.

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 Java-Clientbibliothek bietet eine Funktion zum Generieren der URL der Google-Seite. Im folgenden Code wird die URL der Seite „AuthSubRequest“ abgerufen:

String next = "http://www.example.com/welcome.html";
String scope = "http://www.blogger.com/feeds/";
boolean secure = false;
boolean session = true;
String authSubLogin = AuthSubUtil.getRequestUrl(next, scope, secure, session);

Die Methode getRequestUrl verwendet die folgenden Parameter (entsprechend den Abfrageparametern, die vom AuthSubRequest-Handler verwendet werden):

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.

Das obige Beispiel zeigt einen Aufruf, bei dem kein sicheres Token angefordert wird (der Wert von secure ist false). Die resultierende Anfrage-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 = true angegeben wurde, kann dieses Token gegen ein AuthSub-Sitzungstoken eingetauscht werden, indem der Dienst AuthSubSessionToken wie unten beschrieben aufgerufen wird. Dabei ist urlFromAuthSub die URL, an die AuthSub das Token angehängt hat:

String token = AuthSubUtil.getTokenFromReply(urlFromAuthSub);
String sessionToken = AuthSubUtil.exchangeForSessionToken(token, null);

Sie übergeben also Ihr Einmaltoken zusammen mit null (für den nicht registrierten Modus) oder einem privaten Schlüssel (für den registrierten Modus) an die exchangeForSessionToken-Methode. Die AuthSub-Benutzeroberfläche gibt dann ein Sitzungstoken zurück. Weitere Informationen zu registrierten Anwendungen und privaten Schlüsseln finden Sie im Abschnitt Anfragen signieren der AuthSub-Dokumentation.

Ihre Anwendung kann das Sitzungstoken dann bei nachfolgenden Interaktionen mit Blogger verwenden. Wenn du der Java-Clientbibliothek mitteilen möchtest, dass das Sitzungstoken automatisch mit jeder Anfrage gesendet werden soll, ruf die Methode setAuthSubToken des GoogleService-Objekts auf:

GoogleService.setAuthSubToken(sessionToken, null);

Danach sendet die Clientbibliothek das Token automatisch mit jeder Anfrage.

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). Rufe dazu einfach die Methode setUserCredentials für dein GoogleService-Objekt auf. Alle nachfolgenden Interaktionen mit Blogger werden dann authentifiziert:

GoogleService myService = new GoogleService("blogger", "exampleCo-exampleApp-1");
myService.setUserCredentials("user@example.com", "secretPassword");

Im obigen Snippet übergeben wir dem GoogleService-Konstruktor zwei Parameter. Der erste Parameter ist der Name des Dienstes, mit dem wir interagieren möchten. Der zweite Parameter ist der Name unserer Anwendung im Format companyName-applicationName-versionID.

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.

Im folgenden Beispielcode wird ein authentifiziertes GoogleService-Objekt verwendet, um den Metafeed abzurufen. Anschließend wird der Titel jedes Blogs ausgegeben.

public static void printUserBlogs(GoogleService myService)
    throws ServiceException, IOException {

  // Request the feed
  final URL feedUrl = new URL("http://www.blogger.com/feeds/default/blogs");
  Feed resultFeed = myService.getFeed(feedUrl, Feed.class);

  // Print the results
  System.out.println(resultFeed.getTitle().getPlainText());
  for (int i = 0; i < resultFeed.getEntries().size(); i++) {
    Entry entry = resultFeed.getEntries().get(i);
    System.out.println("\t" + entry.getTitle().getPlainText());
  }
}

Notieren Sie sich die URL, die von der Methode getFeed verwendet wird. Das ist die Standard-Metafeed-URL. Sie gibt eine Liste der Blogs für den aktuell authentifizierten Nutzer zurück. Wenn du auf einen Feed für einen anderen Nutzer zugreifen möchtest, kannst du die ID des Nutzers anstelle von default in die Metafeed-URL einfügen. Die ID des Nutzers ist die Ziffernfolge am Ende der Profil-URL des Nutzers.

Beiträge erstellen

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

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.

Blogpost veröffentlichen

Mit der Java-Clientbibliothek können Sie neue Blogbeiträge veröffentlichen.

Erstellen Sie zuerst ein Entry-Objekt für den Blogpost. Anschließend können Sie den Titel, den Inhalt und andere Attribute des Blogposts festlegen. Verwenden Sie abschließend das GoogleService-Objekt, um den Beitrag einzufügen. Hier ein Beispiel für die Veröffentlichung eines neuen Blogposts:

public static Entry createPost(
    GoogleService myService, String blogID, String title,
    String content, String userName)
    throws ServiceException, IOException {
  // Create the entry to insert
  Entry myEntry = new Entry();
  myEntry.setTitle(new PlainTextConstruct(title));
  myEntry.setContent(new PlainTextConstruct(content));

  // Ask the service to insert the new entry
  URL postUrl = new URL("http://www.blogger.com/feeds/" + blogID + "/posts/default");
  return myService.insert(postUrl, myEntry);
}

Die Methode insert verwendet die Post-URL des Dienstes als Parameter. Anschließend gibt die Methode den Eintrag zurück, wie er von Blogger gespeichert wurde. Der zurückgegebene Eintrag ist derselbe, den Sie gesendet haben, enthält aber auch verschiedene von Blogger hinzugefügte Elemente, z. B. eine Beitrags-ID.

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

Entwurfsbeiträge werden genauso erstellt wie öffentliche Beiträge. Sie müssen jedoch das draft-Attribut des Entry-Objekts festlegen. Sie können einen Blogpost wie den oben genannten als Entwurf erstellen, indem Sie die hervorgehobene Zeile hinzufügen:

public static Entry createPost(GoogleService myService, String blogId,
    String title, String content, String userName,
    Boolean isDraft)
    throws ServiceException, IOException {
  // Create the entry to insert
  Entry myEntry = new Entry();
  myEntry.setTitle(new PlainTextConstruct(title));
  myEntry.setContent(new PlainTextConstruct(content));
  myEntry.setDraft(isDraft);

  // Ask the service to insert the new entry
  URL postUrl = new URL("http://www.blogger.com/feeds/" + blogID + "/posts/default");
  return myService.insert(postUrl, myEntry);
}

Sie können einen vorhandenen Blogpost-Entwurf in einen veröffentlichten Beitrag umwandeln, indem Sie den Entwurf abrufen, das Attribut „draft“ auf „false“ setzen und den Beitrag dann aktualisieren. In den nächsten beiden Abschnitten erfahren Sie, wie Sie Beiträge abrufen und aktualisieren.

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 musst du die setUserCredentials-Methode nicht aufrufen oder die AuthSub-Authentifizierung durchführen, bevor du Beiträge aus einem öffentlichen Blog abrufen kannst.

Alle Blogbeiträge abrufen

Rufe zum Abrufen der Beiträge des Nutzers dieselbe getFeed-Methode auf, die auch zum Abrufen des Metafeeds des Blogs verwendet wurde. Sende diesmal jedoch die Feed-URL des Blogposts:

public static void printAllPosts(
    GoogleService myService, String blogId)
    throws ServiceException, IOException {
  // Request the feed
  URL feedUrl = new URL("http://www.blogger.com/feeds/" + blogID + "/posts/default");
  Feed resultFeed = myService.getFeed(feedUrl, Feed.class);

  // Print the results
  System.out.println(resultFeed.getTitle().getPlainText());
  for (int i = 0; i < resultFeed.getEntries().size(); i++) {
    Entry entry = resultFeed.getEntries().get(i);
    System.out.println("\t" + entry.getTitle().getPlainText());
  }
  System.out.println();
}

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. Dazu erstellen Sie ein Query-Objekt und übergeben es an die Methode GoogleService.getQuery.

Wenn Sie beispielsweise eine Abfrage für einen bestimmten Zeitraum senden möchten, verwenden Sie die Methoden setPublishedMin und setPublishedMax des Query-Objekts. Im folgenden Code-Snippet wird der Titel jedes Blogposts ausgegeben, der zwischen der angegebenen Start- und Endzeit veröffentlicht wurde:

public static void printDateRangeQueryResults(
    GoogleService myService, String blogId,
    DateTime startTime, DateTime endTime)
    throws ServiceException, IOException {
  // Create query and submit a request
  URL feedUrl = new URL("http://www.blogger.com/feeds/" + blogID + "/posts/default");
  Query myQuery = new Query(feedUrl);
  myQuery.setPublishedMin(startTime);
  myQuery.setPublishedMax(endTime);
  Feed resultFeed = myService.query(myQuery, Feed.class);

  // Print the results
  System.out.println(resultFeed.getTitle().getPlainText() +
      " posts between " + startTime + " and " + endTime);
  for (int i = 0; i < resultFeed.getEntries().size(); i++) {
    Entry entry = resultFeed.getEntries().get(i);
    System.out.println("\t" + entry.getTitle().getPlainText());
    System.out.println("\t" + entry.getUpdated().toStringRfc822());
  }
  System.out.println();
}

Das Query-Objekt wird mit derselben Postfeed-URL erstellt, die zum Abrufen von Beiträgen verwendet wird.

Die Blogger Data API unterstützt die folgenden Query-Methoden:

addCategoryFilter: Geben Sie 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.
setMaxResults: Legen Sie die maximale Anzahl der zurückzugebenden Einträge fest.
setPublishedMin, setPublishedMax: Legen Sie die Grenzen für die Veröffentlichungsdaten der Einträge fest.
setStartIndex: Legen Sie den Index (ab 1) des ersten abzurufenden Ergebnisses fest (für die Paginierung).
setUpdatedMin, setUpdatedMax: Legen Sie die Grenzen für die Datumsangaben für die Aktualisierung von Einträgen fest. Diese Abfrageparameter werden ignoriert, es sei denn, der Parameter orderby ist auf updated gesetzt.

Hinweis: Derzeit gibt es keine Setter für den Abfrageparameter orderby. Sie können jedoch weiterhin die Query.addCustomParameter()-Methode verwenden, wenn Sie dies festlegen möchten.

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 Sie einen vorhandenen Blogpost aktualisieren möchten, rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten, ändern ihn und senden Sie ihn dann mit der Methode update an Blogger. Im folgenden Code-Snippet wird der Titel eines Blogposts geändert, vorausgesetzt, Sie haben den Eintrag bereits vom Server abgerufen.

public static Entry updatePostTitle(
    GoogleService myService, Entry entryToUpdate, String newTitle)
    throws ServiceException, IOException {
  entryToUpdate.setTitle(new PlainTextConstruct(newTitle));
  URL editUrl = new URL(entryToUpdate.getEditLink().getHref());
  return myService.update(editUrl, entryToUpdate);
}

Der obige Code gibt eine Entry zurück, die den gesamten neu aktualisierten Beitrag enthält. Wenn du andere Properties aktualisieren möchtest, musst du sie einfach im Entry-Objekt festlegen, bevor du update aufrufst.

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

Beiträge löschen

Wenn du einen Beitrag löschen möchtest, übergebe die Bearbeitungs-URL des Beitrags an die delete-Methode deines GoogleService-Objekts. So gehts:

public static void deletePost(
    GoogleService myService, String editLinkHref)
    throws ServiceException, IOException {
  URL deleteUrl = new URL(editLinkHref);
  myService.delete(deleteUrl);
}

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 Entry-Objekt und füge es so ein:

public static Entry createComment(
    GoogleService myService, String blogID, String postId,
    String commentText)
    throws ServiceException, IOException {
  // Build the comment feed URI
  String commentsFeedUri = "http://www.blogger.com/feeds/" + blogID + "/" + postId + "/comments/default";
  URL feedUrl = new URL(commentsFeedUri);

  // Create a new entry for the comment and submit it to the GoogleService
  Entry myEntry = new Entry();
  myEntry.setContent(new PlainTextConstruct(commentText));
  return myService.insert(feedUrl, myEntry);
}

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 über die Kommentarfeed-URL des Beitrags abrufen:

public static void printAllComments(
    GoogleService myService, String blogID, String postId)
    throws ServiceException, IOException {
  // Build comment feed URI and request comments on the specified post
  String commentsFeedUri = "http://www.blogger.com/feeds/" + blogID + "/" + postId + "/comments/default";
  URL feedUrl = new URL(commentsFeedUri);
  Feed resultFeed = myService.getFeed(feedUrl, Feed.class);

  // Display the results
  System.out.println(resultFeed.getTitle().getPlainText());
  for (int i = 0; i < resultFeed.getEntries().size(); i++) {
    Entry entry = resultFeed.getEntries().get(i);
    System.out.println("\t" +
        ((TextContent) entry.getContent()).getContent().getPlainText());
    System.out.println("\t" + entry.getUpdated().toStringRfc822());
  }
  System.out.println();
}

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

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

Kommentare löschen

Wenn du einen Kommentar löschen möchtest, übergebe die Bearbeitungs-URL des Kommentars so an die delete-Methode deines GoogleService-Objekts:

public static void deleteComment(GoogleService myService, String editLinkHref)
    throws ServiceException, IOException {
  URL deleteUrl = new URL(editLinkHref);
  myService.delete(deleteUrl);
}

Nach oben