map中批量图层的加载和展示

private function configopLayermaps():void
            {
var i:int = 0;
var len_configData_opLayers:int=configData.opLayers.length;//configData.opLayers获取的是config配置文件中的所有layer节点的图层
                for (i = 0; i < len_configData_opLayers; i++)//依次添加config中的图层到map_view中
                {
                    addLayerToMap(configData.opLayers[i], this.map_View);
                }
            }
                   /* 给Map对象添加地图服务，这里只添加有时间轴属性的卫片图层，按照各种不同的图层类型分别加载 */
private function  addLayerToMap(layerObject:Object,map:Map):void
            {
var operationalLayer:Boolean=false;
const timeline:String = layerObject.timeline;


if(timeline==null || timeline=="")//将有时间轴属性的卫片图层加载到map中
                {
return;
                }

//获取每个图层中常用的属性信息
                const alpha:Number = Number(layerObject.alpha);
const autoRefresh:Number = Number(layerObject.autoRefresh);
const lyrid:String = layerObject.lyrid;//图层ID
                const tilelevel:int = layerObject.tilelevel;//切片级别
                
const label:String = layerObject.label;
const style:String = layerObject.style;
const token:String = layerObject.token;
const type:String = layerObject.type;
const url:String = layerObject.url;
const bingMapKey:String = layerObject.key;
const culture:String = layerObject.culture;
const visibleLayers:String = layerObject.visibleLayers;
const visible:Boolean = layerObject.visible;
const useAMF:String = layerObject.useAMF;
const mode:String = layerObject.mode;
const noData:Number = Number(layerObject.noData);
const useProxy:Boolean = layerObject.useProxy;
const serviceHost:String = layerObject.serviceHost;
const serviceName:String = layerObject.serviceName;
const proxyUrl:String = configData.proxyUrl;
const definitionExpression:String = layerObject.definitionExpression;

switch (type.toLowerCase())//根据图层类型依次添加图层服务
                {
case "tiled":
                    {
var tiledLayer:ArcGISTiledMapServiceLayer = new ArcGISTiledMapServiceLayer(url);
                        tiledLayer.alpha = alpha;  
                        tiledLayer.id = lyrid;
                        tiledLayer.name = label;
                        tiledLayer.token = token;
                        tiledLayer.visible = visible;
if (proxyUrl && useProxy)
                        {
                            tiledLayer.proxyURL = proxyUrl;
                        }
if (operationalLayer)
                        {
                            layerObject.layer = tiledLayer;
                        }
                        map.addLayer(tiledLayer);
break;
                    }
case "bjtiled":
                    {
var bjtiledlayer:BJZYXXTiledMapServiceLayer=new BJZYXXTiledMapServiceLayer(url);
                        bjtiledlayer.id=lyrid;
                        bjtiledlayer.name=label;
                        bjtiledlayer.visible=visible;
                        bjtiledlayer.alpha=alpha;
                        map.addLayer(bjtiledlayer);
break;
                    }
case "bjwms":
                    {                        
var bjwmslayer:BJZYXXWMSLayer=new BJZYXXWMSLayer(url);
                        bjwmslayer.id=lyrid;
                        bjwmslayer.name=label;
                        bjwmslayer.visible=visible;
                        bjwmslayer.alpha=alpha;
                        map.addLayer(bjwmslayer);
break;
                    }
case "wms":
                    {                        
var wmslayer:WMSLayer=new WMSLayer();
                        wmslayer.url=url;
                        wmslayer.proxyURL=configData.proxyUrl;
                        wmslayer.id=lyrid;
                        wmslayer.name=label;
                        wmslayer.visible=visible;
                        wmslayer.alpha=alpha;
                        map.addLayer(wmslayer);
break;
                    }
case "tiled-dynamic":
                    {

var mixedLayers:Array=[];
var urlAry:Array=url.split(";");
var mixed_tiledlayer:ArcGISTiledMapServiceLayer=new ArcGISTiledMapServiceLayer(urlAry[0]);
                        mixed_tiledlayer.alpha=alpha;
                        mixed_tiledlayer.id="0_" + lyrid;
                        mixed_tiledlayer.name=label;
                        mixed_tiledlayer.token = token;
                        mixed_tiledlayer.visible=visible;
if (proxyUrl && useProxy)
                        {
                            mixed_tiledlayer.proxyURL = proxyUrl;
                        }
if (operationalLayer)
                        {
                            layerObject.layer = mixed_tiledlayer;
                        }
                        map.addLayer(mixed_tiledlayer);
                        mixedLayers.push(mixed_tiledlayer);


var mixed_dynlayer:ArcGISDynamicMapServiceLayer=new ArcGISDynamicMapServiceLayer(urlAry[1]);
                        mixed_dynlayer.alpha=alpha;
                        mixed_dynlayer.id="1_" + lyrid;
                        mixed_dynlayer.name=label;
                        mixed_dynlayer.token = token;
                        mixed_dynlayer.visible=visible;
if (proxyUrl && useProxy)
                        {
                            mixed_dynlayer.proxyURL = proxyUrl;
                        }
if (operationalLayer)
                        {
                            layerObject.layer = mixed_dynlayer;
                        }
                        mixedLayers.push(mixed_dynlayer);
var mixedinfo:Object={mixedLayers: mixedLayers, tilelevel: tilelevel};
                        mixedinfos.push(mixedinfo);

break;

                    }
case "dynamic":
                    {
var dynLayer:ArcGISDynamicMapServiceLayer = new ArcGISDynamicMapServiceLayer(url);
                        dynLayer.alpha = alpha;
                        dynLayer.id = lyrid;
                        dynLayer.name = label;
                        dynLayer.token = token;
                        dynLayer.visible = visible;
if (autoRefresh > 0)
                        {
                            setInterval(dynLayer.refresh, autoRefresh * 1000);
                        }
if (visibleLayers)
                        {
var vizLayers:Array = visibleLayers.split(",");
for (var i:int = 0; i < vizLayers.length; i++)
                            {
                                vizLayers[i] = Number(vizLayers[i]); // convert to Numbers
                            }
                            dynLayer.visibleLayers = new ArrayCollection(vizLayers);
                        }
if (proxyUrl && useProxy)
                        {
                            dynLayer.proxyURL = proxyUrl;
                        }
if (operationalLayer)
                        {
                            layerObject.layer = dynLayer;
                        }
                        map.addLayer(dynLayer);
break;
                    }
case "feature":
                    {
var featureLayer:FeatureLayer = new FeatureLayer(url);
                        featureLayer.alpha = alpha;
                        featureLayer.id = lyrid;
                        featureLayer.name = label;
                        featureLayer.outFields = [ '*' ];
                        featureLayer.token = token;
                        featureLayer.visible = visible;
if (useAMF)
                        {
                            featureLayer.useAMF = useAMF == "true";
                        }
if (mode)
                        {
                            featureLayer.mode = mode;
                        }
if (definitionExpression && definitionExpression != "")
                        {
                            featureLayer.definitionExpression = definitionExpression;
                        }
if (proxyUrl && useProxy)
                        {
                            featureLayer.proxyURL = proxyUrl;
                        }
if (operationalLayer)
                        {
                            layerObject.layer = featureLayer;
                        }
                        map.addLayer(featureLayer);
break;
                    }
case "bing":
                    {
var veTiledLayer:VETiledLayer = new VETiledLayer();
                        veTiledLayer.id = lyrid;
                        veTiledLayer.name = label;
                        veTiledLayer.key = bingMapKey;
                        veTiledLayer.visible = visible;
                        veTiledLayer.alpha = alpha;
if (style)
                        {
                            veTiledLayer.mapStyle = style;
                        }
if (culture)
                        {
                            veTiledLayer.culture = culture;
                        }
if (operationalLayer)
                        {
                            layerObject.layer = veTiledLayer;
                        }
                        map.addLayer(veTiledLayer);
break;
                    }
case "image":
                    {
var imgLayer:ArcGISImageServiceLayer = new ArcGISImageServiceLayer(url);
                        imgLayer.id = lyrid;
                        imgLayer.name = label;
                        imgLayer.alpha = alpha;
                        imgLayer.token = token;
                        imgLayer.visible = visible;
                        imgLayer.noData = noData;
if (proxyUrl && useProxy)
                        {
                            imgLayer.proxyURL = proxyUrl;
                        }
if (operationalLayer)
                        {
                            layerObject.layer = imgLayer;
                        }
                        map.addLayer(imgLayer);
break;
                    }
case "arcims":
                    {
var arcimsLayer:ArcIMSMapServiceLayer = new ArcIMSMapServiceLayer;
                        arcimsLayer.alpha = alpha;
                        arcimsLayer.id = lyrid;
                        arcimsLayer.name = label;
                        arcimsLayer.visible = visible;
                        arcimsLayer.serviceHost = serviceHost;
                        arcimsLayer.serviceName = serviceName;
if (autoRefresh > 0)
                        {
                            setInterval(arcimsLayer.refresh, autoRefresh * 1000);
                        }
if (visibleLayers)
                        {
var visLayers:Array = visibleLayers.split(",");
var len_visLayers:int=visLayers.length;//dcx_yh_3
                            for (var j:int = 0; j < len_visLayers; j++)
                            {
                                visLayers[j] = Number(visLayers[j]); // convert to Numbers
                            }
                            arcimsLayer.visibleLayers = new ArrayCollection(visLayers);
                        }
if (proxyUrl && useProxy)
                        {
                            arcimsLayer.proxyURL = proxyUrl;
                        }
if (operationalLayer)
                        {
                            layerObject.layer = arcimsLayer;
                        }
                        map.addLayer(arcimsLayer);
break;
                    }
default:
                    {
                        Alert.show('"' + type + '" is not a supported layer "type".  Use "feature", "tiled", "dynamic", "image", "bing" or "arcims" instead.'
                            + '\n\n<layer type="' + type + '" '
                            + 'label="' + label + '" '
                            + 'url="' + url + '" ...', "Incorrect layer type");
break;
                    }
                }
            }

 上面只是完成啦图层的加载，但通常情况下只会显示一个图层，于是还需要控制一下显示，这个用visible实现

 下面主要是先获取要显示的图层的url然后将其对应图层的visible制空即可。

public  function initMap():void
            {
var i:int = 0;
var len_configData_opLayers:int=configData.opLayers.length;
for (i = 0; i < len_configData_opLayers; i++)
                {
var layerObject:Object= configData.opLayers[i]
var timeline:String = layerObject.timeline;

if(timeline!=null && timeline!="" )//只有有timeline属性的图层服务才能设visible设为true
                    {
var url:String = layerObject.url;
if(url!="") 
                        {
                            VisibleLayerByUrl(url,true);
break;                        //只设置第一个时间轴的图层，其他的为false
                        }

                    }
                }
            }
//给指定的url的图层的visible制为true
            private function VisibleLayerByUrl(url:String, isVisible:Boolean):void
            {
var layerEx:Layer=null;
var len:int=this.map_View.layers.length;
var urlEx:String="urlEx";

for (var i:int=0; i < len; i++)
                {

                    layerEx=this.map_View.layers[i];

if (layerEx == null)//若图层为空则继续
                    { 
continue;
                    }
if(layerEx is GraphicsLayer)//将GraphicsLayer排除在外
                    {
continue;
                    }
//获取图层的地址
                    if (layerEx is ArcGISDynamicMapServiceLayer)
                    {
                        urlEx=(layerEx as ArcGISDynamicMapServiceLayer).url;
                    }
else if (layerEx is ArcGISTiledMapServiceLayer)
                    {
                        urlEx=(layerEx as ArcGISTiledMapServiceLayer).url;
                    }
else if (layerEx is BJZYXXTiledMapServiceLayer)
                    {
                        urlEx=(layerEx as BJZYXXTiledMapServiceLayer).url;
                    }
else if (layerEx is ArcGISImageServiceLayer)
                    {
                        urlEx=(layerEx as ArcGISImageServiceLayer).url;
                    }


if (url.indexOf(urlEx, 0) > -1)//若此图层的地址和目标匹配上则让其可见，用于将一个设为可见图层
                    {
                        layerEx.visible=true;
                    }
else
                    {
                        layerEx.visible=false;
                    }

                }
            }