我正在使用Google Place API进行地点搜索：
https://developers.google.com/places/documentation/search
在第一次查询api之后，我通过设置pagetoken来获取下一页。如果我在请求之间等待2秒，它会起作用，但我注意到如果我在前一个查询之后立即进行下一个查询，它将返回状态INVALID_REQUEST。
这是某种限速吗？我在文档中的任何地方都没有看到这一点。
https://developers.google.com/places/usage
由于每个请求有20个位置，因此获取100个结果的列表将花费超过10秒，这对于某人等待使用应用程序来说是很长的时间。
答案 0 :(得分：16)
有记录，请参阅documentation
默认情况下，每个附近搜索或文本搜索最多可返回20个建立结果 查询;但是，每个搜索可以返回多达60个结果，分为三个页面。如果 您的搜索将返回超过20，然后搜索响应将包括一个额外的 value - next_page_token。将next_page_token的值传递给pagetoken参数 新搜索以查看下一组结果。如果next_page_token为null，或者不是 返回，然后没有进一步的结果。 a之间有短暂的延迟 发出next_page_token，并且它何时生效。请求下一页 可用将返回INVALID_REQUEST响应。使用相同的方法重试请求 next_page_token将返回结果的下一页。
答案 1 :(得分：6)
虽然我不是百分之百确定这是原因，但我会在这里留下这个答案，因为我花了大约6个小时来弄清楚这个并且可能对某人有帮助。
正如geocodezip在他的回答中指出的那样，返回的下一页令牌与该页面实际可用之间存在轻微的延迟。所以我没有找到任何其他方法来解决它，除了使用某种sleep。
但我确实发现，在第一次INVALID_REQUEST响应之后每个请求也发出INVALID_REQUEST响应，无论我是等待1,2或10秒。
我怀疑它与谷歌Part的缓存响应有关。我找到的解决方案是将一个随机增量新参数附加到URL，使其成为“不同”的URL，因此请求无缓存响应。
我使用的参数是request_count，对于每个请求，我都将它递增1。
为了便于说明，这里是我使用的Python POC代码（不要复制粘贴，因为这只是一个POC片段，不起作用）：
# If except raises, it's most likely due to an invalid api key
# The while True is used to keep trying a new key each time
query_result_next_page = None
google_places = GooglePlaces(api_key)
invalid_requests_found = 0
request_count = 0
while True:
request_count = request_count + 1
try:
query_result = google_places.nearby_search(
lat_lng={'lat': event['latitude'], 'lng': event['longitude']},
radius=event['radius'],
pagetoken=query_result_next_page,
request_count=request_count)
# If there are additional result pages, lets get it on the next while step
if query_result.has_next_page_token:
query_result_next_page = query_result.next_page_token
else:
break
except Exception as e:
# If the key is over the query limit, try a new one
if str(e).find('OVER_QUERY_LIMIT') != -1:
logInfo("Key "+api_key+" unavailable.")
self.set_unavailable_apikey(api_key)
api_key = self.get_api_key()
# Sometimes the Places API doesn't create the next page
# despite having a next_page_key and throws an INVALID_REQUEST.
# We should just sleep for a bit and try again.
elif str(e).find('INVALID_REQUEST') != -1:
# Maximum of 4 INVALID_REQUEST responses
invalid_requests_found = invalid_requests_found + 1
if invalid_requests_found > 4:
raise e
time.sleep(1)
continue
# If it is another error, different from zero results, raises an exception
elif str(e).find('ZERO_RESULTS') == -1:
raise e
else:
break
编辑：忘记提及GooglePlaces对象来自slimkrazy's Google API lib。不幸的是，我不得不调整实际lib的代码来接受这个新的request_count参数。
我必须为此替换nearby_search方法：
def nearby_search(self, language=lang.ENGLISH, keyword=None, location=None,
lat_lng=None, name=None, radius=3200, rankby=ranking.PROMINENCE,
sensor=False, type=None, types=[], pagetoken=None, request_count=0):
"""Perform a nearby search using the Google Places API.
One of either location, lat_lng or pagetoken are required, the rest of
the keyword arguments are optional.
keyword arguments:
keyword -- A term to be matched against all available fields, including
but not limited to name, type, and address (default None)
location -- A human readable location, e.g 'London, England'
(default None)
language -- The language code, indicating in which language the
results should be returned, if possible. (default lang.ENGLISH)
lat_lng -- A dict containing the following keys: lat, lng
(default None)
name -- A term to be matched against the names of the Places.
Results will be restricted to those containing the passed
name value. (default None)
radius -- The radius (in meters) around the location/lat_lng to
restrict the search to. The maximum is 50000 meters.
(default 3200)
rankby -- Specifies the order in which results are listed :
ranking.PROMINENCE (default) or ranking.DISTANCE
(imply no radius argument).
sensor -- Indicates whether or not the Place request came from a
device using a location sensor (default False).
type -- Optional type param used to indicate place category.
types -- An optional list of types, restricting the results to
Places (default []). If there is only one item the request
will be send as type param.
pagetoken-- Optional parameter to force the search result to return the next
20 results from a previously run search. Setting this parameter
will execute a search with the same parameters used previously.
(default None)
"""
if location is None and lat_lng is None and pagetoken is None:
raise ValueError('One of location, lat_lng or pagetoken must be passed in.')
if rankby == 'distance':
# As per API docs rankby == distance:
# One or more of keyword, name, or types is required.
if keyword is None and types == [] and name is None:
raise ValueError('When rankby = googleplaces.ranking.DISTANCE, ' +
'name, keyword or types kwargs ' +
'must be specified.')
self._sensor = sensor
radius = (radius if radius <= GooglePlaces.MAXIMUM_SEARCH_RADIUS
else GooglePlaces.MAXIMUM_SEARCH_RADIUS)
lat_lng_str = self._generate_lat_lng_string(lat_lng, location)
self._request_params = {'location': lat_lng_str}
if rankby == 'prominence':
self._request_params['radius'] = radius
else:
self._request_params['rankby'] = rankby
if type:
self._request_params['type'] = type
elif types:
if len(types) == 1:
self._request_params['type'] = types[0]
elif len(types) > 1:
self._request_params['types'] = '|'.join(types)
if keyword is not None:
self._request_params['keyword'] = keyword
if name is not None:
self._request_params['name'] = name
if pagetoken is not None:
self._request_params['pagetoken'] = pagetoken
if language is not None:
self._request_params['language'] = language
self._request_params['request_count'] = request_count
self._add_required_param_keys()
url, places_response = _fetch_remote_json(
GooglePlaces.NEARBY_SEARCH_API_URL, self._request_params)
_validate_response(url, places_response)
return GooglePlacesSearchResult(self, places_response)