Panduan Developer: Java

Penting: Kami akan menghentikan dukungan untuk Google Data API v2.0 pada 30 September 2024. Untuk memastikan fungsi berkelanjutan, update aplikasi Anda yang mengandalkan solusi Google v2.0 Data API ke versi API terbaru. Untuk versi terbaru, gunakan link di menu navigasi sebelah kiri. Catatan: meskipun beberapa permintaan GET (seperti postingan listingan) akan terus didukung sebagai feed URL, ada perbedaan kecil dalam perilakunya. Untuk informasi selengkapnya, lihat Dokumentasi Bantuan Blogger.

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 blog baru postingan, edit atau hapus postingan blog yang ada, dan kueri postingan blog yang cocok kriteria tertentu.

Selain memberikan beberapa latar belakang tentang kemampuan Blogger Data API, dokumen ini memberikan contoh interaksi Data API dasar menggunakan klien Java library. Jika Anda tertarik untuk memahami lebih lanjut tentang dasar-dasar yang digunakan library, lihat bagian Protokol dalam panduan developer ini.

Daftar Isi

  1. Penonton
  2. Memulai
    1. Membuat akun Blogger
    2. Menjalankan kode contoh
  3. Mengautentikasi ke layanan Blogger
    1. Autentikasi OAuth
    2. Autentikasi proxy AuthSub
    3. Autentikasi nama pengguna/sandi ClientLogin
  4. Mengambil daftar blog
  5. Membuat postingan
    1. Memublikasikan postingan blog
    2. Membuat draf postingan blog
  6. Mengambil postingan
    1. Mengambil semua postingan blog
    2. Mengambil postingan menggunakan parameter kueri
  7. Memperbarui postingan
  8. Menghapus postingan
  9. Komentar
    1. Membuat komentar
    2. Mengambil komentar
    3. Menghapus komentar

Audiens

Dokumen ini ditujukan bagi programmer yang ingin menulis program Java aplikasi yang dapat berinteraksi dengan Blogger.

Dokumen ini mengasumsikan bahwa Anda memahami 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 Blogger Data API umum, 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 kelas yang diperlukan untuk memulai di File java/lib/gdataclient-1.0.jar.

Membuat akun Blogger

Anda mungkin ingin mendaftar untuk Akun Blogger untuk tujuan pengujian. Blogger menggunakan Akun Google, jadi jika Anda sudah memiliki akun Google, Anda sudah siap.

Menjalankan kode contoh

Klien contoh yang berfungsi penuh, berisi semua kode contoh yang ditampilkan dalam tersedia di distribusi library klien Java, di bawah direktori gdata/java/sample/blogger/BloggerClient.java. Membangun dan petunjuk eksekusi disertakan dalam direktori yang sama dalam File README.txt.

Klien contoh melakukan beberapa operasi pada 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 memodifikasi blog, maka klien Anda perlu melakukan otentikasi sebelum meminta feed pribadi. Alat ini dapat melakukan autentikasi menggunakan salah satu dari tiga pendekatan berikut: autentikasi OAuth, proxy AuthSub autentikasi atau nama pengguna/sandi ClientLogin autentikasi.

Untuk informasi selengkapnya tentang autentikasi dengan Google Data API secara umum, lihat dokumen autentikasi dokumentasi tambahan.

Sebagian besar contoh di bagian selanjutnya dari dokumen ini mengasumsikan bahwa Anda telah objek GoogleService yang diautentikasi.

Autentikasi OAuth

Untuk dokumentasi tentang autentikasi OAuth menggunakan library GData Java, lihat OAuth di Library Klien Protokol Data Google.

Autentikasi proxy AuthSub

Autentikasi proxy AuthSub digunakan oleh aplikasi web yang perlu mengautentikasi penggunanya 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 bertindak atas nama pengguna tertentu. Untuk mengetahui informasi yang lebih mendetail, lihat dokumentasi AuthSub.

Ketika pengguna pertama kali mengunjungi aplikasi Anda, mereka belum telah diotentikasi. Dalam hal ini, Anda perlu menampilkan beberapa informasi dan tautan mengarahkan pengguna ke halaman Google untuk mengautentikasi permintaan akses Anda ke blog mereka. Library klien Java menyediakan fungsi untuk menghasilkan URL halaman. 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 mengambil parameter berikut (sesuai dengan parameter kueri yang digunakan oleh AuthSubRequest ):

berikutnya
URL halaman tujuan pengalihan pengguna oleh Google setelah autentikasi.
cakupan
Menunjukkan bahwa aplikasi meminta token untuk mengakses feed Blogger. String cakupan yang akan digunakan adalah http://www.blogger.com/feeds/ (tentunya berenkode URL).
aman
Menunjukkan apakah klien meminta token aman.
sesi
Menunjukkan apakah token yang ditampilkan dapat ditukarkan dengan token multiguna (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 melakukan autentikasi ke URL menggunakan Akun Layanan Anda.

Setelah pengguna melakukan autentikasi, sistem AuthSub akan mengalihkan mereka ke URL yang Anda tentukan dalam parameter kueri next pada AuthSubRequest . Sistem AuthSub menambahkan token otentikasi ke URL tersebut, sebagai parameter kueri token. Contoh:

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

Nilai token ini mewakili token AuthSub sekali pakai. Dalam contoh ini, karena session = true ditentukan, token ini dapat ditukar dengan token sesi AuthSub dengan memanggil layanan AuthSubSessionToken, seperti berikut, dengan urlFromAuthSub adalah URL tempat AuthSub menambahkan token:

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

Artinya, Anda meneruskan token sekali pakai ke metode exchangeForSessionToken, bersama dengan null (untuk mode yang tidak terdaftar) atau kunci pribadi (untuk mode terdaftar), dan antarmuka AuthSub akan menampilkan token sesi. Untuk mengetahui informasi selengkapnya tentang aplikasi terdaftar dan kunci pribadi, lihat bagian "Menandatangani permintaan" dalam dokumentasi AuthSub.

Kemudian, aplikasi Anda dapat menggunakan token sesi dalam interaksi berikutnya dengan Blogger. Untuk memberi tahu library klien Java agar secara otomatis mengirim sesi untuk setiap permintaan, panggil objek GoogleService Metode setAuthSubToken:

GoogleService.setAuthSubToken(sessionToken, null);

Setelah itu, library klien akan otomatis mengirimkan token beserta setiap permintaan.

Autentikasi nama pengguna/sandi ClientLogin

Gunakan autentikasi ClientLogin jika klien Anda adalah klien mandiri dan satu pengguna yang "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 untuk berinteraksi. Parameter kedua adalah nama dari aplikasi dalam bentuk companyName—applicationName—versionID.

Untuk informasi selengkapnya tentang autentikasi ClientLogin, termasuk contoh permintaan dan respons, lihat dokumen Autentikasi untuk yang Terinstal Aplikasi.

Catatan: Gunakan token yang sama untuk semua permintaan dalam sesi tertentu; tidak memperoleh token baru untuk setiap permintaan Blogger.

Catatan: Seperti yang dijelaskan dalam ClientLogin dokumentasi, permintaan otentikasi mungkin gagal dan meminta CAPTCHA tantangan. Jika Anda ingin Google mengeluarkan dan menangani tantangan CAPTCHA, kirim pengguna ke https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (bukan URL penanganan CAPTCHA yang diberikan di ClientLogin dokumentasi).

Mengambil daftar blog

Blogger Data API menyediakan feed yang mencantumkan blog untuk user; feed tersebut dikenal sebagai "metafeed."

Kode contoh berikut menggunakan 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());
  }
}

Catat URL yang digunakan oleh metode getFeed. Ini adalah default URL feed meta; sistem itu menghasilkan daftar blog untuk pengguna yang saat ini diotentikasi. Untuk mengakses feed bagi pengguna lain, Anda dapat memasukkan ID pengguna sebagai pengganti default di URL metafeed. ID pengguna adalah string digit di akhir URL profil pengguna.

Membuat postingan

Blogger Data API memungkinkan Anda membuat dan memublikasikan entri blog baru, serta membuat draf entri.

Catatan: Menetapkan penulis kustom untuk postingan saat ini tidak didukung. Semua postingan baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini diautentikasi.

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 dari postingan blog. Terakhir, gunakan objek GoogleService untuk menyisipkan postingan. Berikut ini contohnya tentang 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 menggunakan URL postingan layanan sebagai parameter. Kemudian, metode akan 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 alasan tertentu, Blogger mungkin menampilkan kode status yang berbeda. Untuk mendapatkan informasi tentang kode status, lihat Data Google Dokumen referensi protokol API.

Membuat draf postingan blog

Postingan draf dibuat dengan cara yang sama seperti postingan publik, tetapi Anda perlu menetapkan atribut draft dari objek Entry. Anda dapat membuat postingan blog seperti 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 draf postingan blog yang ada menjadi postingan yang dipublikasikan dengan mengambil postingan draf, menyetel atribut draf ke salah (false), lalu memperbarui postingan. Kita akan membahas pengambilan dan pembaruan postingan di dua bagian berikutnya.

Mengambil postingan

Bagian berikut menjelaskan cara mengambil daftar posting blog, dengan dan tanpa parameter kueri.

Anda dapat melakukan kueri feed publik Blogger tanpa autentikasi. Oleh karena itu, Anda tidak perlu memanggil metode setUserCredentials atau melakukan AuthSub autentikasi sebelum mengambil posting 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 sekumpulan 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 dari objek Query. Tujuan cuplikan kode berikut mencetak judul setiap postingan blog yang dipublikasikan antara waktu mulai dan waktu berakhir tertentu:

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
Menentukan kategori (juga disebut sebagai label) untuk memfilter hasil feed. Misalnya, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie menampilkan entri dengan label Fritz dan Laurie.
setMaxResults
Tetapkan jumlah maksimum entri yang akan ditampilkan.
setPublishedMin, setPublishedMax
Menetapkan batas pada tanggal publikasi entri.
setStartIndex
Menetapkan indeks berbasis 1 dari hasil pertama yang akan diambil (untuk paging).
setUpdatedMin, setUpdatedMax
Menetapkan batas pada tanggal pembaruan entri. Parameter kueri ini diabaikan kecuali jika parameter orderby ditetapkan ke updated.

Catatan: Saat ini tidak ada penyetel untuk Parameter kueri orderby. Namun, Anda masih dapat menggunakan Query.addCustomParameter() jika Anda perlu menetapkannya.

Untuk informasi selengkapnya tentang parameter kueri, lihat Referensi Blogger Data API Guide dan Google Panduan Referensi Data API.

Memperbarui postingan

Untuk memperbarui postingan blog yang ada, pertama-tama Anda mengambil entri yang ingin diperbarui, lalu mengubahnya, lalu mengirimkannya 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 yang baru diperbarui. 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, 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 pembuatan, pengambilan, dan penghapusan komentar. Memperbarui komentar tidak didukung (dan tidak tersedia di antarmuka web).

Membuat komentar

Untuk memposting komentar, buat objek Entry dan masukkan 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 yang dimiliki oleh pengguna terautentikasi.

Catatan: Menetapkan penulis kustom untuk komentar saat ini tidak didukung. Semua komentar baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini diotentikasi.

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

Anda juga bisa mendapatkan komentar dari semua postingan dengan 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 seperti ini:

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

Kembali ke atas