Esta página foi traduzida pela API Cloud Translation.

Guia do desenvolvedor: Java

Importante: esta é uma versão antiga desta 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 cliente vejam e atualizem o conteúdo do Blogger na forma de feeds da API Google Data.

Seu aplicativo cliente pode usar a API de dados do Blogger para criar novas postagens de blog, editar ou excluir postagens de blog existentes e consultar postagens de blog que correspondam a critérios específicos.

Além de fornecer informações sobre os recursos da API de dados do Blogger, este documento apresenta exemplos de interações básicas da API Data usando a biblioteca de cliente Java. Se você quiser saber mais sobre o protocolo subjacente que a biblioteca usa, consulte a seção de protocolo deste guia do desenvolvedor.

Índice

Público
Primeiros passos
1. Como criar uma conta do Blogger
2. Executar o exemplo de código
Como autenticar no serviço do Blogger
1. Autenticação de proxy dSYM
2. Autenticação de nome de usuário/senha do ClientLogin
Recuperar uma lista de blogs
Como criar postagens
1. Como publicar uma postagem do blog
2. Como criar um rascunho de postagem do blog
Recuperar postagens
1. Recuperar todas as postagens do blog
2. Recuperar postagens usando parâmetros de consulta
Atualização de postagens
Como excluir postagens
Comentários

Público-alvo

Este documento é destinado a programadores que querem criar aplicativos cliente Java que possam interagir com o Blogger.

Neste documento, presumimos que você entenda 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 do Java. Para informações gerais de referência da API Blogger Data, consulte o Guia de referência de protocolos.

Primeiros passos

Se você precisar de ajuda para configurar a biblioteca de cliente, consulte o Guia de primeiros passos.

A biblioteca de cliente do Java requer o 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.

Criar uma conta do Blogger

Inscreva-se em uma conta do Blogger para fins de teste. O Blogger usa as Contas do Google. Portanto, se você já tem uma Conta do Google, está tudo pronto.

Como executar o código de amostra

Um cliente de exemplo completo de trabalho, contendo todo o código de amostra mostrado neste documento, está disponível na distribuição da biblioteca de cliente do 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 amostra executa várias operações no blog fornecido para demonstrar o uso da API de dados do Blogger.

Para compilar os exemplos deste documento em seu próprio 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 privados. Ele pode se autenticar usando uma das duas abordagens: autenticação de proxy SMTP ou 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 das amostras nas seções subsequentes deste documento pressupõe que você tenha um objeto GoogleService autenticado.

Autenticação via proxy do AuthSub

A autenticação de proxy dSYM é 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 dSYM especiais que permitem ao cliente agir em nome de um usuário específico. Para informações mais detalhadas, consulte a documentação do SWF.

Quando um usuário visita seu aplicativo pela primeira vez, ele ainda não foi autenticado. Nesse caso, é necessário exibir algumas informações e um link que direcione o usuário para uma página do Google para autenticar sua solicitação de acesso aos blogs. 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 dSYMRequest:

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 dSYMRequest):

próxima: O URL da página a que o Google deve redirecionar o usuário após a autenticação.
escopo: Indica que o aplicativo está solicitando um token para acessar feeds do Blogger. A string do escopo a ser usada é http://www.blogger.com/feeds/ (codificada para URL, é claro).
proteger: 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 poderá 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.

Depois que o usuário faz a autenticação, o sistema dSYM os redireciona para o URL especificado no parâmetro de consulta next do URL de dSYMRequest. O sistema dSYM 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. Neste exemplo, como session = true foi especificado, esse token pode ser trocado por um token de sessão dSYM chamando o serviço AuthSubSessionToken, da seguinte maneira, em que urlFromAuthSub é o URL que o dSYM anexou ao token:

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

Ou seja, você transmite o token de uso único para o método exchangeForSessionToken, com null (para o modo não registrado) ou uma chave privada (para o modo registrado), e a interface dSYM retorna um token de sessão. Para mais informações sobre aplicativos registrados e chaves privadas, consulte a seção Solicitações de assinatura da documentação do dSYM.

Seu aplicativo poderá usar o token de sessão em interações subsequentes com o Blogger. Para solicitar que a biblioteca de cliente Java envie automaticamente o token da sessão a 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 junto com cada solicitação.

Autenticação por nome de usuário/senha do ClientLogin

Use a autenticação ClientLogin se o cliente for um cliente independente"instalado"(como um aplicativo de desktop). Basta chamar o método setUserCredentials no seu 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 para o construtor do GoogleService. O primeiro parâmetro é o nome do serviço com que queremos interagir. O segundo parâmetro é o nome do nosso aplicativo no formato companyName-applicationName-versionID.

Para mais informações sobre a autenticação do ClientLogin, incluindo solicitações e respostas de amostra, consulte a documentação de Autenticação em 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 ClientLogin, a solicitação de autenticação pode falhar e solicitar um desafio CAPTCHA. Se você quiser que o Google emita e processe o desafio CAPTCHA, envie o usuário para https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger, em vez do URL de gerenciamento do CAPTCHA fornecido na documentação do ClientLogin.

Recuperar uma lista de blogs

A API de dados do Blogger fornece um feed que lista os blogs para um usuário específico. Esse feed é conhecido como "metafeed."

A amostra 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. Este é o URL do metafeed padrão. Ele retorna uma lista de blogs para o usuário autenticado no momento. Para acessar um feed de um usuário diferente, coloque o ID do usuário em vez 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

A API de dados do Blogger permite criar e publicar novas entradas de blog, bem como criar rascunhos de entradas.

Observação: no momento, não é possível definir um autor personalizado para postagens. Todas as novas postagens aparecerão como se tivessem sido criadas pelo usuário autenticado no momento.

Publicar uma postagem do blog

Você pode usar a biblioteca de cliente Java para publicar novas entradas de blog.

Primeiro, crie um objeto Entry para representar a postagem do blog. Depois, você pode definir o título, o conteúdo e outros atributos da postagem. Por fim, use o objeto GoogleService para inserir a postagem. Veja um exemplo de como publicar uma nova postagem no 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 de postagem do serviço como um 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 um ID de postagem.

Se a sua solicitação falhar por algum motivo, o Blogger pode retornar um código de status diferente. Para informações sobre os códigos de status, consulte o documento de referência do protocolo da API Google Data.

Criando um rascunho de postagem do blog

Os rascunhos de postagens são criados da mesma forma que as postagens públicas, mas você precisa definir o atributo draft do objeto Entry. Você pode criar uma postagem de blog como a acima como rascunho adicionando a linha em destaque:

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 uma postagem do blog atual em uma postagem publicada, recupere a postagem de rascunho, defina o atributo rascunho como falso e atualize a postagem. Falaremos sobre como recuperar e atualizar postagens nas próximas duas seções.

Recuperar postagens

As seções a seguir descrevem como recuperar uma lista de postagens de blog, com e sem parâmetros de consulta.

Você pode consultar um feed público do Blogger sem autenticação. Portanto, você não precisa chamar o método setUserCredentials ou fazer a autenticação dSYM antes de recuperar postagens de um blog público.

Recuperar 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, desta vez, envie o URL do feed da postagem do blog:

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 de dados do Blogger, você pode solicitar um conjunto de entradas que correspondam a critérios específicos, como a solicitação de postagens do blog publicadas ou atualizadas em um determinado período. Para fazer isso, crie um objeto Query e o transmita 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 mostra o título de cada postagem do blog publicada entre o horário de início e de término informados:

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 é criado 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: Especifique as categorias (também conhecidas como rótulos) para filtrar os resultados do feed. Por exemplo, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie retorna entradas com os rótulos Fritz e Laurie.
setMaxResults: Defina o número máximo de entradas a serem retornadas.
setPublishMin, setPublishMax: Defina os limites nas datas de publicação de entrada.
Índice SetStart: Defina o índice baseado em 1 do primeiro resultado a ser recuperado (para paginação).
setUpdatedMin, setUpdatedMax: Defina os limites nas datas de atualização de entrada. Esses parâmetros de consulta são ignorados a menos que o parâmetro orderby esteja definido como updated.

Observação: no momento, não há setters para o parâmetro de consulta orderby. No entanto, ainda é possível usar o método Query.addCustomParameter() se precisar defini-lo.

Para mais informações sobre os parâmetros de consulta, consulte o Guia de referência da API de dados do Blogger e o Guia de referência das APIs de dados do Google.

Atualizando postagens

Para atualizar uma postagem do blog, primeiro recupere a entrada que quer atualizar, modifique-a e envie-a ao Blogger usando o método update. O snippet de código a seguir modifica o título de uma entrada de blog, supondo que você já tenha recuperado a entrada 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 contendo a postagem completamente 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 a postagens.

Como excluir postagens

Para excluir uma postagem, transmita o URL de edição da postagem ao método delete no objeto GoogleService, desta maneira:

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

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.

Como recuperar comentários

Você pode recuperar os comentários de uma postagem específica no URL de 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, para ver os comentários de todas as postagens, use o URL do feed de comentários do blog:

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

Como excluir comentários

Para excluir um comentário, transmita o URL de edição dele para o método delete no objeto GoogleService da seguinte maneira:

public static void deleteComment(GoogleService myService, String editLinkHref)
    throws ServiceException, IOException {
  URL deleteUrl = new URL(editLinkHref);
  myService.delete(deleteUrl);
}

Voltar ao início