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

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

Blogger Data API ช่วยให้แอปพลิเคชันไคลเอ็นต์ดูและอัปเดตเนื้อหา 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 ดูข้อมูลอ้างอิงทั่วไปเกี่ยวกับ Data API ของ Blogger ได้ที่คู่มืออ้างอิงโปรโตคอล

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

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

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

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

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

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

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

ไคลเอ็นต์ตัวอย่างดำเนินการหลายอย่างในบล็อกที่ให้ไว้เพื่อสาธิตการใช้งาน API ข้อมูลของ Blogger

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

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

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

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

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

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

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

โค้ดตัวอย่างต่อไปนี้ใช้ออบเจ็กต์ 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 เพิ่มเข้ามา เช่น รหัสโพสต์

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

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

การเรียกโพสต์โดยใช้พารามิเตอร์การค้นหา

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

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