अहम जानकारी: हम 30 सितंबर, 2024 से Google Data API के v2.0 वर्शन के साथ काम करना बंद कर देंगे. काम जारी रहे, यह पक्का करने के लिए Google के v2.0 वर्शन पर आधारित अपने ऐप्लिकेशन अपडेट करें Data API को एपीआई के सबसे नए वर्शन पर अपडेट करें. नए वर्शन के लिए, बाईं ओर मौजूद नेविगेशन बार में दिए गए लिंक का इस्तेमाल करें. ध्यान दें: कुछ GET अनुरोध (जैसे कि लिस्टिंग पोस्ट), फ़ीड के यूआरएल के तौर पर काम करते रहेंगे. हालांकि, उनके काम करने के तरीके में थोड़े अंतर हैं. ज़्यादा जानकारी के लिए, Blogger सहायता दस्तावेज़ देखें.
Blogger Data API, क्लाइंट ऐप्लिकेशन को Blogger को देखने और अपडेट करने की अनुमति देता है Google Data API फ़ीड के तौर पर कॉन्टेंट उपलब्ध कराता है.
आपका क्लाइंट ऐप्लिकेशन, Blogger Data API का इस्तेमाल करके नई ब्लॉग पोस्ट बना सकता है. साथ ही, मौजूदा ब्लॉग पोस्ट में बदलाव कर सकता है या उन्हें मिटा सकता है. इसके अलावा, किसी खास शर्त से मैच होने वाली ब्लॉग पोस्ट के लिए क्वेरी भी कर सकता है.
इस दस्तावेज़ में, Blogger Data API की सुविधाओं के बारे में जानकारी दी गई है. साथ ही, Java क्लाइंट लाइब्रेरी का इस्तेमाल करके, Data API के बुनियादी इंटरैक्शन के उदाहरण भी दिए गए हैं. अगर आपको इसके बारे में ज़्यादा जानना है वह प्रोटोकॉल जो लाइब्रेरी में इस्तेमाल होता है, इसका प्रोटोकॉल सेक्शन देखें इस डेवलपर की गाइड पढ़ें.
कॉन्टेंट
ऑडियंस
यह दस्तावेज़ उन प्रोग्रामर के लिए है जो Java क्लाइंट लिखना चाहते हैं ऐसे ऐप्लिकेशन जो Blogger के साथ इंटरैक्ट कर सकते हैं.
इस दस्तावेज़ में यह माना गया है कि आपको 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 का इस्तेमाल करके, सार्वजनिक और निजी, दोनों फ़ीड ऐक्सेस किए जा सकते हैं. सार्वजनिक फ़ीड के लिए पुष्टि करने की ज़रूरत नहीं होती. हालांकि, ये फ़ीड रीड-ओनली होते हैं. अगर आपको ब्लॉग में बदलाव करने हैं, तो निजी फ़ीड का अनुरोध करने से पहले, आपके क्लाइंट को पुष्टि करनी होगी. यह इन तीन तरीकों में से किसी एक का इस्तेमाल करके पुष्टि कर सकता है: OAuth की मदद से पुष्टि करना, AuthSub प्रॉक्सी प्रमाणीकरण या ClientLogin उपयोगकर्ता नाम/पासवर्ड पुष्टि करने के लिए.
Google Data API से पुष्टि करने के बारे में ज़्यादा जानने के लिए, पुष्टि करने की प्रक्रिया दस्तावेज़ में दिया गया है.
इस दस्तावेज़ के बाद के सेक्शन में दिए गए ज़्यादातर सैंपल का मतलब है कि आपके पास
पुष्टि किया गया GoogleService ऑब्जेक्ट.
OAuth से पुष्टि
Java GData लाइब्रेरी का इस्तेमाल करके, OAuth की पुष्टि करने से जुड़े दस्तावेज़ के लिए, तो OAuth का इस्तेमाल करें, Google डेटा प्रोटोकॉल क्लाइंट लाइब्रेरी.
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 दस्तावेज़ का "हस्ताक्षर करने के अनुरोध" सेक्शन देखें.
इसके बाद, आपका ऐप्लिकेशन आने वाले इंटरैक्शन में सेशन टोकन का इस्तेमाल कर सकता है
से करें. 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, setUpdatedMax
- एंट्री अपडेट तारीखों के लिए सीमाएं सेट करें. जब तक
orderbyपैरामीटर कोupdatedपर सेट नहीं किया जाता, तब तक इन क्वेरी पैरामीटर को अनदेखा किया जाता है.
ध्यान दें: फ़िलहाल, orderby क्वेरी पैरामीटर के लिए कोई सेटर नहीं है. हालांकि, आपको अब भी
अगर आपको इसे सेट करना है, तो Query.addCustomParameter() तरीका इस्तेमाल करें.
क्वेरी पैरामीटर के बारे में ज़्यादा जानकारी के लिए, Blogger का डेटा एपीआई रेफ़रंस देखें गाइड और 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
method में इस तरह पास करें:
public static void deleteComment(GoogleService myService, String editLinkHref)
throws ServiceException, IOException {
URL deleteUrl = new URL(editLinkHref);
myService.delete(deleteUrl);
}