Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerhandbuch: Java

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 unter Verwendung der Java-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Bibliothek verwendet wird, finden Sie im Abschnitt zu Protokollen in diesem Entwicklerhandbuch.

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 hinter dem Google Data APIs-Protokoll vertraut sind.

Referenzinformationen zu den von der Clientbibliothek bereitgestellten Klassen und Methoden finden Sie in der API-Referenz zur Java-Clientbibliothek. Allgemeine Referenzinformationen zur Blogger Data API finden Sie in der Übersicht zu Protokollen.

Erste Schritte

Informationen zur Einrichtung der Clientbibliothek finden Sie im Startleitfaden.

Die Java-Client-Bibliothek erfordert Java 1.5. Nach dem Herunterladen der Clientbibliothek findest du die für den Einstieg erforderlichen Klassen in der Datei java/lib/gdataclient-1.0.jar.

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.

Beispielcode ausführen

Ein voll funktionsfähiger Beispielclient mit dem gesamten Beispielcode in diesem Dokument ist in der Distribution der Java-Clientbibliothek im Verzeichnis gdata/java/sample/blogger/BloggerClient.java verfügbar. Build- und Ausführungsanweisungen befinden sich im selben Verzeichnis in der Datei README.txt.

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

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

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 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 davon ausgegangen, dass Sie ein authentifiziertes GoogleService-Objekt haben.

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 Java-Clientbibliothek bietet eine Funktion zum Generieren der URL der Google-Seite. Mit dem folgenden Code wird die URL der AuthSubRequest-Seite 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, die den vom AuthSubRequest-Handler verwendeten Abfrageparametern entsprechen:

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.

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 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 = true angegeben wurde, kann dieses Token gegen ein AuthSub-Sitzungstoken eingetauscht werden, indem der Dienst AuthSubSessionToken so 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);

Das heißt, Sie übergeben Ihr einmaliges Token zusammen mit null (im nicht registrierten Modus) oder einem privaten Schlüssel (im registrierten Modus) an die Methode exchangeForSessionToken und die AuthSub-Schnittstelle gibt ein Sitzungstoken zurück. Weitere Informationen zu registrierten Anwendungen und privaten Schlüsseln finden Sie im Abschnitt Signierungsanfragen der AuthSub-Dokumentation.

Ihre Anwendung kann das Sitzungstoken dann bei nachfolgenden Interaktionen mit Blogger verwenden. Wenn Sie die Java-Clientbibliothek anweisen möchten, das Sitzungstoken bei jeder Anfrage automatisch zu senden, rufen Sie die Methode setAuthSubToken des GoogleService-Objekts auf:

GoogleService.setAuthSubToken(sessionToken, null);

Danach sendet die Clientbibliothek automatisch das Token zusammen mit jeder Anfrage.

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

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

Im Snippet oben werden zwei Parameter an den Konstruktor GoogleService übergeben. 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 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.

Der folgende Beispielcode verwendet ein authentifiziertes GoogleService-Objekt, um den Metafeed abzurufen, und gibt dann den Titel jedes Blogs aus.

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 von der Methode getFeed verwendete URL. Dies ist die Standard-Metafeed-URL. Sie gibt eine Liste von Blogs für den aktuell authentifizierten Nutzer zurück. Wenn Sie auf den Feed eines anderen Nutzers zugreifen möchten, können Sie in der Metafeed-URL anstelle von default die ID des Nutzers einfügen. Die Nutzer-ID ist die Ziffernfolge am Ende der Profil-URL des Nutzers.

Beiträge werden erstellt

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

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.

Blogposts veröffentlichen

Sie können die Java-Client-Bibliothek verwenden, um neue Blog-Einträge zu veröffentlichen.

Erstellen Sie zuerst ein Entry-Objekt, das den Blogpost darstellt. Anschließend können Sie den Titel, den Inhalt und andere Attribute des Blogposts festlegen. Verwenden Sie schließlich das Objekt GoogleService, um den Beitrag einzufügen. Hier ist ein Beispiel dafür, wie ein neuer Blogpost veröffentlicht wird:

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 so zurück, wie er von Blogger gespeichert wurde. Der zurückgegebene Eintrag ist derselbe, den Sie gesendet haben. Er enthält aber auch verschiedene von Blogger hinzugefügte Elemente, z. B. eine Post-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.

Entwurf eines Blogposts wird erstellt

Beitragsentwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Sie müssen jedoch das Attribut draft des Entry-Objekts festlegen. Sie können einen Blogpost wie den obigen 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 Post umwandeln, indem Sie den Entwurf abrufen, das Entwurfsattribut auf "false" setzen und dann den Post aktualisieren. In den nächsten beiden Abschnitten erfahren Sie, wie Sie Beiträge abrufen und aktualisieren.

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 vor dem Abrufen von Beiträgen von einem öffentlichen Blog weder die Methode setUserCredentials aufrufen noch eine AuthSub-Authentifizierung durchführen.

Alle Blogposts werden abgerufen

Wenn Sie die Beiträge des Nutzers abrufen möchten, rufen Sie dieselbe getFeed-Methode auf, die zum Abrufen des Blogs-Metafeeds verwendet wurde, aber dieses Mal die Blogpost-Feed-URL senden:

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

Wenn Sie beispielsweise eine Zeitraumabfrage senden möchten, verwenden Sie die Methoden setPublishedMin und setPublishedMax des Objekts Query. Das folgende Code-Snippet gibt den Titel jedes Blogposts aus, 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();
}

Beachten Sie, dass das Query-Objekt mit derselben Post-Feed-URL erstellt wird, die zum Abrufen von Beiträgen verwendet wird.

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

addCategoryFilter: Geben Sie Kategorien (auch Labels genannt) 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.
setMaxResults: Legen Sie die maximale Anzahl der zurückzugebenden Einträge fest.
setPublishedMin, setPublishedMax: Grenzen für die Veröffentlichungsdaten von Einträgen festlegen.
setStartIndex: Legen Sie den 1-basierten Index des ersten abzurufenden Ergebnisses fest (für die Seitenordnung).
setUpdatedMin, setUpdatedMax: Grenzen für Datumsangaben für die Aktualisierung von Einträgen festlegen. Diese Suchparameter werden ignoriert, sofern der Parameter orderby nicht auf updated festgelegt ist.

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

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 Eintrag ab, den Sie aktualisieren möchten. Anschließend ändern Sie ihn und senden ihn mit der Methode update an Blogger. Mit dem folgenden Code-Snippet wird der Titel eines Blogeintrags geändert. Dabei wird davon ausgegangen, dass Sie den Eintrag bereits vom Server abgerufen haben.

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 Code oben gibt ein Entry zurück, das den gesamten neu aktualisierten Beitrag enthält. Wenn Sie andere Attribute aktualisieren möchten, legen Sie sie einfach im Entry-Objekt fest, bevor Sie update aufrufen.

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

Beiträge werden gelöscht

Wenn du einen Beitrag löschen möchtest, übergib die Bearbeitungs-URL des Beitrags an die Methode delete auf deinem GoogleService-Objekt. Das sieht dann so aus:

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 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 Entry-Objekt und fügen Sie 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.

Kommentare werden abgerufen

Sie können die Kommentare für einen 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();
}

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

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

Kommentare werden gelöscht

Wenn Sie einen Kommentar löschen möchten, übergeben Sie die Bearbeitungs-URL des Kommentars so an die Methode delete in Ihrem GoogleService-Objekt:

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

Nach oben