Esta página foi traduzida pela API Cloud Translation.

Guia do desenvolvedor: Java

Importante: vamos descontinuar o suporte à API Google Data v2.0 em 30 de setembro de 2024. Para continuar funcionando, atualize os aplicativos que usam a API Google Data v2.0 para a versão mais recente. Para usar a versão mais recente, use os links na barra de navegação à esquerda. Observação: embora algumas solicitações GET (como postagens de listagem) continuem sendo aceitas como URLs de feed, há pequenas diferenças no comportamento delas. Para informações detalhadas, consulte a documentação da Ajuda do Blogger.

A API Data do Blogger permite que os aplicativos clientes visualizem e atualizem o conteúdo do Blogger na forma de feeds da API Data do Google.

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

Além de fornecer alguns antecedentes sobre os recursos da API Data do Blogger, este documento apresenta exemplos de interações básicas da API Data usando a biblioteca de cliente Java. Se você tiver interesse em entender mais sobre os protocolo usado pela biblioteca, consulte a seção Protocolo do este guia do desenvolvedor.

Conteúdo

Público
Como começar
1. Como criar uma conta do Blogger
2. Como executar o exemplo de código
Como autenticar no serviço do Blogger
Recuperando uma lista de blogs
Como criar postagens
1. Publicar uma postagem do blog
2. Como criar o rascunho de uma postagem do blog
Recuperando postagens
1. Recuperando todas as postagens do blog
2. Como recuperar postagens usando parâmetros de consulta
Como atualizar postagens
Como excluir postagens
Comentários

Público-alvo

Este documento é destinado a programadores que desejam escrever código de cliente Java aplicativos que podem interagir com o Blogger.

Este documento pressupõe que você entenda as ideias gerais por trás do protocolo das APIs Data 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 referência geral da API de dados do Blogger do aplicativo, consulte a Referência do protocolo guia.

Primeiros passos

Para obter ajuda na configuração da biblioteca de cliente, consulte a seção Como Guia para iniciantes

A biblioteca de cliente Java requer Java 1.5. Depois de fazer o download do biblioteca de cliente, encontrará as classes de que precisa para começar a arquivo java/lib/gdataclient-1.0.jar.

Como criar uma conta do Blogger

Talvez seja melhor criar uma conta do Blogger para fins de teste. O Blogger usa Contas do Google. Se você já tem uma, está tudo pronto.

Como executar o código de amostra

Uma amostra de cliente completa e funcional, contendo todos os exemplos de código mostrados neste está disponível na distribuição da biblioteca cliente Java, na seção diretório gdata/java/sample/blogger/BloggerClient.java. As instruções de build e execução são incluídas no mesmo diretório no arquivo README.txt.

O cliente de exemplo realiza várias operações no blog fornecido para demonstrar o uso da API Data do Blogger.

Para compilar os exemplos deste documento no seu próprio código, você vai 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

É possível acessar feeds públicos e privados usando a API Data do Blogger. Os feeds públicos não exigem autenticação, mas são somente leitura. Se você quer modificar blogs, seu cliente precisa se autenticar antes de solicitar feeds privados. Ela pode ser autenticada usando uma destas três abordagens: autenticação OAuth, autenticação de proxy AuthSub ou autenticação de nome de usuário/senha ClientLogin.

Para mais informações sobre autenticação com as APIs de dados do Google em geral, consulte a página sobre a documentação Documentação.

A maioria dos exemplos nas seções seguintes deste documento pressupõe que você tenha um objeto GoogleService autenticado.

Autenticação OAuth

Para conferir a documentação sobre a autenticação OAuth usando a biblioteca Java GData, consulte OAuth nas bibliotecas de cliente do protocolo de dados do Google.

Autenticação via proxy do AuthSub

A autenticação por proxy BYOL é usada por aplicativos da Web que precisam autenticam 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 AuthSub especiais que permitem que ele aja em nome de um usuário específico. Para informações mais detalhadas, consulte a documentação do OCR.

Quando um usuário acessa seu aplicativo pela primeira vez, ele ainda não foi autenticados. Nesse caso, você precisa mostrar algumas informações e um link direcionando o usuário a uma página do Google para autenticar sua solicitação de acesso aos blogs. A biblioteca-cliente Java fornece uma função para gerar a biblioteca-cliente URL da sua página. O código abaixo recupera o URL da página AuthSubRequest:

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 de AuthSubRequest:

próxima: O URL da página para onde o Google vai 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.
sessão: Indica se o token retornado pode ser trocado por um token de uso múltiplo (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 será semelhante a este:

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 é autenticado, o sistema AuthSub redireciona ele para o URL especificado no parâmetro de consulta next do URL AuthSubRequest. O sistema AuthSub 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 vezes chamando o método AuthSubSessionToken da seguinte forma, em que urlFromAuthSub é o URL para o qual o Tensorflow anexou o token a:

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

Ou seja, você passa seu 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 chave interface de usuário retorna um token de sessão. Para mais informações sobre registros aplicativos e chaves privadas, consulte a seção "Como assinar solicitações" da documentação do GroupByKey.

Seu aplicativo poderá usar o token de sessão em interações posteriores com o Blogger. Instruir a biblioteca de cliente Java a enviar automaticamente a sessão token com cada solicitação, chame o método GoogleService Método setAuthSubToken:

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 Tensor se seu cliente for um cliente autônomo, de usuário único "instalado" cliente (como um aplicativo para computador). 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, passamos dois parâmetros para o construtor GoogleService. O primeiro parâmetro é o nome ou serviço com o qual queremos interagir. O segundo parâmetro é o nome do app no formato companyName-applicationName-versionID.

Para obter mais informações sobre a autenticação dessa, incluindo as amostras e respostas, consulte a seção Autenticação de domínios Applications (em inglês).

Observação: use o mesmo token para todas as solicitações em uma determinada sessão não adquirem um novo token para cada solicitação do Blogger.

Observação: conforme descrito no arquivo Systrace documentação, a solicitação de autenticação pode falhar e solicitar um CAPTCHA desafio. Se você quiser que o Google emita e lide com o desafio CAPTCHA: enviar o usuário para https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (em vez do URL de manipulação de CAPTCHA fornecido no campo documentação).

Como recuperar uma lista de blogs

A API de dados do Blogger fornece um feed que lista os blogs de um determinado user; esse feed é conhecido como "metafeed".

O exemplo de código abaixo usa um objeto GoogleService autenticado para extrair 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());
  }
}

Anote 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. Para acessar o feed de outro usuário, você pode colocar 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

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

Observação: definir um autor personalizado para as postagens é não tem suporte no momento. Todas as novas postagens vão aparecer como se tivessem sido criadas por o 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. Depois, você pode definir o título, 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 conforme 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 solicitação falhar por algum motivo, o Blogger poderá 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.

Criar um rascunho de postagem do blog

As postagens pendentes são criadas da mesma forma que as postagens públicas, mas você precisa definir o atributo draft do objeto Entry. É possível criar uma postagem de 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 o rascunho de uma postagem do blog em uma publicação, recupere a postagem de rascunho, definindo o atributo rascunho como falso e atualizando o 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 AuthSub antes de extrair 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 de blogs, mas envie o URL do feed de postagens 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

A API Blogger Data permite solicitar um conjunto de entradas que correspondem 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 ao 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 a seguir imprime o título de cada postagem do blog publicada entre as determinados horários de início e de término:

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 extrair postagens.

A API Data do Blogger oferece suporte aos seguintes métodos Query:

addCategoryFilter: Especifique 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: Define o número máximo de entradas a serem retornadas.
setPublicadoMin, setPublicadoMax: Defina os limites nas datas de publicação da entrada.
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 são ignorados, a menos que o parâmetro orderby seja definido como updated.

Observação: no momento, não há setters para o parâmetro de consulta orderby. No entanto, você ainda pode usar o Query.addCustomParameter() se você precisar definir isso.

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

Como atualizar postagens

Para atualizar uma postagem do blog, primeiro recupere a entrada que deseja atualizar, modificar e enviar para o Blogger usando o update. O snippet de código a seguir modifica o título de uma entrada de blog, presumindo que você já tenha extraído 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 toda a postagem recém-atualizada. Para atualizar outras propriedades, basta defini-las no Entry antes de chamar update.

Observação: modificar os dados do autor associados a de postagens não é compatível no momento.

Como excluir 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 Data do Blogger permite criar, recuperar e excluir comentários. Não é possível atualizar comentários nem usar esse recurso 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 que pertence ao usuário autenticado.

Observação: no momento, não é possível definir um autor personalizado para comentários. Todos os novos comentários vão aparecer como se tivessem sido criados pelo usuário autenticado no momento.

Recuperando comentários

É possível recuperar os comentários de uma postagem específica pelo URL do feed de comentários:

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

Excluir comentários

Para excluir um comentário, transmita o URL de edição dele para a 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);
}

Voltar ao início