Przewodnik dla programistów: Java

Ważne: to jest stara wersja tej strony. Aby użyć najnowszej wersji, kliknij linki na pasku nawigacyjnym po lewej stronie.

Interfejs API danych Bloggera umożliwia aplikacjom klienckim wyświetlanie i aktualizowanie treści z Bloggera w postaci kanałów interfejsu API danych Google.

Aplikacja kliencka może używać interfejsu Blogger Data API do tworzenia nowych postów na blogu, edytowania i usuwania dotychczasowych postów oraz wysyłania zapytań dotyczących postów na blogu odpowiadających konkretnym kryteriom.

Znajdziesz w nim nie tylko informacje o możliwościach interfejsu API danych Bloggera, ale także przykłady podstawowych interakcji z interfejsem Data API za pomocą biblioteki klienta Java. Jeśli chcesz dowiedzieć się więcej o podstawowym protokole, z którego korzysta biblioteka, zapoznaj się z sekcją Protokoł w tym przewodniku.

Spis treści

  1. Odbiorcy
  2. Pierwsze kroki
    1. Tworzenie konta Bloggera
    2. Uruchamianie przykładowego kodu
  3. Uwierzytelnianie w usłudze Blogger
    1. Uwierzytelnianie serwera proxy OAuthSub
    2. Uwierzytelnianie nazwy użytkownika i hasła klienta logowania
  4. Pobieranie listy blogów
  5. Tworzenie postów
    1. Publikowanie posta na blogu
    2. Tworzenie wersji roboczej posta na blogu
  6. Pobieranie postów
    1. Pobieranie wszystkich postów na blogu
    2. Pobieranie postów z parametrami zapytania
  7. Aktualizowanie postów
  8. Usuwanie postów
  9. Komentarze
    1. Tworzenie komentarzy
    2. Pobieranie komentarzy
    3. Usuwanie komentarzy

Odbiorców

Ten dokument jest przeznaczony dla programistów, którzy chcą tworzyć aplikacje klienckie Java, które mogą współpracować z Bloggerem.

W tym dokumencie zakładamy, że rozumiesz ogólne pomysły związane z protokołem interfejsów API danych Google.

Więcej informacji o klasach i metodach dostępnych w bibliotece klienta znajdziesz w dokumentacji interfejsu API biblioteki klienta w języku Java. Ogólne informacje o interfejsie API danych Bloggera znajdziesz w przewodniku po protokołach.

Pierwsze kroki

Aby uzyskać pomoc w konfigurowaniu biblioteki klienta, przeczytaj Przewodnik dla początkujących.

Biblioteka klienta Java wymaga środowiska Java 1.5. Po pobraniu biblioteki klienta znajdziesz w pliku java/lib/gdataclient-1.0.jar klasy, których potrzebujesz.

Tworzenie konta w Bloggerze

Jeśli chcesz, możesz założyć konto w Bloggerze na potrzeby testów. Blogger korzysta z kont Google, więc jeśli masz już konto Google, masz wszystko gotowe.

Uruchamianie przykładowego kodu

W pełni działający przykładowy klient, który zawiera cały przykładowy kod widoczny w tym dokumencie, jest dostępny w dystrybucji biblioteki klienta w języku Java w katalogu gdata/java/sample/blogger/BloggerClient.java. Instrukcje kompilacji i wykonywania są zawarte w tym samym katalogu w pliku README.txt.

Przykładowy klient wykonuje kilka operacji na blogu, aby pokazać, jak można korzystać z interfejsu Blogger Data API.

Aby połączyć przykłady w tym dokumencie do własnego kodu, potrzebujesz tych instrukcji import:

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

Uwierzytelnianie w usłudze Blogger

Za pomocą interfejsu Blogger Data API masz dostęp do kanałów publicznych i prywatnych. Publiczne kanały nie wymagają uwierzytelniania, ale są tylko do odczytu. Jeśli chcesz zmodyfikować blogi, klient musi uwierzytelnić się przed wysłaniem żądania prywatnych kanałów. Może uwierzytelniać się na jeden z 2 sposobów: za pomocą serwera proxy AuthSub lub ClientLogin, za pomocą nazwy użytkownika i hasła.

Więcej ogólnych informacji o uwierzytelnianiu za pomocą interfejsów Google Data API znajdziesz w dokumentacji uwierzytelniania.

Większość przykładów w kolejnych sekcjach tego dokumentu zakłada, że masz uwierzytelniony obiekt GoogleService.

Uwierzytelnianie serwera proxy AuthSub

Uwierzytelnianie serwera proxy AuthSub jest używane przez aplikacje internetowe, które muszą uwierzytelniać użytkowników na kontach Google. Operator witryny i kod klienta nie mają dostępu do nazwy użytkownika ani hasła użytkownika Bloggera. Zamiast tego klient otrzymuje specjalne tokeny uwierzytelniania, które pozwalają klientowi działać w imieniu konkretnego użytkownika. Więcej informacji znajdziesz w dokumentacji AuthSub.

Gdy użytkownik po raz pierwszy odwiedzi Twoją aplikację, nie zostanie on jeszcze uwierzytelniony. W takim przypadku musisz wyświetlić pewne informacje i link kierujący użytkownika na stronę Google, aby uwierzytelnić prośbę o dostęp do bloga. Biblioteka klienta w Javie umożliwia wygenerowanie adresu URL strony Google. Ten kod pobiera adres URL strony AuthSubRequest:

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

Metoda getRequestUrl przyjmuje te parametry (odpowiadają parametrom zapytania używanym przez moduł obsługi AuthSubRequest):

dalej
Adres URL strony, na którą Google ma przekierować użytkownika po uwierzytelnianiu.
zakres
Wskazuje, że aplikacja żąda tokena dostępu do kanałów Bloggera. Zakres zakresu do użycia to http://www.blogger.com/feeds/ (oczywiście zakodowany na potrzeby adresu URL).
Bezpieczny
Wskazuje, czy klient żąda bezpiecznego tokena.
sesja
Wskazuje, czy zwrócony token można wymienić na token wielokrotnego użytku (sesja).

W przykładzie powyżej pojawia się wywołanie, które nie wymaga bezpiecznego tokena (wartość secure to false). Otrzymany adres URL żądania może wyglądać tak:

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

Użytkownik klika link prowadzący do witryny Google i uwierzytelnia się na koncie Google.

Gdy użytkownik się uwierzytelni, system AuthSub przekierowuje go do adresu URL określonego w parametrze zapytania next AuthSubRequest. System AuthSub dodaje do tego adresu URL token uwierzytelniający jako wartość parametru zapytania token. Przykład:

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

Ta wartość odpowiada pojedynczemu tokenowi AuthSub. W tym przykładzie, ponieważ określono session = true token, można go wymienić na token sesji AuthSub, wywołując usługę AuthSubSessionToken w następujący sposób, gdzie urlFromAuthSub jest adresem URL, do którego token przypisał AuthSub:

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

Oznacza to, że przekazujesz token jednorazowy do metody exchangeForSessionToken wraz z null (w trybie niezarejestrowanym) lub prywatnym (w przypadku trybu zarejestrowanego), a interfejs AuthSub zwraca token sesji. Więcej informacji o zarejestrowanych aplikacjach i kluczach prywatnych znajdziesz w sekcji "Podpisywanie żądań w dokumentacji AuthSub.

Aplikacja może następnie użyć tokena sesji w kolejnych interakcjach z Bloggerem. Aby poinformować bibliotekę klienta Java o automatycznym wysyłaniu sesji przy każdym żądaniu, wywołaj metodę GoogleService obiektu setAuthSubToken:

GoogleService.setAuthSubToken(sessionToken, null);

Potem biblioteka klienta automatycznie wysyła token wraz z każdym żądaniem.

Uwierzytelnianie nazwy użytkownika i hasła klienta

Użyj uwierzytelniania ClientLogin, jeśli klient jest oddzielnym klientem (instalowanym przez klienta (np. aplikacją komputerową). Wystarczy, że wywołasz metodę setUserCredentials w obiekcie GoogleService, a wszystkie kolejne interakcje z Bloggerem będą uwierzytelnione:

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

W powyższym fragmencie kodu przekazujemy do konstruktora GoogleService dwa parametry. Pierwszy parametr to nazwa usługi, z którą mamy współpracować. Drugi parametr to nazwa aplikacji w formacie companyName-applicationName-versionID.

Więcej informacji o uwierzytelnianiu za pomocą ClientLogin, w tym przykładowych żądaniach i odpowiedziach, znajdziesz w dokumentacji dotyczącej uwierzytelniania zainstalowanych aplikacji.

Uwaga: użyj tego samego tokena dla wszystkich żądań w określonej sesji. Nie zdobywaj nowego tokena dla każdego żądania Bloggera.

Uwaga: jak opisano w dokumentacji ClientLogin, żądanie uwierzytelniania może się nie powieść i zażądać testu CAPTCHA. Jeśli chcesz, aby test CAPTCHA był przeprowadzany i obsługiwany przez tę funkcję, wyślij użytkownika na adres https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (zamiast na adres URL obsługi CAPTCHA podany w dokumentacji ClientLogin).

Pobieranie listy blogów

Interfejs Blogger Data API zapewnia kanał z listą blogów wybranego użytkownika. Ten kanał jest nazywany „"metafeed."

Przykładowy kod używa uwierzytelnionego obiektu GoogleService do pobrania metatagu, a następnie drukuje każdy tytuł bloga.

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());
  }
}

Zapisz adres URL używany w metodzie getFeed. Jest to domyślny adres URL metatagu, który zawiera listę blogów aktualnie uwierzytelnionego użytkownika. Aby uzyskać dostęp do kanału innego użytkownika, możesz umieścić w metatagu adres URL identyfikatora użytkownika w miejscu default. Identyfikator użytkownika to ciąg cyfr na końcu adresu URL profilu użytkownika.

Tworzenie postów

Interfejs API danych Bloggera umożliwia tworzenie i publikowanie nowych postów w blogach oraz tworzenie wersji roboczych wpisów.

Uwaga: ustawianie niestandardowego autora postów jest obecnie niemożliwe. Wszystkie nowe wpisy będą wyglądać tak, jakby zostały utworzone przez aktualnie uwierzytelnionego użytkownika.

Publikowanie posta na blogu

Dzięki bibliotece klienta Java możesz publikować nowe posty na blogu.

Najpierw utwórz obiekt Entry reprezentujący posta na blogu. Następnie możesz ustawić tytuł, treść i inne atrybuty posta na blogu. Na koniec użyj obiektu GoogleService, aby wstawić posta. Oto przykład publikacji nowego posta na blogu:

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);
}

Metoda insert pobiera adres URL posta w usłudze jako parametr. Następnie metoda zwraca wpis zapisany w Bloggerze. Zwrócony wpis to taki, który został wysłany, ale zawiera też różne elementy dodane przez Bloggera, takie jak identyfikator posta.

Jeśli z jakiegoś powodu żądanie się nie powiedzie, Blogger może zwrócić inny kod stanu. Więcej informacji o kodach stanu znajdziesz w dokumentacji referencyjnej protokołu API danych Google.

Tworzenie wersji roboczej posta na blogu

Wersje robocze postów są tworzone w taki sam sposób jak posty publiczne, ale musisz ustawić atrybut draft obiektu Entry. Post na blogu możesz utworzyć jako wersję roboczą powyżej, dodając zaznaczony wiersz:

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);
}

Możesz zmienić istniejącego posta w blogu w opublikowany post, pobierając wersję roboczą posta, ustawiając atrybut wersji roboczej na fałsz, a następnie aktualizując posta. W kolejnych 2 sekcjach omówimy pobieranie i aktualizowanie postów.

Pobieram posty

W sekcjach poniżej opisujemy, jak pobrać listę postów na blogu z parametrami zapytania i bez nich.

Do zapytań dotyczących publicznych kanałów Bloggera możesz wysyłać zapytania bez uwierzytelniania. W takiej sytuacji nie musisz wywoływać metody setUserCredentials ani uwierzytelniania AuthSub przed pobieraniem postów z publicznego bloga.

Pobieranie wszystkich postów na blogu

Aby pobrać posty użytkownika, użyj tej samej metody getFeed w celu pobrania metatagu kanału, ale tym razem wyślij URL kanału:

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();
}

Pobieranie postów z wykorzystaniem parametrów zapytania

Interfejs API danych Bloggera umożliwia żądanie zestawu wpisów spełniających określone kryteria, takich jak żądania postów opublikowanych na blogu lub opublikowanych w danym zakresie dat. Aby to zrobić, utwórz obiekt Query i przekaż go do metody GoogleService.getQuery.

Aby na przykład wysłać zapytanie dotyczące zakresu dat, użyj metod setPublishedMin i setPublishedMax obiektu Query. Ten fragment kodu powoduje wyświetlenie tytułu każdego posta opublikowanego między czasem rozpoczęcia a zakończeniem:

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();
}

Zwróć uwagę, że obiekt Query jest tworzony przy użyciu tego samego adresu URL kanału postów, który był używany do pobierania postów.

Interfejs API danych Bloggera obsługuje te metody Query:

dodaj filtr kategorii
Określ kategorie (zwane też etykietami), aby filtrować wyniki pliku danych. Na przykład http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie zwraca wpisy z etykietami Fritz i Laurie.
SetMaxResults
Ustaw maksymalną liczbę elementów do zwrócenia.
setpublishedMin, setpublishedMax
Ustaw limity dat publikacji.
setStartIndex
Ustaw indeks 1 dla pierwszego wyniku do pobrania (na potrzeby stronicowania).
setUpdatedMin., setUpdateMax
Ustaw limity dat aktualizacji wpisu. Te parametry zapytania są ignorowane, chyba że parametr orderby jest ustawiony na updated.

Uwaga: obecnie nie ma ustawień dla parametru zapytania orderby. Jeśli jest taka potrzeba, nadal możesz użyć metody Query.addCustomParameter().

Więcej informacji o parametrach zapytań znajdziesz w Przewodniku po interfejsach API danych Bloggera i w przewodniku po interfejsach Google Data API.

Aktualizowanie postów

Aby zaktualizować istniejącego posta na blogu, najpierw pobierz wpis, który chcesz zaktualizować, zmodyfikuj go, a następnie wyślij do Bloggera za pomocą metody update. Ten fragment kodu powoduje zmianę tytułu posta na blogu przy założeniu, że został on już pobrany z serwera.

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);
}

Powyższy kod zwraca Entry zawierający nowy wpis. Aby zaktualizować pozostałe właściwości, po prostu ustaw je w obiekcie Entry przed wywołaniem funkcji update.

Uwaga: modyfikowanie danych autora powiązanych z postami nie jest obecnie obsługiwane.

Usuwanie postów

Aby usunąć posta, przekaż jego adres URL do metody delete w obiekcie GoogleService. Przykład:

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

Komentarze

Interfejs API danych Bloggera umożliwia tworzenie, pobieranie i usuwanie komentarzy. Aktualizowanie komentarzy nie jest obsługiwane (także w interfejsie internetowym).

Tworzenie komentarzy

Aby opublikować komentarz, utwórz obiekt Entry i wstaw go w następujący sposób:

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);
}

Uwaga: obecnie komentarze można publikować tylko na blogu należącym do uwierzytelnionego użytkownika.

Uwaga: ustawianie autora niestandardowego dla komentarzy nie jest obecnie obsługiwane. Wszystkie nowe komentarze będą wyglądać tak, jakby zostały utworzone przez aktualnie uwierzytelnionego użytkownika.

Pobieranie komentarzy

Możesz pobrać komentarze do konkretnego posta z adresu URL kanału komentarzy:

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();
}

Możesz też wyświetlić komentarze ze wszystkich postów, korzystając z adresu URL kanału komentarzy:

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

Usuwanie komentarzy

Aby usunąć komentarz, przekaż jego URL edycji do metody delete w obiekcie GoogleService w następujący sposób:

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

Powrót do góry