Laya LoaderManager小记
LoaderManager 类用于用于批量加载资源。此类是单例，不要手动实例化此类，请通过Laya.loader访问。全部队列加载完成，会派发 Event.COMPLETE 事件；如果队列中任意一个加载失败，会派发 Event.ERROR 事件，事件回调参数值为加载出错的资源地址。
LoaderManager 类提供了以下几种功能： 多线程：默认5个加载线程，可以通过maxLoader属性修改线程数量； 多优先级：有0-4共5个优先级，优先级高的优先加载。0最高，4最低； 重复过滤：自动过滤重复加载（不会有多个相同地址的资源同时加载）以及复用缓存资源，防止重复加载； 错误重试：资源加载失败后，会重试加载（以最低优先级插入加载队列），retryNum设定加载失败后重试次数，retryDelay设定加载重试的时间间隔。
LoaderManager是Laya加载资源的统一入口，管理laya的加载器（Laya.Loader），负责控制加载优先级，加载线程维护与上限上线控制，加载失败后重试等操作。在laya中使用的Laya.loader是LoaderManager的实例，而不是Laya.Loader的实例。
源码阅读
属性简介
/**@private */
private static var _resMap:Object = {}; //@资源map，url做key，resInfo为value， 用于检测资源是否已经在队列中，防止重复加载。
/**@private */
public static var createMap:Object = {atlas: [null, Loader.ATLAS]}; //@用于检测create方法的类型。
/** 加载出错后的重试次数，默认重试一次*/
public var retryNum:int = 1;
/** 延迟时间多久再进行错误重试，默认立即重试*/
public var retryDelay:int = 0;
/** 最大下载线程，默认为5个*/
public var maxLoader:int = 5;
/**@private */
private var _loaders:Array = []; //@缓存的loader列表
/**@private */
private var _loaderCount:int = 0; //@正在使用的loader数量、加载线程数量
/**@private */
private var _resInfos:Array = []; //@加载资源列表，存放所有需要加载的资源，按优先级和队列顺序排列
/**@private */
private var _infoPool:Array = []; //@加载数据对象的缓存池
/**@private */
private var _maxPriority:int = 5; //@优先级数量 0-4
/**@private */
private var _failRes:Object = {}; //@失败资源的加载次数，用于失败后重试计数
初始化
- LoaderManager在Laya.init时创建，赋值给Laya.loader。
- 按照优先级，创建5（_maxPriority）个队列，用于存放需要加载的资源数据。队列的索引就是加载的优先级，0-4，数字越小，优先级越高。加载时，按照优先级和队列顺序依次加载。
/**
* <p>创建一个新的 <code>LoaderManager</code> 实例。</p>
* <p><b>注意：</b>请使用Laya.loader加载资源，这是一个单例，不要手动实例化此类，否则会导致不可预料的问题。</p>
*/
public function LoaderManager() {
for (var i:int = 0; i < this._maxPriority; i++) this._resInfos[i] = [];is._resInfos[i] = [];
}
单个资源加载流程
- 判断资源是否存在，如果存在则直接调用progress和complete。加载的资源存放在Laya.Loader中，不在LoaderManager中。
- 判断资源是否在加载队列中：
- 如果存在，则监听COMPLETE和PROFRESS事件。注：添加时不能设置offBefore，防止后续加载的资源的回调覆盖之前的加载完成事件。
- 如果不存在，则创建ResInfo，将info放到对应优先级队列的末尾，监听COMPLETE事件。调用next方法，尝试加载。
- 检测当前正在使用的loader的数量，如果数量不足maxLoader个数，则按优先级查找队列，再取队列的第一个数据去加载。如果当前正在使用的loader的count为0，则触发Laya.loader（LoaderManager）的COMPLETE事件。
- 加载是使用Laya.Loader执行加载逻辑。
- 加载完成后（或者失败），回收当前loader，更新loader数量，如果加载失败，则重新放入加载队列，并且优先级设置为最低。如果失败多次，则出发Error事件，将url传递出去。加载成功或者失败都会出发COMPLETE事件，调用complete方法。清理和回收相关数据。
- 尝试调用next，尝试选择下一个资源加载。
/**
* <p>加载资源。资源加载错误时，本对象会派发 Event.ERROR 事件，事件回调参数值为加载出错的资源地址。</p>
* <p>因为返回值为 LoaderManager 对象本身，所以可以使用如下语法：Laya.loader.load(...).load(...);</p>
* @param url 要加载的单个资源地址或资源信息数组。比如：简单数组：["a.png","b.png"]；复杂数组[{url:"a.png",type:Loader.IMAGE,size:100,priority:1},{url:"b.json",type:Loader.JSON,size:50,priority:1}]。
* @param complete 加载结束回调。根据url类型不同分为2种情况：1. url为String类型，也就是单个资源地址，如果加载成功，则回调参数值为加载完成的资源，否则为null；2. url为数组类型，指定了一组要加载的资源，如果全部加载成功，则回调参数值为true，否则为false。
* @param progress 加载进度回调。回调参数值为当前资源的加载进度信息(0-1)。
* @param type 资源类型。比如：Loader.IMAGE。
* @param priority (default = 1)加载的优先级，优先级高的优先加载。有0-4共5个优先级，0最高，4最低。
* @param cache 是否缓存加载结果。
* @param group 分组，方便对资源进行管理。
* @param ignoreCache 是否忽略缓存，强制重新加载。
* @return 此 LoaderManager 对象本身。
*/
public function load(url:*, complete:Handler = null, progress:Handler = null, type:String = null, priority:int = 1, cache:Boolean = true, group:String = null, ignoreCache:Boolean = false):LoaderManager {
if (url is Array) return _loadAssets(url as Array, complete, progress, type, priority, cache, group);
var content:* = Loader.getRes(url);
if (content != null) {
//增加延迟回掉
Laya.timer.frameOnce(1, null, function():void {
progress && progress.runWith(1);
complete && complete.runWith(content);
//判断是否全部加载，如果是则抛出complete事件
_loaderCount || event(Event.COMPLETE);
});
} else {
var info:ResInfo = _resMap[url];
if (!info) {
info = _infoPool.length ? _infoPool.pop() : new ResInfo();
info.url = url;
info.type = type;
info.cache = cache;
info.group = group;
info.ignoreCache = ignoreCache;
//@收到ResInfo的COMPLETE事件则执行complete方法
complete && info.on(Event.COMPLETE, complete.caller, complete.method, complete.args);
progress && info.on(Event.PROGRESS, progress.caller, progress.method, progress.args);
_resMap[url] = info;
//@选择对应优先级队列
priority = priority < this._maxPriority ? priority : this._maxPriority - 1;
this._resInfos[priority].push(info);
_next();
} else {
//@如果已经在加载队列，则只注册事件，不创建加载数据。
//@注:这里offBefore设置为false，防止事件被覆盖，导致complete执行不全。
complete && info._createListener(Event.COMPLETE, complete.caller, complete.method, complete.args, false, false);
progress && info._createListener(Event.PROGRESS, progress.caller, progress.method, progress.args, false, false);
}
}
return this;
}
private function _next():void {
//@loader满了则返回等待空闲loader
if (this._loaderCount >= this.maxLoader) return;
//@按优先级查找列表
for (var i:int = 0; i < this._maxPriority; i++) {
var infos:Array = this._resInfos[i];
while (infos.length > 0) {
var info:ResInfo = infos.shift();
if (info) return _doLoad(info);
}
}
//@所有loader都空闲，则触发LoaderManager的加载完成
_loaderCount || event(Event.COMPLETE);
}
private function _doLoad(resInfo:ResInfo):void {
this._loaderCount++;
var loader:Loader = this._loaders.length ? this._loaders.pop() : new Loader();
loader.on(Event.COMPLETE, null, onLoaded);
loader.on(Event.PROGRESS, null, function(num:Number):void {
resInfo.event(Event.PROGRESS, num);
});
loader.on(Event.ERROR, null, function(msg:*):void {
onLoaded(null);
});
var _this:LoaderManager = this;
function onLoaded(data:* = null):void {
//@清理、回收loader
loader.offAll();
loader._data = null;
loader._customParse = false;
_this._loaders.push(loader);
_this._endLoad(resInfo, data is Array ? [data] : data);
_this._loaderCount--;
_this._next();
}
//@具体加载流程在Loader中实现
loader._class = resInfo.clas;
loader.load(resInfo.url, resInfo.type, resInfo.cache, resInfo.group, resInfo.ignoreCache);
}
private function _endLoad(resInfo:ResInfo, content:*):void {
//如果加载后为空，放入队列末尾重试
var url:String = resInfo.url;
if (content == null) {
var errorCount:int = this._failRes[url] || 0;
//@记录失败次数
if (errorCount < this.retryNum) {
console.warn("[warn]Retry to load:", url);
this._failRes[url] = errorCount + 1;
//@重新放回加载队列
Laya.timer.once(retryDelay, this, _addReTry, [resInfo], false);
return;
} else {
//超过retryNum则直接抛出ERROR事件
console.warn("[error]Failed to load:", url);
event(Event.ERROR, url);
}
}
if (_failRes[url]) _failRes[url] = 0;
delete _resMap[url];
//@通知info执行complete方法
resInfo.event(Event.COMPLETE, content);
resInfo.offAll();
_infoPool.push(resInfo);
}
private function _addReTry(resInfo:ResInfo):void {
this._resInfos[this._maxPriority - 1].push(resInfo);
_next();
}
加载多个资源流程
LoaderManager.load支持传入简单类型数组，比如：简单数组：["a.png","b.png"]；复杂数组[{url:"a.png",type:Loader.IMAGE,size:100,priority:1},{url:"b.json",type:Loader.JSON,size:50,priority:1}]。
- 遍历所有数组，记录总数，用于计算progress。记录下载的总数。
- 分别调用load方法，加载每一个元素。
- 每加载完一个资源，检查加载的数量是否等于本次的总数量，如果是，则执行complete操作。
/**
* @private
* 加载数组里面的资源。
* @param arr 简单：["a.png","b.png"]，复杂[{url:"a.png",type:Loader.IMAGE,size:100,priority:1},{url:"b.json",type:Loader.JSON,size:50,priority:1}]*/
private function _loadAssets(arr:Array, complete:Handler = null, progress:Handler = null, type:String = null, priority:int = 1, cache:Boolean = true, group:String = null):LoaderManager {
var itemCount:int = arr.length;
var loadedCount:int = 0;
var totalSize:int = 0;
var items:Array = [];
var success:Boolean = true;
for (var i:int = 0; i < itemCount; i++) {
var item:Object = arr[i];
if (item is String) item = {url: item, type: type, size: 1, priority: priority};
if (!item.size) item.size = 1;
item.progress = 0;
totalSize += item.size;
items.push(item);
var progressHandler:* = progress ? Handler.create(null, loadProgress, [item], false) : null;
var completeHandler:* = (complete || progress) ? Handler.create(null, loadComplete, [item]) : null;
load(item.url, completeHandler, progressHandler, item.type, item.priority || 1, cache, item.group || group);
}
function loadComplete(item:Object, content:* = null):void {
loadedCount++;
item.progress = 1;
if (!content) success = false;
if (loadedCount === itemCount && complete) {
complete.runWith(success);
}
}
function loadProgress(item:Object, value:Number):void {
if (progress != null) {
item.progress = value;
var num:Number = 0;
for (var j:int = 0; j < items.length; j++) {
var item1:Object = items[j];
num += item1.size * item1.progress;
}
var v:Number = num / totalSize;
progress.runWith(v);
}
}
return this;
}
create方法
根据clas类型创建一个未初始化资源的对象，随后进行异步加载，资源加载完成后，初始化对象的资源，并通过此对象派发 Event.LOADED 事件，事件回调参数值为此对象本身。套嵌资源的子资源会保留资源路径"?"后的部分。
如果url为数组，返回true；否则返回指定的资源类对象，可以通过侦听此对象的 Event.LOADED 事件来判断资源是否已经加载完毕。
注意：cache参数只能对文件后缀为atlas的资源进行缓存控制，其他资源会忽略缓存，强制重新加载。
-
create方法可以先创建一个指定类型的壳，同步返回给调用者。壳里的资源则通过异步的方式加载。
-
create方法主要是在Laya3D中使用，主要是Laya内部组件使用。使用create创建的类型有严格限制，在2D下支持Atlas，在3D有一定扩展。
-
这些类型都要实现ICreateResource方法，提供onAsynLoaded，_setUrl等方法。如果创建一些不支持的类型，会直接抛出异常。
-
同load方法一样，支持传入一个或者多个资源地址。
-
使用create方法加载Atlas资源时，会返回null。
-
Laya3D所支持的类型：
//在Laya3D初始化时设置
var createMap:Object = LoaderManager.createMap;
createMap["lh"] = [Sprite3D, Laya3D.HIERARCHY];
createMap["ls"] = [Scene, Laya3D.HIERARCHY];
createMap["lm"] = [Mesh, Laya3D.MESH];
createMap["lmat"] = [StandardMaterial, Laya3D.MATERIAL];
createMap["lpbr"] = [PBRMaterial, Laya3D.MATERIAL];
createMap["ltc"] = [TextureCube, Laya3D.TEXTURECUBE];
createMap["jpg"] = [Texture2D, "nativeimage"];
createMap["jpeg"] = [Texture2D, "nativeimage"];
createMap["png"] = [Texture2D, "nativeimage"];
createMap["pkm"] = [Texture2D, Loader.BUFFER];
createMap["lsani"] = [AnimationTemplet, Loader.BUFFER];
createMap["lrani"] = [AnimationTemplet, Loader.BUFFER];
createMap["raw"] = [DataTexture2D, Loader.BUFFER];
createMap["mipmaps"] = [DataTexture2D, Loader.BUFFER];
createMap["thdata"] = [TerrainHeightData, Loader.BUFFER];
createMap["lt"] = [TerrainRes, Laya3D.TERRAIN];
createMap["lani"] = [AnimationClip, Loader.BUFFER];
createMap["lav"] = [Avatar, Loader.JSON];
createMap["ani"] = [AnimationTemplet, Loader.BUFFER];//兼容接口
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
