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