หน้านี้ได้รับการแปลโดย Cloud Translation API

คู่มือสำหรับนักพัฒนาซอฟต์แวร์: Java

สำคัญ: หน้านี้เป็นหน้าเวอร์ชันเก่า หากต้องการใช้เวอร์ชันล่าสุด ให้ใช้ลิงก์ในแถบนําทางด้านซ้าย

Blogger Data API ช่วยให้แอปพลิเคชันไคลเอ็นต์ดูและอัปเดตเนื้อหา Blogger ได้ในรูปแบบฟีด Google Data API

แอปพลิเคชันไคลเอ็นต์สามารถใช้ Blogger Data API เพื่อสร้างบล็อกโพสต์ใหม่ แก้ไขหรือลบบล็อกโพสต์ที่มีอยู่ และค้นหาบล็อกโพสต์ที่ตรงกับเกณฑ์ที่เฉพาะเจาะจง

นอกจากข้อมูลเบื้องต้นเกี่ยวกับความสามารถของ Blogger Data API แล้ว เอกสารนี้ยังมีตัวอย่างการโต้ตอบพื้นฐานของ Data API โดยใช้ไลบรารีของไคลเอ็นต์ Java ด้วย หากต้องการทำความเข้าใจเพิ่มเติมเกี่ยวกับโปรโตคอลพื้นฐานที่ไลบรารีใช้ โปรดดูส่วนโปรโตคอลของคู่มือนักพัฒนาซอฟต์แวร์นี้

เนื้อหา

ผู้ชม
การเริ่มต้นใช้งาน
1. การสร้างบัญชี Blogger
2. การเรียกใช้โค้ดตัวอย่าง
การตรวจสอบสิทธิ์ในบริการ Blogger
1. การตรวจสอบสิทธิ์พร็อกซี AuthSub
2. การตรวจสอบสิทธิ์ด้วยชื่อผู้ใช้/รหัสผ่านของ ClientLogin
การเรียกข้อมูลรายการบล็อก
การสร้างโพสต์
1. การเผยแพร่บล็อกโพสต์
2. การสร้างบล็อกโพสต์ฉบับร่าง
การดึงข้อมูลโพสต์
1. การดึงข้อมูลบล็อกโพสต์ทั้งหมด
2. การดึงข้อมูลโพสต์โดยใช้พารามิเตอร์การค้นหา
การอัปเดตโพสต์
การลบโพสต์
ความคิดเห็น

ผู้ชม

เอกสารนี้มีไว้สำหรับโปรแกรมเมอร์ที่ต้องการเขียนแอปพลิเคชันไคลเอ็นต์ Java ที่โต้ตอบกับ Blogger ได้

เอกสารนี้ถือว่าคุณเข้าใจแนวคิดทั่วไปที่อยู่เบื้องหลังโปรโตคอล Google Data API

ดูข้อมูลอ้างอิงเกี่ยวกับคลาสและเมธอดที่ไลบรารีของไคลเอ็นต์มีให้ได้ที่ข้อมูลอ้างอิง API ของไลบรารีของไคลเอ็นต์ Java ดูข้อมูลอ้างอิงทั่วไปเกี่ยวกับ Blogger Data API ได้ที่คู่มือข้อมูลอ้างอิงเกี่ยวกับโปรโตคอล

เริ่มต้นใช้งาน

หากต้องการความช่วยเหลือในการตั้งค่าไลบรารีของไคลเอ็นต์ โปรดดูคู่มือการเริ่มต้นใช้งาน

ไลบรารีของไคลเอ็นต์ Java ต้องใช้ Java 1.5 หลังจากดาวน์โหลดไฟล์คลังไคลเอ็นต์แล้ว คุณจะเห็นคลาสที่จําเป็นสําหรับเริ่มต้นใช้งานในไฟล์ java/lib/gdataclient-1.0.jar

การสร้างบัญชี Blogger

คุณอาจต้องลงชื่อสมัครใช้บัญชี Blogger เพื่อวัตถุประสงค์ในการทดสอบ Blogger ใช้บัญชี Google ดังนั้นหากคุณมีบัญชี Google อยู่แล้ว ก็พร้อมใช้งาน

การเรียกใช้โค้ดตัวอย่าง

ไคลเอ็นต์ตัวอย่างที่ใช้งานได้จริงซึ่งมีโค้ดตัวอย่างทั้งหมดที่แสดงในเอกสารนี้พร้อมให้ใช้งานในชุดแจกจ่ายไลบรารีของไคลเอ็นต์ Java ภายใต้ไดเรกทอรี gdata/java/sample/blogger/BloggerClient.java วิธีการสร้างและวิธีเรียกใช้จะรวมอยู่ในไดเรกทอรีเดียวกันในไฟล์ README.txt

ไคลเอ็นต์ตัวอย่างจะดําเนินการหลายอย่างกับบล็อกที่ระบุเพื่อสาธิตการใช้ Blogger Data API

หากต้องการคอมไพล์ตัวอย่างในเอกสารนี้เป็นโค้ดของคุณเอง คุณจะต้องมีคำสั่ง import ต่อไปนี้

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

การตรวจสอบสิทธิ์บริการ Blogger

คุณเข้าถึงทั้งฟีดสาธารณะและฟีดส่วนตัวได้โดยใช้ Blogger Data API ฟีดสาธารณะไม่จําเป็นต้องตรวจสอบสิทธิ์ แต่จะเป็นฟีดแบบอ่านอย่างเดียว หากต้องการแก้ไขบล็อก ลูกค้าจะต้องตรวจสอบสิทธิ์ก่อนขอฟีดส่วนตัว โดยสามารถตรวจสอบสิทธิ์ได้โดยใช้แนวทางใดแนวทางหนึ่งต่อไปนี้ การตรวจสอบสิทธิ์พร็อกซี AuthSub หรือการตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่าน ClientLogin

ดูข้อมูลเพิ่มเติมเกี่ยวกับการตรวจสอบสิทธิ์ด้วย Google Data API โดยทั่วไปได้ที่เอกสารประกอบเกี่ยวกับการตรวจสอบสิทธิ์

ตัวอย่างส่วนใหญ่ในส่วนต่อๆ ไปของเอกสารนี้จะถือว่าคุณมีออบเจ็กต์ GoogleService ที่ตรวจสอบสิทธิ์แล้ว

การตรวจสอบสิทธิ์พร็อกซี AuthSub

เว็บแอปพลิเคชันที่ต้องการตรวจสอบสิทธิ์ผู้ใช้กับบัญชี Google จะใช้การตรวจสอบสิทธิ์พร็อกซี AuthSub ผู้ดำเนินการเว็บไซต์และโค้ดไคลเอ็นต์จะไม่มีสิทธิ์เข้าถึงชื่อผู้ใช้และรหัสผ่านของผู้ใช้ Blogger แต่จะได้รับโทเค็น AuthSub พิเศษที่อนุญาตให้ไคลเอ็นต์ดำเนินการในนามของผู้ใช้รายหนึ่งๆ ดูรายละเอียดเพิ่มเติมได้ที่เอกสารประกอบของ AuthSub

เมื่อผู้ใช้เข้าชมแอปพลิเคชันเป็นครั้งแรก ผู้ใช้จะยังไม่ได้รับการตรวจสอบสิทธิ์ ในกรณีนี้ คุณต้องแสดงข้อมูลบางอย่างและลิงก์ที่นำผู้ใช้ไปยังหน้า Google เพื่อตรวจสอบสิทธิ์คําขอเข้าถึงบล็อก ไลบรารีของไคลเอ็นต์ Java มีฟังก์ชันในการสร้าง URL ของหน้า Google โค้ดด้านล่างจะดึงข้อมูล URL ของหน้า 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);

เมธอด getRequestUrl จะใช้พารามิเตอร์ต่อไปนี้ (ซึ่งสอดคล้องกับพารามิเตอร์การค้นหาที่ตัวแฮนเดิล AuthSubRequest ใช้)

ถัดไป: URL ของหน้าเว็บที่ Google ควรเปลี่ยนเส้นทางผู้ใช้ไปหลังจากการตรวจสอบสิทธิ์
ขอบเขต: บ่งบอกว่าแอปพลิเคชันกำลังขอโทเค็นเพื่อเข้าถึงฟีด Blogger สตริงขอบเขตที่จะใช้คือ http://www.blogger.com/feeds/ (ซึ่งเข้ารหัส URL อยู่แล้ว)
รักษาความปลอดภัย: ระบุว่าไคลเอ็นต์กำลังขอโทเค็นที่ปลอดภัยหรือไม่
เซสชัน: ระบุว่าโทเค็นที่แสดงผลสามารถแลกเป็นโทเค็น (เซสชัน) แบบใช้ซ้ำได้หรือไม่

ตัวอย่างข้างต้นแสดงการเรียกที่ไม่ขอโทเค็นที่ปลอดภัย (ค่าของ secure คือ false) URL คำขอที่ได้อาจมีลักษณะดังนี้

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

ผู้ใช้ไปที่ลิงก์ไปยังเว็บไซต์ของ Google และตรวจสอบสิทธิ์ในบัญชี Google

หลังจากผู้ใช้ตรวจสอบสิทธิ์แล้ว ระบบ AuthSub จะเปลี่ยนเส้นทางผู้ใช้ไปยัง URL ที่คุณระบุไว้ในnextพารามิเตอร์การค้นหาของ URL AuthSubRequest ระบบ AuthSub จะเพิ่มโทเค็นการตรวจสอบสิทธิ์ต่อท้าย URL นั้น เป็นค่าของพารามิเตอร์การค้นหา token เช่น

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

ค่าโทเค็นนี้แสดงถึงโทเค็น AuthSub แบบใช้ครั้งเดียว ในตัวอย่างนี้ เนื่องจากมีการระบุ session = true จึงสามารถแลกเปลี่ยนโทเค็นนี้เพื่อรับโทเค็นเซสชัน AuthSub ได้โดยเรียกใช้บริการ AuthSubSessionToken ดังนี้ โดยที่ urlFromAuthSub คือ URL ที่ AuthSub ต่อท้ายโทเค็น

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

กล่าวคือ คุณต้องส่งโทเค็นแบบใช้ครั้งเดียวไปยังเมธอด exchangeForSessionToken พร้อมกับ null (สําหรับโหมดที่ยังไม่ได้ลงทะเบียน) หรือคีย์ส่วนตัว (สําหรับโหมดที่ลงทะเบียนแล้ว) และอินเทอร์เฟซ AuthSub จะแสดงผลโทเค็นเซสชัน ดูข้อมูลเพิ่มเติมเกี่ยวกับแอปพลิเคชันที่ลงทะเบียนและคีย์ส่วนตัวได้ที่ส่วน "Signing requests" ของเอกสารประกอบ AuthSub

จากนั้นแอปพลิเคชันจะใช้โทเค็นเซสชันในการโต้ตอบกับ Blogger ในภายหลังได้ หากต้องการบอกให้ไลบรารีไคลเอ็นต์ Java ส่งโทเค็นเซสชันโดยอัตโนมัติพร้อมกับคำขอแต่ละรายการ ให้เรียกใช้เมธอด setAuthSubToken ของGoogleServiceออบเจ็กต์ ดังนี้

GoogleService.setAuthSubToken(sessionToken, null);

หลังจากนั้น ไลบรารีของไคลเอ็นต์จะส่งโทเค็นพร้อมกับคําขอทุกรายการโดยอัตโนมัติ

การตรวจสอบสิทธิ์ชื่อผู้ใช้/รหัสผ่านของ ClientLogin

ใช้การตรวจสอบสิทธิ์ ClientLogin หากไคลเอ็นต์เป็นไคลเอ็นต์ "ที่ติดตั้ง" แบบสแตนด์อโลนและผู้ใช้คนเดียว (เช่น แอปพลิเคชันบนเดสก์ท็อป) เพียงเรียกใช้วิธี setUserCredentials ในออบเจ็กต์ GoogleService แล้วการโต้ตอบกับ Blogger ทั้งหมดที่ตามมาจะได้รับการตรวจสอบสิทธิ์

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

ในข้อมูลโค้ดด้านบน เราได้ส่งพารามิเตอร์ 2 รายการไปยังคอนสตรัคเตอร์GoogleService พารามิเตอร์แรกคือชื่อบริการที่เราต้องการโต้ตอบด้วย พารามิเตอร์ที่ 2 คือชื่อแอปพลิเคชันในรูปแบบ companyName-applicationName-versionID

ดูข้อมูลเพิ่มเติมเกี่ยวกับการตรวจสอบสิทธิ์ ClientLogin รวมถึงตัวอย่างคำขอและการตอบกลับได้ในเอกสารประกอบการตรวจสอบสิทธิ์สําหรับแอปพลิเคชันที่ติดตั้ง

หมายเหตุ: ใช้โทเค็นเดียวกันสำหรับคำขอทั้งหมดในเซสชันหนึ่งๆ อย่าขอโทเค็นใหม่สำหรับคำขอ Blogger แต่ละรายการ

หมายเหตุ: ตามที่อธิบายไว้ในเอกสารประกอบของ ClientLogin คําขอตรวจสอบสิทธิ์อาจไม่สําเร็จและขอคําถาม CAPTCHA หากต้องการให้ Google แสดงและจัดการคำถาม CAPTCHA ให้ส่งผู้ใช้ไปที่ https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (แทนที่จะส่งไปยัง URL สำหรับจัดการ CAPTCHA ที่ระบุไว้ในเอกสารประกอบ ClientLogin)

การดึงข้อมูลรายการบล็อก

Blogger Data API มีฟีดที่แสดงรายการบล็อกของผู้ใช้รายหนึ่งๆ ซึ่งฟีดดังกล่าวเรียกว่า "ฟีดเมตา"

ตัวอย่างโค้ดต่อไปนี้ใช้GoogleService ออบเจ็กต์ที่ตรวจสอบสิทธิ์เพื่อดึงข้อมูลเมตาฟีด จากนั้นจึงพิมพ์ชื่อของบล็อกแต่ละรายการ

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

จด URL ที่ใช้โดยเมธอด getFeed นี่คือ URL ของฟีดเมตาเริ่มต้น ซึ่งจะแสดงรายการบล็อกของผู้ใช้ที่ตรวจสอบสิทธิ์แล้วในปัจจุบัน หากต้องการเข้าถึงฟีดของผู้ใช้รายอื่น ให้ใส่รหัสของผู้ใช้แทน default ใน URL ของเมตาฟีด รหัสของผู้ใช้คือสตริงตัวเลขที่อยู่ท้าย URL ของโปรไฟล์ผู้ใช้

การสร้างโพสต์

Blogger Data API ช่วยให้คุณสร้างและเผยแพร่รายการบล็อกใหม่ รวมถึงสร้างรายการฉบับร่างได้

หมายเหตุ: ขณะนี้ระบบยังไม่รองรับการตั้งค่าผู้เขียนที่กำหนดเองสำหรับโพสต์ โพสต์ใหม่ทั้งหมดจะปรากฏราวกับว่าสร้างขึ้นโดยผู้ใช้ที่ตรวจสอบสิทธิ์แล้วในปัจจุบัน

การเผยแพร่บล็อกโพสต์

คุณสามารถใช้ไลบรารีไคลเอ็นต์ Java เพื่อเผยแพร่รายการบล็อกใหม่ได้

ก่อนอื่น ให้สร้างออบเจ็กต์ Entry เพื่อแสดงบล็อกโพสต์ จากนั้นคุณสามารถตั้งค่าชื่อ เนื้อหา และแอตทริบิวต์อื่นๆ ของบล็อกโพสต์ สุดท้าย ใช้ออบเจ็กต์ GoogleService เพื่อแทรกโพสต์ ต่อไปนี้คือตัวอย่างวิธีเผยแพร่บล็อกโพสต์ใหม่

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

เมธอด insert จะใช้ URL ของโพสต์ของบริการเป็นพารามิเตอร์ จากนั้นเมธอดจะแสดงผลรายการตามที่ Blogger จัดเก็บไว้ รายการที่แสดงเป็นรายการเดียวกับที่คุณส่ง แต่ก็มีองค์ประกอบต่างๆ ที่ Blogger เพิ่มเข้าไปด้วย เช่น รหัสโพสต์

หากคำขอไม่สำเร็จด้วยเหตุผลบางประการ Blogger อาจแสดงรหัสสถานะอื่น ดูข้อมูลเกี่ยวกับรหัสสถานะได้ที่เอกสารอ้างอิงเกี่ยวกับโปรโตคอล Google Data API

การสร้างฉบับร่างของบล็อกโพสต์

ระบบจะสร้างโพสต์ฉบับร่างในลักษณะเดียวกับโพสต์สาธารณะ แต่คุณต้องตั้งค่าแอตทริบิวต์ draft ของออบเจ็กต์ Entry คุณสร้างบล็อกโพสต์แบบด้านบนเป็นฉบับร่างได้โดยเพิ่มบรรทัดที่ไฮไลต์ไว้ดังนี้

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

คุณเปลี่ยนฉบับร่างของบล็อกโพสต์ที่มีอยู่ให้เป็นโพสต์ที่เผยแพร่แล้วได้โดยดึงข้อมูลฉบับร่างโพสต์ ตั้งค่าแอตทริบิวต์ฉบับร่างเป็น "เท็จ" แล้วอัปเดตโพสต์ เราจะพูดถึงการดึงข้อมูลและการอัปเดตโพสต์ในส่วนถัดไป

กำลังเรียกข้อมูลโพสต์

ส่วนต่อไปนี้อธิบายวิธีดึงข้อมูลรายการบล็อกโพสต์ที่มีและไม่มีพารามิเตอร์การค้นหา

คุณค้นหาฟีดสาธารณะของ Blogger ได้โดยไม่ต้องมีการตรวจสอบสิทธิ์ คุณจึงไม่จำเป็นต้องเรียกใช้เมธอด setUserCredentials หรือทำการรับรอง AuthSub ก่อนดึงข้อมูลโพสต์จากบล็อกสาธารณะ

กําลังดึงข้อมูลบล็อกโพสต์ทั้งหมด

หากต้องการดึงข้อมูลโพสต์ของผู้ใช้ ให้เรียกใช้เมธอด getFeed เดียวกันกับที่ใช้ดึงข้อมูลเมตาฟีดของบล็อก แต่ครั้งนี้ให้ส่ง URL ฟีดโพสต์ของบล็อก

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

การดึงข้อมูลโพสต์โดยใช้พารามิเตอร์การค้นหา

Blogger Data API ช่วยให้คุณขอชุดรายการที่ตรงกับเกณฑ์ที่ระบุได้ เช่น การขอบล็อกโพสต์ที่เผยแพร่หรืออัปเดตในช่วงวันที่ที่ระบุ โดยสร้างออบเจ็กต์ Query แล้วส่งไปยังเมธอด GoogleService.getQuery

เช่น หากต้องการส่งการค้นหาช่วงวันที่ ให้ใช้เมธอด setPublishedMin และ setPublishedMax ของออบเจ็กต์ Query ข้อมูลโค้ดต่อไปนี้จะแสดงชื่อของบล็อกโพสต์แต่ละรายการที่เผยแพร่ระหว่างเวลาเริ่มต้นและเวลาสิ้นสุดที่ระบุ

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

โปรดทราบว่าออบเจ็กต์ Query สร้างขึ้นโดยใช้ URL ฟีดโพสต์เดียวกับที่ใช้ดึงข้อมูลโพสต์

Blogger Data API รองรับQueryเมธอดต่อไปนี้

addCategoryFilter: ระบุหมวดหมู่ (หรือที่เรียกว่าป้ายกำกับ) เพื่อกรองผลลัพธ์ของฟีด เช่น http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie จะแสดงรายการที่มีทั้งป้ายกํากับ Fritz และ Laurie
setMaxResults: กำหนดจำนวนรายการสูงสุดที่จะแสดง
setPublishedMin, setPublishedMax: กำหนดขอบเขตวันที่เผยแพร่รายการ
setStartIndex: ตั้งค่าดัชนีฐาน 1 ของผลการค้นหารายการแรกที่จะดึงข้อมูล (สำหรับการแบ่งหน้า)
setUpdatedMin, setUpdatedMax: กำหนดขอบเขตวันที่อัปเดตรายการ ระบบจะไม่สนใจพารามิเตอร์การค้นหาเหล่านี้ เว้นแต่จะมีการตั้งค่าพารามิเตอร์ orderby เป็น updated

หมายเหตุ: ปัจจุบันยังไม่มีตัวตั้งค่าสําหรับพารามิเตอร์การค้นหา orderby อย่างไรก็ตาม คุณยังคงใช้วิธี Query.addCustomParameter() ได้หากต้องการตั้งค่านี้

ดูข้อมูลเพิ่มเติมเกี่ยวกับพารามิเตอร์การค้นหาได้ในคู่มืออ้างอิง Blogger Data API และคู่มืออ้างอิง Google Data API

การอัปเดตโพสต์

หากต้องการอัปเดตบล็อกโพสต์ที่มีอยู่ ก่อนอื่นให้เรียกข้อมูลรายการที่ต้องการอัปเดต จากนั้นแก้ไข แล้วส่งไปยัง Blogger โดยใช้วิธีการ update ข้อมูลโค้ดต่อไปนี้จะแก้ไขชื่อของรายการบล็อก โดยสมมติว่าคุณดึงข้อมูลรายการจากเซิร์ฟเวอร์แล้ว

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

โค้ดด้านบนจะแสดงผล Entry ที่มีโพสต์ที่อัปเดตใหม่ทั้งหมด หากต้องการอัปเดตพร็อพเพอร์ตี้อื่นๆ ให้ตั้งค่าในออบเจ็กต์ Entry ก่อนเรียกใช้ update

หมายเหตุ: ปัจจุบันระบบยังไม่รองรับการแก้ไขข้อมูลผู้เขียนที่เชื่อมโยงกับโพสต์

การลบโพสต์

หากต้องการลบโพสต์ ให้ส่ง URL การแก้ไขของโพสต์ไปยังเมธอด delete ในออบเจ็กต์ GoogleService ดังนี้

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

ความคิดเห็น

Blogger Data API ช่วยให้สร้าง เรียกข้อมูล และลบความคิดเห็นได้ ระบบไม่รองรับการอัปเดตความคิดเห็น (และไม่พร้อมใช้งานในอินเทอร์เฟซเว็บ)

การสร้างความคิดเห็น

หากต้องการโพสต์ความคิดเห็น ให้สร้างออบเจ็กต์ Entry แล้วแทรกดังนี้

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

หมายเหตุ: ปัจจุบันคุณสามารถโพสต์ความคิดเห็นได้เฉพาะในบล็อกที่ผู้ใช้ที่ตรวจสอบสิทธิ์เป็นเจ้าของ

หมายเหตุ: ขณะนี้ระบบยังไม่รองรับการตั้งค่าผู้เขียนที่กำหนดเองสำหรับความคิดเห็น ความคิดเห็นใหม่ทั้งหมดจะปรากฏราวกับว่าสร้างขึ้นโดยผู้ใช้ที่ตรวจสอบสิทธิ์อยู่ในขณะนี้

กำลังดึงข้อมูลความคิดเห็น

คุณดึงข้อมูลความคิดเห็นของโพสต์หนึ่งๆ ได้จาก URL ฟีดความคิดเห็นของโพสต์นั้น โดยทำดังนี้

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

หรือจะรับความคิดเห็นจากโพสต์ทั้งหมดโดยใช้ฟีดความคิดเห็นของบล็อกก็ได้ โดย URL ของฟีดมีดังนี้

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

กำลังลบความคิดเห็น

หากต้องการลบความคิดเห็น ให้ส่ง URL การแก้ไขของความคิดเห็นไปยังdelete เมธอดในออบเจ็กต์ GoogleService ดังนี้

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

กลับไปด้านบน