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

Przewodnik dla programistów: protokół

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ą nieprzetworzonych plików XML i HTTP. Po zapoznaniu się z tym dokumentem możesz dowiedzieć się więcej na temat interakcji z interfejsem API za pomocą naszych bibliotek klienta. Aby dowiedzieć się więcej, przeczytaj sekcje poświęcone językowi programowania w tym przewodniku.

Spis treści

Odbiorców

Ten dokument jest przeznaczony dla programistów, którzy chcą tworzyć aplikacje klienckie obsługujące interakcje z Bloggerem w formacie XML i HTTP.

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

Jeśli używasz systemu UNIX i chcesz wypróbować przykłady w tym dokumencie bez wpisywania kodu, mogą Ci się przydać narzędzia wiersza poleceń UNIX curl lub wget. Więcej informacji znajdziesz na ich stronach ręcznych.

Informacje o interfejsie API danych Bloggera znajdziesz w przewodniku po protokołach.

Pierwsze kroki

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.

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 się, że stosowane jest 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 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.

W adresie URL AuthSubRequest znajdują się te parametry zapytania:

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

URL 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 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=1, ten token można wymienić na token sesji AuthSub, wywołując usługę AuthSubSessionToken z tokenem jednorazowym 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 pozostanie ważny.

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

Oto przykład żądania HTTP zawierającego niezabezpieczony token, który możesz 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 nazwy użytkownika i hasła klienta

Użyj uwierzytelniania ClientLogin, jeśli klient jest oddzielnym klientem (instalowanym przez klienta (np. aplikacją komputerową). Aby wysłać prośbę o token do uwierzytelnienia za pomocą 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 przy użyciu typu treści application/x-www-form-urlencoded. Te parametry to:

E-mail: Adres e-mail użytkownika.
Passwd: Hasło użytkownika.
usługa: Nazwa usługi Blogger to blogger. (Inne nazwy usług znajdziesz na liście nazw usług).
rodzaj konta: W przypadku korzystania z interfejsu Blogger API ten atrybut powinien zawsze mieć wartość GOOGLE. Jeśli nie ustawisz tego parametru, użytkownicy nie będą mogli korzystać z konta G Suite.
source: Identyfikuje aplikację kliencką. Powinien mieć format companyName-applicationName-versionID. W przykładach podano nazwę exampleCo-exampleApp-1.

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

Jeśli żądanie uwierzytelniania się nie powiedzie, serwer zwróci kod stanu HTTP 403 Forbidden.

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

Wszystkie żądania wysyłane do prywatnych kanałów wymagają uwierzytelnienia, dlatego musisz ustawić nagłówek autoryzacji we wszystkich kolejnych interakcjach z Bloggerem, korzystając z tego formatu:

Authorization: GoogleLogin auth=yourAuthToken

Gdzie yourAuthToken to ciąg uwierzytelniania zwracany przez żądanie ClientLogin.

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."

Aby pobrać listę blogów, wyślij HTTP GET na ten adres URL:

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

Uwaga: możesz też zastąpić default identyfikatorem użytkownika, dzięki czemu Blogger będzie zwracał listę blogów użytkownika, którego dane logowania są powiązane z żądaniem.

Wpis w metadanych 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 tym, co oznacza każdy z tych elementów, znajdziesz w dokumentacji protokołu danych 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 dokumencie Protokół Google API.

Tworzenie postów

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

Publikowanie posta na blogu

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

Najpierw utwórz plik XML z wpisem 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: 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.

Aby opublikować ten wpis, prześlij go na adres URL posta na blogu w taki sposób: Najpierw umieść element Atom <entry> w nowym żądaniu POST za pomocą typu treści application/atom+xml. Następnie w metatagu znajdź adres URL posta na blogu, znajdując element <link>, gdzie atrybut rel kończy się ciągiem #post. URL posta na blogu jest atrybutem href tego elementu w takim formacie:

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> bloga w wersji czytelnej dla człowieka.

Blogger tworzy posta na blogu z przesłanym przez Ciebie wpisem, a następnie zwraca kod stanu HTTP 201 CREATED wraz z kopią nowego posta w elemencie <entry>. Zwrócony wpis to ten, który został przez Ciebie wysłany, ale zawiera też inne elementy dodane przez Bloggera, np. element <id>.

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 wpisy publiczne, ale z wpisem <app:control>, który oznacza, że post powinien zostać opublikowany.

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

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

Aby element został rozpoznany jako wersja robocza, dane zawarte w elemencie <app:draft> muszą być ciągiem yes.

Możesz zmienić istniejącego posta na blogu w opublikowany post, pobierając wersję roboczą posta, ustawiając dla danych <app:draft> element w ciągu no i aktualizując post. Pobieranie i aktualizowanie postów jest opisane w kolejnych 2 sekcjach.

Uwaga: więcej informacji o protokołu publikowania Atom, w tym przestrzenie nazw <app:control> i <app:draft>, znajdziesz w dokumencie RFC 5023.

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 związku z tym nie musisz ustawiać parametru autoryzacji przy pobieraniu postów z bloga publicznego.

Pobieranie wszystkich postów na blogu

Aby pobrać posty użytkownika, wyślij żądanie HTTP GET na adres URL kanału bloga. Następnie zwraca kanał z odpowiednimi wpisami bloga. Aby na przykład uzyskać listę postów na blogu dla liz@gmail.com, wyślij następujące żądanie HTTP do Bloggera (oczywiście w miejscu blogID oczywiście):

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

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

Poniżej znajduje się przykład kanału na blogu z tylko jednym postem. Zmieniliśmy trochę ten przykład, by czytelnicy mogli go łatwiej odczytać. 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 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 na przykład wysłać zapytanie dotyczące zakresu dat, dodaj parametry published-min i published-max do adresu URL żądania. Aby uzyskać wszystkie wpisy w blogu utworzone między 16 marca 2008 roku 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 zwraca kod stanu HTTP 200 OK i kanał z wszelkimi postami na blogu utworzonymi w określonym zakresie dat.

Parametry updated-min i updated-max mogą być też używane do aktualizowania wszystkich wpisów bloga w danym 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 pliku danych. Na przykład http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie zwraca wpisy z etykietami Fritz i Laurie.
wyniki-maksymalne: Maksymalna liczba elementów do zwrócenia.
uporządkowane według: Kolejność, w jakiej będą zwracane wpisy, np. lastmodified (domyślnie), starttime lub updated.
opublikowanych, minut:-max: Limity dat publikacji wpisów.
indeks-początkowy: Indeks oparty na 1 pierwszym wyniku do pobrania (na potrzeby stronicowania).
update-min, update-max,: Ograniczenia dotyczące dat aktualizacji wpisu. Te parametry zapytania są ignorowane, chyba że parametr orderby jest ustawiony na updated.

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ący post na blogu, najpierw pobierz wpis, który chcesz zaktualizować, a następnie zmodyfikuj go, a następnie wyślij żądanie PUT ze zaktualizowanym wpisem w treści wiadomości do adresu URL edycji posta. Sprawdź, czy wartość <id> we wpisie PUT dokładnie odpowiada wartości <id> istniejącego wpisu.

Edytowany adres URL jest wyróżniony w tym wierszu:

<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ć większą zgodność, pamiętaj, aby PUTzaktualizowany wpis zachował wszystkieplik XML dostępny podczas pobierania wpisu z Bloggera. Jeśli tego nie zrobisz, gdy wdrożymy nowe elementy i umieścimy w nim elementy <new-awesome-feature>, Twój klient ich nie zwróci. Biblioteki klienta interfejsu API danych Google obsługują wszystko prawidłowo, więc jeśli używasz jednej z bibliotek, które zostały skonfigurowane,

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 HTTP PUT. Aby obejść ten problem, możesz dołączyć nagłówek X-HTTP-Method-Override: PUT w żądaniu POST. Więcej informacji znajdziesz w dokumencie Podstawy protokołu danych Google.

Usuwanie postów

Aby usunąć posta, wyślij żądanie DELETE na adres URL edycji posta. Jest to ten sam adres URL używany 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 dołączyć nagłówek X-HTTP-Method-Override: DELETE w żądaniu POST. Więcej informacji znajdziesz w dokumencie Podstawy protokołu danych Google.

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 element Atom <entry> 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 za pomocą 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 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, wysyłając GET pod ten adres URL kanału komentarzy:

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

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

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

W ramach tych żądań zwracany jest kanał komentarzy:

<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 żądanie DELETE na adres URL edycji komentarza. Ten URL jest wyróżniony powyżej w oknie 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 eksportu jest dokładnie taki sam jak format Atom opisany w sekcjach dotyczących pobierania postów i komentarzy. Ten plik będzie zawierał treści kanału z postami oraz zawartość pliku komentarzy w jednym dokumencie.

Aby wyeksportować lub zaimportować dane bloga w formacie eksportu, wejdź na stronę Ustawienia bloga. Aby pobrać plik eksportu dla bloga przy użyciu interfejsu API danych, użyj tego adresu URL:

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

Aby zaimportować plik eksportu, utwórz żądanie POST na ten adres URL, podając zawartość pliku eksportu jako dane żądania, i application/atom+xml jako typ treści:

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

Żaden z powyższych adresów URL nie obsługuje parametrów zapytania. Oba żądania muszą również zawierać informacje dotyczące uwierzytelniania i tylko administratorzy bloga będą mogli importować lub eksportować bloga za pomocą tych adresów URL kanału.

Uwaga: jeśli tworzysz własny plik eksportu Bloggera, obecnie istnieje jedno ograniczenie dotyczące kolejności postów i komentarzy. W pliku eksportu Bloggera są wymienione wszystkie posty, a potem wszystkie komentarze. Przeplatanie postów i komentarzy jest dozwolone, pod warunkiem, że komentarz znajduje się po postie, którego dotyczy komentarz.

Więcej informacji o tym, jak Blogger używa formatu Atom w pliku eksportu, znajdziesz w przewodniku po protokolu.

Powrót do góry