Ta strona została przetłumaczona przez Cloud Translation API.

Przewodnik dla programistów: protokół

Ważne: to jest stara wersja tej strony. Aby uzyskać najnowszą wersję, użyj linków na pasku nawigacyjnym po lewej stronie.

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

Aplikacja kliencka Bloggera może używać interfejsu API danych Bloggera do tworzenia nowych postów na blogu, edytowania i usuwania istniejących postów, a także wysyłania zapytań o posty spełniające określone kryteria.

Poza omówieniem możliwości interfejsu API danych Bloggera, dokument ten przedstawia przykłady podstawowych interakcji interfejsu Data API z wykorzystaniem nieprzetworzonego kodu XML i protokołu HTTP. Z tego dokumentu dowiesz się więcej o interakcji z interfejsem API za pomocą bibliotek klienta, zapoznając się z sekcjami poświęconymi programowaniu w tym przewodniku.

Spis treści

Odbiorcy

Ten dokument jest przeznaczony dla programistów, którzy chcą pisać aplikacje klienckie wchodzące w interakcje z Bloggerem za pomocą kodu XML i HTTP.

Zakładamy w nim, że rozumiesz ogólne koncepcje protokołu interfejsów API danych Google.

Jeśli używasz systemu UNIX i chcesz wypróbować przykłady z tego dokumentu bez konieczności pisania kodu, przydatne mogą być narzędzia wiersza poleceń UNIX curl lub wget. Więcej informacji znajdziesz na stronach z instrukcjami tych narzędzi.

Informacje referencyjne na temat interfejsu API danych Bloggera znajdziesz w Przewodniku po protokole.

Pierwsze kroki

Tworzenie konta w Bloggerze

Aby przeprowadzić testy, możesz założyć konto Bloggera. Blogger korzysta z kont Google, więc jeśli już masz konto Google, nie musisz nic robić.

Uwierzytelnianie w usłudze Blogger

Interfejs API danych Bloggera umożliwia dostęp zarówno do publicznych, jak i prywatnych kanałów. Publiczne kanały nie wymagają uwierzytelniania, ale są tylko do odczytu. Jeśli chcesz zmodyfikować blogi, Twój klient musi się uwierzytelnić przed wysłaniem prośby o dostęp do kanałów prywatnych. Może uwierzytelniać się z użyciem 2 sposobów: uwierzytelniania serwera proxy AuthSub lub uwierzytelniania ClientLogin przy użyciu nazwy użytkownika i hasła.

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

Większość przykładów w kolejnych sekcjach tego dokumentu zakłada, że stosujesz odpowiednie uwierzytelnianie.

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 i hasła Bloggera. Zamiast tego klient uzyskuje specjalne tokeny AuthSub, które umożliwiają klientowi działanie w imieniu konkretnego użytkownika. Szczegółowe informacje znajdziesz w dokumentacji AuthSub.

Gdy użytkownik po raz pierwszy odwiedza Twoją aplikację, nie jest jeszcze uwierzytelniony. W takim przypadku musisz podać informacje i link przekierowujący użytkownika do strony Google, aby uwierzytelnić prośbę o dostęp do jego blogów.

W adresie URL AuthSubRequest znajdują się następujące parametry zapytania:

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. Ciąg zakresu, którego chcesz użyć, to http://www.blogger.com/feeds/ (oczywiście zakodowany pod adresem URL).
Bezpieczny: Wskazuje, czy klient prosi o bezpieczny token.
sesja: Wskazuje, czy zwrócony token można wymienić na token wielokrotnego użytku (sesyjny).

Adres URL żądania AuthSubRequest 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 się na swoim koncie Google.

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

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

Ta wartość tokena reprezentuje jednorazowy token AuthSub. W tym przykładzie, ponieważ określono session=1, token sesji można wymienić na token sesji AuthSub, wywołując usługę AuthSubSessionToken z tokenem jednorazowego użytku w nagłówku autoryzacji w następujący sposób:

GET /accounts/AuthSubSessionToken HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourAuthToken"
User-Agent: Java/1.5.0_06
Host: www.google.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

Odpowiedź usługi AuthSubSessionToken zawiera nagłówek Token zawierający token sesji oraz nagłówek Expiration, który wskazuje, jak długo token pozostaje ważny.

Twoja aplikacja może następnie używać wartości tokena sesji w nagłówku Authorization podczas kolejnych interakcji z Bloggerem.

Oto przykład żądania HTTP zawierającego niezabezpieczony token, które można wysłać do Bloggera:

GET /feeds/blogID/blogs/posts/defaults HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourSessionToken"
User-Agent: Java/1.5.0_06
Host: www.blogger.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

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

Użyj uwierzytelniania ClientLogin, jeśli klient jest samodzielnym, „zainstalowanym” klientem „zainstalowanym” przez pojedynczego użytkownika (np. aplikacją komputerową). Aby poprosić o token uwierzytelniania przy użyciu mechanizmu ClientLogin, wyślij żądanie POST na ten adres URL:

https://www.google.com/accounts/ClientLogin

Treść POST powinna zawierać zestaw parametrów zapytania, które wyglądają jak parametry przekazywane przez formularz HTML o typie treści application/x-www-form-urlencoded. Są to:

Wyślij e-mailem: Adres e-mail użytkownika.
Hasło: Hasło użytkownika.
usługa: Nazwa usługi Blogger to blogger. Listę innych nazw usług znajdziesz na liście nazw usług.
accountType: Gdy używasz interfejsu Blogger API, zawsze powinna być ustawiona wartość GOOGLE. Jeśli nie ustawisz tego parametru, dostęp do niego będą mieli osoby, które mają też konto G Suite.
source: Identyfikuje aplikację kliencką. Powinien mieć postać companyName-applicationName-versionID. W przykładach jest to exampleCo-exampleApp-1.

Więcej informacji o parametrach znajdziesz w dokumencie Uwierzytelnianie zainstalowanych aplikacji.

Jeśli żądanie uwierzytelnienia nie powiedzie się, serwer zwraca kod stanu HTTP 403 Forbidden.

Jeśli operacja się uda, serwer zwróci kod stanu HTTP 200 OK oraz 3 długie kody alfanumeryczne w treści odpowiedzi: SID, LSID i Auth. Wartość Auth to token autoryzacji, który wysyłasz do Bloggera z każdym kolejnym żądaniem, dlatego zachowaj kopię tej wartości. Możesz ignorować wartości SID i LSID.

Ponieważ wszystkie żądania wysyłane do prywatnych kanałów wymagają uwierzytelniania, nagłówek autoryzacji musisz ustawić we wszystkich kolejnych interakcjach z Bloggerem, używając tego formatu:

Authorization: GoogleLogin auth=yourAuthToken

Gdzie yourAuthToken to ciąg uwierzytelniania zwrócony przez żądanie ClientLogin.

Więcej informacji o uwierzytelnianiu ClientLogin, w tym przykładowe żądania i odpowiedzi, znajdziesz w dokumentacji uwierzytelniania zainstalowanych aplikacji.

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 w dokumentacji ClientLogin może się zdarzyć, że żądanie uwierzytelnienia się nie powiedzie i zostanie wykonane zadanie CAPTCHA. Jeśli Google ma uruchamiać i obsługiwać test CAPTCHA, wyślij użytkownikowi adres https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (a nie adres URL obsługi CAPTCHA podany w dokumentacji ClientLogin).

Pobieranie listy blogów

Interfejs API danych Bloggera to kanał z listą blogów konkretnego użytkownika. Kanał ten jest nazywany „metakanałem”.

Wyślij żądanie HTTP GET na ten adres URL, aby pobrać listę blogów:

http://www.blogger.com/feeds/userID/blogs

Uwaga: identyfikator użytkownika możesz też zastąpić wartością default, aby poinformować Bloggera, że ma zwrócić listę blogów użytkownika, którego dane logowania zostały powiązane z żądaniem.

Wpis w metatagach może wyglądać tak:

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-08-02T18:44:43.089-07:00</published>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <summary type='html'>Being the journal of Elizabeth Bennet</summary>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='http://schemas.google.com/g/2005#post'
    type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

Informacje o znaczeniu każdego z tych elementów znajdziesz w dokumentacji protokołu Google Data API lub w specyfikacji Atom 1.0.

Jeśli z jakiegoś powodu żądanie się nie powiedzie, Blogger może zwrócić inny kod stanu. Więcej informacji o kodach stanu HTTP znajdziesz też w opisie protokołu interfejsów API danych Google (w języku angielskim).

Tworzenie postów

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

Publikowanie posta na blogu

Po uwierzytelnieniu możesz publikować nowe wpisy na blogu.

Najpierw utwórz reprezentację XML posta do opublikowania. Ten kod XML musi mieć formę elementu <entry> Atom, która może wyglądać tak:

<entry xmlns='http://www.w3.org/2005/Atom'>
  <title type='text'>Marriage!</title>
  <content type='xhtml'>
    <div xmlns="http://www.w3.org/1999/xhtml">
      <p>Mr. Darcy has <em>proposed marriage</em> to me!</p>
      <p>He is the last man on earth I would ever desire to marry.</p>
      <p>Whatever shall I do?</p>
    </div>
  </content>
  <category scheme="http://www.blogger.com/atom/ns#" term="marriage" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
</entry>

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

Aby opublikować ten wpis, wyślij go na adres URL posta na blogu w następujący sposób. Najpierw umieść element Atom <entry> w treści nowego żądania POST, używając typu treści application/atom+xml. Następnie odszukaj w metatagu adres URL posta na blogu, znajdując element <link>, w którym atrybut rel kończy się na #post. Adres URL posta na blogu jest podany jako atrybut href tego elementu, który ma następujący format:

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

Uwaga: ten adres URL jest taki sam jak adres URL w tagu <link rel="service.post">, który pojawia się w sekcji <head> w czytelnej dla człowieka wersji bloga.

Blogger tworzy posta na blogu na podstawie wysłanego przez Ciebie wpisu, a następnie zwraca kod stanu HTTP 201 CREATED oraz kopię nowego posta w formie elementu <entry>. Zwrócony wpis jest taki sam jak ten, który został przez Ciebie wysłany, ale zawiera też różne elementy dodane przez Bloggera, np. element <id>.

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

Tworzenie wersji roboczej posta na blogu

Wersje robocze postów tworzy się tak samo jak posty publiczne, z tym że do wpisu jest dodawany element <app:control>, który wskazuje, że posta nie powinien (jeszcze) zostać opublikowany.

Ten element <app:control> powinien zawierać pojedynczy element <app:draft> jako element podrzędny:

<app:control xmlns:app='http://purl.org/atom/app#'>
  <app:draft>yes</app:draft>
</app:control>

Aby post został rozpoznany jako wersja robocza, dane zawarte w elemencie <app:draft> muszą mieć ciąg yes.

Możesz przekształcić istniejącą wersję roboczą posta na blogu w opublikowanego posta, pobierając jego wersję roboczą, ustawiając dane elementu <app:draft> jako ciąg znaków no, a następnie aktualizując posta. Pobieranie i aktualizowanie postów omówimy w następnych dwóch sekcjach.

Uwaga: więcej informacji o protokole AtomPublishing Protocol, w tym o przestrzeniach nazw <app:control> i <app:draft>, zawiera dokument RFC 5023.

Pobieram posty

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

Możesz wysyłać zapytania dotyczące publicznego kanału Bloggera bez uwierzytelniania. Dzięki temu nie musisz ustawiać parametru autoryzacji podczas pobierania postów z bloga publicznego.

Pobieranie wszystkich postów z bloga

Aby pobrać posty użytkownika, wyślij żądanie HTTP GET na adres URL kanału bloga. Następnie Blogger zwraca kanał z odpowiednimi wpisami na blogu. Aby np. uzyskać listę postów na blogu liz@gmail.com, wyślij do Bloggera to żądanie HTTP (oczywiście z odpowiednią wartością zamiast blogID):

GET http://www.blogger.com/feeds/blogID/posts/default

Blogger zwraca kod stanu HTTP 200 OK i standardowy kanał Atom 1.0 zawierający posty z bloga.

Poniżej znajduje się przykład kanału bloga z jednym postem. Zwróć uwagę, że w tym przykładzie zmieniliśmy trochę, aby był bardziej czytelny dla użytkowników. W szczególności prawdziwy kanał Bloggera zawiera rzeczywiste identyfikatory i adresy URL.

<feed xmlns='http://www.w3.org/2005/Atom'>
  <id>tag:blogger.com,1999:blog-blogID</id>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/index.html'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
  <generator version='7.00' uri='http://www2.blogger.com'>Blogger</generator>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
    <published>2006-11-08T18:10:00.000-08:00</published>
    <updated>2006-11-08T18:10:14.954-08:00</updated>
    <title type='text'>Quite disagreeable</title>
    <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
      this evening. I found him quite disagreeable.&lt;/p&gt;</content>
    <link rel='alternate' type='text/html'
      href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
    </link>
    <link rel='self' type='application/atom+xml'
      href='http://blogName.blogspot.com/feeds/posts/default/postID'>
    </link>
    <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
    </link>
    <author>
      <name>Elizabeth Bennet</name>
      <email>noreply@blogger.com</email>
      <uri>http://www.blogger.com/profile/profileID</uri>
    </author>
  </entry>
</feed>

Pobieranie postów przy użyciu parametrów zapytania

Interfejs API danych Bloggera umożliwia żądanie zbioru wpisów spełniających określone kryteria, na przykład żądania postów na blogu opublikowanych lub zaktualizowanych w wybranym zakresie dat.

Aby np. wysłać zapytanie dotyczące zakresu dat, dodaj do adresu URL żądania parametry published-min oraz published-max. Aby pobrać wszystkie wpisy na blogu utworzone między 16 a 24 marca 2008 roku, wyślij żądanie HTTP na adres URL kanału bloga:

GET http://www.blogger.com/feeds/blogID/posts/default?published-min=2008-03-16T00:00:00&published-max=2008-03-24T23:59:59

Gdy wyślesz żądanie GET, Blogger zwróci kod stanu HTTP 200 OK i kanał z wszystkimi postami utworzonymi w wybranym przez Ciebie zakresie dat.

Za pomocą parametrów updated-min i updated-max można też zaktualizować wszystkie wpisy na blogu w określonym zakresie. Pamiętaj jednak, że te parametry są ignorowane, chyba że parametr orderby ma też wartość updated.

Interfejs API danych Bloggera obsługuje następujące parametry zapytania:

alternatywnych: Typ pliku danych do zwrócenia, na przykład atom (domyślny) lub rss.
/category: Określa kategorie (nazywane też etykietami), aby filtrować wyniki z pliku danych. Na przykład funkcja http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie zwraca wpisy z etykietami Fritz i Laurie.
max-results: Maksymalna liczba wpisów do zwrócenia.
Orderby: Kolejność zwracania wpisów, na przykład lastmodified (domyślna), starttime lub updated.
liczba publikacji: minimalna, liczba publikacji – maks.: Granice dat publikacji wpisów.
start-index: Indeks od 1 pierwszego wyniku do pobrania (na potrzeby stronicowania).
minimalna aktualizacja, maks. liczba aktualizacji: Granice dat aktualizacji wpisów. Te parametry zapytania są ignorowane, chyba że parametr orderby ma wartość updated.

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

Aktualizuję posty

Aby zaktualizować istniejącego posta na blogu, musisz najpierw pobrać wpis, który chcesz zaktualizować, następnie zmodyfikować go, a następnie wysłać żądanie PUT ze zaktualizowanym wpisem w treści wiadomości do adresu URL edycji posta. Upewnij się, że wartość <id> we wpisie PUT dokładnie odpowiada wartości <id> istniejącego wpisu.

Adres URL edycji jest wyróżniony w tym wpisie:

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-11-08T18:10:00.000-08:00</published>
  <updated>2006-11-08T18:10:14.954-08:00</updated>
  <title type='text'>Quite disagreeable</title>
  <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
    this evening. I found him quite disagreeable.&lt;/p&gt;</content>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default/postID'>
  </link>
  <link rel='edit' type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
  </link>
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Bingley" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

WAŻNE: aby zapewnić zgodność dalej, pamiętaj, aby podczas PUTaktualizacji zaktualizowanego wpisu zachowywać cały kod XML, który był w momencie pobierania wpisu z Bloggera. W przeciwnym razie, gdy wdrożymy nowe elementy i uwzględnimy w pliku danych elementy <new-awesome-feature>, klient nie zwróci ich, a użytkownicy coś pominą. Biblioteki klienta interfejsu Google Data API prawidłowo obsługują tę funkcję, więc jeśli używasz jednej z bibliotek, nie musisz nic robić.

Uwaga: obecnie nie można zmieniać danych o autorze powiązanych z postami.

Wskazówka dotycząca rozwiązywania problemów: niektóre zapory sieciowe blokują wiadomości HTTP PUT. Aby obejść ten problem, możesz dodać do żądania POST nagłówek X-HTTP-Method-Override: PUT. Szczegółowe informacje znajdziesz w dokumencie z podstawowymi informacjami o protokole interfejsu Google Data API.

Usuwam posty

Aby usunąć posta, wyślij prośbę o DELETE na adres URL jego edycji. Jest to ten sam adres URL, który służy do aktualizowania postów.

Wskazówka dotycząca rozwiązywania problemów: niektóre zapory sieciowe blokują wiadomości HTTP DELETE. Aby obejść ten problem, możesz dodać do żądania POST nagłówek X-HTTP-Method-Override: DELETE. Szczegółowe informacje znajdziesz w dokumencie z podstawowymi informacjami o protokole interfejsu Google Data API.

Komentarze

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

Tworzenie komentarzy

Aby opublikować komentarz, utwórz element <entry> Atom w ten sposób:

  <entry xmlns='http://www.w3.org/2005/Atom'>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
  </entry>

Aby opublikować ten komentarz, umieść element Atom <entry> w treści nowego żądania POST, używając typu treści application/atom+xml. Następnie wyślij żądanie POST na odpowiedni adres URL Bloggera:

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

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

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

Pobieranie komentarzy

Aby pobrać komentarze do konkretnego posta, wyślij GET na adres URL kanału komentarzy do tego posta:

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

Możesz też wyświetlić komentarze do wszystkich postów, używając adresu URL kanału komentarzy bloga:

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

Żądania te zwracają kanał komentarzy podobny do tego:

<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
         xmlns:thr="http://purl.org/syndication/thread/1.0">
  <id>tag:blogger.com,1999:blog-blogID.post-postID.comment-commentID</id>
  <updated>2007-04-04T21:56:29.803-07:00</updated>
  <title type="text">My Blog : Time to relax</title>
  <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html"/>
  <link rel="http://schemas.google.com/g/2005#feed" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default"/>
  <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default"/>
  <author>
    <name>Blog Author name</name>
  </author>
  <generator version="7.00" uri="http://www2.blogger.com">Blogger</generator>
  <openSearch:totalResults>1</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-commentID</id>
    <published>2007-04-04T21:56:00.000-07:00</published>
    <updated>2007-04-04T21:56:29.803-07:00</updated>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
    <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html#commentID"/>
    <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default/commentID"/>
    <link rel="edit" type="application/atom+xml" href="http://www.blogger.com/feeds/blogID/postID/comments/default/commentID"/>
    <thr:in-reply-to href="http://blogName.blogspot.com/2007/04/first-post.html" 
                     ref="tag:blogger.com,1999:blog-blogID.post-postID" 
                     source="http://www.blogger.com/feeds/posts/default/blogID"
                     type="text/html"/>
    <author>
      <name>Blog Author name</name>
      <email>blog_author@gmail.com</email>
      <uri>http://www.blogger.com/profile/userID</uri>
    </author>
    <thr:in-reply-to xmlns:thr='http://purl.org/syndication/thread/1.0' 
         href='http://blogName.blogspot.com/2007/04/first-post.html' 
         ref='tag:blogger.com,1999:blog-blogID.post-postID' 
         source='http://blogName.blogspot.com/feeds/posts/default/postID'
         type='text/html' />
  </entry>
</feed>

Usuwanie komentarzy

Aby usunąć komentarz, wyślij prośbę DELETE na adres URL do edycji komentarza. Ten adres URL jest wyróżniony w sekcji komentarzy powyżej.

Format eksportu

Blogger umożliwia użytkownikom eksportowanie i importowanie blogów za pomocą pliku eksportu Bloggera. Ten plik eksportu zawiera wszystkie posty i komentarze na blogu. Plik eksportu ma dokładnie taki sam format Atom, jaki opisano w sekcjach dotyczących pobierania postów i komentarzy. Będzie on zawierał jedną treść pliku danych z komentarzami oraz zawartość pliku z komentarzami.

Aby wyeksportować lub zaimportować dane bloga za pomocą formatu eksportu, otwórz stronę Ustawienia bloga. Aby pobrać plik eksportu bloga za pomocą interfejsu Data API, użyj tego adresu URL:

GET http://www.blogger.com/feeds/blogID/archive

Aby zaimportować plik eksportu, utwórz żądanie POST na poniższy adres URL z zawartością pliku eksportu jako danymi żądania i application/atom+xml jako typem treści:

POST http://www.blogger.com/feeds/blogID/archive/full

Żaden z podanych wyżej adresów URL nie obsługuje parametrów zapytania. Oba żądania muszą też zawierać informacje dotyczące uwierzytelniania i tylko administratorzy bloga mogą importować i eksportować bloga przy użyciu tych adresów URL kanałów.

Uwaga: jeśli tworzysz własny plik eksportu Bloggera, obecnie obowiązuje jedno ograniczenie dotyczące kolejności wpisów i komentarzy. W pliku eksportu Bloggera najpierw zostaną wymienione wszystkie posty, a później wszystkie komentarze. Łączenie komentarzy z postami i komentarzami jest dozwolone, pod warunkiem że dany komentarz pojawia się po nim.

Więcej informacji o tym, jak Blogger korzysta z formatu Atom w pliku eksportu, znajdziesz w przewodniku po protokole.

Powrót do góry