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

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

Blogger डेटा एपीआई, क्लाइंट ऐप्लिकेशन को Google डेटा एपीआई फ़ीड के रूप में Blogger कॉन्टेंट देखने और उसे अपडेट करने की सुविधा देता है.

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

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

कॉन्टेंट

  1. दर्शक
  2. इस्तेमाल शुरू करना
    1. Blogger खाता बनाना
    2. सैंपल कोड चलाना
  3. Blogger की सेवा के लिए पुष्टि करना
    1. AuthSub प्रॉक्सी की पुष्टि करना
    2. ClientLogin उपयोगकर्ता नाम/पासवर्ड की पुष्टि करना
  4. ब्लॉग की सूची वापस लाना
  5. पोस्ट बनाना
    1. ब्लॉग पोस्ट प्रकाशित करना
    2. ड्राफ़्ट ब्लॉग पोस्ट बनाना
  6. पोस्ट वापस पाना
    1. सभी ब्लॉग पोस्ट वापस पाना
    2. क्वेरी पैरामीटर का इस्तेमाल करके, पोस्ट को वापस लाना
  7. पोस्ट अपडेट करना
  8. पोस्ट मिटाना
  9. टिप्पणियां
    1. टिप्पणियां बनाना
    2. टिप्पणियां वापस पाना
    3. टिप्पणियां मिटाना

दर्शक

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

इस दस्तावेज़ में यह माना जाता है कि आप Google के डेटा एपीआई प्रोटोकॉल को इस्तेमाल करने के सामान्य आइडिया समझते हैं.

क्लाइंट लाइब्रेरी से मिली क्लास और मेथड के बारे में जानकारी पाने के लिए, Java क्लाइंट लाइब्रेरी एपीआई का रेफ़रंस देखें. Blogger के डेटा एपीआई की सामान्य जानकारी के लिए, प्रोटोकॉल रेफ़रंस गाइड देखें.

रिपोर्ट का इस्तेमाल करना

क्लाइंट लाइब्रेरी सेट अप करने में मदद पाने के लिए, शुरुआती निर्देश देखें.

Java क्लाइंट लाइब्रेरी को Java 1.5 की ज़रूरत होती है. क्लाइंट लाइब्रेरी डाउनलोड करने के बाद, आपको java/lib/gdataclient-1.0.jar फ़ाइल में वे कक्षाएं मिलेंगी जिन्हें आपको शुरू करना है.

Blogger खाता बनाना

टेस्टिंग के मकसद से, ब्लॉगर खाते के लिए साइन अप किया जा सकता है. Blogger, Google खातों का इस्तेमाल करता है, इसलिए अगर आपके पास पहले से कोई Google खाता है, तो आप पूरी तरह से तैयार हैं.

सैंपल कोड चलाना

एक पूरी तरह से काम करने वाला सैंपल क्लाइंट, जिसमें इस दस्तावेज़ में दिखाया गया सभी सैंपल कोड शामिल है, वह gdata/java/sample/blogger/BloggerClient.java निर्देशिका के तहत Java क्लाइंट लाइब्रेरी में उपलब्ध है. README.txt फ़ाइल में, एक ही डायरेक्ट्री में बिल्ड और एक्ज़ीक्यूशन के निर्देश शामिल होते हैं.

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

Google डेटा एपीआई की मदद से पुष्टि करने के बारे में ज़्यादा जानकारी के लिए, पुष्टि करने वाला दस्तावेज़ देखें.

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

String token = AuthSubUtil.getTokenFromReply(urlFromAuthSub);
String sessionToken = AuthSubUtil.exchangeForSessionToken(token, null);

इसका मतलब है कि आपके इस्तेमाल के लिए एक बार इस्तेमाल होने वाले टोकन को exchangeForSessionToken तरीके से पास किया जाता है. साथ ही, null (रजिस्टर किए गए मोड के लिए) या निजी कुंजी (रजिस्टर किए गए मोड के लिए) भी पास की जाती है. साथ ही, AuthSub इंटरफ़ेस, सेशन टोकन दिखाता है. रजिस्टर किए गए ऐप्लिकेशन और निजी कुंजियों के बारे में ज़्यादा जानकारी के लिए, AuthSub दस्तावेज़ के "अनुरोध सबमिट करना" सेक्शन देखें.

फिर आपका ऐप्लिकेशन बाद के इंटरैक्शन वाले Blogger में सेशन टोकन का इस्तेमाल कर सकता है. हर अनुरोध को अपने-आप सेशन भेजने के लिए, Java क्लाइंट लाइब्रेरी को यह बताने के लिए, GoogleService ऑब्जेक्ट और #39;setAuthSubToken तरीके का इस्तेमाल करें:

GoogleService.setAuthSubToken(sessionToken, null);

उसके बाद, क्लाइंट लाइब्रेरी अपने-आप हर अनुरोध के साथ टोकन भेज देती है.

क्लाइंट लॉगिन उपयोगकर्ता नाम/पासवर्ड की पुष्टि करना

अगर आपका क्लाइंट स्टैंडअलोन, सिंगल-उपयोगकर्ता और इंस्टॉल किया गया" क्लाइंट (जैसे कि एक डेस्कटॉप ऐप्लिकेशन) है, तो ClientLogin पुष्टि का इस्तेमाल करें. बस अपने GoogleService ऑब्जेक्ट पर setUserCredentials तरीका कॉल करें और Blogger के साथ होने वाले सभी इंटरैक्शन की पुष्टि की जाएगी:

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

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

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

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

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

ब्लॉग की सूची फ़ेच की जा रही है

Blogger डेटा एपीआई में एक फ़ीड होता है, जो किसी खास उपयोगकर्ता के ब्लॉग की सूची बनाता है; उस फ़ीड को "metafeed.&quot कहा जाता है;

नीचे दिया गया सैंपल कोड, 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 के डेटा एपीआई का इस्तेमाल करके, आप नई ब्लॉग एंट्री बना सकते हैं और प्रकाशित कर सकते हैं. साथ ही, आप एंट्री के ड्राफ़्ट भी बना सकते हैं.

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

ब्लॉग पोस्ट पब्लिश करना

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

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

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

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

कैटगरी फ़िल्टर जोड़ें
फ़ीड के नतीजे फ़िल्टर करने के लिए, कैटगरी (इन्हें लेबल भी कहा जाता है) तय करें. उदाहरण के लिए, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie, Fritz और Laurie, दोनों लेबल के साथ एंट्री दिखाता है.
setMaxResults
वापस जाने के लिए प्रविष्टियों की अधिकतम संख्या सेट करें.
setpublishedMin, setpublishedMax
एंट्री की तारीख, प्रकाशन की तारीख के हिसाब से सेट करें.
setStartindex
पहले नतीजे पाने के लिए, एक पर आधारित इंडेक्स सेट करें (पेजिंग के लिए).
setUpdatedMin, setUpdatedMax
एंट्री अपडेट की तारीखों की सीमाएं सेट करें. इन क्वेरी पैरामीटर को तब तक अनदेखा किया जाता है, जब तक orderby पैरामीटर updated पर सेट न हो.

ध्यान दें: फ़िलहाल, orderby क्वेरी पैरामीटर के लिए कोई सेटर नहीं है. हालांकि, अगर आपको इसे सेट करना है, तो Query.addCustomParameter() तरीके का इस्तेमाल करें.

क्वेरी पैरामीटर के बारे में ज़्यादा जानने के लिए, Blogger डेटा एपीआई के रेफ़रंस की गाइड और Google डेटा एपीआई के रेफ़रंस की गाइड देखें.

पोस्ट अपडेट की जा रही हैं

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

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

टिप्पणी पोस्ट करने के लिए, 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

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

किसी टिप्पणी को मिटाने के लिए, टिप्पणी और #39;s के यूआरएल में बदलाव करें. ऐसा करने के लिए, अपने GoogleService ऑब्जेक्ट में, delete तरीके का इस्तेमाल करें:

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

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