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

สำคัญ เราจะหยุดรองรับ Google Data API เวอร์ชัน 2.0 ในวันที่ 30 กันยายน 2024 โปรดอัปเดตแอปพลิเคชันที่อาศัย Google Data API เวอร์ชัน 2.0 เป็น API เวอร์ชันล่าสุดเพื่อให้แอปพลิเคชันทำงานต่อไปได้ หากต้องการใช้เวอร์ชันล่าสุด ให้ใช้ลิงก์ในแถบนําทางด้านซ้าย หมายเหตุ: แม้ว่าคำขอ GET บางรายการ (เช่น โพสต์รายชื่อ) จะยังคงได้รับการรองรับเป็นฟีด URL มีลักษณะการทำงานที่ต่างกันเล็กน้อย ดูข้อมูลโดยละเอียดได้ในเอกสารประกอบความช่วยเหลือของ Blogger

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

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

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

เนื้อหา

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

ผู้ชม

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

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

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

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

สำหรับเอกสารประกอบเกี่ยวกับการตรวจสอบสิทธิ์ OAuth โดยใช้ไลบรารี Java GData โปรดดู OAuth ใน ไลบรารีของไคลเอ็นต์โปรโตคอลข้อมูลของ Google

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

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

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

หลังจากผู้ใช้ตรวจสอบสิทธิ์แล้ว ระบบ 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 พารามิเตอร์แรกคือชื่อบริการที่เราต้องการโต้ตอบด้วย พารามิเตอร์ที่สองคือชื่อของ ใบสมัครในแบบฟอร์ม companyName-applicationName-versionID

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

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

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

เรียกดูรายการบล็อก

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

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

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

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

กำลังเรียกโพสต์

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

คุณสามารถค้นหาฟีดสาธารณะของ 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 ฟีดโพสต์เดียวกับที่ใช้ดึงข้อมูลโพสต์

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

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

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

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

กำลังอัปเดตโพสต์

หากต้องการอัปเดตบล็อกโพสต์ที่มีอยู่ ก่อนอื่นคุณต้องเรียกข้อมูลรายการที่ต้องการ อัปเดต จากนั้นให้คุณแก้ไข แล้วส่งไปยังบล็อกเกอร์โดยใช้ 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);
}

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