Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerleitfaden: Java

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

Ihre Clientanwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und nach Blogposts zu suchen, die bestimmten Kriterien entsprechen.

Neben Informationen zu den Möglichkeiten der Blogger Data API enthält dieses Dokument auch Beispiele für grundlegende Data API-Interaktionen mit der Java-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das in der Bibliothek verwendet wird, finden Sie im Abschnitt zum Protokoll in diesem Entwicklerleitfaden.

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

Referenzinformationen zu den Klassen und Methoden der Clientbibliothek finden Sie in der API-Referenz zur Java-Clientbibliothek. Allgemeine Informationen zur Blogger Data API finden Sie im Protokollreferenzleitfaden.

Erste Schritte

Hilfe zum Einrichten der Clientbibliothek finden Sie im Startleitfaden.

Für die Java-Clientbibliothek ist Java 1.5 erforderlich. Nachdem Sie die Clientbibliothek heruntergeladen haben, finden Sie die für den Einstieg erforderlichen Kurse in der Datei java/lib/gdataclient-1.0.jar.

Blogger-Konto erstellen

Du kannst dich auch für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn Sie also bereits ein Google-Konto haben, müssen Sie nichts weiter tun.

Beispielcode ausführen

Ein voll funktionsfähiger Beispielclient, der den gesamten in diesem Dokument gezeigten Beispielcode enthält, ist in der Java-Clientbibliothek unter dem Verzeichnis gdata/java/sample/blogger/BloggerClient.java verfügbar. Build- und Ausführungsanweisungen sind im selben Verzeichnis in der Datei README.txt enthalten.

Der Beispielclient führt im angegebenen 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 in 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;

Authentifizierung beim Blogger-Dienst

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 schreibgeschützt. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor du private Feeds anfordern kannst. Für die Authentifizierung gibt es drei Möglichkeiten: die OAuth-Authentifizierung, die AuthSub-Proxyauthentifizierung oder die ClientLogin-Authentifizierung für Nutzernamen und Passwörter.

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

Bei den meisten Beispielen in nachfolgenden Abschnitten dieses Dokuments wird davon ausgegangen, dass Sie ein authentifiziertes GoogleService-Objekt haben.

OAuth-Authentifizierung

Informationen zur OAuth-Authentifizierung mit der Java GData-Bibliothek finden Sie unter OAuth in den Google Data Protocol-Clientbibliotheken.

AuthSub-Proxy-Authentifizierung

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

Wenn ein Nutzer Ihre Anwendung zum ersten Mal aufruft, wurde er noch nicht authentifiziert. In diesem Fall musst du einige Informationen und einen Link anzeigen, der den Nutzer zu einer Google-Seite weiterleitet, damit deine Zugriffsanfrage für seine Blogs authentifiziert werden kann. Die Java-Clientbibliothek bietet eine Funktion, mit der die URL der Google-Seite generiert werden kann. 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 (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).
geschützt?: Gibt an, ob der Client ein sicheres Token anfordert.
session: Gibt an, ob das zurückgegebene Token gegen ein Mehrzwecktoken (Sitzungsversion) eingetauscht werden kann.

Das obige Beispiel zeigt einen Aufruf, der kein sicheres Token anfordert (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 werden sie vom AuthSub-System an die URL weitergeleitet, die Sie im Abfrageparameter next der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt als Wert des Abfrageparameters token ein Authentifizierungstoken an diese URL an. Beispiel:

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

Dieser Tokenwert stellt ein Einweg-Token für die einmalige Verwendung dar. Da in diesem Beispiel session = true angegeben wurde, kann dieses Token gegen ein AuthSub-Sitzungstoken eingetauscht werden. Rufen Sie dazu den Dienst AuthSubSessionToken auf, wobei urlFromAuthSub die URL ist, an die AuthSub das Token angehängt hat:

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

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

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

GoogleService.setAuthSubToken(sessionToken, null);

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

Authentifizierung mit Nutzername/Passwort für ClientLogin

Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger, einzelner Nutzerclient ist, z. B. eine Desktopanwendung. Rufen Sie einfach die Methode setUserCredentials für das Objekt GoogleService 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 geben wir zwei Parameter an den Konstruktor GoogleService weiter. Der erste Parameter ist der Name des Dienstes, mit dem Sie 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 für alle Anfragen in einer bestimmten Sitzung dasselbe Token. Erhalten Sie nicht für jede Blogger-Anfrage ein neues Token.

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, schlägt die Authentifizierungsanfrage möglicherweise fehl und fordert ein CAPTCHA an. Wenn Google die CAPTCHA-Abfrage ausstellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter anstatt zur in der ClientLogin-Dokumentation angegebenen CAPTCHA-Verarbeitungs-URL.

Liste von Blogs abrufen

Die Blogger Data API bietet einen Feed, in dem die Blogs eines bestimmten Nutzers aufgelistet werden. Dieser Feed wird als Metametafeed bezeichnet.

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

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. Um auf einen Feed für einen anderen Nutzer zuzugreifen, können Sie die ID des Nutzers anstelle von default in der Meta-Feed-URL angeben. 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 sowohl neue Blogeinträge als auch Entwürfe erstellen und veröffentlichen.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Beiträge wird derzeit nicht unterstützt. Alle neuen Beiträge sehen so aus, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.

Blogpost veröffentlichen

Sie können die Java-Clientbibliothek verwenden, um neue Blogeinträge zu veröffentlichen.

Erstelle zuerst ein Entry-Objekt, das den Blogpost darstellt. Anschließend kannst du den Titel, den Inhalt und andere Attribute des Blogposts festlegen. Verwenden Sie abschließend das Objekt GoogleService, 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 Beitrags-URL des Dienstes als Parameter. Die Methode gibt dann den Eintrag so zurück, wie er in Blogger gespeichert wurde. Der zurückgegebene Eintrag ist der gleiche, den Sie gesendet haben, er enthält aber auch verschiedene von Blogger hinzugefügte Elemente wie 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 in der Referenzdokumentation zum Google Data API-Protokoll.

Blogpostentwurf erstellen

Entwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Sie müssen jedoch das Attribut draft des Objekts Entry 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 in einen veröffentlichten Beitrag umwandeln. Rufen Sie dazu den Entwurfsbeitrag ab, setzen Sie das Entwurfsattribut auf „false“ und aktualisieren Sie dann den Beitrag. 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 Suchparameter abrufen.

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher musst du die Methode setUserCredentials nicht aufrufen und keine AuthSub-Authentifizierung durchführen, bevor du Beiträge von einem öffentlichen Blog abrufen kannst.

Alle Blogposts werden abgerufen

Um die Posts des Nutzers abzurufen, rufe dieselbe getFeed-Methode auf, die zum Abrufen des Blog-Metafeeds verwendet wird. Dieses Mal senden Sie jedoch die Blogpost-Feed-URL:

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 mit Suchparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. das Anfordern von Blogposts, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden. Erstellen Sie dazu ein Query-Objekt und übergeben Sie es an die Methode GoogleService.getQuery.

Verwenden Sie beispielsweise zum Senden einer Zeitraumabfrage die Methoden setPublishedMin und setPublishedMax des Objekts Query. Das folgende Code-Snippet gibt den Titel jedes Blogposts aus, der zwischen dem angegebenen Start- und Enddatum 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 Beitrags-URL erstellt, die zum Abrufen von Beiträgen verwendet wurde.

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

Kategoriefilter hinzufügen: Geben Sie Kategorien (auch Labels) an, um die Feedergebnisse zu filtern. http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt beispielsweise Einträge mit den Labels Fritz und Laurie zurück.
Maximale Ergebnisse festlegen: Legen Sie die maximale Anzahl der Einträge fest, die zurückgegeben werden sollen.
setPublishMin, setPublishMax: Die Grenzen für die Veröffentlichungstermine von Beiträgen festlegen.
setStartIndex: Legen Sie den 1-basierten Index des ersten abzurufenden Ergebnisses fest (für das Paging).
setUpdatedMin, setUpdatedMax: Die Grenzen für die Aktualisierung von Einträgen festlegen. Diese Suchparameter werden ignoriert, sofern der Parameter orderby nicht auf updated gesetzt ist.

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

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

Beiträge werden aktualisiert

Zum Aktualisieren eines vorhandenen Blogposts rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten. Dann ändern Sie ihn und senden ihn dann mithilfe der Methode update an Blogger. Das folgende Code-Snippet ändert den Titel eines Blogeintrags unter der Annahme, dass du den Eintrag bereits vom Server abgerufen hast.

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

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

Beiträge löschen

Wenn Sie einen Beitrag löschen möchten, übergeben Sie die Bearbeitungs-URL des Beitrags an die Methode delete Ihres GoogleService-Objekts. 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 weder unterstützt noch in der 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 in einem Blog nur Kommentare veröffentlichen, deren Inhaber der authentifizierte Nutzer ist.

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

Kommentare werden abgerufen

So kannst du die Kommentare für einen bestimmten Beitrag über die Feed-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();
}

Du kannst auch die Kommentare zu allen Beiträgen über die Kommentar-Feed-URL des Blogs abrufen:

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

Kommentare löschen

Übergib den Bearbeitungs-URL des Kommentars an die Methode delete deines GoogleService-Objekts, um einen Kommentar zu löschen:

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

Nach oben