Guía para desarrolladores: Java

Importante: Esta es una versión antigua de esta página. Para obtener la versión más reciente, usa los vínculos de la barra de navegación de la izquierda.

La API de Blogger Data permite que las aplicaciones cliente vean y actualicen el contenido de Blogger en forma de feeds de la API de Google Data.

Tu aplicación cliente puede usar la API de Blogger Data para crear entradas de blog nuevas, editar o borrar entradas de blog existentes, y consultar entradas de blog que coincidan con criterios particulares.

Además de proporcionar información sobre las funciones de la API de datos de Blogger, este documento ofrece ejemplos de interacciones básicas con la API de datos mediante la biblioteca cliente de Java. Si te interesa obtener más información sobre el protocolo subyacente que usa la biblioteca, consulta la sección Protocolo de esta guía para desarrolladores.

Contenido

  1. Público
  2. Cómo comenzar
    1. Cómo crear una cuenta de Blogger
    2. Cómo ejecutar el código de muestra
  3. Cómo autenticarte en el servicio de Blogger
    1. Autenticación de proxy de AuthSub
    2. Autenticación de nombre de usuario o contraseña de ClientLogin
  4. Cómo recuperar una lista de blogs
  5. Cómo crear publicaciones
    1. Publicación de una entrada de blog
    2. Cómo crear un borrador de una entrada de blog
  6. Cómo recuperar publicaciones
    1. Cómo recuperar todas las entradas de blog
    2. Cómo recuperar publicaciones con parámetros de consulta
  7. Cómo actualizar publicaciones
  8. Cómo borrar publicaciones
  9. Comentarios
    1. Cómo crear comentarios
    2. Cómo recuperar comentarios
    3. Cómo borrar comentarios

Público

Este documento está dirigido a programadores que deseen escribir aplicaciones cliente de Java que puedan interactuar con Blogger.

En este documento, se da por sentado que comprendes las ideas generales detrás del protocolo de las APIs de Google Data.

Para obtener información de referencia sobre las clases y los métodos que proporciona la biblioteca cliente, consulta la referencia de la API de la biblioteca cliente de Java. Para obtener información general de referencia de la API de Blogger Data, consulta la Guía de referencia del protocolo.

Cómo comenzar

Si necesitas ayuda para configurar la biblioteca cliente, consulta la Guía de introducción.

La biblioteca cliente de Java requiere Java 1.5. Después de descargar la biblioteca cliente, encontrarás las clases que necesitas para comenzar en el archivo java/lib/gdataclient-1.0.jar.

Crea una cuenta de Blogger

Te recomendamos que te registres para obtener una cuenta de Blogger para realizar pruebas. Blogger usa Cuentas de Google, por lo que, si ya tienes una, puedes comenzar a usar el servicio.

Cómo ejecutar el código de muestra

Un cliente de muestra funcional completo, que contiene todo el código de muestra que se muestra en este documento, está disponible en la distribución de la biblioteca cliente de Java, en el directorio gdata/java/sample/blogger/BloggerClient.java. Las instrucciones de compilación y ejecución se incluyen en el mismo directorio en el archivo README.txt.

El cliente de ejemplo realiza varias operaciones en el blog proporcionado para demostrar el uso de la API de Blogger Data.

Para compilar los ejemplos de este documento en tu propio código, necesitarás las siguientes instrucciones import:

import com.google.gdata.client.*;
import com.google.gdata.data.*;
import com.google.gdata.util.*;
import java.io.IOException;
import java.net.URL;

Cómo autenticar en el servicio de Blogger

Puedes acceder a feeds públicos y privados con la API de Blogger Data. Los feeds públicos no requieren ninguna autenticación, pero son de solo lectura. Si quieres modificar blogs, tu cliente debe autenticarse antes de solicitar feeds privados. Puede autenticarse con uno de los siguientes dos enfoques: la autenticación de proxy AuthSub o la autenticación de nombre de usuario y contraseña ClientLogin.

Para obtener más información sobre la autenticación con las APIs de Google Data en general, consulta la documentación de autenticación.

En la mayoría de los ejemplos de las secciones posteriores de este documento, se supone que tienes un objeto GoogleService autenticado.

Autenticación de proxy de AuthSub

Las aplicaciones web que necesitan autenticar a sus usuarios en Cuentas de Google usan la autenticación de proxy de AuthSub. El operador del sitio web y el código cliente no tienen acceso al nombre de usuario ni a la contraseña del usuario de Blogger. En cambio, el cliente obtiene tokens de AuthSub especiales que le permiten actuar en nombre de un usuario en particular. Para obtener información más detallada, consulta la documentación de AuthSub.

Cuando un usuario visita tu aplicación por primera vez, aún no se autenticó. En este caso, debes mostrar información y un vínculo que dirija al usuario a una página de Google para autenticar tu solicitud de acceso a sus blogs. La biblioteca cliente de Java proporciona una función para generar la URL de la página de Google. El siguiente código recupera la URL de la 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);

El método getRequestUrl toma los siguientes parámetros (que corresponden a los parámetros de consulta que usa el controlador AuthSubRequest):

siguiente
Es la URL de la página a la que Google debe redireccionar al usuario después de la autenticación.
alcance
Indica que la aplicación solicita un token para acceder a los feeds de Blogger. La cadena de alcance que se debe usar es http://www.blogger.com/feeds/ (codificada como URL, por supuesto).
seguro
Indica si el cliente solicita un token seguro.
sesión
Indica si el token que se muestra se puede intercambiar por un token de uso múltiple (sesión).

En el ejemplo anterior, se muestra una llamada que no solicita un token seguro (el valor de secure es false). La URL de solicitud resultante podría verse de la siguiente manera:

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

El usuario sigue el vínculo al sitio de Google y se autentica en su Cuenta de Google.

Después de que el usuario se autentica, el sistema de AuthSub lo redirecciona a la URL que especificaste en el parámetro de consulta next de la URL de AuthSubRequest. El sistema de AuthSub agrega un token de autenticación a esa URL, como el valor del parámetro de consulta token. Por ejemplo:

http://www.example.com/welcome.html?token=yourAuthToken

Este valor de token representa un token de AuthSub de un solo uso. En este ejemplo, como se especificó session = true, este token se puede intercambiar por un token de sesión de AuthSub llamando al servicio AuthSubSessionToken, como se indica a continuación, en el que urlFromAuthSub es la URL a la que AuthSub adjunta el token:

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

Es decir, pasas tu token de uso único al método exchangeForSessionToken, junto con null (para el modo no registrado) o una clave privada (para el modo registrado), y la interfaz de AuthSub muestra un token de sesión. Para obtener más información sobre las aplicaciones registradas y las claves privadas, consulta la sección "Firma de solicitudes" de la documentación de AuthSub.

Luego, tu aplicación puede usar el token de sesión en interacciones posteriores con Blogger. Para indicarle a la biblioteca cliente de Java que envíe automáticamente el token de sesión con cada solicitud, llama al método setAuthSubToken del objeto GoogleService:

GoogleService.setAuthSubToken(sessionToken, null);

Después de eso, la biblioteca cliente envía automáticamente el token junto con cada solicitud.

Autenticación de nombre de usuario o contraseña de ClientLogin

Usa la autenticación de ClientLogin si tu cliente es un cliente "instalado" independiente para un solo usuario (como una aplicación para computadoras de escritorio). Solo llama al método setUserCredentials en tu objeto GoogleService y se autenticarán todas las interacciones posteriores con Blogger:

GoogleService myService = new GoogleService("blogger", "exampleCo-exampleApp-1");
myService.setUserCredentials("user@example.com", "secretPassword");

En el fragmento anterior, pasamos dos parámetros al constructor GoogleService. El primer parámetro es el nombre del servicio con el que queremos interactuar. El segundo parámetro es el nombre de nuestra aplicación en el formato companyName-applicationName-versionID.

Para obtener más información sobre la autenticación de ClientLogin, incluidas las solicitudes y respuestas de muestra, consulta la documentación Autenticación para aplicaciones instaladas.

Nota: Usa el mismo token para todas las solicitudes en una sesión determinada. No adquieras un token nuevo para cada solicitud de Blogger.

Nota: Como se describe en la documentación de ClientLogin, es posible que la solicitud de autenticación falle y solicite un desafío de CAPTCHA. Si deseas que Google emita y controle el desafío de CAPTCHA, envía al usuario a https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (en lugar de a la URL de control de CAPTCHA que se proporciona en la documentación de ClientLogin).

Cómo recuperar una lista de blogs

La API de Blogger Data proporciona un feed que enumera los blogs de un usuario en particular. Ese feed se conoce como “metafeed”.

En el siguiente código de muestra, se usa un objeto GoogleService autenticado para recuperar el metafeed y, luego, se imprime el 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());
  }
}

Anota la URL que usa el método getFeed. Esta es la URL predeterminada del metafeed, que muestra una lista de blogs para el usuario autenticado actualmente. Para acceder a un feed de otro usuario, puedes colocar el ID del usuario en lugar de default en la URL del metafeed. El ID del usuario es la cadena de dígitos que aparece al final de la URL de su perfil.

Cómo crear publicaciones

La API de Blogger Data te permite crear y publicar entradas de blog nuevas, así como crear borradores de entradas.

Nota: Por el momento, no se admite configurar un autor personalizado para las publicaciones. Todas las publicaciones nuevas aparecerán como si las hubiera creado el usuario autenticado actualmente.

Publica una entrada de blog

Puedes usar la biblioteca cliente de Java para publicar nuevas entradas de blog.

Primero, crea un objeto Entry para representar la entrada de blog. Luego, puedes establecer el título, el contenido y otros atributos de la entrada de blog. Por último, usa el objeto GoogleService para insertar la publicación. Este es un ejemplo de cómo publicar una nueva entrada de 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);
}

El método insert toma la URL de la publicación del servicio como parámetro. Luego, el método muestra la entrada tal como la almacenó Blogger. La entrada que se muestra es la misma que enviaste, pero también contiene varios elementos que agregó Blogger, como un ID de publicación.

Si tu solicitud falla por algún motivo, es posible que Blogger muestre un código de estado diferente. Para obtener información sobre los códigos de estado, consulta el documento de referencia del protocolo de la API de Google Data.

Cómo crear un borrador de entrada de blog

Las publicaciones de borrador se crean de la misma manera que las publicaciones públicas, pero debes configurar el atributo draft del objeto Entry. Para crear una entrada de blog como la anterior como borrador, agrega la línea 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 convertir un borrador de entrada de blog existente en una entrada publicada, recupera la entrada de borrador, establece el atributo de borrador en "false" y, luego, actualízala. En las siguientes dos secciones, hablaremos sobre cómo recuperar y actualizar publicaciones.

Cómo recuperar publicaciones

En las siguientes secciones, se describe cómo recuperar una lista de publicaciones de blog, con y sin parámetros de consulta.

Puedes consultar un feed público de Blogger sin autenticación. Por lo tanto, no necesitas llamar al método setUserCredentials ni realizar la autenticación de AuthSub antes de recuperar publicaciones de un blog público.

Cómo recuperar todas las entradas de blog

Para recuperar las publicaciones del usuario, llama al mismo método getFeed que se usa para recuperar el metafeed de los blogs, pero esta vez envía la URL del feed de publicaciones de 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();
}

Cómo recuperar publicaciones con parámetros de consulta

La API de Blogger Data te permite solicitar un conjunto de entradas que coincidan con criterios especificados, como solicitar publicaciones de blog publicadas o actualizadas en un período determinado. Para ello, crea un objeto Query y pásalo al método GoogleService.getQuery.

Por ejemplo, para enviar una consulta de período, usa los métodos setPublishedMin y setPublishedMax del objeto Query. En el siguiente fragmento de código, se imprime el título de cada entrada de blog publicada entre la hora de inicio y la de finalización determinadas:

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();
}

Ten en cuenta que el objeto Query se construye con la misma URL del feed de publicaciones que se usa para recuperar las publicaciones.

La API de Blogger Data admite los siguientes métodos de Query:

addCategoryFilter
Especifica categorías (también conocidas como etiquetas) para filtrar los resultados del feed. Por ejemplo, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie muestra entradas con las etiquetas Fritz y Laurie.
setMaxResults
Establece la cantidad máxima de entradas que se mostrarán.
setPublishedMin, setPublishedMax
Establece los límites de las fechas de publicación de las entradas.
setStartIndex
Establece el índice basado en 1 del primer resultado que se recuperará (para paginación).
setUpdatedMin, setUpdatedMax
Establece los límites de las fechas de actualización de las entradas. Estos parámetros de consulta se ignoran, a menos que el parámetro orderby se establezca en updated.

Nota: Actualmente, no hay set de métodos para el parámetro de consulta orderby. Sin embargo, puedes usar el método Query.addCustomParameter() si necesitas configurarlo.

Para obtener más información sobre los parámetros de consulta, consulta la Guía de referencia de la API de datos de Blogger y la Guía de referencia de las APIs de datos de Google.

Actualiza publicaciones

Para actualizar una entrada de blog existente, primero recupera la entrada que deseas actualizar, luego modifícala y, luego, envíala a Blogger con el método update. En el siguiente fragmento de código, se modifica el título de una entrada de blog, siempre que ya hayas recuperado la entrada del 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);
}

El código anterior muestra una Entry que contiene toda la entrada que se actualizó recientemente. Para actualizar cualquier otra propiedad, simplemente configúralas en el objeto Entry antes de llamar a update.

Nota: Actualmente, no se admite la modificación de los datos del autor asociados con las publicaciones.

Cómo borrar publicaciones

Para borrar una publicación, pasa la URL de edición de la publicación al método delete en tu objeto GoogleService, de la siguiente manera:

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

Comentarios

La API de Blogger Data permite crear, recuperar y borrar comentarios. No se pueden actualizar los comentarios (ni están disponibles en la interfaz web).

Cómo crear comentarios

Para publicar un comentario, crea un objeto Entry y, luego, insértalo de la siguiente manera:

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);
}

Nota: Actualmente, solo puedes publicar comentarios en un blog que pertenezca al usuario autenticado.

Nota: Por el momento, no se admite configurar un autor personalizado para los comentarios. Todos los comentarios nuevos aparecerán como si los hubiera creado el usuario autenticado actualmente.

Cómo recuperar comentarios

Puedes recuperar los comentarios de una publicación en particular desde la URL del feed de comentarios de la publicación:

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();
}

También puedes obtener los comentarios de todas las publicaciones con la URL del feed de comentarios del blog:

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

Cómo borrar comentarios

Para borrar un comentario, pasa la URL de edición del comentario al método delete de tu objeto GoogleService de la siguiente manera:

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

Volver al principio