Google Geocoder v3 का उपयोग करते हुए, यदि मैं 20 पतों को जियोकोड करने की कोशिश करता हूं, तो मुझे एक OVER_QUERY_LIMIT मिलता है जब तक कि मैं उन्हें ~ 1 सेकंड से अलग नहीं करता, लेकिन तब मेरे मार्करों को रखे जाने से पहले 20 सेकंड लगते हैं।
क्या ऐसा करने का कोई अन्य तरीका है, जो पहले से निर्देशांक को संग्रहीत करने के अलावा है?
जवाबों:
नहीं, वास्तव में कोई अन्य तरीका नहीं है: यदि आपके पास कई स्थान हैं और उन्हें मानचित्र पर प्रदर्शित करना चाहते हैं, तो सबसे अच्छा समाधान यह है:
यह निश्चित रूप से, यह देखते हुए कि आपके पास स्थानों के परामर्श से बहुत कम सृजन / संशोधन है।
हां, इसका मतलब है कि स्थानों को सहेजते समय आपको थोड़ा और काम करना होगा - लेकिन इसका मतलब यह भी है:
आपको वास्तव में प्रत्येक अनुरोध के लिए एक पूर्ण सेकंड इंतजार नहीं करना होगा। मैंने पाया कि अगर मैं प्रत्येक अनुरोध के बीच 200 मिलिसेकंड प्रतीक्षा करता हूं तो मैं OVER_QUERY_LIMIT प्रतिक्रिया से बचने में सक्षम हूं और उपयोगकर्ता अनुभव पास होने योग्य है। इस समाधान से आप 4 सेकंड में 20 आइटम लोड कर सकते हैं।
$(items).each(function(i, item){
setTimeout(function(){
geoLocate("my address", function(myLatlng){
...
});
}, 200 * i);
}
setIntervalइसके बजाय आवश्यक अनुरोधों की संख्या पर होना चाहिए setTimeout, और इसे करने के लिए सेट करना होगा 100- बस अगर पते की राशि भविष्य में कभी-कभी राशि का विस्तार करेगी 20।
दुर्भाग्य से यह Google मानचित्र सेवा का प्रतिबंध है।
मैं वर्तमान में जियोकोडिंग सुविधा का उपयोग करके एक एप्लिकेशन पर काम कर रहा हूं, और मैं प्रत्येक उपयोगकर्ता के आधार पर प्रत्येक अद्वितीय पते को बचा रहा हूं। मैं Google मानचित्र द्वारा दी गई जानकारी के आधार पर पते की जानकारी (शहर, सड़क, राज्य इत्यादि) उत्पन्न करता हूं, और फिर डेटाबेस में लैट / लंबी जानकारी को भी सहेजता हूं। यह आपको चीजों को फिर से कोड करने से रोकता है, और आपको अच्छी तरह से स्वरूपित पते देता है।
ऐसा करने का एक और कारण यह है कि एक विशेष आईपी पते से जियोकोड किए जा सकने वाले पतों की संख्या पर दैनिक सीमा होती है। आप नहीं चाहते कि आपका आवेदन किसी व्यक्ति के लिए उस कारण से विफल हो।
मैं एक ही समस्या का सामना कर रहा हूँ 140 पते जियोकोड की कोशिश कर रहा हूं।
अगले जियोकोडिंग अनुरोध के प्रत्येक लूप के लिए मेरा समाधान usleep (100000) जोड़ रहा था । यदि अनुरोध की स्थिति OVER_QUERY_LIMIT है, तो usleep 50000 से बढ़ जाता है और अनुरोध दोहराया जाता है, और इसी तरह।
और कारण सभी प्राप्त डेटा (lat / long) को XML फ़ाइल में संग्रहीत किया जाता है ताकि पृष्ठ लोड होने पर हर बार अनुरोध न चलाएं।
संपादित करें:
यह कहना भूल गए कि यह समाधान शुद्ध js में है, केवल एक चीज जो आपको चाहिए वह है एक ब्राउज़र जो वादों का समर्थन करता है https://developer.mozilla.org/it/docs/Web/JavaScript/Reference/Global_Objects/romise
उन लोगों के लिए जिन्हें अभी भी ऐसा करने की आवश्यकता है, मैंने अपना स्वयं का समाधान लिखा है जो टाइमआउट के साथ वादों को जोड़ती है।
कोड:
/*
class: Geolocalizer
- Handles location triangulation and calculations.
-- Returns various prototypes to fetch position from strings or coords or dragons or whatever.
*/
var Geolocalizer = function () {
this.queue = []; // queue handler..
this.resolved = [];
this.geolocalizer = new google.maps.Geocoder();
};
Geolocalizer.prototype = {
/*
@fn: Localize
@scope: resolve single or multiple queued requests.
@params: <array> needles
@returns: <deferred> object
*/
Localize: function ( needles ) {
var that = this;
// Enqueue the needles.
for ( var i = 0; i < needles.length; i++ ) {
this.queue.push(needles[i]);
}
// return a promise and resolve it after every element have been fetched (either with success or failure), then reset the queue.
return new Promise (
function (resolve, reject) {
that.resolveQueueElements().then(function(resolved){
resolve(resolved);
that.queue = [];
that.resolved = [];
});
}
);
},
/*
@fn: resolveQueueElements
@scope: resolve queue elements.
@returns: <deferred> object (promise)
*/
resolveQueueElements: function (callback) {
var that = this;
return new Promise(
function(resolve, reject) {
// Loop the queue and resolve each element.
// Prevent QUERY_LIMIT by delaying actions by one second.
(function loopWithDelay(such, queue, i){
console.log("Attempting the resolution of " +queue[i-1]);
setTimeout(function(){
such.find(queue[i-1], function(res){
such.resolved.push(res);
});
if (--i) {
loopWithDelay(such,queue,i);
}
}, 1000);
})(that, that.queue, that.queue.length);
// Check every second if the queue has been cleared.
var it = setInterval(function(){
if (that.queue.length == that.resolved.length) {
resolve(that.resolved);
clearInterval(it);
}
}, 1000);
}
);
},
/*
@fn: find
@scope: resolve an address from string
@params: <string> s, <fn> Callback
*/
find: function (s, callback) {
this.geolocalizer.geocode({
"address": s
}, function(res, status){
if (status == google.maps.GeocoderStatus.OK) {
var r = {
originalString: s,
lat: res[0].geometry.location.lat(),
lng: res[0].geometry.location.lng()
};
callback(r);
}
else {
callback(undefined);
console.log(status);
console.log("could not locate " + s);
}
});
}
};
कृपया ध्यान दें कि यह एक बड़ी लाइब्रेरी का एक हिस्सा है जिसे मैंने गूगल मैप्स सामान को संभालने के लिए लिखा था, इसलिए टिप्पणियाँ भ्रमित हो सकती हैं।
उपयोग काफी सरल है, दृष्टिकोण, हालांकि, थोड़ा अलग है: एक समय में एक पते को लूप करने और हल करने के बजाय, आपको कक्षा में पते की एक सरणी को पास करने की आवश्यकता होगी और यह वादा करके खुद ही खोज को संभाल लेगा, जो , जब हल किया जाता है, एक सरणी को सभी हल किए गए (और अनसुलझे) पते देता है।
उदाहरण:
var myAmazingGeo = new Geolocalizer();
var locations = ["Italy","California","Dragons are thugs...","China","Georgia"];
myAmazingGeo.Localize(locations).then(function(res){
console.log(res);
});
कंसोल आउटपुट:
Attempting the resolution of Georgia
Attempting the resolution of China
Attempting the resolution of Dragons are thugs...
Attempting the resolution of California
ZERO_RESULTS
could not locate Dragons are thugs...
Attempting the resolution of Italy
लौटाई गई वस्तु:
पूरा जादू यहां होता है:
(function loopWithDelay(such, queue, i){
console.log("Attempting the resolution of " +queue[i-1]);
setTimeout(function(){
such.find(queue[i-1], function(res){
such.resolved.push(res);
});
if (--i) {
loopWithDelay(such,queue,i);
}
}, 750);
})(that, that.queue, that.queue.length);
मूल रूप से, यह प्रत्येक आइटम को 750 मिलीसेकेंड की देरी के साथ उनमें से प्रत्येक के बीच में जोड़ता है, इसलिए प्रत्येक 750 मिलीसेकंड एक पते को नियंत्रित किया जाता है।
मैंने कुछ और परीक्षण किए हैं और मुझे पता चला है कि 700 मिलीसेकंड पर भी मुझे कभी-कभी QUERY_LIMIT त्रुटि मिल रही थी, जबकि 750 के साथ मेरे पास कोई मुद्दा नहीं था।
किसी भी मामले में, ऊपर दिए गए 750 को संपादित करने के लिए स्वतंत्र महसूस करें यदि आपको लगता है कि आप कम देरी को संभालकर सुरक्षित हैं।
आशा है कि यह निकट भविष्य में किसी की मदद करता है;)
मैंने अभी-अभी Google जियोकोडर का परीक्षण किया है और आपको जैसी समस्या हुई है। मैंने देखा कि मुझे हर 12 अनुरोधों के बाद केवल OVER_QUERY_LIMIT का दर्जा मिलता है, इसलिए मैं 1 सेकंड की प्रतीक्षा करता हूं (यह प्रतीक्षा करने के लिए न्यूनतम विलंब है) यह आवेदन को धीमा कर देता है लेकिन हर दूसरे अनुरोध का इंतजार करने से कम है
info = getInfos(getLatLng(code)); //In here I call Google API
record(code, info);
generated++;
if(generated%interval == 0) {
holdOn(delay); // Every x requests, I sleep for 1 second
}
मूल होल्डऑन विधि के साथ:
private void holdOn(long delay) {
try {
Thread.sleep(delay);
} catch (InterruptedException ex) {
// ignore
}
}
आशा करता हूँ की ये काम करेगा