Cette page a été traduite par l'API Cloud Translation.

Guide du développeur: Java

Important : La version 2.0 de Google Data API ne sera plus prise en charge à partir du 30 septembre 2024. Pour vous assurer que vos applications qui dépendent de l'API Google Data 2.0 continuent de fonctionner, mettez-les à jour vers la dernière version de l'API. Pour obtenir la dernière version, utilisez les liens de la barre de navigation de gauche. Remarque : Bien que certaines requêtes GET (telles que les posts de fiches) continuent d'être acceptées en tant qu'URL de flux, leur comportement présente de légères différences. Pour en savoir plus, consultez la documentation Aide Blogger.

L'API Blogger Data permet aux applications clientes d'afficher et de mettre à jour le contenu Blogger sous la forme de flux de l'API Google Data.

Votre application cliente peut utiliser l'API Blogger Data pour créer un blog des articles, modifier ou supprimer des articles de blog existants, et rechercher des articles de blog qui correspondent des critères particuliers.

En plus de vous présenter les fonctionnalités de Blogger, Data API, ce document fournit des exemples d'interactions élémentaires de l'API Data à l'aide de le client Java bibliothèque. Pour en savoir plus sur le protocole sous-jacent utilisé par la bibliothèque, consultez la section sur le protocole de ce guide du développeur.

Sommaire

Audience
Premiers pas
1. Créer un compte Blogger
2. Exécuter l'exemple de code
S'authentifier auprès du service Blogger
Récupérer une liste de blogs
Créer des posts
1. Publier un article de blog
2. Créer un brouillon d'article de blog
Récupération des posts
1. Récupération de tous les articles de blog
2. Récupérer des posts à l'aide de paramètres de requête
Modifier des posts
Supprimer des posts
Commentaires

Audience

Ce document s'adresse aux programmeurs qui souhaitent écrire des applications clientes Java pouvant interagir avec Blogger.

Dans ce document, nous partons du principe que vous comprenez le concept général qui sous-tend les API Google Data protocole.

Pour obtenir des informations de référence sur les classes et les méthodes fournies par la bibliothèque cliente, consultez la documentation de référence de l'API de la bibliothèque cliente Java. Pour en savoir plus sur l'API Blogger Data, consultez le guide de référence du protocole.

Premiers pas

Si vous avez besoin d'aide pour configurer la bibliothèque cliente, reportez-vous à la section Guide de démarrage.

La bibliothèque cliente Java nécessite Java 1.5. Après avoir téléchargé les bibliothèque cliente, vous trouverez les cours dont vous avez besoin pour démarrer dans la java/lib/gdataclient-1.0.jar.

Création d'un compte Blogger

Vous pouvez vous inscrire à un Blogger à des fins de test. Blogger utilise un compte Google. Si vous possédez déjà un compte Google, vous êtes prêt.

Exécuter l'exemple de code

Un exemple de client complet et fonctionnel, contenant tous les exemples de code présentés dans ce disponible dans la distribution de la bibliothèque cliente Java, sous répertoire gdata/java/sample/blogger/BloggerClient.java. Les instructions de compilation et d'exécution sont incluses dans le même répertoire dans le fichier README.txt.

L'exemple de client effectue plusieurs opérations sur le blog fourni pour illustrer l'utilisation de l'API Blogger Data.

Pour compiler les exemples de ce document dans votre propre code, vous avez besoin des instructions import suivantes :

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

S'authentifier auprès du service Blogger

Vous pouvez accéder aux flux publics et privés à l'aide de l'API Blogger Data. Les flux publics ne nécessitent aucune authentification, mais ils sont en lecture seule. Si vous souhaitez modifier des blogs, votre client doit s'authentifier avant de demander des flux privés. Il peut s'authentifier à l'aide de l'une des trois approches suivantes : authentification OAuth, authentification par proxy AuthSub ou authentification nom d'utilisateur/mot de passe ClientLogin.

Pour en savoir plus sur l'authentification avec les API Google Data en général, consultez la documentation sur l'authentification.

La plupart des exemples des sections suivantes de ce document supposent que vous avez un objet GoogleService authentifié.

Authentification OAuth

Pour en savoir plus sur l'authentification OAuth à l'aide de la bibliothèque Java GData, consultez OAuth dans les bibliothèques clientes du protocole Google Data.

Authentification par proxy AuthSub

L'authentification par proxy AuthSub est utilisée par les applications Web qui doivent à authentifier leurs utilisateurs auprès des utilisateurs de comptes Google. L’opérateur du site Web et le client code n'a pas accès au nom d'utilisateur ni au mot de passe de l'utilisateur Blogger. À la place, le client obtient des jetons AuthSub spéciaux qui lui permettent d'agir au nom d'un utilisateur particulier. Pour en savoir plus, consultez la documentation AuthSub.

Lorsqu'un utilisateur accède à votre application pour la première fois, il n'est pas encore authentifié. Dans ce cas, vous devez afficher des informations et un lien redirigeant l'utilisateur vers une page Google pour authentifier votre demande d'accès à ses blogs. La bibliothèque cliente Java fournit une fonction permettant de générer l'URL de la page Google. Le code ci-dessous récupère l'URL de la page de requête AuthSub:

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

La méthode getRequestUrl utilise les paramètres suivants : (correspondant aux paramètres de requête utilisés par AuthSubRequest) gestionnaire):

suivant: URL de la page vers laquelle Google doit rediriger l'utilisateur après l'authentification.
champ d'application: Indique que l'application demande un jeton pour accéder aux flux Blogger. La chaîne de portée à utiliser est http://www.blogger.com/feeds/ (encodée au format URL, bien entendu).
sécurisé: Indique si le client demande un jeton sécurisé.
session: Indique si le jeton renvoyé peut être échangé contre un jeton à usages multiples (session).

L'exemple ci-dessus montre un appel qui ne demande pas de jeton sécurisé (la valeur de secure est false). L'URL de requête obtenue peut se présenter comme suit:

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

L'utilisateur suit le lien vers le site Google et s'authentifie sur son compte Compte.

Une fois l'utilisateur authentifié, le système AuthSub le redirige vers l'URL. que vous avez spécifié dans le paramètre de requête next de l'AuthSubRequest URL. Le système AuthSub ajoute un jeton d'authentification à cette URL, puisque Valeur du paramètre de requête token. Exemple :

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

Cette valeur de jeton représente un jeton AuthSub à usage unique. Dans cet exemple, comme session = true a été spécifié, ce jeton peut être échangé contre un jeton de session AuthSub en appelant le service AuthSubSessionToken, comme suit, où urlFromAuthSub est l'URL à laquelle AuthSub a ajouté le jeton :

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

Autrement dit, vous transmettez votre jeton à usage unique à la méthode exchangeForSessionToken, avec null (pour le mode non enregistré) ou une clé privée (pour le mode enregistré), et l'interface AuthSub renvoie un jeton de session. Pour en savoir plus sur les enregistrements applications et de clés privées, consultez la section Signing requests de la documentation AuthSub.

Votre application peut ensuite utiliser le jeton de session dans les interactions ultérieures. avec Blogger. Pour demander à la bibliothèque cliente Java d'envoyer automatiquement le jeton de session avec chaque requête, appelez la méthode setAuthSubToken de l'objet GoogleService :

GoogleService.setAuthSubToken(sessionToken, null);

Ensuite, la bibliothèque cliente envoie automatiquement le jeton avec chaque requête.

Authentification par nom d'utilisateur/mot de passe ClientLogin

Utilisez l'authentification ClientLogin si votre client est un utilisateur autonome et unique. "installé" (comme une application de bureau). Il vous suffit d'appeler la méthode Méthode setUserCredentials sur votre objet GoogleService et toutes les interactions ultérieures avec Blogger seront authentifiées:

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

Dans l'extrait ci-dessus, nous transmettons deux paramètres Constructeur GoogleService. Le premier paramètre est le nom du service avec lequel nous souhaitons interagir. Le deuxième paramètre est le nom dans le formulaire companyName, applicationName et versionID

Pour en savoir plus sur l'authentification ClientLogin, y compris des exemples requêtes et les réponses correspondantes, consultez la section Authentification pour les Applications.

Remarque : Utilisez le même jeton pour toutes les requêtes d'une session donnée. N'obtenez pas de nouveau jeton pour chaque requête Blogger.

Remarque : Comme décrit dans la documentation ClientLogin, la requête d'authentification peut échouer et demander un défi CAPTCHA. Si vous souhaitez que Google émette et gère le test CAPTCHA, redirigez l'utilisateur vers https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (plutôt que vers l'URL de gestion du CAPTCHA indiquée dans la documentation ClientLogin).

Récupérer une liste de blogs

L'API Blogger Data fournit un flux qui liste les blogs d'un utilisateur donné. Ce flux est appelé "metaflux".

L'exemple de code suivant utilise un GoogleService authentifié pour récupérer le métaflux et imprime le titre de chaque 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());
  }
}

Notez l'URL utilisée par la méthode getFeed. Il s'agit de l'URL du métaflux par défaut. Elle renvoie la liste des blogs de l'utilisateur actuellement authentifié. Pour accéder à un flux pour un autre utilisateur, vous pouvez remplacer default par l'ID de l'utilisateur dans l'URL du métaflux. L'identifiant de l'utilisateur est une chaîne de chiffres à la fin de l'URL du profil de l'utilisateur.

Création de posts

L'API Blogger Data vous permet de créer et de publier des articles de blog, ainsi que des brouillons d'articles.

Remarque : Il n'est actuellement pas possible de définir un auteur personnalisé pour les posts. Tous les nouveaux posts apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Publication d'un article de blog

Vous pouvez utiliser la bibliothèque cliente Java pour publier de nouveaux articles de blog.

Commencez par créer un objet Entry pour représenter l'article de blog. Ensuite, vous pouvez définir le titre, le contenu et d'autres attributs de l'article de blog. Enfin, utilisez l'objet GoogleService pour insérer le post. Voici un exemple de procédure à suivre pour publier un nouveau post 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);
}

La méthode insert utilise l'URL de publication du service comme paramètre. La méthode renvoie ensuite l'entrée telle qu'elle a été stockée par Blogger. L'entrée renvoyé est le même que celui que vous avez envoyé, mais il contient également divers éléments ajoutés par Blogger, comme un ID d'article.

Si votre requête échoue pour une raison quelconque, Blogger peut renvoyer un code d'état différent. Pour en savoir plus sur les codes d'état, consultez le document de référence sur le protocole de l'API Google Data.

Créer un brouillon d'article de blog

Les brouillons sont créés de la même façon que les posts publics, mais vous devez définir L'attribut draft de l'objet Entry Vous pouvez créez un brouillon d'article de blog comme celui présenté ci-dessus en ajoutant ligne:

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

Vous pouvez transformer un brouillon d'article de blog existant en article publié en récupérant le brouillon, en définissant l'attribut "brouillon" sur "false", puis en mettant à jour l'article. Nous verrons comment récupérer et mettre à jour des posts dans les deux sections suivantes.

Récupérer des posts

Les sections suivantes expliquent comment récupérer une liste d'articles de blog, avec et sans paramètres de requête.

Vous pouvez interroger un flux public Blogger sans vous authentifier. Par conséquent, vous n'avez pas besoin d'appeler la méthode setUserCredentials ni d'effectuer l'authentification AuthSub avant de récupérer les posts d'un blog public.

Récupération de tous les articles de blog

Pour récupérer les posts de l'utilisateur, appelez la même méthode getFeed que celle utilisée. pour récupérer le métaflux des blogs, en envoyant cette fois l'URL du flux d'articles 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();
}

Récupérer des posts à l'aide de paramètres de requête

L'API Blogger Data vous permet de demander un ensemble d'entrées correspondant à critères, comme demander la publication d'articles de blog ou la mise à jour à une date donnée la plage d'adresses IP. Pour ce faire, vous devez créer un objet Query et le transmettre à la GoogleService.getQuery.

Par exemple, pour envoyer une requête de plage de dates, utilisez les méthodes setPublishedMin et setPublishedMax de l'objet Query. La l'extrait de code suivant imprime le titre de chaque article de blog publié entre le heure de début et de fin données:

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

Notez que l'objet Query est construit à l'aide de la même URL de flux de posts utilisée pour récupérer les posts.

L'API Blogger Data est compatible avec les méthodes Query suivantes :

addCategoryFilter: Spécifiez des catégories (également appelées "libellés") pour filtrer les résultats du flux. Par exemple, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie renvoie des entrées avec les étiquettes Fritz et Laurie.
setMaxResults: Définit le nombre maximal d'entrées à renvoyer.
setPublishedMin, setPublishedMax: Fixez des limites aux dates de publication des entrées.
setStartIndex: Définit l'index en base 1 du premier résultat à récupérer (pour la pagination).
setUpdatedMin, setUpdatedMax: Définir les limites des dates de mise à jour des entrées Ces paramètres de requête sont ignorés, sauf si le paramètre orderby est défini sur updated.

Remarque : Il n'existe actuellement aucun setter pour le paramètre de requête orderby. Toutefois, vous pouvez toujours utiliser la méthode Query.addCustomParameter() si vous devez le définir.

Pour en savoir plus sur les paramètres de requête, consultez le guide de référence de l'API Blogger Data et le guide de référence des API Google Data.

Mise à jour des posts...

Pour mettre à jour un article de blog existant, vous devez d'abord récupérer l'entrée que vous souhaitez modifier, puis la modifier, puis l'envoyer à Blogger à l'aide de la méthode update. L'extrait de code suivant modifie le titre d'une en partant du principe que vous l'avez déjà récupérée Google Cloud.

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

Le code ci-dessus renvoie un Entry contenant l'intégralité post récemment mis à jour. Pour mettre à jour d'autres propriétés, il vous suffit de les définir dans le Entry avant d'appeler update.

Remarque : Il n'est pas possible de modifier les données d'auteur associées aux posts pour le moment.

Suppression des posts

Pour supprimer un post, transmettez l'URL de modification du post à la méthode delete de votre objet GoogleService, comme suit :

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

Commentaires

L'API Blogger Data permet de créer, de récupérer et de supprimer des commentaires. La mise à jour des commentaires n'est pas disponible (cette fonctionnalité n'est pas non plus disponible sur le Web) .

Créer des commentaires

Pour publier un commentaire, créez un objet Entry et insérez-le comme suit:

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

Remarque: Actuellement, vous ne pouvez publier des commentaires que pour un blog appartenant à l’utilisateur authentifié.

Remarque: Définir un auteur personnalisé pour les commentaires est n'est actuellement pas prise en charge. Tous les nouveaux commentaires apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Récupération des commentaires

Vous pouvez récupérer les commentaires d'un post spécifique à partir de l'URL du flux de commentaires du post :

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

Vous pouvez également obtenir les commentaires de tous les articles à l'aide de l'URL du flux de commentaires du blog :

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

Suppression des commentaires

Pour supprimer un commentaire, transmettez l'URL de modification du commentaire à la méthode delete de votre objet GoogleService comme suit :

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

Haut de page