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

คู่มือของนักพัฒนาซอฟต์แวร์: Java

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

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

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

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

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

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

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

GoogleService.setAuthSubToken(sessionToken, null);

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

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

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

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

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

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

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

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

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

API ข้อมูลของ Blogger มีฟีดที่แสดงรายการบล็อกของผู้ใช้บางราย ฟีดนั้นเรียกว่า "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 โปรไฟล์ของผู้ใช้

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

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

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

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

คุณใช้ไลบรารีของไคลเอ็นต์ 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);
}

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

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

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับพารามิเตอร์การค้นหาได้ที่คู่มืออ้างอิง API ข้อมูลของ Blogger และคู่มืออ้างอิงสําหรับ 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 #39;

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

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