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

Przewodnik dla programistów: protokół

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

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ą nieprzetworzonego kodu XML i protokołu HTTP. Po przeczytaniu tego dokumentu możesz dowiedzieć się więcej o interakcjach z interfejsem API za pomocą naszych bibliotek klienta. Wystarczy, że przeczytasz sekcje dotyczące języka programowania w tym przewodniku dla programistów.

Spis treści

Odbiorcy

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

W tym dokumencie zakładamy, że rozumiesz ogólne założenia protokołu interfejsów Google Data API.

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

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

Pierwsze kroki

Tworzenie konta w Bloggerze

Możesz zarejestrować się konta Bloggera. Blogger korzysta z kont Google, jeśli więc masz już konto Google, wszystko gotowe.

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 Jeśli chcesz zmodyfikować blogi, Twój klient musi się uwierzytelnić przed wysłaniem żądania prywatnych kanałów. Może on uwierzytelniać się na 2 sposoby: za pomocą uwierzytelniania przez serwer proxy AuthSub lub uwierzytelniania za pomocą nazwy użytkownika i hasła ClientLogin.

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

Większość przykładów w kolejnych sekcjach tego dokumentu zakłada, że zapewnienie odpowiedniego uwierzytelniania.

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ę, uwierzytelniono. W tym przypadku musisz wyświetlić informacje i link Kierowanie użytkownika na stronę Google, gdzie zostanie uwierzytelniona prośba o dostęp do swoje blogi.

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 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 jednorazowy token AuthSub. W tym przykładzie ponieważ określono session=1, ten token można wymienić na token sesji AuthSub przez wywołanie metody 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 i nagłówek Expiration, wskazuje, jak długo token będzie ważny.

Aplikacja może następnie używać wartości tokena sesji w sekcji Nagłówek Authorization kolejnych interakcji z Bloggerem.

Oto przykład żądania HTTP zawierającego niezabezpieczony token Użytkownik może 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 Twój klient jest samodzielnym, jednoużytkownikowym klientem „zainstalowanym” (np. aplikacją na komputer). Aby poprosić o token uwierzytelniający za pomocą mechanizmu ClientLogin, wyślij POSTżądanie pod tym adresem URL:

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

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

E-mail: Adres e-mail użytkownika.
Hasło: Hasło użytkownika.
usługa: Nazwa usługi Blogger to blogger. (Inne usługi) Więcej informacji znajdziesz na liście nazw usług).
accountType: Gdy używasz interfejsu Blogger API, zawsze powinna być ustawiona wartość GOOGLE. Nieustawienie tego parametru uniemożliwi dostęp użytkownikom, którzy mają też konto G Suite.
źródło: Identyfikuje aplikację kliencką. Powinien mieć format companyName-applicationName-versionID. W przykładach nosi ona nazwę exampleCo-exampleApp-1.

Więcej informacji o parametrach znajdziesz w artykule Uwierzytelnianie dla Zainstalowane aplikacje.

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

W przypadku powodzenia serwer zwraca stan HTTP 200 OK oraz trzy długie kody alfanumeryczne w treści odpowiedzi: SID, LSID, oraz Auth. Wartość Auth to token autoryzacji, który wysyłasz do Bloggera. przy każdej kolejnej prośbie, warto więc zachować kopię tej wartości. Dostępne opcje ignorują wartości SID i LSID.

Ponieważ wszystkie żądania dotyczące prywatnych kanałów wymagają uwierzytelnienia, musisz ustawić nagłówek Authorization we wszystkich kolejnych interakcjach z Bloggerem, używając tego formatu:

Authorization: GoogleLogin auth=yourAuthToken

Gdzie yourAuthToken to ciąg uwierzytelniania zwrócony przez funkcję Żądanie ClientLogin.

Więcej informacji o uwierzytelnianiu ClientLogin, w tym przykłady żądań i odpowiedzi zawiera sekcja Uwierzytelnianie zainstalowanych elementów aplikacji.

Uwaga: używaj tego samego tokena dla 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”.

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

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

Uwaga: możesz też zastąpić ciąg default dla identyfikatora użytkownika, który informuje Bloggera, aby zwrócić listę blogów użytkownika, którego dane logowania dołączone do żądania.

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 na temat znaczenia każdego z tych elementów znajdziesz w dokumencie Google Dokument „Data API Protocol” lub dokument Atom Specyfikacja 1.0.

Jeśli z jakiegoś powodu żądanie nie zostanie zrealizowane, Blogger może zwrócić inny stan w kodzie. Więcej informacji o kodach stanu HTTP znajdziesz też w dokumentacji [Google Data API] Reference (w języku angielskim).

Tworzenie postów

Interfejs API danych Bloggera umożliwia tworzenie i publikowanie nowych wpisów na blogu, oraz 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. Plik XML musi mieć postać elementu Atom <entry>, który 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: 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.

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 nowej prośby POST, używając typu treści application/atom+xml. Następnie w metakanale znajdź adres URL posta na blogu, wyszukując tag Element <link>, w którym atrybut rel kończy się na #post Adres URL posta na blogu jest podawany jako atrybut href tego elementu. Jego format jest następujący:

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

Uwaga: ten adres URL jest taki sam jak adres w parametrze <link rel="service.post"> widoczny w sekcji <head> w czytelnej dla człowieka wersji .

Blogger utworzy posta na blogu na podstawie wysłanego wpisu, a następnie zwróci żądanie HTTP 201 CREATED wraz z kopią nowego posta w elementu <entry>. Zwrócony wpis jest taki sam jak wysłany, ale zawiera też różne elementy dodane przez Bloggera, takie jak element <id>.

Jeśli z jakiegoś powodu żądanie nie zostanie zrealizowane, Blogger może zwrócić inny stan w kodzie. Informacje o kodach stanu znajdziesz w dokumentacji interfejsu Google Data API.

Tworzenie wersji roboczej posta na blogu

Wersje robocze postów są tworzone tak samo jak posty publiczne, ale z dodatkową Do wpisu dodano element <app:control> wskazujący, że nie powinny zostać (jeszcze) opublikowane.

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

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

Dane zawarte w elemencie <app:draft> muszą być typu ciąg yes, aby post został rozpoznany jako wersja robocza.

Aby zmienić istniejący opublikowany post na wersję roboczą, pobierz post, ustaw dane elementu <app:draft> na ciąg znaków no, a następnie zaktualizuj post. Pobieranie i aktualizowanie postów omawiamy w kolejnych 2 sekcjach.

Uwaga: więcej informacji o protokole Atom Publishing Protocol, w tym o przestrzeniach nazw <app:control> i <app:draft>, znajdziesz w dokumencie RFC 5023.

Pobieram posty

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

Możesz wysyłać zapytania dotyczące publicznego kanału Bloggera bez uwierzytelniania. Dlatego nie muszą ustawiać parametru autoryzacji w przypadku pobierania postów na blogu z na publicznym blogu.

Pobieranie wszystkich wpisów na blogu

Aby pobrać wpisy użytkownika, wyślij żądanie HTTP GET do adresu URL kanału bloga. Blogger zwraca wtedy kanał zawierający odpowiednie wpisy na blogu. Aby na przykład uzyskać listę postów na blogu na adres liz@gmail.com, wyślij wiadomość po żądaniu HTTP do Bloggera (z odpowiednią wartością w miejscu blogID):

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

Następnie Blogger zwraca kod stanu HTTP 200 OK i standardowy kanał Atom 1.0 zawierający wpisy na blogu.

Poniżej znajdziesz przykład kanału dla bloga z jednym wpisem. Uwaga trochę zmodyfikowaliśmy ten przykład, aby był bardziej czytelny ludzi. Prawdziwy plik danych Bloggera zawiera m.in. 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 zgodnych z określonym takie jak żądanie postów na blogu opublikowanych lub zaktualizowanych w określonym dniu zakres dat.

Na przykład aby wysłać zapytanie dotyczące zakresu dat, dodaj published-min i published-max do adresu URL żądania. Aby uzyskać dostęp do wszystkich wpisy w blogu utworzone między 16 marca 2008 a 24 marca 2008 wysyłają żądanie 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 błąd HTTP kodu stanu 200 OK oraz kanału zawierającego wszelkie posty na blogu, które zostały utworzone w wybranym zakresie dat.

Parametry updated-min i updated-max mogą również służy do aktualizacji wszystkich wpisów bloga w danym zakresie. Pamiętaj jednak, są ignorowane, chyba że parametr orderby jest ustawiono na 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 (zwane też etykietami) służące do filtrowania wyników w pliku danych. Na przykład http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie zwraca wpisy z etykietami Fritz i Laurie.
maksymalna liczba wyników: Maksymalna liczba wpisów do zwrócenia.
Orderby: Kolejność zwracania wpisów, na przykład lastmodified (domyślna), starttime lub updated.
published-min, published-max: 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. Przewodnik i Google Przewodnik po interfejsach API danych

Aktualizuję posty

Aby zaktualizować istniejący post na blogu, najpierw pobierz wpis, który chcesz zaktualizować, zmodyfikować i wysłać żądanie PUT z zaktualizowany wpis w treści wiadomości do adresu URL edycji posta. Upewnij się, że Wartość <id> we wpisie PUT ściśle pasuje do <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ść w przyszłości, pamiętaj, aby po PUTzaktualizowaniu wpisu zachować wszystkie kod XML, który występował podczas pobierania wpisu z Bloggera. W przeciwnym razie, gdy wprowadzimy nowe elementy i uwzględnimy je w pliku danych, Twój klient nie zwróci tych elementów, a użytkownicy nie będą mogli z nich skorzystać. Google Biblioteki klienta interfejsu Data API obsługują tę funkcję prawidłowo, więc jeśli używasz Teraz masz już wszystko gotowe.

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

Wskazówka dotycząca rozwiązywania problemów: niektóre zapory sieciowe blokują wiadomości HTTPPUT. Aby tego uniknąć, możesz dodać nagłówek X-HTTP-Method-Override: PUT do żądania POST. Szczegółowe informacje znajdziesz w dokumentacji interfejsu Google Data API dotyczącej podstaw protokołu.

Usuwanie postów

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ą HTTP. DELETE wiadomości. Aby tego uniknąć, możesz dodać nagłówek X-HTTP-Method-Override: DELETE do żądania POST. Aby dowiedzieć się więcej, poczytaj o interfejsie Google Data API. podstawy protokołu.

Komentarze

Interfejs Blogger Data API umożliwia tworzenie, pobieranie i usuwanie komentarzy. Aktualizowanie komentarzy nie jest obsługiwane (ani w interfejsie internetowym).

Tworzenie komentarzy

Aby opublikować komentarz, utwórz element Atom <entry>, na przykład:

  <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 nowej prośby POST, używając typu treści application/atom+xml. Następnie wyślij POST na odpowiedni adres URL Bloggera:

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

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

Uwaga: ustawienie niestandardowego autora komentarzy jest obecnie nieobsługiwane. 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ć, wysyłając GET do adresu URL kanału komentarzy do tego posta:

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

Możesz też pobrać komentarze do wszystkich postów, korzystając z kanału komentarzy do bloga. Adres URL:

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

Te żądania zwracają plik danych z komentarzami, który wygląda tak:

<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ę o DELETE do zmiany komentarza Adres URL. Ten adres URL jest wyróżniony w powyższym okienku komentarzy.

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 z jednego bloga. Format pliku wyeksportowanego jest dokładnie taki sam jak format Atom opisany w sekcji dotyczących pobierania postów i komentarzy. Ten plik eksportu będzie zawierać łącznie z zawartością kanału postów i komentarzy; w jeden dokument.

Aby wyeksportować lub zaimportować dane bloga w formacie 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 do następujący adres URL z zawartością pliku eksportu jako danymi żądania oraz application/atom+xml jako typ 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 o uwierzytelnianiu. Tylko administratorzy bloga będą mogli importować i eksportować bloga za pomocą tych adresów URL.

Uwaga: jeśli tworzysz własne konto Bloggera eksportu pliku, obecnie jest jedno ograniczenie dotyczące kolejności postów i komentarzy. W pliku eksportu Bloggera najpierw zostaną wymienione wszystkie posty, a potem wszystkie komentarze. Dopuszczamy przeplatanie wpisów z postami i komentarzami, o ile komentarz pojawia się po wpisie, do którego się odnosi.

Aby uzyskać więcej informacji o tym, jak Blogger używa formatu Atom podczas eksportowania, można znaleźć w artykule Protokół .

Powrót do góry