Questa pagina è stata tradotta dall'API Cloud Translation.

Guida per gli sviluppatori: Java

Importante: A partire dal 30 settembre 2024 interromperemo il supporto per la versione 2.0 dell'API di dati di Google. Per garantire una funzionalità continua, aggiorna le applicazioni che si basano sulla versione 2.0 di Google l'API Data alla versione più recente dell'API. Per la versione più recente, utilizza i link nella barra di navigazione a sinistra. Nota: anche se alcune richieste GET (ad esempio l'elenco dei post) continueranno a essere supportate come feed negli URL, il loro comportamento presenta differenze minime. Per informazioni dettagliate, consulta la documentazione della guida di Blogger.

L'API dati di Blogger consente alle applicazioni client di visualizzare e aggiornare Blogger contenuti sotto forma di feed di API di dati di Google.

La tua applicazione client può utilizzare l'API di dati di Blogger per creare un nuovo blog post, modificare o eliminare post del blog esistenti e cercare post del blog che corrispondano criteri specifici.

Oltre a fornire alcune informazioni sulle funzionalità di Blogger API di dati, questo documento fornisce esempi di interazioni di base dell'API di dati utilizzando il client Java libreria di Google. Se vuoi saperne di più sugli elementi di base, utilizzato dalla libreria, consulta la sezione Protocollo della questa guida per gli sviluppatori.

Sommario

Pubblico

Questo documento è destinato ai programmatori che desiderano scrivere un client Java di applicazioni in grado di interagire con Blogger.

In questo documento si presume che tu abbia compreso le idee generali alla base delle API di dati di Google del protocollo.

Per informazioni di riferimento sulle classi e sui metodi forniti dalla libreria client, consulta il riferimento all'API della libreria client Java. Per informazioni generali sulle API di dati di Blogger informazioni, consulta la documentazione di riferimento del protocollo .

Per iniziare

Per assistenza sulla configurazione della libreria client, consulta la Guida introduttiva.

La libreria client Java richiede Java 1.5. Dopo aver scaricato la libreria client, troverai i classi necessari per iniziare nel file java/lib/gdataclient-1.0.jar.

Creazione di un account Blogger

Puoi registrarti per un Blogger a scopo di test. Blogger utilizza gli Account Google, quindi se hai già un Account Google, non devi fare altro.

Eseguire il codice di esempio

Un client di esempio completamente funzionante contenente tutto il codice campione mostrato in questo è disponibile nella distribuzione della libreria client Java, nel directory gdata/java/sample/blogger/BloggerClient.java. Le istruzioni di compilazione e esecuzione sono incluse nella stessa directory nel file README.txt.

Il client di esempio esegue diverse operazioni sul blog fornito per dimostrare l'utilizzo dell'API di dati di Blogger.

Per compilare gli esempi in questo documento nel tuo codice, ti serviranno le seguenti istruzioni import:

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

Autenticazione nel servizio Blogger

Puoi accedere ai feed pubblici e privati utilizzando l'API Blogger Data. I feed pubblici non richiedono alcuna autenticazione, ma sono di sola lettura. Se vuoi modificare i blog, il tuo cliente deve autenticarsi prima di richiedere i feed privati. Può eseguire l'autenticazione utilizzando uno dei tre approcci seguenti: autenticazione OAuth, proxy AuthSub autenticazione o nome utente e password di ClientLogin autenticazione.

Per ulteriori informazioni sull'autenticazione con le API di dati di Google in generale, vedi il link di autenticazione documentazione.

La maggior parte degli esempi nelle sezioni successive di questo documento presuppone che tu abbia un oggetto GoogleService autenticato.

Autenticazione OAuth

Per la documentazione sull'autenticazione OAuth utilizzando la libreria GData per Java, consulta OAuth nelle librerie client del protocollo Google Data.

Autenticazione proxy AuthSub

L'autenticazione proxy AuthSub viene usata dalle applicazioni web che devono autenticare i propri utenti agli Account Google. L'operatore del sito web e il cliente non abbiano accesso al nome utente e alla password dell'utente di Blogger; il client ottiene speciali token AuthSub che gli consentono di agire per conto di uno specifico utente. Per informazioni più dettagliate, consulta la documentazione di AuthSub.

Quando un utente visita per la prima volta la tua applicazione, non è ancora stato autenticato. In questo caso, devi mostrare alcune informazioni e un link che indirizzi l'utente a una pagina di Google per autenticare la tua richiesta di accesso ai suoi blog. La libreria client Java fornisce una funzione per generare dell'URL della pagina. Il codice riportato di seguito recupera l'URL della pagina 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);

Il metodo getRequestUrl accetta i seguenti parametri (corrispondenti ai parametri di query utilizzati dall'handler AuthSubRequest):

avanti: L'URL della pagina a cui Google deve reindirizzare l'utente dopo l'autenticazione.
ambito: Indica che l'applicazione sta richiedendo un token per accedere ai feed di Blogger. La stringa di ambito da utilizzare è http://www.blogger.com/feeds/ (ovviamente codificata come URL).
sicuro: Indica se il client richiede un token sicuro.
sessione: Indica se il token restituito può essere scambiato con un token (di sessione) multiuso.

L'esempio precedente mostra una chiamata che non richiede un token sicuro (il valore di secure è false). L'URL della richiesta risultante potrebbe avere il seguente aspetto:

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'utente segue il link al sito di Google ed esegue l'autenticazione sul proprio sito Account.

Dopo l'autenticazione, il sistema AuthSub lo reindirizza all'URL specificato nel parametro di query next di AuthSubRequest URL. Il sistema AuthSub aggiunge un token di autenticazione a quell'URL come valore del parametro di query token. Ad esempio:

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

Questo valore del token rappresenta un token AuthSub monouso. In questo esempio, poiché è stato specificato session = true, questo token può essere scambiato un token di sessione AuthSub richiamando AuthSubSessionToken come segue, dove urlFromAuthSub è l'URL di AuthSub ha aggiunto il token a:

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

In altre parole, passi il token monouso al metodo exchangeForSessionToken, insieme a null (per la modalità non registrata) o a una chiave privata (per la modalità registrata) e l'interfaccia AuthSub restituisce un token di sessione. Per ulteriori informazioni sulle applicazioni e sulle chiavi private registrate, consulta la sezione "Firma delle richieste" della documentazione di AuthSub.

La tua applicazione potrà quindi utilizzare il token di sessione nelle interazioni successive con Blogger. Per indicare alla libreria client Java di inviare automaticamente il token di sessione con ogni richiesta, chiama il metodo setAuthSubToken dell'oggetto GoogleService:

GoogleService.setAuthSubToken(sessionToken, null);

Dopodiché, la libreria client invia automaticamente il token con ogni richiesta.

Autenticazione nome utente/password ClientLogin

Utilizza l'autenticazione ClientLogin se il client è un client "installato" autonomo per un solo utente (ad esempio un'applicazione desktop). Basta chiamare il metodo setUserCredentials sull'oggetto GoogleService e tutte le interazioni successive con Blogger verranno autenticate:

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

Nello snippet riportato sopra, passiamo due parametri al constructor GoogleService. Il primo parametro è il nome del servizio con cui vogliamo interagire. Il secondo parametro è il nome della nostra applicazione nel formato companyName-applicationName-versionID.

Per ulteriori informazioni sull'autenticazione ClientLogin, incluso un esempio richieste e risposte, consulta la sezione Autenticazione per Applicazioni.

Nota: utilizza lo stesso token per tutte le richieste in un una data sessione; non acquisire un nuovo token per ogni richiesta di Blogger.

Nota: come descritto nella documentazione di ClientLogin, la richiesta di autenticazione potrebbe non riuscire e richiedere una verifica CAPTCHA. Se desideri che Google emetta e gestisca il test CAPTCHA, indirizza l'utente a https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (anziché l'URL di gestione CAPTCHA fornito in ClientLogin documentazione).

Recupero di un elenco di blog

L'API Blogger Data fornisce un feed che elenca i blog di un determinato utente; questo feed è noto come "metafeed".

Il seguente codice di esempio utilizza un oggetto GoogleService autenticato per recuperare il metafeed e poi stampa il titolo di ogni 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());
  }
}

Prendi nota dell'URL utilizzato dal metodo getFeed. Questa è l'impostazione predefinita URL del metafeed; viene restituito un elenco di blog per l'utente attualmente autenticato. Per accedere a un feed per un utente diverso, puoi inserire l'ID utente al posto di default nell'URL del metafeed. L'ID utente è la stringa di cifre alla fine dell'URL del profilo dell'utente.

Creazione di post

L'API di dati di Blogger ti consente di creare e pubblicare nuove voci di blog, nonché la creazione di bozze delle voci.

Nota: l'impostazione di un autore personalizzato per i post non è attualmente supportata. Tutti i nuovi post verranno visualizzati come se fossero stati creati dall'utente attualmente autenticato.

Pubblicazione di un post del blog

Puoi utilizzare la libreria client Java per pubblicare nuovi articoli del blog.

Per prima cosa, crea un oggetto Entry per rappresentare il post del blog. Poi puoi impostare il titolo, i contenuti e altri attributi del post del blog. Infine, utilizza l'oggetto GoogleService per inserire il post. Ecco un esempio su come pubblicare un nuovo post del 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);
}

Il metodo insert utilizza come parametro l'URL post del servizio. Il metodo restituisce quindi la voce così come era archiviata da Blogger. Voce restituito è lo stesso che hai inviato, ma contiene anche vari elementi aggiunti da Blogger, ad esempio un ID post.

Se per qualche motivo la richiesta non va a buon fine, Blogger potrebbe restituire uno stato diverso. le API nel tuo codice. Per informazioni sui codici di stato, consulta la pagina relativa ai codici di stato documento di riferimento del protocollo API.

Creare una bozza di un post del blog

I post in bozza vengono creati nello stesso modo dei post pubblici, ma devi impostare l'attributo draft dell'oggetto Entry. Puoi crea un post del blog come quello sopra come bozza aggiungendo le voci evidenziate riga:

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

Puoi trasformare una bozza di post del blog esistente in un post pubblicato recuperando la bozza del post, impostando l'attributo "bozza" su "false" e aggiornando il post. Il recupero e l'aggiornamento dei post verranno trattati nelle due sezioni successive.

Recupero dei post

Le seguenti sezioni descrivono come recuperare un elenco di post del blog, con e senza parametri di query.

Puoi eseguire query su un feed pubblico di Blogger senza autenticazione. Pertanto, non è necessario chiamare il metodo setUserCredentials o eseguire AuthSub l'autenticazione prima di recuperare i post da un blog pubblico.

Recupero di tutti i post del blog

Per recuperare i post dell'utente, chiama lo stesso metodo getFeed utilizzato per recuperare il metafeed del blog, ma questa volta invia l'URL del feed del post del 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();
}

Recupero dei post utilizzando i parametri di query

L'API Blogger Data ti consente di richiedere un insieme di voci che corrispondono a criteri specificati, ad esempio richiedere post del blog pubblicati o aggiornati in un determinato intervallo di date. A questo scopo, crea un oggetto Query e passalo al metodo GoogleService.getQuery.

Ad esempio, per inviare una query relativa a un intervallo di date, utilizza setPublishedMin e setPublishedMax dell'oggetto Query. La Il seguente snippet di codice stampa il titolo di ciascun post del blog pubblicato tra un'ora di inizio e un'ora di fine specificate:

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

Tieni presente che l'oggetto Query è stato creato utilizzando lo stesso URL del feed dei post utilizzato per recuperare i post.

L'API di dati di Blogger supporta i seguenti metodi Query:

addCategoryFilter: Specifica le categorie (dette anche etichette) per filtrare i risultati del feed. Ad esempio, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie restituisce voci con entrambe le etichette Fritz e Laurie.
setMaxResults: Imposta il numero massimo di voci da restituire.
setPublishedMin, setPublishedMax: Imposta i limiti per le date di pubblicazione delle voci.
setStartIndex: Imposta l'indice su base 1 del primo risultato da recuperare (per il paging).
setUpdatedMin, setUpdatedMax: Imposta i limiti per le date di aggiornamento delle voci. Questi parametri di query vengono ignorati a meno che il parametro orderby non sia impostato su updated.

Nota: al momento non sono presenti setter per Parametro di query orderby. Tuttavia, puoi comunque utilizzare Query.addCustomParameter() se devi impostarlo.

Per ulteriori informazioni sui parametri di query, consulta la Guida di riferimento dell'API di dati di Blogger e la Guida di riferimento delle API di dati di Google.

Aggiornamento dei post

Per aggiornare un post del blog esistente, devi prima recuperare la voce da aggiornare, poi modificarla e infine inviarla a Blogger utilizzando il metodo update. Il seguente snippet di codice modifica il titolo di un articolo del blog, sempre che tu abbia già recuperato la voce dal o server web.

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

Il codice riportato sopra restituisce un Entry contenente l'intero post appena aggiornato. Per aggiornare altre proprietà, impostale nell'oggetto Entry prima di chiamare update.

Nota: la modifica dei dati dell'autore associati ai post non è attualmente supportata.

Eliminazione dei post

Per eliminare un post, passa l'URL di modifica del post al metodo delete nell'oggetto GoogleService, come segue:

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

Commenti

L'API Blogger Data consente di creare, recuperare ed eliminare i commenti. L'aggiornamento dei commenti non è supportato (e non è disponibile nell'interfaccia web).

Creazione di commenti in corso...

Per pubblicare un commento, crea un oggetto Entry e inseriscilo come segue:

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: al momento puoi pubblicare commenti solo su un blog di proprietà dell'utente autenticato.

Nota: l'impostazione di un autore personalizzato per i commenti non è attualmente supportata. Tutti i nuovi commenti verranno visualizzati come se fossero stati creati dall'utente attualmente autenticato.

Recupero dei commenti

Puoi recuperare i commenti per un determinato post dall'URL del relativo feed dei commenti:

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

In alternativa, puoi recuperare i commenti di tutti i post utilizzando l'URL del feed dei commenti del blog:

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

Eliminazione dei commenti in corso...

Per eliminare un commento, trasmetti l'URL di modifica del commento a delete sull'oggetto GoogleService in questo modo:

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

Torna all'inizio