ArcGIS API For JavaScript（1）之前端获取地图服务MapServer的所有数据（突破默认1000条的限制）-CSDN博客

本文链接：https://blog.csdn.net/wokao253615105/article/details/116163131

该博客探讨了在地图服务中遇到大数据量查询超时的问题。通过查询所有ID，然后使用Promise.all并行处理多个小规模查询，实现了获取全部数据的解决方案。这种方法可以避免单次请求数据量过大导致的服务超时。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在实际的应用场景中，有可能需要一次性读取到地图服务中的所有数据的需求，当服务中数据量超过默认1000条时，因数据量限制，请求只会得出前1000条，虽然可以通过对ArcGIS Server中更新请求最大值，但数据稍大些时，往往会造成服务超时的情况，导致请求失败。

以下通过先查询所有ID,然后使用Promise.all等待多个query查询结束后合并所有结果来实现。

        function queryAll(config,map,callback) {
            // var load = layer.load(0, {
            //     shade: [0.1, "#fff"], //0.1透明度的白色背景
            //     content: "正在初始化数据...",
            //     success: function (layero) {
            //         layero.find(".layui-layer-content").css({
            //             "padding-top": "39px",
            //             width: "150px",
            //         });
            //     },
            // });
            var reultArr=[];
            //只查询ids
            queryForIds(config,map,function (result) {
                if(result&&result.length>0) {
                    config.isReturnGeometry = true;
                    config.fields=['*'];
                    var promiseArr = [];
                    var n = Math.ceil(result.length / 1000);

                    for (var a = 0; a < n; a++) {
                        var objectIds = "OBJECTID in ("
                        var start = 1000 * a;
                        var end = 1000 * (a + 1);
                        if (end > result.length) {
                            end = result.length;
                        }
                        for (var b = start; b < end; b++) {
                            if (b + 1 == end) {
                                objectIds += result[b];
                            } else {
                                objectIds += result[b] + ",";
                            }

                        }
                        objectIds += ")";
                        config.whereCluse = objectIds;
                        promiseArr.push(query(config, map));
                    }
                    if (promiseArr.length > 0) {
                        //多个Query查询，以便能实现数据量大于单次最大返回数时也能读取到
                        Promise.all(promiseArr).then(function (resultArr) {
                            console.log(resultArr);
                            if(resultArr&&resultArr.length>0){
                                for(var r in resultArr){
                                    var result=resultArr[r];
                                    if(result&&result.features&&result.features.length>0){
                                        for(var i in result.features){
                                            result.features[i].attributes.geometry=result.features[i].geometry;
                                        }
                                        if(reultArr.length==0){
                                            reultArr=result.features.map(f=>f.attributes);
                                        }
                                        else {
                                            result.features.map(f=>f.attributes).forEach(s=>reultArr.push(s));
                                        }

                                    }
                                }
                            }
                            if(callback){
                                callback(reultArr);
                            }
                            // layer.close(load);
                        }).catch(function (e) {
                            console.log(e);
                            // layer.close(load);
                        });
                    }
                }
                else {
                    // layer.close(load);
                }
            })
        }

只查询ID值

        function queryForIds(option,map,callback) {
            //executeForIds
            var url = option.serverUrl
            let queryTask = new QueryTask(url)
            let query = new Query()
            query.where = option.whereCluse ? option.whereCluse:"1=1"
            query.returnGeometry = option.isReturnGeometry!=undefined ?
                option.isReturnGeometry : true;
            query.outSpatialReference = map.spatialReference
            query.outFields = option.fields?option.fields:['*']
            query.geometry = option.geometry ? option.geometry : null
            return queryTask.executeForIds(query,
                function (result) {
                    if (callback) {
                        callback(result);
                    }
                }, function (error) {
                    console.log(error);
                });
        }