Utilizzando Google Geocoder v3, se provo a geocodificare 20 indirizzi, ottengo un OVER_QUERY_LIMIT a meno che non cronometri che siano a ~ 1 secondo di distanza, ma poi ci vogliono 20 secondi prima che i miei marcatori siano tutti posizionati.
C'è un altro modo per farlo, oltre a memorizzare le coordinate in anticipo?
Risposte:
No, in realtà non c'è altro modo: se hai molte località e vuoi visualizzarle su una mappa, la soluzione migliore è:
Questo, ovviamente, considerando che hai molta meno creazione / modifica di posizioni rispetto alle consultazioni di posizioni.
Sì, significa che dovrai lavorare un po 'di più quando salvi le posizioni, ma significa anche:
In realtà non è necessario attendere un secondo intero per ogni richiesta. Ho scoperto che se aspetto 200 millisecondi tra ogni richiesta sono in grado di evitare la risposta OVER_QUERY_LIMIT e l'esperienza dell'utente è passabile. Con questa soluzione puoi caricare 20 articoli in 4 secondi.
$(items).each(function(i, item){
setTimeout(function(){
geoLocate("my address", function(myLatlng){
...
});
}, 200 * i);
}
setIntervalil numero di richieste necessarie, invece di setTimeout, e impostarlo su 100- nel caso in cui l'importo dell'indirizzo in futuro estenderà l' 20importo.
Purtroppo questa è una restrizione del servizio di mappe di Google.
Al momento sto lavorando a un'applicazione che utilizza la funzione di geocodifica e sto salvando ogni indirizzo univoco per utente. Genero le informazioni sull'indirizzo (città, via, stato, ecc.) In base alle informazioni restituite da Google Maps, quindi salvo anche le informazioni su latitudine / longitudine nel database. Questo ti impedisce di dover ricodificare le cose e ti dà indirizzi ben formattati.
Un altro motivo per cui vuoi farlo è perché esiste un limite giornaliero al numero di indirizzi che possono essere geocodificati da un particolare indirizzo IP. Non vuoi che la tua richiesta fallisca per una persona per questo motivo.
Sto affrontando lo stesso problema cercando di geocodificare 140 indirizzi.
La mia soluzione alternativa era l'aggiunta di usleep (100000) per ogni ciclo della successiva richiesta di geocodifica. Se lo stato della richiesta è OVER_QUERY_LIMIT, l'usleep viene aumentato di 50000 e la richiesta viene ripetuta, e così via.
E di causa tutti i dati ricevuti (lat / long) vengono memorizzati nel file XML per non eseguire la richiesta ogni volta che la pagina viene caricata.
MODIFICARE:
Ho dimenticato di dire che questa soluzione è in puro js, l'unica cosa di cui hai bisogno è un browser che supporti le promesse https://developer.mozilla.org/it/docs/Web/JavaScript/Reference/Global_Objects/Promise
Per coloro che hanno ancora bisogno di farlo, ho scritto la mia soluzione che combina le promesse con i timeout.
Codice:
/*
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);
}
});
}
};
Tieni presente che è solo una parte di una libreria più grande che ho scritto per gestire le cose di Google Maps, quindi i commenti potrebbero creare confusione.
L'utilizzo è abbastanza semplice, l'approccio, tuttavia, è leggermente diverso: invece di ripetere in loop e risolvere un indirizzo alla volta, dovrai passare un array di indirizzi alla classe che gestirà la ricerca da sola, restituendo una promessa che , una volta risolto, restituisce un array contenente tutti gli indirizzi risolti (e irrisolti).
Esempio:
var myAmazingGeo = new Geolocalizer();
var locations = ["Italy","California","Dragons are thugs...","China","Georgia"];
myAmazingGeo.Localize(locations).then(function(res){
console.log(res);
});
Uscita console:
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
Oggetto restituito:
L'intera magia avviene qui:
(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);
Fondamentalmente, esegue il loop di ogni elemento con un ritardo di 750 millisecondi tra ciascuno di essi, quindi ogni 750 millisecondi viene controllato un indirizzo.
Ho fatto ulteriori test e ho scoperto che anche a 700 millisecondi a volte ricevevo l'errore QUERY_LIMIT, mentre con 750 non ho avuto alcun problema.
In ogni caso, sentiti libero di modificare il 750 sopra se ritieni di essere al sicuro gestendo un ritardo inferiore.
Spero che questo aiuti qualcuno nel prossimo futuro;)
Ho appena testato Google Geocoder e ho riscontrato lo stesso problema che hai tu. Ho notato che ottengo lo stato OVER_QUERY_LIMIT solo una volta ogni 12 richieste Quindi aspetto 1 secondo (questo è il ritardo minimo di attesa) Rallenta l'applicazione ma meno di 1 secondo ogni richiesta
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
}
Con il metodo holdOn di base:
private void holdOn(long delay) {
try {
Thread.sleep(delay);
} catch (InterruptedException ex) {
// ignore
}
}
Spero che sia d'aiuto