Importante: questa è una versione obsoleta della pagina. Per la versione più recente, utilizza i link nella barra di navigazione a sinistra.
L'API di dati di Blogger consente alle applicazioni client di visualizzare e aggiornare i contenuti di Blogger sotto forma di feed di API di dati di Google.
La tua applicazione client può utilizzare l'API di dati di Blogger per creare nuovi post del blog, modificare o eliminare post di blog esistenti ed eseguire query per i post dei blog che corrispondono a determinati criteri.
Oltre a fornire alcune informazioni sulle funzionalità dell'API di dati di Blogger, questo documento fornisce esempi di interazioni di base dell'API di dati utilizzando la libreria client Java. Se ti interessa saperne di più sul protocollo sottostante utilizzato dalla libreria, consulta la sezione Protocollo di questa guida per gli sviluppatori.
Contenuti
Pubblico
Questo documento è destinato ai programmatori che desiderano scrivere applicazioni client Java in grado di interagire con Blogger.
In questo documento si presume che tu abbia compreso le idee generali alla base del protocollo delle API di dati di Google.
Per informazioni di riferimento sulle classi e sui metodi forniti dalla libreria client, consulta Riferimento API della libreria client Java. Per informazioni generali di riferimento sull'API Blogger Data, consulta la Guida di riferimento del protocollo.
Per iniziare
Per assistenza nella configurazione della libreria client, consulta la Guida introduttiva.
La libreria client Java richiede Java 1.5. Dopo aver scaricato la libreria client, troverai nel file java/lib/gdataclient-1.0.jar
i corsi che ti servono per iniziare.
Creazione di un account Blogger
Ti consigliamo di registrare un account Blogger a scopo di test. Blogger utilizza Account Google, quindi se disponi già di un account Google, non devi fare altro.
Esecuzione del codice campione
Un client di esempio funzionante completo contenente tutto il codice campione mostrato in questo documento è disponibile nella distribuzione della libreria client Java, nella directory gdata/java/sample/blogger/BloggerClient.java
. Le istruzioni per la build e l'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, sono necessarie 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 a feed pubblici e privati utilizzando l'API di dati di Blogger. I feed pubblici non richiedono alcuna autenticazione, ma sono di sola lettura. Se vuoi modificare i blog, il client deve eseguire l'autenticazione prima di richiedere feed privati. Può eseguire l'autenticazione utilizzando uno dei due metodi seguenti: autenticazione proxy AuthSub o autenticazione nome utente/password ClientLogin.
Per ulteriori informazioni sull'autenticazione con le API di dati di Google in generale, consulta la documentazione sull'autenticazione.
La maggior parte dei campioni nelle sezioni successive di questo documento presuppone
che tu abbia un oggetto GoogleService
autenticato.
Autenticazione proxy AuthSub
L'autenticazione proxy AuthSub viene utilizzata dalle applicazioni web che devono autenticare i propri utenti tramite Account Google. L'operatore del sito web e il codice client non hanno accesso al nome utente e alla password dell'utente di Blogger; il client riceve invece speciali token AuthSub che consentono al client di agire per conto di un determinato 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, dovrai visualizzare alcune informazioni e un link che indirizzi l'utente a una pagina Google per autenticare la tua richiesta di accesso ai suoi blog. La libreria client Java fornisce una funzione per generare l'URL della pagina Google. 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
richiede i seguenti parametri
(corrispondenti ai parametri di query utilizzati dal gestore AuthSubRequest):
- avanti
- L'URL della pagina a cui Google deve reindirizzare l'utente dopo l'autenticazione.
- ambito
- Indica che l'applicazione richiede un token per accedere ai feed di Blogger. La stringa di ambito da utilizzare è
http://www.blogger.com/feeds/
(con codifica URL, ovviamente). - 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 riportato sopra 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 Account Google.
Dopo l'autenticazione dell'utente, il sistema AuthSub lo reindirizza all'URL specificato nel parametro di query next
dell'URL AuthSubRequest. 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
con un token di sessione AuthSub chiamando il servizio AuthSubSessionToken
, come segue, dove urlFromAuthSub
è l'URL a cui AuthSub
ha aggiunto il token:
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 registrate e sulle chiavi private, consulta la sezione "Richieste di firma" della documentazione di AuthSub.
L'applicazione può quindi utilizzare il token di sessione nelle interazioni successive con Blogger. Per indicare alla libreria client Java di inviare automaticamente il token di sessione a ogni richiesta, chiama il metodo setAuthSubToken
dell'oggetto GoogleService
:
GoogleService.setAuthSubToken(sessionToken, null);
Dopodiché, la libreria client invia automaticamente il token insieme a ogni richiesta.
Autenticazione nome utente/password ClientLogin
Utilizza l'autenticazione ClientLogin se il client è un client autonomo e "installato" per un singolo utente (ad esempio un'applicazione desktop). Richiama 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 precedente passiamo due parametri al
costruttore GoogleService
. Il primo parametro è il nome del
servizio con cui vogliamo interagire. Il secondo parametro è il nome dell'applicazione nel formato companyName-applicationName-versionID.
Per ulteriori informazioni sull'autenticazione ClientLogin, incluse richieste e risposte di esempio, consulta la documentazione Autenticazione per le applicazioni installate.
Nota: utilizza lo stesso token per tutte le richieste in una data sessione; non acquisire un nuovo token per ogni richiesta di Blogger.
Nota: come descritto nella documentazione ClientLogin, la richiesta di autenticazione potrebbe non riuscire e richiedere una verifica CAPTCHA. Se vuoi che Google emetta e gestisca il test CAPTCHA, invia l'utente a https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(anziché all'URL di gestione CAPTCHA fornito nella documentazione ClientLogin).
Recupero di un elenco di blog
L'API di dati di Blogger fornisce un feed che elenca i blog per un determinato utente; tale feed è noto come "metafeed".
Il codice di esempio seguente utilizza un oggetto GoogleService
autenticato per recuperare il metafeed, quindi 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
. Questo è l'URL del metafeed predefinito e restituisce un elenco di blog per l'utente attualmente autenticato.
Per accedere a un feed per un altro utente, 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 nuovi articoli di blog, nonché di creare bozze di voci.
Nota: l'impostazione di un autore personalizzato per i post non è al momento supportata. Tutti i nuovi post verranno visualizzati come se fossero stati creati dall'utente attualmente autenticato.
Pubblicare un post del blog
Puoi utilizzare la libreria client Java per pubblicare nuovi articoli del blog.
Innanzitutto, crea un oggetto Entry
per rappresentare il post del blog. Dopodiché 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 di 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. La voce
restituita è la stessa che hai inviato, ma contiene anche vari elementi aggiunti
da Blogger, come un ID post.
Se per qualche motivo la tua richiesta non va a buon fine, Blogger potrebbe restituire un codice di stato diverso. Per informazioni sui codici di stato, consulta il documento di riferimento sul protocollo dell'API di dati di Google.
Creazione di una bozza di post del blog
Le bozze dei post vengono create come i post pubblici, ma è necessario impostare l'attributo draft
dell'oggetto Entry
. Puoi creare un post del blog come quello riportato sopra come bozza aggiungendo la riga evidenziata:
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 di post in corso
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 l'autenticazione AuthSub prima di recuperare i post da un blog pubblico.
Recupero di tutti i post del blog
Per recuperare i post dell'utente, richiama 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 di dati di Blogger consente di richiedere un insieme di voci che corrispondono a criteri specifici, come la richiesta di post di blog pubblicati o aggiornati in un determinato intervallo di date. Per farlo, puoi creare un oggetto Query
e passarlo al
metodo GoogleService.getQuery
.
Ad esempio, per inviare una query su un intervallo di date, utilizza i metodi setPublishedMin
e setPublishedMax
dell'oggetto Query
. Il seguente snippet di codice stampa il titolo di ogni post del blog pubblicato tra l'ora di inizio e quella di fine:
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 (note anche come etichette) per filtrare i risultati dei feed. Ad esempio,
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie
restituisce voci con entrambe le etichetteFritz
eLaurie
. - 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 suupdated
.
Nota: al momento non sono presenti setter per il
parametro di query orderby
. Tuttavia, se devi impostarlo, puoi comunque utilizzare il metodo Query.addCustomParameter()
.
Per ulteriori informazioni sui parametri di query, consulta la guida di riferimento delle 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 una voce del blog, a condizione che tu abbia già recuperato la voce dal server.
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 qualsiasi altra proprietà, è sufficiente impostarle 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
, in questo modo:
public static void deletePost( GoogleService myService, String editLinkHref) throws ServiceException, IOException { URL deleteUrl = new URL(editLinkHref); myService.delete(deleteUrl); }
Commenti
L'API di dati di Blogger consente di creare, recuperare ed eliminare i commenti. L'aggiornamento dei commenti non è supportato (né è 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 in un blog di proprietà dell'utente autenticato.
Nota: al momento l'impostazione di un autore personalizzato per i commenti non è supportata. Tutti i nuovi commenti appariranno come se fossero stati creati dall'utente attualmente autenticato.
Recupero dei commenti in corso...
Puoi recuperare i commenti di un determinato post dall'URL del feed dei commenti del 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(); }
Oppure 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, passa l'URL di modifica del commento al metodo 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); }