डेवलपर की गाइड: Java

अहम जानकारी: यह इस पेज का पुराना वर्शन है. नए वर्शन के लिए, बाईं ओर मौजूद नेविगेशन बार में दिए गए लिंक का इस्तेमाल करें.

Blogger Data API की मदद से, क्लाइंट ऐप्लिकेशन, Google Data API फ़ीड के तौर पर Blogger कॉन्टेंट को देख सकते हैं और उसे अपडेट कर सकते हैं.

आपका क्लाइंट ऐप्लिकेशन, Blogger Data API का इस्तेमाल करके नई ब्लॉग पोस्ट बना सकता है. साथ ही, मौजूदा ब्लॉग पोस्ट में बदलाव कर सकता है या उन्हें मिटा सकता है. इसके अलावा, किसी खास शर्त से मैच होने वाली ब्लॉग पोस्ट के लिए क्वेरी भी कर सकता है.

इस दस्तावेज़ में, Blogger Data API की सुविधाओं के बारे में कुछ जानकारी दी गई है. साथ ही, Java क्लाइंट लाइब्रेरी का इस्तेमाल करके, Data API के बुनियादी इंटरैक्शन के उदाहरण भी दिए गए हैं. अगर आपको लाइब्रेरी में इस्तेमाल किए जाने वाले प्रोटोकॉल के बारे में ज़्यादा जानना है, तो डेवलपर के लिए बनी इस गाइड का प्रोटोकॉल सेक्शन देखें.

कॉन्टेंट

ऑडियंस

यह दस्तावेज़ उन प्रोग्रामर के लिए है जो Blogger के साथ इंटरैक्ट करने वाले Java क्लाइंट ऐप्लिकेशन लिखना चाहते हैं.

इस दस्तावेज़ में यह माना गया है कि आपको Google Data 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 प्रॉक्सी की पुष्टि

AuthSub प्रॉक्सी की पुष्टि करने की सुविधा का इस्तेमाल, वेब ऐप्लिकेशन करते हैं. इन ऐप्लिकेशन को अपने उपयोगकर्ताओं की पुष्टि, Google खातों के लिए करनी होती है. वेबसाइट ऑपरेटर और क्लाइंट कोड के पास, Blogger उपयोगकर्ता के उपयोगकर्ता नाम और पासवर्ड का ऐक्सेस नहीं होता. इसके बजाय, क्लाइंट को खास AuthSub टोकन मिलते हैं. इनकी मदद से, क्लाइंट किसी उपयोगकर्ता की ओर से कार्रवाई कर सकता है. ज़्यादा जानकारी के लिए, AuthSub दस्तावेज़ देखें.

जब कोई उपयोगकर्ता पहली बार आपके ऐप्लिकेशन पर आता है, तब उसकी पुष्टि नहीं की जाती. इस मामले में, आपको कुछ जानकारी और एक लिंक दिखाना होगा. इस लिंक से उपयोगकर्ता को Google के एक पेज पर ले जाया जाएगा. इस पेज पर, उपयोगकर्ता को अपने ब्लॉग को ऐक्सेस करने के अनुरोध की पुष्टि करनी होगी. Java क्लाइंट लाइब्रेरी, Google पेज का यूआरएल जनरेट करने के लिए एक फ़ंक्शन उपलब्ध कराती है. यहां दिया गया कोड, 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 हैंडलर के इस्तेमाल किए गए क्वेरी पैरामीटर से मेल खाते हैं):

अगली

उस पेज का यूआरएल जिस पर Google को पुष्टि करने के बाद उपयोगकर्ता को रीडायरेक्ट करना चाहिए.

दायरा

इससे पता चलता है कि ऐप्लिकेशन, Blogger फ़ीड को ऐक्सेस करने के लिए टोकन का अनुरोध कर रहा है. इस्तेमाल की जाने वाली स्कोप स्ट्रिंग http://www.blogger.com/feeds/ है (यह कोड में बदला गया यूआरएल है).

सुरक्षित

इससे पता चलता है कि क्लाइंट, सुरक्षित टोकन का अनुरोध कर रहा है या नहीं.

सत्र

यह बताता है कि लौटाए गए टोकन को, एक से ज़्यादा बार इस्तेमाल किए जा सकने वाले (सेशन) टोकन के लिए बदला जा सकता है या नहीं.

ऊपर दिया गया उदाहरण, एक ऐसे कॉल को दिखाता है जो सुरक्षित टोकन का अनुरोध नहीं करता (secure की वैल्यू false है). इससे मिलने वाला अनुरोध यूआरएल ऐसा दिख सकता है:

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 सिस्टम उसे उस यूआरएल पर रीडायरेक्ट करता है जिसे आपने AuthSubRequest यूआरएल के next क्वेरी पैरामीटर में बताया है. AuthSub सिस्टम, token क्वेरी पैरामीटर की वैल्यू के तौर पर, उस यूआरएल में पुष्टि करने वाला टोकन जोड़ता है. उदाहरण के लिए:

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

इस टोकन की वैल्यू, एक बार इस्तेमाल होने वाले AuthSub टोकन को दिखाती है. इस उदाहरण में, session = true के तय होने पर, इस टोकन को AuthSubSessionToken सेवा को कॉल करके, AuthSub सेशन टोकन के लिए बदला जा सकता है. इसके लिए, यहां दिया गया तरीका अपनाएं. यहां urlFromAuthSub वह यूआरएल है जिस पर 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 की पुष्टि करने की सुविधा का इस्तेमाल करें. जैसे, डेस्कटॉप ऐप्लिकेशन. बस अपने GoogleService ऑब्जेक्ट पर setUserCredentials तरीका कॉल करें और Blogger के साथ होने वाले सभी इंटरैक्शन की पुष्टि की जाएगी:

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

ऊपर दिए गए स्निपेट में, हमने GoogleService कंस्ट्रक्टर को दो पैरामीटर पास किए हैं. पहला पैरामीटर, उस सेवा का नाम है जिससे हमें इंटरैक्ट करना है. दूसरा पैरामीटर, हमारे ऐप्लिकेशन का नाम है. यह नाम companyName-applicationName-versionID फ़ॉर्मैट में होना चाहिए.

ClientLogin की पुष्टि करने के बारे में ज़्यादा जानकारी के लिए, इंस्टॉल किए गए ऐप्लिकेशन के लिए पुष्टि से जुड़ा दस्तावेज़ देखें. इसमें, अनुरोध और जवाब के सैंपल भी शामिल हैं.

ध्यान दें: किसी सेशन में सभी अनुरोधों के लिए एक ही टोकन का इस्तेमाल करें. हर Blogger अनुरोध के लिए नया टोकन न लें.

ध्यान दें: ClientLogin दस्तावेज़ में बताए गए तरीके के मुताबिक, पुष्टि करने का अनुरोध पूरा न हो पाए और सीएपीटीCHA चुनौती का अनुरोध किया जाए. अगर आपको Google से कैप्चा चुनौती जारी करने और उसे मैनेज करने की अनुमति देनी है, तो उपयोगकर्ता को https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger पर भेजें. ऐसा करने के लिए, 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());
  }
}

getFeed तरीके से इस्तेमाल किए गए यूआरएल पर ध्यान दें. यह डिफ़ॉल्ट मेटाफ़ीड यूआरएल है. यह, पुष्टि किए गए मौजूदा उपयोगकर्ता के ब्लॉग की सूची दिखाता है. किसी दूसरे उपयोगकर्ता के फ़ीड को ऐक्सेस करने के लिए, मेटाफ़ीड यूआरएल में default के बजाय उपयोगकर्ता का आईडी डाला जा सकता है. उपयोगकर्ता का आईडी, उपयोगकर्ता की प्रोफ़ाइल के यूआरएल के आखिर में मौजूद अंकों की स्ट्रिंग होती है.

पोस्ट बनाना

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 तरीका, सेवा के पोस्ट यूआरएल को पैरामीटर के तौर पर लेता है. इसके बाद, यह तरीका उस एंट्री को दिखाता है जिसे Blogger ने सेव किया था. आपको जो एंट्री दिखेगी वह वही होगी जो आपने भेजी थी. हालांकि, इसमें Blogger के जोड़े गए कई एलिमेंट भी शामिल होंगे. जैसे, पोस्ट का आईडी.

अगर किसी वजह से आपका अनुरोध पूरा नहीं हो पाता है, तो हो सकता है कि Blogger कोई दूसरा स्टेटस कोड दिखाए. स्टेटस कोड के बारे में जानकारी के लिए, Google Data API प्रोटोकॉल का रेफ़रंस दस्तावेज़ देखें.

ब्लॉग पोस्ट का ड्राफ़्ट बनाना

ड्राफ़्ट पोस्ट, सार्वजनिक पोस्ट की तरह ही बनाई जाती हैं. हालांकि, आपको Entry ऑब्जेक्ट का draft एट्रिब्यूट सेट करना होगा. ऊपर दी गई ब्लॉग पोस्ट की तरह ही, हाइलाइट की गई लाइन जोड़कर ड्राफ़्ट के तौर पर ब्लॉग पोस्ट बनाई जा सकती है:

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 तरीके का ही इस्तेमाल करें. हालांकि, इस बार ब्लॉग पोस्ट फ़ीड का यूआरएल भेजें:

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 मेथड में पास करें.

उदाहरण के लिए, तारीख की सीमा वाली क्वेरी भेजने के लिए, Query ऑब्जेक्ट के setPublishedMin और setPublishedMax तरीकों का इस्तेमाल करें. यहां दिया गया कोड स्निपेट, शुरू होने और खत्म होने के दिए गए समय के बीच पब्लिश की गई हर ब्लॉग पोस्ट का टाइटल प्रिंट करता है:

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 ऑब्जेक्ट को उसी पोस्ट फ़ीड यूआरएल का इस्तेमाल करके बनाया गया है जिसका इस्तेमाल पोस्ट वापस पाने के लिए किया जाता है.

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 रेफ़रंस गाइड देखें.

पोस्ट अपडेट करना

किसी मौजूदा ब्लॉग पोस्ट को अपडेट करने के लिए, सबसे पहले वह एंट्री पाएं जिसे अपडेट करना है. इसके बाद, उसमें बदलाव करें और फिर update तरीके का इस्तेमाल करके उसे Blogger पर भेजें. यहां दिया गया कोड स्निपेट, ब्लॉग एंट्री के टाइटल में बदलाव करता है. ऐसा तब माना जाता है, जब आपने एंट्री को पहले ही सर्वर से वापस पा लिया हो.

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 दिखाता है, जिसमें पूरी तरह से अपडेट की गई पोस्ट शामिल होती है. किसी भी अन्य प्रॉपर्टी को अपडेट करने के लिए, update को कॉल करने से पहले उन्हें Entry ऑब्जेक्ट में सेट करें.

ध्यान दें: फ़िलहाल, पोस्ट से जुड़े लेखक के डेटा में बदलाव नहीं किया जा सकता.

पोस्ट मिटाना

किसी पोस्ट को मिटाने के लिए, पोस्ट में बदलाव करने के यूआरएल को अपने GoogleService ऑब्जेक्ट के delete तरीके पर पास करें. जैसे:

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

ध्यान दें: फ़िलहाल, सिर्फ़ उस ब्लॉग पर टिप्पणी की जा सकती है जिसका मालिकाना हक पुष्टि किए गए उपयोगकर्ता के पास है.

ध्यान दें: फ़िलहाल, टिप्पणियों के लिए कस्टम लेखक सेट करने की सुविधा उपलब्ध नहीं है. सभी नई टिप्पणियां, इस तरह दिखेंगी जैसे कि उन्हें पुष्टि किए गए मौजूदा उपयोगकर्ता ने बनाया हो.

टिप्पणियां वापस लाना

किसी पोस्ट के टिप्पणियों वाले फ़ीड के यूआरएल से, उस पोस्ट की टिप्पणियां वापस पाई जा सकती हैं:

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

इसके अलावा, ब्लॉग के टिप्पणियों वाले फ़ीड के यूआरएल का इस्तेमाल करके, सभी पोस्ट की टिप्पणियां देखी जा सकती हैं:

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

टिप्पणियां मिटाना

किसी टिप्पणी को मिटाने के लिए, टिप्पणी में बदलाव करने के यूआरएल को अपने GoogleService ऑब्जेक्ट के delete method में इस तरह पास करें:

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

वापस सबसे ऊपर जाएं