Importante: esta é uma versão antiga da página. Para a versão mais recente, use os links na barra de navegação do lado esquerdo.
A API de dados do Blogger permite que aplicativos clientes visualizem e atualizem o conteúdo do Blogger na forma de feeds da API de dados do Google.
Seu aplicativo cliente pode usar a API de dados do Blogger para criar novas postagens, editar ou excluir postagens existentes e consultar as postagens que correspondam a critérios específicos.
Além de fornecer algumas informações sobre os recursos da API de dados do Blogger, este documento traz exemplos de interações básicas dessa API usando a biblioteca de cliente Java. Se você quiser entender mais sobre o protocolo subjacente usado pela biblioteca, consulte a seção "Protocolo" deste guia para desenvolvedores.
Conteúdo
Público
Este documento é destinado a programadores que querem criar aplicativos cliente Java que possam interagir com o Blogger.
Este documento pressupõe que você compreende as ideias gerais por trás do protocolo das APIs de dados do Google.
Para informações de referência sobre as classes e os métodos fornecidos pela biblioteca de cliente, consulte a referência da API da biblioteca de cliente Java. Para informações gerais de referência da API Blogger Data, consulte o Guia de referência de protocolo.
Como começar
Para receber ajuda na configuração da biblioteca de cliente, consulte o Guia explicativo.
A biblioteca de cliente Java requer Java 1.5. Depois de fazer o download
da biblioteca de cliente, você encontrará as classes necessárias para começar no
arquivo java/lib/gdataclient-1.0.jar.
Como criar uma conta do Blogger
Recomendamos que você se inscreva em uma conta do Blogger para fins de teste. O Blogger usa Contas do Google. Portanto, se você já tem uma, não precisa fazer mais nada.
Como executar o código de amostra
Um cliente de amostra funcional completo, contendo todo o código de amostra mostrado neste documento, está disponível na distribuição da biblioteca de cliente Java, no diretório gdata/java/sample/blogger/BloggerClient.java. As instruções de criação e
execução estão incluídas no mesmo diretório no
arquivo README.txt.
O cliente de exemplo executa várias operações no blog fornecido para demonstrar o uso da API de dados do Blogger.
Para compilar os exemplos deste documento no seu código, você precisará das seguintes instruções import:
import com.google.gdata.client.*; import com.google.gdata.data.*; import com.google.gdata.util.*; import java.io.IOException; import java.net.URL;
Como autenticar no serviço do Blogger
Você pode acessar feeds públicos e privados usando a API de dados do Blogger. Os feeds públicos não exigem autenticação, mas são somente leitura. Se você quiser modificar blogs, seu cliente precisará se autenticar antes de solicitar feeds particulares. A autenticação pode ser feita usando uma destas duas abordagens: autenticação de proxy AuthSub ou a autenticação de nome de usuário/senha do ClientLogin.
Para mais informações sobre autenticação com as APIs de dados do Google em geral, consulte a documentação de autenticação.
A maioria dos exemplos nas seções subsequentes deste documento presume que você tem um objeto GoogleService autenticado.
Autenticação via proxy do AuthSub
A autenticação por proxy BYOL é usada por aplicativos da Web que precisam autenticar os usuários nas Contas do Google. O operador do site e o código do cliente não têm acesso ao nome de usuário e à senha do usuário do Blogger. Em vez disso, o cliente recebe tokens MRAID especiais que permitem que ele atue em nome de um usuário específico. Para informações mais detalhadas, consulte a documentação do MRAID (em inglês).
Quando um usuário acessa seu aplicativo pela primeira vez, ele ainda não foi autenticado. Nesse caso, você precisa exibir algumas informações e um link que direciona o usuário a uma página do Google para autenticar sua solicitação de acesso aos blogs dele. A biblioteca de cliente Java fornece uma função para gerar o URL da página do Google. O código abaixo recupera o URL da página NGINXRequest:
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);
O método getRequestUrl usa os seguintes parâmetros
(correspondentes aos parâmetros de consulta usados pelo gerenciador StatefulSetRequest):
- próxima
- O URL da página para onde o Google deve redirecionar o usuário após a autenticação.
- escopo
- Indica que o aplicativo está solicitando um token para acessar os feeds do Blogger. A string de escopo a ser usada é
http://www.blogger.com/feeds/(codificado em URL, obviamente). - seguro
- Indica se o cliente está solicitando um token seguro.
- seção
- Indica se o token retornado pode ser trocado por um token multiuso (sessão).
O exemplo acima mostra uma chamada que não solicita um token seguro (o valor de secure é false). O URL de solicitação resultante pode ter a seguinte aparência:
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
O usuário segue o link para o site do Google e faz a autenticação na Conta do Google.
Após a autenticação do usuário, o sistema StatefulSet redireciona o usuário para o URL
especificado no parâmetro de consulta next desse URL. O sistema NGINX anexa um token de autenticação a esse URL, como o
valor do parâmetro de consulta token. Exemplo:
http://www.example.com/welcome.html?token=yourAuthToken
Esse valor de token representa um token AuthSub de um único uso. Nesse exemplo,
como session = true foi especificado, esse token pode ser trocado por
um token de sessão do MRAID chamando o serviço AuthSubSessionToken, conforme mostrado a seguir, em que urlFromAuthSub é o URL ao qual estrela
anexou o token:
String token = AuthSubUtil.getTokenFromReply(urlFromAuthSub); String sessionToken = AuthSubUtil.exchangeForSessionToken(token, null);
Ou seja, você transmite seu token de uso único para o método exchangeForSessionToken, junto com null (para o modo não registrado) ou uma chave privada (para modo registrado), e a interface noindex retorna um token de sessão. Para mais informações sobre aplicativos
registrados e chaves privadas, consulte a seção "Assinar solicitações"
da documentação do AOSP.
Seu aplicativo poderá usar o token de sessão em interações subsequentes com o Blogger. Para instruir a biblioteca de cliente Java a enviar automaticamente o token de sessão com cada solicitação, chame o método setAuthSubToken do objeto GoogleService:
GoogleService.setAuthSubToken(sessionToken, null);
Depois disso, a biblioteca de cliente envia automaticamente o token com cada solicitação.
Autenticação por nome de usuário/senha do ClientLogin
Use a autenticação GroupByKey se seu cliente for um cliente "instalado" independente e de usuário único (como um aplicativo de área de trabalho). Basta chamar o método setUserCredentials no objeto GoogleService e todas as interações subsequentes com o Blogger serão autenticadas:
GoogleService myService = new GoogleService("blogger", "exampleCo-exampleApp-1");
myService.setUserCredentials("user@example.com", "secretPassword");
No snippet acima, transmitimos dois parâmetros ao construtor GoogleService. O primeiro parâmetro é o nome do
serviço com o qual queremos interagir. O segundo parâmetro é o nome do aplicativo no formato companyName-applicationName-versionID.
Para mais informações sobre a autenticação do ConstraintLayout, incluindo exemplos de solicitações e respostas, consulte a documentação Autenticação para aplicativos instalados.
Observação: use o mesmo token para todas as solicitações em uma determinada sessão. Não adquira um novo token para cada solicitação do Blogger.
Observação: conforme descrito na documentação do ConstraintLayout, a solicitação de autenticação pode falhar e solicitar um desafio de CAPTCHA. Se você quiser que o Google emita e lide com o desafio CAPTCHA, encaminhe o usuário para
https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(e não para o URL de processamento de CAPTCHA fornecido na documentação do
Systrace).
Como recuperar uma lista de blogs
A API de dados do Blogger fornece um feed que lista os blogs de um usuário específico. Esse feed é conhecido como "metafeed".
O exemplo de código a seguir usa um objeto GoogleService autenticado para recuperar o metafeed e imprimir o título de cada blog.
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());
}
}
Observe o URL usado pelo método getFeed. Esse é o URL de metafeed padrão. Ele retorna uma lista de blogs para o usuário autenticado no momento.
Para acessar o feed de outro usuário, coloque o ID do usuário no lugar de default no URL do metafeed. O ID do usuário é a string de dígitos
no final do URL do perfil do usuário.
Como criar postagens
Com a API Blogger Data, você pode criar e publicar novas entradas de blog, além de criar rascunhos de entradas.
Observação: no momento, não é possível definir um autor personalizado para as postagens. Todas as novas postagens serão exibidas como se tivessem sido criadas pelo usuário autenticado no momento.
Publicar uma postagem do blog
Você pode usar a biblioteca cliente Java para publicar novas entradas de blog.
Primeiro, crie um objeto Entry para representar a postagem do blog. Em seguida, defina o título, o conteúdo e outros atributos da postagem do blog. Por fim, use o objeto GoogleService para inserir a postagem. Confira um exemplo de como
publicar uma nova postagem do blog:
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);
}
O método insert usa o URL da postagem do serviço como parâmetro.
Em seguida, o método retorna a entrada como ela foi armazenada pelo Blogger. A entrada retornada é a mesma que você enviou, mas também contém vários elementos adicionados pelo Blogger, como o ID da postagem.
Se a solicitação falhar por algum motivo, o Blogger poderá retornar um código de status diferente. Para mais informações sobre os códigos de status, consulte o documento de referência do protocolo da API Google Data.
Como criar o rascunho de uma postagem do blog
Os rascunhos de postagens são criados da mesma forma que as públicas, mas é necessário definir
o atributo draft do objeto Entry. Você pode criar uma postagem do blog como a acima como rascunho adicionando a linha destacada:
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);
}
Para transformar um rascunho de postagem do blog em uma publicada, basta recuperar a postagem de rascunho, definir o atributo de rascunho como falso e atualizar a postagem. Abordaremos como recuperar e atualizar postagens nas próximas duas seções.
Recuperando postagens
As seções a seguir descrevem como recuperar uma lista de postagens do blog, com e sem parâmetros de consulta.
Você pode consultar um feed público do Blogger sem autenticação. Portanto, não
é necessário chamar o método setUserCredentials ou fazer a autenticação
do estrela antes de recuperar postagens de um blog público.
Recuperando todas as postagens do blog
Para recuperar as postagens do usuário, chame o mesmo método getFeed usado para recuperar o metafeed dos blogs, mas envie o URL do feed da postagem do blog desta vez:
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();
}
Como recuperar postagens usando parâmetros de consulta
Com a API Blogger Data, você pode solicitar um conjunto de entradas que correspondam a critérios
especificados, como solicitar postagens do blog publicadas ou atualizadas em um determinado
período. Para fazer isso, crie um objeto Query e transmita-o para o
método GoogleService.getQuery.
Por exemplo, para enviar uma consulta de período, use os métodos setPublishedMin e setPublishedMax do objeto Query. O
snippet de código abaixo imprime o título de cada postagem do blog publicada entre os
horários de início e término fornecidos:
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();
}
O objeto Query é construído usando o mesmo URL do feed de postagens usado para recuperar postagens.
A API de dados do Blogger é compatível com os seguintes métodos Query:
- addCategoryFilter
- Especificar categorias (também conhecidas como rótulos) para filtrar os resultados do feed. Por exemplo,
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurieretorna entradas com os rótulosFritzeLaurie. - setMaxResults
- Define o número máximo de entradas a serem retornadas.
- setPublishMin, setPublishedMax
- Defina os limites para as datas de publicação das inscrições.
- setStartIndex
- Define o índice de base 1 do primeiro resultado a ser recuperado (para paginação).
- setUpdatedMin, setUpdatedMax
- Define os limites para as datas de atualização de entrada. Esses parâmetros de consulta serão ignorados, a menos que o parâmetro
orderbyseja definido comoupdated.
Observação: no momento, não há setters para o
parâmetro de consulta orderby. No entanto, você ainda poderá usar o
método Query.addCustomParameter() se precisar definir isso.
Para mais informações sobre parâmetros de consulta, consulte o Guia de referência da API Blogger Data e o Guia de referência das APIs Google Data.
Atualizando postagens
Para atualizar uma postagem do blog, primeiro recupere a entrada que você quer atualizar, modifique-a e envie-a para o Blogger usando o método update. O snippet de código a seguir modifica o título de uma
entrada do blog, supondo que você já a tenha recuperado do
servidor.
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);
}
O código acima retorna um Entry que contém toda a
postagem recém-atualizada. Para atualizar outras propriedades, basta defini-las no objeto Entry antes de chamar update.
Observação: no momento, não é possível modificar os dados do autor associados às postagens.
Excluindo postagens
Para excluir uma postagem, transmita o URL de edição dela para o método delete
no objeto GoogleService da seguinte forma:
public static void deletePost(
GoogleService myService, String editLinkHref)
throws ServiceException, IOException {
URL deleteUrl = new URL(editLinkHref);
myService.delete(deleteUrl);
}
Comentários
A API de dados do Blogger permite criar, recuperar e excluir comentários. Não é possível atualizar comentários (nem disponível na interface da Web).
Como criar comentários
Para postar um comentário, crie um objeto Entry e insira-o da seguinte maneira:
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);
}
Observação: no momento, só é possível postar comentários em um blog de propriedade do usuário autenticado.
Observação: no momento, não é possível definir um autor personalizado para comentários. Todos os novos comentários serão exibidos como se tivessem sido criados pelo usuário autenticado no momento.
Recuperando comentários
Você pode recuperar os comentários de uma postagem específica no URL do feed de comentários da postagem:
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();
}
Ou você pode obter os comentários de todas as postagens usando o URL do feed de comentários do blog:
http://www.blogger.com/feeds/blogID/comments/default
Excluindo comentários
Para excluir um comentário, transmita o URL de edição dele ao método delete
no objeto GoogleService da seguinte forma:
public static void deleteComment(GoogleService myService, String editLinkHref)
throws ServiceException, IOException {
URL deleteUrl = new URL(editLinkHref);
myService.delete(deleteUrl);
}