Penting: Ini adalah versi lama halaman ini. Untuk versi terbaru, gunakan link di menu navigasi sebelah kiri.
Blogger Data API memungkinkan aplikasi klien melihat dan memperbarui konten Blogger dalam bentuk feed Google Data API.
Aplikasi klien Anda dapat menggunakan Blogger Data API untuk membuat postingan blog baru, mengedit atau menghapus postingan blog yang sudah ada, dan membuat kueri untuk postingan blog yang sesuai dengan kriteria tertentu.
Selain menyediakan beberapa latar belakang tentang kemampuan Blogger Data API, dokumen ini memberikan contoh interaksi Data API dasar menggunakan library klien Java. Jika Anda tertarik untuk memahami lebih lanjut protokol dasar yang digunakan library, lihat bagian Protokol dari panduan developer ini.
Daftar Isi
Audiens
Dokumen ini ditujukan untuk programmer yang ingin menulis aplikasi klien Java yang dapat berinteraksi dengan Blogger.
Dokumen ini mengasumsikan bahwa Anda memahami ide-ide umum di balik protokol Google Data API.
Untuk informasi referensi tentang class dan metode yang disediakan oleh library klien, lihat referensi API library klien Java. Untuk informasi referensi umum Blogger Data API, lihat Panduan referensi protokol.
Memulai
Untuk mendapatkan bantuan dalam menyiapkan library klien, lihat Panduan Memulai.
Library klien Java memerlukan Java 1.5. Setelah mendownload
library klien, Anda akan menemukan class yang diperlukan untuk memulai dalam
file java/lib/gdataclient-1.0.jar
.
Membuat akun Blogger
Anda dapat mendaftar ke akun Blogger untuk tujuan pengujian. Blogger menggunakan Akun Google, jadi jika Anda sudah memiliki Akun Google, berarti Anda sudah siap.
Menjalankan kode contoh
Klien contoh yang berfungsi penuh, yang berisi semua kode contoh yang ditampilkan dalam
dokumen ini, tersedia dalam distribusi library klien Java, di
direktori gdata/java/sample/blogger/BloggerClient.java
. Petunjuk build dan eksekusi disertakan dalam direktori yang sama di file README.txt
.
Klien contoh melakukan beberapa operasi di blog yang disediakan untuk menunjukkan penggunaan Blogger Data API.
Untuk mengompilasi contoh dalam dokumen ini ke dalam kode Anda sendiri, Anda memerlukan pernyataan import
berikut:
import com.google.gdata.client.*; import com.google.gdata.data.*; import com.google.gdata.util.*; import java.io.IOException; import java.net.URL;
Mengautentikasi ke layanan Blogger
Anda dapat mengakses feed publik dan pribadi menggunakan Blogger Data API. Feed publik tidak memerlukan autentikasi apa pun, tetapi bersifat hanya baca. Jika Anda ingin mengubah blog, klien Anda perlu melakukan autentikasi sebelum meminta feed pribadi. Autentikasi dapat dilakukan menggunakan salah satu dari dua pendekatan berikut: autentikasi proxy AuthSub atau autentikasi nama pengguna/sandi ClientLogin.
Untuk informasi selengkapnya tentang autentikasi dengan Google Data API secara umum, lihat dokumentasi autentikasi.
Sebagian besar sampel di bagian berikutnya dalam dokumen ini mengasumsikan bahwa Anda memiliki objek GoogleService
yang diautentikasi.
Autentikasi proxy AuthSub
Autentikasi proxy AuthSub digunakan oleh aplikasi web yang perlu mengautentikasi pengguna ke Akun Google. Operator situs dan kode klien tidak memiliki akses ke nama pengguna dan sandi untuk pengguna Blogger; sebagai gantinya, klien mendapatkan token AuthSub khusus yang memungkinkan klien untuk bertindak atas nama pengguna tertentu. Untuk mengetahui informasi yang lebih detail, lihat dokumentasi AuthSub.
Saat pertama kali mengunjungi aplikasi Anda, pengguna belum diautentikasi. Dalam hal ini, Anda perlu menampilkan beberapa informasi dan link yang mengarahkan pengguna ke halaman Google untuk mengautentikasi permintaan Anda agar dapat mengakses blog mereka. Library klien Java menyediakan fungsi untuk menghasilkan URL halaman Google. Kode di bawah mengambil URL halaman 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);
Metode getRequestUrl
menggunakan parameter berikut (sesuai dengan parameter kueri yang digunakan oleh pengendali AuthSubRequest):
- berikutnya
- URL halaman tempat Google akan mengalihkan pengguna setelah autentikasi.
- cakupan
- Menunjukkan bahwa aplikasi meminta token untuk mengakses feed Blogger. String cakupan yang digunakan adalah
http://www.blogger.com/feeds/
(tentu saja dienkode ke URL). - aman
- Menunjukkan apakah klien meminta token aman.
- sesi
- Menunjukkan apakah token yang ditampilkan dapat ditukarkan dengan token multi-penggunaan (sesi).
Contoh di atas menunjukkan panggilan yang tidak meminta token aman (nilai secure
adalah false
). URL permintaan yang dihasilkan mungkin terlihat seperti ini:
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
Pengguna mengikuti link ke situs Google dan mengautentikasi ke Akun Google mereka.
Setelah pengguna melakukan autentikasi, sistem AuthSub akan mengalihkan mereka ke URL yang Anda tentukan dalam parameter kueri next
dari URL AuthSubRequest. Sistem AuthSub menambahkan token autentikasi ke URL tersebut, sebagai nilai parameter kueri token
. Contoh:
http://www.example.com/welcome.html?token=yourAuthToken
Nilai token ini mewakili token AuthSub satu kali pakai. Dalam contoh ini,
karena session = true
ditentukan, token ini dapat ditukarkan dengan
token sesi AuthSub dengan memanggil layanan AuthSubSessionToken
, sebagai berikut, dengan urlFromAuthSub
adalah URL yang ditambahi token
AuthSub:
String token = AuthSubUtil.getTokenFromReply(urlFromAuthSub); String sessionToken = AuthSubUtil.exchangeForSessionToken(token, null);
Artinya, Anda akan meneruskan token sekali pakai ke
metode exchangeForSessionToken
, beserta null
(untuk mode tidak terdaftar) atau kunci pribadi (untuk mode terdaftar), dan antarmuka AuthSub
menampilkan token sesi. Untuk informasi selengkapnya tentang aplikasi
dan kunci pribadi yang terdaftar, lihat bagian "Permintaan penandatanganan"
dalam dokumentasi AuthSub.
Aplikasi Anda kemudian dapat menggunakan token sesi di interaksi berikutnya
dengan Blogger. Untuk memberi tahu library klien Java agar otomatis mengirimkan token
sesi dengan setiap permintaan, panggil metode
setAuthSubToken
objek GoogleService
:
GoogleService.setAuthSubToken(sessionToken, null);
Setelah itu, library klien akan otomatis mengirimkan token bersama dengan setiap permintaan.
Autentikasi nama pengguna/sandi ClientLogin
Gunakan autentikasi ClientLogin jika klien Anda adalah klien mandiri yang tidak diinstal (seperti aplikasi desktop). Cukup panggil metode setUserCredentials
pada objek GoogleService
Anda dan semua interaksi berikutnya dengan Blogger akan diautentikasi:
GoogleService myService = new GoogleService("blogger", "exampleCo-exampleApp-1"); myService.setUserCredentials("user@example.com", "secretPassword");
Dalam cuplikan di atas, kita meneruskan dua parameter ke
konstruktor GoogleService
. Parameter pertama adalah nama
layanan yang ingin kita gunakan. Parameter kedua adalah nama
aplikasi kita dalam bentuk
companyName-applicationName-versionID.
Untuk informasi selengkapnya tentang autentikasi ClientLogin, termasuk contoh permintaan dan respons, lihat dokumentasi Autentikasi untuk Aplikasi yang Terinstal.
Catatan: Gunakan token yang sama untuk semua permintaan di sesi tertentu; jangan dapatkan token baru untuk setiap permintaan Blogger.
Catatan: Seperti yang dijelaskan dalam dokumentasi ClientLogin, permintaan autentikasi mungkin gagal dan meminta verifikasi CAPTCHA. Jika Anda ingin Google mengeluarkan dan menangani verifikasi CAPTCHA, kirimkan pengguna ke https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(bukan ke URL penanganan CAPTCHA yang diberikan dalam dokumentasi ClientLogin).
Mengambil daftar blog
Blogger Data API menyediakan feed yang mencantumkan blog untuk pengguna tertentu; feed tersebut dikenal sebagai "metafeed."
Kode contoh berikut menggunakan objek GoogleService
yang diautentikasi untuk mengambil metafeed, lalu mencetak setiap judul 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()); } }
Perhatikan URL yang digunakan oleh metode getFeed
. Ini adalah URL metafeed
default; yang menampilkan daftar blog untuk pengguna yang saat ini diautentikasi.
Untuk mengakses feed bagi pengguna lain, Anda dapat menempatkan ID pengguna sebagai pengganti default
di URL feed meta. ID pengguna adalah string angka di akhir URL profil pengguna.
Membuat postingan
Dengan Blogger Data API, Anda dapat membuat dan memublikasikan entri blog baru, serta membuat draf entri.
Catatan: Menyetel penulis kustom untuk postingan saat ini tidak didukung. Semua postingan baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini terautentikasi.
Memublikasikan postingan blog
Anda dapat menggunakan library klien Java untuk memublikasikan entri blog baru.
Pertama, buat objek Entry
untuk mewakili postingan blog. Kemudian, Anda dapat menetapkan judul, konten, dan atribut lainnya untuk postingan blog tersebut. Terakhir, gunakan objek GoogleService
untuk menyisipkan postingan. Berikut adalah contoh
cara memublikasikan postingan blog baru:
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); }
Metode insert
akan menggunakan URL postingan layanan sebagai parameter.
Kemudian, metode ini menampilkan entri seperti yang disimpan oleh Blogger. Entri yang ditampilkan sama dengan yang Anda kirim, tetapi juga berisi berbagai elemen yang ditambahkan oleh Blogger, seperti ID postingan.
Jika permintaan Anda gagal karena beberapa alasan, Blogger dapat menampilkan kode status yang berbeda. Untuk informasi tentang kode status, lihat Dokumen referensi protokol Google Data API.
Membuat postingan blog draf
Postingan draf dibuat dengan cara yang sama seperti postingan publik, tetapi Anda perlu menetapkan
atribut draft
objek Entry
. Anda dapat membuat postingan blog seperti yang di atas sebagai draf dengan menambahkan baris yang ditandai:
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); }
Anda dapat mengubah postingan blog draf yang sudah ada menjadi postingan yang dipublikasikan dengan mengambil draf postingan, menyetel atribut draf ke false, lalu memperbarui postingan tersebut. Kami akan membahas cara mengambil dan memperbarui postingan di dua bagian berikutnya.
Mengambil postingan
Bagian berikut ini menjelaskan cara mengambil daftar postingan blog, dengan dan tanpa parameter kueri.
Anda dapat mengajukan kueri feed publik Blogger tanpa autentikasi. Oleh karena itu, Anda
tidak perlu memanggil metode setUserCredentials
atau melakukan autentikasi
AuthSub sebelum mengambil postingan dari blog publik.
Mengambil semua postingan blog
Untuk mengambil postingan pengguna, panggil metode getFeed
yang sama dengan yang digunakan untuk mengambil metafeed blog, tetapi kali ini kirim URL feed postingan 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(); }
Mengambil postingan menggunakan parameter kueri
Blogger Data API memungkinkan Anda meminta serangkaian entri yang cocok dengan kriteria yang ditentukan, seperti meminta postingan blog yang dipublikasikan atau diperbarui dalam rentang tanggal tertentu. Untuk melakukannya, buat objek Query
dan teruskan ke metode GoogleService.getQuery
.
Misalnya, untuk mengirim kueri rentang tanggal, gunakan metode setPublishedMin
dan setPublishedMax
objek Query
. Cuplikan
kode berikut mencetak judul setiap postingan blog yang dipublikasikan antara
waktu mulai dan waktu berakhir:
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(); }
Perhatikan bahwa objek Query
dibuat menggunakan URL feed postingan yang sama dengan yang digunakan untuk mengambil postingan.
Blogger Data API mendukung metode Query
berikut:
- addCategoryFilter
- Tentukan kategori (juga dikenal sebagai label) untuk memfilter hasil feed. Misalnya,
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie
menampilkan entri dengan labelFritz
danLaurie
. - setMaxResults
- Menetapkan jumlah maksimum entri yang akan ditampilkan.
- setPublishMin, setPublishMax
- Tetapkan batas pada tanggal publikasi entri.
- setStartIndex
- Tetapkan indeks berbasis 1 dari hasil pertama yang akan diambil (untuk paging).
- setUpdatedMin, setUpdatedMax
- Tetapkan batas pada tanggal update entri. Parameter kueri ini diabaikan kecuali jika parameter
orderby
disetel keupdated
.
Catatan: Saat ini tidak ada penyetel untuk
parameter kueri orderby
. Namun, Anda tetap dapat menggunakan
metode Query.addCustomParameter()
jika perlu menetapkan metode ini.
Untuk informasi selengkapnya tentang parameter kueri, lihat Panduan Referensi Blogger Data API dan Panduan Referensi Google Data API.
Memperbarui postingan
Untuk memperbarui postingan blog yang sudah ada, pertama-tama Anda harus mengambil entri yang ingin
diperbarui, kemudian mengubahnya, lalu mengirimnya ke Blogger menggunakan
metode update
. Cuplikan kode berikut mengubah judul entri blog, dengan asumsi bahwa Anda telah mengambil entri dari 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); }
Kode di atas menampilkan Entry
yang berisi seluruh postingan yang baru diubah. Untuk memperbarui properti lainnya, cukup tetapkan properti tersebut di objek Entry
sebelum memanggil update
.
Catatan: Mengubah data penulis yang terkait dengan postingan saat ini tidak didukung.
Menghapus postingan
Untuk menghapus postingan, teruskan URL edit postingan ke metode delete
pada objek GoogleService
Anda, seperti ini:
public static void deletePost( GoogleService myService, String editLinkHref) throws ServiceException, IOException { URL deleteUrl = new URL(editLinkHref); myService.delete(deleteUrl); }
Komentar
Blogger Data API memungkinkan Anda membuat, mengambil, dan menghapus komentar. Memperbarui komentar tidak didukung (juga tidak tersedia di antarmuka web).
Membuat komentar
Untuk memposting komentar, buat objek Entry
dan sisipkan seperti
berikut:
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); }
Catatan: Saat ini, Anda hanya dapat memposting komentar ke blog milik pengguna yang diautentikasi.
Catatan: Menyetel penulis kustom untuk komentar saat ini tidak didukung. Semua komentar baru akan muncul seolah-olah komentar tersebut dibuat oleh pengguna yang saat ini sudah diautentikasi.
Mengambil komentar
Anda dapat mengambil komentar untuk postingan tertentu dari URL feed komentar postingan.
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(); }
Atau, Anda bisa mendapatkan komentar dari semua postingan menggunakan URL feed komentar blog:
http://www.blogger.com/feeds/blogID/comments/default
Menghapus komentar
Untuk menghapus komentar, teruskan URL edit komentar ke metode delete
pada objek GoogleService
Anda seperti ini:
public static void deleteComment(GoogleService myService, String editLinkHref) throws ServiceException, IOException { URL deleteUrl = new URL(editLinkHref); myService.delete(deleteUrl); }