前面自定义了Bundle的打包方式，现在就要自定义加载方式了，不然就会走原来设置的远程加载的原本逻辑，我们多做了一个内置包列表和复制移动Bundle到Library中的准备工作就没有用了。

注意如果是UnityWebRequestAssetBundle，则不会支持访问data去保存，不过自行缓存，此时只需要判断是不是内置Bundle就行，其他走web。需要自己缓存Bundle的，需要修改UnityWebRequestAssetBundle为UnityWebRequest

新建一个cs文件MyAssetBundleProvider，复制原内容的AssetBundlePrivider到新建cs脚本中，修改相关类名为自己自定义类名。主要修改IAssetBundleResource的BeginOperation方法和WebRequestOperationCompleted方法

//MyAssetBundleProvider.cs

private void BeginOperation()
{
    string path = m_ProvideHandle.Location.InternalId;
    var url = m_ProvideHandle.ResourceManager.TransformInternalId(m_ProvideHandle.Location);
    string bundleName = Path.GetFileName(url);
    // if a path starts with jar:file, it is an android embeded resource. The resource is a local file but cannot be accessed by 
    // FileStream(called in LoadWithDataProc) directly
    // Need to use webrequest's async call to get the content.
    if (AssetBundleManager.GetInstance().buildInData != null && AssetBundleManager.GetInstance().buildInData.BuildInBundleNames.Contains(bundleName))//本地资源，内置包
    {
        string streamPath = UnityEngine.AddressableAssets.Addressables.RuntimePath + "/" + PlatformMappingService.GetPlatformPathSubFolder() + "/" + bundleName;
        Debug.Log("LoadOne:" + streamPath);
        var crc = m_Options == null ? 0 : m_Options.Crc;
        CompleteBundleLoad(AssetBundle.LoadFromFile(streamPath));
    }
    else if (AssetBundleManager.GetInstance().IsCache(bundleName)) //已经下载过 缓存到本地的Bundle
    {
        string cachePath = Path.Combine(AssetBundleManager.GetInstance().GetBundleCachePath(), bundleName);
        Debug.Log("LoadTwo:" + cachePath);
        var crc = m_Options == null ? 0 : m_Options.Crc;
        CompleteBundleLoad(AssetBundle.LoadFromFile(cachePath));
    }
    else if (ResourceManagerConfig.ShouldPathUseWebRequest(path)) //真正需要下载的Bundle
    {
        Debug.Log("DownloadThree：" + url);
        var req = CreateWebRequest(m_ProvideHandle.Location);
        req.disposeDownloadHandlerOnDispose = false;
        m_WebRequestQueueOperation = WebRequestQueue.QueueRequest(req);
        if (m_WebRequestQueueOperation.IsDone)
        {
            m_RequestOperation = m_WebRequestQueueOperation.Result;
            m_RequestOperation.completed += WebRequestOperationCompleted;
        }
        else
        {
            m_WebRequestQueueOperation.OnComplete += asyncOp =>
            {
                m_RequestOperation = asyncOp;
                m_RequestOperation.completed += WebRequestOperationCompleted;
            };
        }
    }
    else
    {
        m_RequestOperation = null;
        m_ProvideHandle.Complete<MyAssetBundleResource>(null, false, new Exception(string.Format("Invalid path in AssetBundleProvider: '{0}'.", path)));
    }
}


private void WebRequestOperationCompleted(AsyncOperation op)
{
    UnityWebRequestAsyncOperation remoteReq = op as UnityWebRequestAsyncOperation;
    var webReq = remoteReq.webRequest;
    if (!UnityWebRequestUtilities.RequestHasErrors(webReq, out UnityWebRequestResult uwrResult))
    {
        m_downloadHandler = webReq.downloadHandler;
        string path = m_ProvideHandle.ResourceManager.TransformInternalId(m_ProvideHandle.Location);
        string bundleName = Path.GetFileName(path);

        AssetBundleManager.GetInstance().CacheBundle(bundleName, m_downloadHandler.data);//主要是在这里加了一个保存到本地的方法

        if (!m_Completed)
        {
            m_ProvideHandle.Complete(this, true, null);
            m_Completed = true;
        }
    }
    else
    {
        m_downloadHandler = webReq.downloadHandler;
        m_downloadHandler.Dispose();
        m_downloadHandler = null;
        string message = string.Format("Web request {0} failed with error '{1}', retrying ({2}/{3})...", webReq.url, webReq.error, m_Retries, m_Options.RetryCount);

        if (m_Retries < m_Options.RetryCount)
        {
            Debug.LogFormat(message);
            BeginOperation();
            m_Retries++;
        }
        else
        {
            var exception = new Exception(string.Format(
                "RemoteAssetBundleProvider unable to load from url {0}, result='{1}'.", webReq.url,
                webReq.error));
            m_ProvideHandle.Complete<MyAssetBundleResource>(null, false, exception);
        }
    }
    webReq.Dispose();
}

读取内置包列表，缓存Bundle到本地，检查是否有缓存，都是使用 AssetBundleManager.cs

using System.Collections.Generic;
using UnityEngine;
using System;
using System.IO;

[Serializable]
public class BuildInBundleData
{
    public List<string> BuildInBundleNames = new List<string>();
}

public class AssetBundleManager
{
    private static AssetBundleManager _instance = null;
    private string cachePath = "";
    public BuildInBundleData buildInData;

    public static AssetBundleManager GetInstance()
    {
        if (_instance == null)
            _instance = new AssetBundleManager();

        return _instance;
    }

    AssetBundleManager()
    {
        cachePath = Path.Combine(Application.persistentDataPath, "ab");
        if (!Directory.Exists(cachePath))
        {
            Directory.CreateDirectory(cachePath);
        }
    }

    public void Init()
    {
#if !UNITY_EDITOR
            var json = Resources.Load<TextAsset>("Version/BuildInBundleName");
            buildInData = JsonUtility.FromJson<BuildInBundleData>(json.text);
#endif
    }

    public String GetBundleCachePath()
    {
        return cachePath;
    }

    public bool IsCache(string bundleName)
    {
        string filePath = Path.Combine(AssetBundleManager.GetInstance().GetBundleCachePath(), bundleName);
        return File.Exists(filePath);
    }

    public void CacheBundle(string bundlename, byte[] bytes)
    {
        string filePath = Path.Combine(GetBundleCachePath(), bundlename);
        if (File.Exists(filePath))
            File.Delete(filePath);

        File.WriteAllBytes(filePath, bytes);

        string realName = GetRealBundleName(bundlename);
        string oldPath = PlayerPrefs.GetString(realName, "");
        if (oldPath != "")
            File.Delete(oldPath);

        PlayerPrefs.SetString(realName, filePath);
    }

    public string GetRealBundleName(string bundlename)
    {
        if (string.IsNullOrEmpty(bundlename))
            return "";

        int index = bundlename.LastIndexOf("_");
        return bundlename.Substring(0, index);
    }
}

自定义写完后，需要应用使用上这个自定义加载Provider

public static void SetAllGroupToRemote()
{
    var s = AASUtility.GetSettings();
    var groups = s.groups;
    foreach (var group in groups)
    {
        BundledAssetGroupSchema bundledAssetGroupSchema = group.GetSchema<BundledAssetGroupSchema>();
        if (bundledAssetGroupSchema == null)
        {
            bundledAssetGroupSchema = group.AddSchema<BundledAssetGroupSchema>();
        }

        bundledAssetGroupSchema.BuildPath.SetVariableByName(group.Settings, AddressableAssetSettings.kRemoteBuildPath);
        bundledAssetGroupSchema.LoadPath.SetVariableByName(group.Settings, AddressableAssetSettings.kRemoteLoadPath);
        bundledAssetGroupSchema.SetAssetBundleProviderType(typeof(MyAssetBundleProvider)); //主要是这

        EditorUtility.SetDirty(bundledAssetGroupSchema);
    }

    AssetDatabase.Refresh();
}

工具类，这是网上找的，可以动态的创建或删除组，为资源添加label 加入到组。

using System.Collections.Generic;
using UnityEditor.AddressableAssets.Settings;
using UnityEngine;

public class AASUtility : UnityEditor.Editor
{
    public static UnityEditor.AddressableAssets.Settings.AddressableAssetSettings GetSettings()
    {
        //アドレサブルアセットセッティング取得
        var d = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEditor.AddressableAssets.Settings.AddressableAssetSettings>(
            "Assets/AddressableAssetsData/AddressableAssetSettings.asset"
            );
        return d;
    }


    public static UnityEditor.AddressableAssets.Settings.AddressableAssetGroup CreateGroup(string groupName, bool setAsDefaultGroup = false)
    {
        //アドレサブルアセットセッティング取得
        var s = GetSettings();
        //スキーマ生成
        List<UnityEditor.AddressableAssets.Settings.AddressableAssetGroupSchema> schema = new List<UnityEditor.AddressableAssets.Settings.AddressableAssetGroupSchema>() {
             ScriptableObject.CreateInstance<UnityEditor.AddressableAssets.Settings.GroupSchemas.BundledAssetGroupSchema>(),
             ScriptableObject.CreateInstance<UnityEditor.AddressableAssets.Settings.GroupSchemas.ContentUpdateGroupSchema>(),
        };
        //グループの作成
        var f = s.groups.Find((g) => {
            return g.name == groupName;
        });
        if (f == null)
        {
            f = s.CreateGroup(groupName, setAsDefaultGroup, false, true, schema);
        }

        return f;
    }

    public static AddressableAssetEntry AddAssetToGroup(string assetGuid, string groupName)
    {
        if (assetGuid.Equals(""))
        {
            Debug.Log($"assetGuid is empty, groupName: {groupName}");
            return null;
        }
        var s = GetSettings();
        var g = CreateGroup(groupName);
        var entry = s.CreateOrMoveEntry(assetGuid, g);
        return entry;
    }
    public static void SetLabelToAsset(List<string> assetGuidList, string label, bool flag)
    {
        var s = GetSettings();
        //ラベルを追加するように呼んでおく。追加されていないと設定されない。
        s.AddLabel(label);
        List<UnityEditor.AddressableAssets.Settings.AddressableAssetEntry> assetList = new List<UnityEditor.AddressableAssets.Settings.AddressableAssetEntry>();
        s.GetAllAssets(assetList, true);
        foreach (var assetGuid in assetGuidList)
        {
            var asset = assetList.Find((a) => { return a.guid == assetGuid; });
            if (asset != null)
            {
                asset.SetLabel(label, flag);
            }
        }
    }
    public static void RemoveAssetFromGroup(string assetGuid)
    {
        var s = GetSettings();
        s.RemoveAssetEntry(assetGuid);
    }

    public static void RemoveAllGroups()
    {
        var s = GetSettings();
        var list = s.groups;
        List<AddressableAssetGroup> temp_list = new List<AddressableAssetGroup>();
        for (int i = list.Count - 1; i >= 0; i--)
        {
            temp_list.Add(list[i]);
        }
        for (int i = temp_list.Count - 1; i >= 0; i--)
        {
            s.RemoveGroup(temp_list[i]);
        }
    }

    //public static void AddGroup(string groupName, bool setAsDefaultGroup, bool readOnly, bool postEvent, List<AddressableAssetGroupSchema> schemasToCopy, params Type[] types)
    //{
    //    var s = GetSettings();
    //    s.CreateGroup(groupName, setAsDefaultGroup,readOnly,postEvent,schemasToCopy,types);
    //}

    public static void BuildPlayerContent()
    {
        //System.Threading.Thread.Sleep(30000);
        var d = GetSettings();
        d.ActivePlayerDataBuilderIndex = 3;
        //AddressableAssetSettings.CleanPlayerContent(d.ActivePlayerDataBuilder);
        AddressableAssetSettings.BuildPlayerContent();
    }

    public static void CleanPlayerContent()
    {
        // var d = GetSettings();
        // d.ActivePlayerDataBuilderIndex = 3;
        //AddressableAssetSettings.CleanPlayerContent(d.ActivePlayerDataBuilder);
        AddressableAssetSettings.CleanPlayerContent();
        UnityEditor.Build.Pipeline.Utilities.BuildCache.PurgeCache(false);
        // AssetImportMgr.OnDataBuilderComplete();
    }

    static public void Test()
    {
        var d = GetSettings();

        var matguid = UnityEditor.AssetDatabase.AssetPathToGUID("Assets/Data/hogeMat.mat");
        AddAssetToGroup(matguid, "CreatedGroup");
        ////List<string> assetGuidList = new List<string>() { matguid };
        ////SetLabelToAsset(assetGuidList, "mat", true);
        //CreateGroup("CreatedGroup");
    }
}

静态方法，提供给编辑器扩展菜单使用

using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.IO;
using UnityEditor.AddressableAssets.Settings.GroupSchemas;
using UnityEditor.AddressableAssets.Settings;
using UnityEngine.ResourceManagement.ResourceProviders;

public class AddressableTool
{
    private static string PackPath = Config.PackPath; //图集碎片目录名字
    private static string AssetDataPath = Config.AssetDataPath; //打包资源的目录名字
    private static Dictionary<string, bool> originGroups;
    private static Dictionary<string, AddressableAssetGroup> originGroupMaps;

    //严禁一级目录下有需要打包文件，全用二级目录做好分配
    public static void MarkAssets()
    {
        //AASUtility.RemoveAllGroups(); 不要移除所有的组 为改变guid 导致每次的bundle的hash都不一样

        //记录原来的组
        originGroups = new Dictionary<string, bool>();
        originGroupMaps = new Dictionary<string, AddressableAssetGroup>();
        var setting = AASUtility.GetSettings();
        var groups = setting.groups;
        if (groups != null)
        {
            foreach (var g in groups)
            {
                originGroups.Add(g.Name, false);
                originGroupMaps.Add(g.Name, g);
            }
        }

        string assetPath = Path.Combine(Application.dataPath, AssetDataPath);
        DirectoryInfo[] levelsDataDirs = new DirectoryInfo(assetPath).GetDirectories();
        foreach (var dir in levelsDataDirs)
        {
            //场景目录
            MarkLevelDataDir(dir);
        }

        //对比移除无用的组
        foreach (var iter in originGroups)
        {
            if (!iter.Value && originGroupMaps.ContainsKey(iter.Key))
            {
                setting.RemoveGroup(originGroupMaps[iter.Key]);
            }
        }

        AssetDatabase.Refresh();
    }

    private static void MarkLevelDataDir(DirectoryInfo dir)
    {
        string parentName = dir.Name;
        DirectoryInfo[] dirs = dir.GetDirectories();
        foreach (var d in dirs)
        {
            //场景资源分类目录 一个打一个组
            MarkDir(d, parentName);
        }
    }

    private static void MarkDir(DirectoryInfo dir,string parentName)
    {
        if (dir.Name == PackPath) return;
        bool isTipLabel = false;
        if (parentName == "Src")//Lua脚本
        {
            isTipLabel = true;
        }
        string groudName = string.Format("{0}.{1}", parentName, dir.Name);
        AASUtility.CreateGroup(groudName);
        if (originGroups.ContainsKey(groudName))
        {
            originGroups[groudName] = true;
        }

        List<string> allFiles = new List<string>();
        List<string> allFileGuids = new List<string>();
        GetMarkFiles(allFiles, dir);
        foreach(var fileStr in allFiles)
        {
            string uFilePath = UtilityTool.ChangePath(fileStr);
            string guid = AssetDatabase.AssetPathToGUID(uFilePath);
            var entry = AASUtility.AddAssetToGroup(guid, groudName);
            //缩减 可寻址的长度 lua脚本的同步require的路径
            entry.address = uFilePath.Replace("Assets/" + "LevelsData" + "/", "").Replace("Src" + "/", "");
            allFileGuids.Add(guid);
        }

        if (isTipLabel)
        {
            AASUtility.SetLabelToAsset(allFileGuids, groudName, true);//脚本设置lable 用于预加载
        }

        AASUtility.SetLabelToAsset(allFileGuids, "default", true);//所有资源都设为default，以前是拿来检测更新的，现在好像没用了
    }

    private static void GetMarkFiles(List<string> list, DirectoryInfo dir)
    {
        if (dir.Name == PackPath) return;

        FileInfo[] files = dir.GetFiles();
        foreach (var file in files)
        {
            if (file.FullName.EndsWith(".meta")) continue;
            list.Add(file.FullName);
        }

        DirectoryInfo[] dirs = dir.GetDirectories();
        foreach (var d in dirs)
        {
            GetMarkFiles(list, d);
        }
    }
}