Przewodnik dla programistów: Java

Ważne: 30 września 2024 r. zakończymy obsługę interfejsu Google Data API w wersji 2.0. Aby zapewnić nieprzerwany dostęp do funkcji, zaktualizuj aplikacje, które korzystają z interfejsu Google Data API w wersji 2.0, do najnowszej wersji interfejsu API. Aby uzyskać najnowszą wersję, użyj linków na pasku nawigacyjnym po lewej stronie. Uwaga: chociaż niektóre żądania GET (takie jak posty z informacjami o produktach) będą nadal obsługiwane jako kanał są pewne różnice w działaniu. Szczegółowe informacje znajdziesz w dokumentacji Blogger Help.

Interfejs API danych Bloggera pozwala aplikacjom klienckim wyświetlać i aktualizować Bloggera. w postaci kanałów interfejsu API danych Google.

Aplikacja kliencka może używać interfejsu API danych Bloggera do tworzenia nowego bloga posty, edytowanie i usuwanie istniejących postów na blogu oraz zapytania o pasujące posty na blogu określonych kryteriów.

Ten dokument zawiera informacje o możliwościach interfejsu Data API w Bloggerze oraz przykłady podstawowych interakcji z interfejsem Data API za pomocą biblioteki klienta w Javie. Jeśli chcesz dowiedzieć się więcej o podstawowym protokole używanym przez bibliotekę, zapoznaj się z sekcją dotyczącą protokołu w tym przewodniku dla deweloperów.

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 OAuth
    2. Uwierzytelnianie serwera proxy AuthSub
    3. Uwierzytelnianie za pomocą nazwy użytkownika i hasła ClientLogin
  4. Pobieram listę blogów
  5. Tworzenie postów
    1. Publikowanie posta na blogu
    2. Tworzenie szkicu posta na blogu
  6. Pobieram posty
    1. Pobieranie wszystkich wpisów na blogu
    2. Pobieranie postów za pomocą parametrów zapytania
  7. Aktualizowanie postów
  8. Usuwanie postów
  9. Komentarze
    1. Tworzenie komentarzy
    2. Pobieranie komentarzy
    3. Usuwanie komentarzy

Odbiorcy

Ten dokument jest przeznaczony dla programistów, którzy chcą napisać klienta w języku Java które mogą wchodzić w interakcję z Bloggerem.

Zakładamy w nim, że rozumiesz ogólne koncepcje stojące za interfejsami API danych Google .

Informacje referencyjne o klasach i metodach biblioteki klienta znajdziesz w dokumentacji biblioteki klienta interfejsu API w języku Java. Ogólne informacje o interfejsie API danych Bloggera więcej informacji można znaleźć w dokumentacji protokołu .

Pierwsze kroki

Więcej informacji o konfigurowaniu biblioteki klienta znajdziesz w przewodniku wdrożeniowym.

Biblioteka klienta Java wymaga wersji Java 1.5. Po pobraniu w bibliotece klienta, znajdziesz tu zajęcia, których potrzebujesz, aby rozpocząć java/lib/gdataclient-1.0.jar.

Tworzenie konta w Bloggerze

Do celów testowych możesz założyć konto Blogger. Blogger korzysta z kont Google, jeśli więc masz już konto Google, wszystko gotowe.

Uruchamianie przykładowego kodu

Pełnotekstowy działający przykładowy klient zawierający cały przykładowy kod pokazany w tym dokumencie jest dostępny w bibliotece klienta Java w katalogu gdata/java/sample/blogger/BloggerClient.java. Instrukcje kompilacji i wykonania znajdują się w tym samym katalogu w pliku README.txt.

Przykładowy klient wykonuje kilka operacji na udostępnionym blogu, aby zademonstrować użycie interfejsu API danych Bloggera.

Aby skompilować przykłady z tego dokumentu w swój własny kod, musisz użyć 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 możesz uzyskać dostęp do plików danych publicznych i prywatnych. Publiczne kanały nie wymagają uwierzytelniania, ale są tylko do odczytu. Jeśli chcesz zmodyfikować blogi, Twój klient musi się uwierzytelnić, zanim poprosi o pliki danych prywatnych. Może się uwierzytelnić za pomocą dowolnego z 3 podejść: uwierzytelniania OAuth, uwierzytelniania serwera proxy AuthSub lub uwierzytelniania ClientLogin za pomocą nazwy użytkownika i hasła.

Więcej informacji o uwierzytelnianiu za pomocą interfejsów API danych Google znajdziesz na stronie zapoznaj się z uwierzytelnianiem, dokumentacji.

W większości przykładów w kolejnych sekcjach tego dokumentu zakładamy, że uwierzytelniony obiekt GoogleService.

Uwierzytelnianie OAuth

Dokumentację dotyczącą uwierzytelniania OAuth za pomocą biblioteki GData w języku Java znajdziesz w dokumentacji OAuth w bibliotekach klienta interfejsu Google Data Protocol.

Uwierzytelnianie serwera proxy AuthSub

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

Gdy użytkownik po raz pierwszy odwiedza Twoją aplikację, nie został jeszcze uwierzytelniony. W takim przypadku musisz wyświetlić pewne informacje i link, który przekieruje użytkownika na stronę Google, gdzie będzie mógł uwierzytelnić Twoje żądanie dostępu do blogów. Biblioteka klienta w Javie zawiera funkcję generującą adres URL strony. Poniższy 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ące parametrom zapytania używanym przez program obsługi AuthSubRequest):

dalej
Adres URL strony, na którą Google ma przekierować użytkownika po uwierzytelnieniu.
zakres
Wskazuje, że aplikacja prosi o token dostępu do kanałów Bloggera. Użyj ciągu zakresu http://www.blogger.com/feeds/ (oczywiście zakodowanego w formacie URL).
Bezpieczny
Wskazuje, czy klient prosi o token zabezpieczony.
sesja
Wskazuje, czy zwrócony token można zamienić na token wielokrotnego użytku (sesji).

Powyższy przykład pokazuje wywołanie, które nie wymaga tokena zabezpieczającego (wartość secure to false). 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 do witryny Google i uwierzytelnia swoje konto Google.

Gdy użytkownik się uwierzytelni, system AuthSub przekierowuje go do adresu URL podany w parametrze zapytania next w żądaniu AuthSubRequest Adres URL. System AuthSub dołącza do tego adresu URL token uwierzytelniający jako wartość parametru zapytania token. Na przykład:

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

Ta wartość tokena reprezentuje token AuthSub jednorazowego użytku. W tym przykładzie, gdy podano session = true, token można zamienić na token sesji AuthSub, wywołując usługę AuthSubSessionToken w ten sposób: urlFromAuthSub to adres URL, do którego AuthSub dołączył token:

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

Oznacza to, że przekazujesz swój jednorazowy token Metoda exchangeForSessionToken wraz z dowolną metodą null (w przypadku trybu niezarejestrowanego) lub klucz prywatny (w przypadku trybu zarejestrowanego) i AuthSub zwraca token sesji. Więcej informacji o zarejestrowanych aplikacjach i kluczach prywatnych znajdziesz w sekcji „Podpisywanie żądań” dokumentacji AuthSub.

Aplikacja może wtedy używać tokena sesji w kolejnych interakcjach z Bloggerem. Aby umożliwić bibliotece klienta Java automatyczne wysyłanie sesji z każdym żądaniem wywołaj metodę GoogleService Metoda setAuthSubToken:

GoogleService.setAuthSubToken(sessionToken, null);

Następnie biblioteka klienta automatycznie wysyła token z każdym żądaniem.

Uwierzytelnianie za pomocą nazwy użytkownika i hasła ClientLogin

Użyj uwierzytelniania ClientLogin, jeśli Twój klient jest samodzielnym, jednoużytkownikowym klientem „zainstalowanym” (np. aplikacją na komputer). Wystarczy wywołać funkcję Metoda setUserCredentials na obiekcie GoogleService , a wszystkie późniejsze interakcje z Bloggerem będą uwierzytelniane:

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

W tym fragmencie kodu do konstruktora GoogleService przekazujemy 2 parametry. Pierwszym z nich jest nazwa funkcji z której chcemy korzystać. Drugi parametr to nazwa funkcji aplikacji w formularzu companyName–applicationName–versionID.

Więcej informacji o uwierzytelnianiu za pomocą ClientLogin, w tym przykładowe żądania i odpowiedzi, znajdziesz w dokumentacji Uwierzytelnianie w zainstalowanych aplikacjach.

Uwaga: używaj tego samego tokena do wszystkich żądań w danej sesji. Nie pobieraj nowego tokena dla każdego żądania Bloggera.

Uwaga: zgodnie z opisem na stronie ClientLogin dokumentacji, może się to nie udać i pojawi się żądanie CAPTCHA do wyzwania. Jeśli chcesz, aby Google wyświetlał i obsługiwał test CAPTCHA, prześlij użytkownika do https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger(zamiast do adresu URL obsługiwanego przez CAPTCHA podanego w dokumentacji ClientLogin).

Pobieranie listy blogów

Interfejs API danych Bloggera udostępnia kanał z listą blogów o określonej tematyce user; jest nazywany „metakanałem”.

Ten przykładowy kod korzysta z uwierzytelnionego GoogleService w celu pobrania metakanału, a następnie wydrukuje tytuł każdego 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 przez metodę getFeed. To domyślny URL metafeedu; zwraca listę blogów dla aktualnie uwierzytelnionego użytkownika. Aby uzyskać dostęp do pliku danych innego użytkownika, możesz podać jego identyfikator zamiast znaku default w adresie URL metapliku danych. Identyfikator użytkownika jest ciągiem cyfr na końcu adresu URL profilu użytkownika.

Tworzenie postów

Interfejs API danych Bloggera umożliwia tworzenie i publikowanie nowych wpisów na blogu, oraz tworzenie wersji roboczych wpisów.

Uwaga: nie można obecnie ustawić niestandardowego autora postów. Wszystkie nowe posty będą wyświetlane tak, jakby zostały utworzone przez: aktualnie uwierzytelnionego użytkownika.

Publikowanie posta na blogu

Możesz używać biblioteki klienta Java do publikowania nowych wpisów na blogu.

Najpierw utwórz obiekt Entry reprezentujący post na blogu. Następnie możesz ustawić tytuł, treść i inne atrybuty posta na blogu. Na koniec użyj obiektu GoogleService, aby wstawić post. Oto przykład, jak opublikować nowy post 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 przyjmuje jako parametr adres URL przesyłanego elementu usługi. Następnie metoda zwraca wpis w postaci, w której został zapisany przez Bloggera. Wpis jest zwracany przez Ciebie, ale zawiera też różne dodane elementy przez Bloggera, np. identyfikator posta.

Jeśli z jakiegoś powodu nie uda się zrealizować żądania, Blogger może zwrócić inny kod stanu. Informacje o kodach stanu można znaleźć w sekcji Dane Google Dokument z dokumentacją protokołu API.

Tworzenie wersji roboczej posta na blogu

Wersje robocze postów tworzy się tak samo jak posty publiczne, ale musisz skonfigurować atrybut draft obiektu Entry. Możesz utworzyć post na blogu podobny do tego powyżej jako wersję roboczą, dodając wyróżniony 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 przekształcić istniejącą wersję roboczą posta na blogu w opublikowanego posta, pobierając wersji roboczej posta, ustawiając atrybut wersja robocza na „false”, a następnie aktualizując na blogu. Pobieranie i aktualizowanie postów zostanie omówione w następnych dwóch sekcjach.

Pobieranie postów

W kolejnych sekcjach opisano sposób pobierania listy postów na blogu, przy czym i bez parametrów zapytania.

Możesz wysyłać zapytania do publicznego kanału Bloggera bez uwierzytelniania. Dlatego przed pobraniem postów z publicznego bloga nie musisz wywoływać metody setUserCredentials ani przeprowadzać uwierzytelniania AuthSub.

Pobieranie wszystkich wpisów na blogu

Aby pobrać posty użytkownika, wywołaj tę samą metodę getFeed, która służy do pobierania metadanych blogów, ale tym razem prześlij adres URL kanału postów na blogu:

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 za pomocą parametrów zapytania

Interfejs Blogger Data API umożliwia żądanie zestawu wpisów, które odpowiadają określonym kryteriam, np. żądanie postów z bloga opublikowanych lub zaktualizowanych w określonym przedziale czasowym. W tym celu utwórz obiekt Query i przekaż go do Metoda GoogleService.getQuery.

Aby na przykład wysłać zapytanie dotyczące zakresu dat, użyj metod setPublishedMin i setPublishedMax obiektu Query. Ten fragment kodu umożliwia wydrukowanie tytułu każdego posta na blogu opublikowanego między tagami dla danej godziny rozpoczęcia i zakończenia:

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 pliku danych postów, który służy do pobierania postów.

Interfejs API danych Bloggera obsługuje następujące metody metody Query:

addCategoryFilter
Określ kategorie (zwane też etykietami), aby filtrować wyniki w 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ę zwracanych wpisów.
setPublishedMin, setPublishedMax
Określ granice dat publikacji wpisów.
setStartIndex
Ustaw indeks pierwszego wyniku do pobrania (na potrzeby stronicowania) oparty na 1.
setUpdatedMin, setUpdatedMax
Określ granice dat aktualizacji wpisów. Te parametry zapytania są ignorowane, chyba że parametr orderby ma wartość updated.

Uwaga: obecnie nie ma ustawień parametru zapytania orderby. Nadal możesz jednak używać usługi Query.addCustomParameter().

Więcej informacji o parametrach zapytań znajdziesz w przewodniku po interfejsie Blogger Data API oraz w przewodniku po interfejsach Google Data API.

Aktualizuję posty

Aby zaktualizować istniejący post na blogu, najpierw pobierz wpis, który chcesz ją zaktualizować i przesłać do Bloggera za pomocą Metoda update. Ten fragment kodu zmienia tytuł 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 cały nowo zaktualizowany post. Aby zaktualizować inne właściwości, wystarczy ustawić je w Entry obiekt przed wywołaniem update.

Uwaga: zmiana danych o autorze powiązanych z Posty nie są obecnie obsługiwane.

Usuwam posty

Aby usunąć posta, przekaż jego adres URL edycji do metody delete na obiekcie GoogleService w ten sposób:

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 (nie jest też dostępna w przeglądarce) ).

Tworzenie komentarzy

Aby opublikować komentarz, utwórz obiekt Entry i wstaw go w ten 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 możesz tylko publikować komentarze w blogu należącym do uwierzytelnionego użytkownika.

Uwaga: nie można obecnie ustawić niestandardowego autora komentarzy. Wszystkie nowe komentarze będą wyświetlane tak, jakby zostały utworzone przez użytkownika aktualnie uwierzytelnionego użytkownika.

Pobieranie komentarzy

Komentarze do konkretnego posta możesz pobrać za pomocą adresu URL kanału komentarzy pod postem:

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ż uzyskać komentarze do wszystkich postów, używając adresu URL kanału komentarzy bloga:

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

Usuwanie komentarzy

Aby usunąć komentarz, przekaż jego adres URL edycji do funkcji delete na obiekcie GoogleService w taki 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