इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

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

विषय सूची

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

दर्शक

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

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

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

प्रारंभ करना

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

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

Blogger खाता बनाना

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

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

इस दस्तावेज़ में दिखाए गए सभी सैंपल कोड के साथ, पूरी तरह से काम करने वाला सैंपल क्लाइंट, gdata/java/sample/blogger/BloggerClient.java डायरेक्ट्री के तहत 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 दस्तावेज़ में दी गई जानकारी के मुताबिक, पुष्टि करने का अनुरोध पूरा नहीं हो सकता और कैप्चा चैलेंज का अनुरोध किया जा सकता है. अगर आप चाहते हैं कि 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: लौटाने के लिए प्रविष्टियों की ज़्यादा से ज़्यादा संख्या सेट करें.
setपब्लिशMin, setPublishedMax: पब्लिकेशन की तारीखों के लिए सीमाएं सेट करें.
setStartIndex: पेजिंग के लिए, सबसे पहले मिले नतीजे के लिए, एक आधारित इंडेक्स सेट करें.
setUpdatedMin, setअपडेट किया गयाMax: एंट्री अपडेट तारीखों के लिए सीमाएं सेट करें. इन क्वेरी पैरामीटर को तब तक अनदेखा किया जाता है, जब तक 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 डेटा एपीआई की मदद से टिप्पणियां बनाई जा सकती हैं, उन्हें वापस पाया जा सकता है, और मिटाया जा सकता है. टिप्पणियों को अपडेट नहीं किया जा सकता (और न ही यह वेब इंटरफ़ेस में उपलब्ध है).

टिप्पणियां करना

टिप्पणी पोस्ट करने के लिए, 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 वाले तरीके से, टिप्पणी में बदलाव करने का यूआरएल इस तरह से भेजें:

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

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