Guía para desarrolladores: Java

Importante: A partir del 30 de septiembre de 2024, descontinuaremos la compatibilidad con la API de Google Data v2.0. Para garantizar la funcionalidad continua, actualiza las aplicaciones que dependen de la versión 2.0 de Google Data API a la versión más reciente de la API. Para obtener la versión más reciente, usa los vínculos de la barra de navegación de la izquierda. Nota: Aunque algunas solicitudes GET (como las publicaciones de fichas) seguirán siendo compatibles como feed. de sitios web, existen pequeñas diferencias en su comportamiento. Para obtener información detallada, consulta la documentación de la Ayuda de Blogger.

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

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 conocer más sobre los conceptos protocolo 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 autenticar el servicio de Blogger
    1. Autenticación de OAuth
    2. Autenticación de proxy de AuthSub
    3. 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. Publicar 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 las 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 referencia general de la API de datos de Blogger consulta la referencia del protocolo .

Cómo comenzar

Para obtener ayuda en la configuración de la biblioteca cliente, consulta el artículo Cómo obtener de la Guía de inicio rápido.

La biblioteca cliente de Java requiere Java 1.5. Luego de descargar la biblioteca cliente, encontrarás las clases que necesitas para comenzar en la 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 muestra realiza varias operaciones en el blog proporcionado para demostrar el uso de la API de datos de Blogger.

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

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

Autenticación 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 autenticación, pero son de solo lectura. Si quieres modificar blogs, tu cliente debe autenticarse antes de solicitar feeds privados. Puede autenticarse con cualquiera de estos tres enfoques: autenticación OAuth, proxy AuthSub autenticación o nombre de usuario y contraseña de ClientLogin la autenticación de varios factores.

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 las muestras de las secciones posteriores de este documento se supone que has un objeto GoogleService autenticado.

Autenticación de OAuth

Para obtener documentación sobre la autenticación de OAuth con la biblioteca GData de Java, consulta OAuth en Bibliotecas cliente del protocolo de datos de Google.

Autenticación del proxy de AuthSub

La autenticación del proxy de AuthSub es utilizada por las aplicaciones web que necesitan autenticar a sus usuarios en Cuentas de Google. El operador del sitio web y el cliente no tenga acceso al nombre de usuario ni a la contraseña del usuario de Blogger; en su lugar, el cliente obtiene tokens 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 ha estado autenticado. En este caso, debes mostrar información y un vínculo dirigir 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 AuthSub lo redirecciona a la URL que especificaste en el parámetro de consulta next de AuthSubRequest URL. 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 AuthSubSessionToken de la siguiente manera, donde urlFromAuthSub es la URL a la que AuthSub anexaste el token a:

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 aplicaciones y claves privadas, consulta el artículo "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. Cómo indicarle a la biblioteca cliente de Java que envíe la sesión automáticamente token por cada solicitud, llama al GoogleService Método setAuthSubToken:

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/contraseña de ClientLogin

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

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, incluida la solicitudes y respuestas, consulta el artículo Autenticación para Aplicaciones.

Nota: Usa el mismo token para todas las solicitudes de un sesión determinada; no adquieren 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 se encargue del desafío de CAPTCHA, entonces enviar al usuario a https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (en lugar de la URL de control de CAPTCHA que se proporciona en el archivo ClientLogin documentación).

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

Ten en cuenta 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 al feed de un usuario diferente, puedes colocar el ID del usuario en lugar del ID default en la URL del metafeed. El ID del usuario es una cadena de dígitos al final de la URL del perfil del usuario.

Cómo crear publicaciones

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

Nota: Establecer un autor personalizado para las publicaciones es no se admite en este momento. Todas las publicaciones nuevas aparecerán como si hubieran sido creadas por el usuario autenticado actualmente.

Publicar 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. Finalmente, Usa el objeto GoogleService para insertar la publicación. Aquí hay 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 por algún motivo falla tu solicitud, Blogger podría mostrar un estado diferente código. 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

Los borradores de entradas se crean del mismo modo que las publicaciones públicas, pero debes establecer el atributo draft del objeto Entry. Puedes agrega como borrador una entrada de blog como la anterior línea:

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 una entrada de blog existente en una entrada publicada, puedes recuperarla la entrada borrador, configurando el atributo borrador como falso y actualizando el publicación. Abordaremos la recuperación y la actualización de publicaciones en las siguientes dos secciones.

Cómo recuperar publicaciones

En las siguientes secciones, se describe cómo recuperar una lista de entradas 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.

Recuperando todas las entradas del 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 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 hora 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 datos de Blogger admite los siguientes métodos 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 y setPublishedMax
Establece los límites en las fechas de publicación de entrada.
setStartIndex
Configura el índice basado en 1 del primer resultado que se recuperará (para la paginación).
setUpdatedMin, setUpdatedMax
Establece los límites en las fechas de actualización de entradas. Estos parámetros de consulta se ignoran, a menos que el parámetro orderby se establezca en updated.

Nota: Por el momento, no hay métodos set para las Parámetro de consulta orderby. Sin embargo, puedes usar la Query.addCustomParameter() si necesitas configurar esto.

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.

Actualizando 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. El siguiente fragmento de código modifica el título de una entrada de blog, suponiendo que ya recuperaste 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 establécelas en el Entry antes de llamar a update.

Nota: Modificar los datos del autor asociados con publicaciones no es compatible actualmente.

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 datos de Blogger permite crear, recuperar y borrar comentarios. No se admite la actualización de comentarios (tampoco está disponible en la Web) de usuario).

Creación de 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: Por el momento, solo puedes publicar comentarios en un blog que pertenece al usuario autenticado.

Nota: La configuración de un autor personalizado para los comentarios es no se admite en este momento. 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();
}

O puedes ver los comentarios de todas las entradas a través de 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