🎮 Unity AssetBundle 完整指南

📦 AssetBundle 基础概念

什么是 AssetBundle？

AssetBundle（简称AB包）是Unity提供的一种资源打包格式，它可以将游戏资源（如预制体、贴图、音频、场景等）打包成独立的文件，用于实现：

• 热更新：无需重新安装应用即可更新游戏内容
• 按需加载：减少初始安装包大小，运行时动态下载资源
• 资源管理：更灵活地管理和组织游戏资源

AB包的组成结构

AB包的类型

🔨 打包流程详解

Step 1: 资源标记（设置AssetBundle名称）

在打包前，需要为资源设置AssetBundle名称，有两种方式：

方式一：Inspector面板手动设置

选中资源，在Inspector面板底部的AssetBundle下拉框中设置名称和后缀。

方式二：代码批量设置

using UnityEditor;
using System.IO;

public class ABNameSetter
{
    [MenuItem("Tools/Set AB Names")]
    public static void SetABNames()
    {
        // 获取指定文件夹下的所有资源
        string folderPath = "Assets/Resources/Prefabs";
        string[] guids = AssetDatabase.FindAssets("t:Prefab", new[] { folderPath });
        
        foreach (string guid in guids)
        {
            string assetPath = AssetDatabase.GUIDToAssetPath(guid);
            AssetImporter importer = AssetImporter.GetAtPath(assetPath);
            
            // 设置AB包名称（小写，不含扩展名）
            string abName = Path.GetFileNameWithoutExtension(assetPath).ToLower();
            importer.assetBundleName = abName;
            importer.assetBundleVariant = "ab"; // 可选后缀
        }
        
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
    }
}

Step 2: 执行打包

using UnityEditor;
using System.IO;

public class ABBuilder
{
    [MenuItem("Tools/Build AssetBundles")]
    public static void BuildAllAB()
    {
        string outputPath = "Assets/StreamingAssets/AB";
        
        // 确保输出目录存在
        if (!Directory.Exists(outputPath))
            Directory.CreateDirectory(outputPath);
        
        // 核心打包API
        BuildPipeline.BuildAssetBundles(
            outputPath,
            BuildAssetBundleOptions.ChunkBasedCompression, // LZ4压缩
            BuildTarget.StandaloneWindows64
        );
        
        AssetDatabase.Refresh();
        Debug.Log("AB包打包完成！");
    }
}

Step 3: 打包选项详解

Step 4: Manifest文件解析

打包完成后会生成与AB包同名的.manifest文件，包含重要的依赖信息：

ManifestFileVersion: 0
CRC: 2422504565
Hashes:
  AssetFileHash:
    serializedVersion: 2
    Hash: 8b1a9953c4611296a827abf8c47804d7
  TypeTreeHash:
    serializedVersion: 2
    Hash: 7c2eb1e930d19e8c2d9e8d70cf7e8a2d
HashAppended: 0
ClassTypes:
- Class: 1
  Script: {instanceID: 0}
- Class: 114
  Script: {fileID: 11500000, guid: abc123, type: 3}
Assets:
- Assets/Prefabs/Player.prefab
Dependencies:
- materials.ab
- textures.ab

⚠️ 打包常见坑与解决方案

// 分析依赖，将公共资源单独打包
public static void AnalyzeAndSetDependencies()
{
    string[] allBundles = AssetDatabase.GetAllAssetBundleNames();
    Dictionary<string, List<string>> assetRefCount = new();
    
    foreach (string bundle in allBundles)
    {
        string[] assets = AssetDatabase.GetAssetPathsFromAssetBundle(bundle);
        foreach (string asset in assets)
        {
            string[] deps = AssetDatabase.GetDependencies(asset, true);
            foreach (string dep in deps)
            {
                if (!assetRefCount.ContainsKey(dep))
                    assetRefCount[dep] = new List<string>();
                if (!assetRefCount[dep].Contains(bundle))
                    assetRefCount[dep].Add(bundle);
            }
        }
    }
    
    // 被多个包引用的资源，单独打成公共包
    foreach (var kvp in assetRefCount)
    {
        if (kvp.Value.Count > 1)
        {
            AssetImporter importer = AssetImporter.GetAtPath(kvp.Key);
            if (importer != null && string.IsNullOrEmpty(importer.assetBundleName))
            {
                importer.assetBundleName = "common/shared_assets";
            }
        }
    }
}

<!-- link.xml 示例 -->
<linker>
    <assembly fullname="Assembly-CSharp">
        <type fullname="YourNamespace.YourScript" preserve="all"/>
    </assembly>
</linker>

// 预热Shader变体
ShaderVariantCollection svc = Resources.Load<ShaderVariantCollection>("ShaderVariants");
svc.WarmUp();

📥 加载流程详解

加载方式对比

完整加载流程

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

public class ABLoader : MonoBehaviour
{
    private AssetBundleManifest manifest;
    private Dictionary<string, AssetBundle> loadedBundles = new();
    private string basePath;
    
    void Start()
    {
        // 根据平台设置基础路径
        string platformFolder = GetPlatformFolder();
        basePath = Application.streamingAssetsPath + "/AB/" + platformFolder;
        
        // 首先加载主Manifest
        StartCoroutine(LoadManifest());
    }
    
    IEnumerator LoadManifest()
    {
        string manifestPath = basePath + "/" + GetPlatformFolder();
        AssetBundle manifestBundle = AssetBundle.LoadFromFile(manifestPath);
        
        if (manifestBundle != null)
        {
            manifest = manifestBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
            manifestBundle.Unload(false);
            Debug.Log("Manifest加载成功！");
        }
        yield return null;
    }
    
    /// <summary>
    /// 加载AB包及其所有依赖
    /// </summary>
    public IEnumerator LoadAssetBundleWithDependencies(string bundleName)
    {
        if (manifest == null)
        {
            Debug.LogError("Manifest未加载！");
            yield break;
        }
        
        // 获取所有依赖
        string[] dependencies = manifest.GetAllDependencies(bundleName);
        
        // 先加载所有依赖
        foreach (string dep in dependencies)
        {
            yield return LoadSingleBundle(dep);
        }
        
        // 再加载目标AB包
        yield return LoadSingleBundle(bundleName);
    }
    
    private IEnumerator LoadSingleBundle(string bundleName)
    {
        if (loadedBundles.ContainsKey(bundleName))
        {
            Debug.Log($"AB包已加载: {bundleName}");
            yield break;
        }
        
        string fullPath = basePath + "/" + bundleName;
        AssetBundleCreateRequest request = AssetBundle.LoadFromFileAsync(fullPath);
        yield return request;
        
        if (request.assetBundle != null)
        {
            loadedBundles[bundleName] = request.assetBundle;
            Debug.Log($"AB包加载成功: {bundleName}");
        }
        else
        {
            Debug.LogError($"AB包加载失败: {bundleName}");
        }
    }
    
    /// <summary>
    /// 从AB包加载资源
    /// </summary>
    public T LoadAsset<T>(string bundleName, string assetName) where T : Object
    {
        if (!loadedBundles.TryGetValue(bundleName, out AssetBundle bundle))
        {
            Debug.LogError($"AB包未加载: {bundleName}");
            return null;
        }
        
        return bundle.LoadAsset<T>(assetName);
    }
    
    private string GetPlatformFolder()
    {
        #if UNITY_ANDROID
            return "Android";
        #elif UNITY_IOS
            return "iOS";
        #elif UNITY_WEBGL
            return "WebGL";
        #else
            return "Windows";
        #endif
    }
}

使用UnityWebRequest加载（支持远程）

using UnityEngine;
using UnityEngine.Networking;
using System.Collections;

public class WebABLoader : MonoBehaviour
{
    public IEnumerator LoadFromWeb(string url, uint crc = 0)
    {
        // 使用缓存版本（推荐）
        UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(
            url, 
            1,  // version - 用于缓存管理
            crc // CRC校验（可选，0表示不校验）
        );
        
        request.SendWebRequest();
        
        // 显示下载进度
        while (!request.isDone)
        {
            Debug.Log($"下载进度: {request.downloadProgress * 100:F1}%");
            yield return null;
        }
        
        if (request.result == UnityWebRequest.Result.Success)
        {
            AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(request);
            Debug.Log("下载并加载成功！");
            // 使用bundle...
        }
        else
        {
            Debug.LogError($"下载失败: {request.error}");
        }
    }
}

🚨 加载常见坑与解决方案

// 正确的加载顺序
string[] deps = manifest.GetAllDependencies(targetBundle);
foreach (var dep in deps)
{
    AssetBundle.LoadFromFile(path + dep); // 先加载依赖
}
AssetBundle.LoadFromFile(path + targetBundle); // 再加载目标

private Dictionary<string, AssetBundle> loadedBundles = new();

public AssetBundle LoadBundle(string name)
{
    if (loadedBundles.TryGetValue(name, out var bundle))
        return bundle; // 已加载，直接返回
    
    bundle = AssetBundle.LoadFromFile(path + name);
    loadedBundles[name] = bundle;
    return bundle;
}

// Android必须使用UnityWebRequest读取StreamingAssets
public IEnumerator LoadOnAndroid(string bundleName)
{
    string path;
    
    #if UNITY_ANDROID && !UNITY_EDITOR
        // Android上StreamingAssets的正确路径
        path = Application.streamingAssetsPath + "/" + bundleName;
        // 或者使用 "jar:file://" + Application.dataPath + "!/assets/" + bundleName
        
        using (UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(path))
        {
            yield return request.SendWebRequest();
            AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(request);
        }
    #else
        // 其他平台可以直接LoadFromFile
        path = Application.streamingAssetsPath + "/" + bundleName;
        AssetBundle bundle = AssetBundle.LoadFromFile(path);
        yield return null;
    #endif
}

// Unload参数说明：
bundle.Unload(false); // 只卸载AB包，保留已加载的资源（可能导致内存泄漏）
bundle.Unload(true);  // 卸载AB包和所有从中加载的资源（谨慎使用）

// 最佳实践：使用引用计数管理
public class BundleRef
{
    public AssetBundle Bundle;
    public int RefCount = 0;
    
    public void Retain() => RefCount++;
    
    public void Release()
    {
        RefCount--;
        if (RefCount <= 0)
        {
            Bundle.Unload(true);
        }
    }
}

// 方式1：协程等待
IEnumerator LoadAsync()
{
    AssetBundleCreateRequest bundleReq = AssetBundle.LoadFromFileAsync(path);
    yield return bundleReq; // 必须等待！
    
    AssetBundleRequest assetReq = bundleReq.assetBundle.LoadAssetAsync<GameObject>(name);
    yield return assetReq; // 必须等待！
    
    GameObject prefab = assetReq.asset as GameObject;
    Instantiate(prefab);
}

// 方式2：回调方式
IEnumerator LoadWithCallback(System.Action<GameObject> onLoaded)
{
    // ... 加载代码 ...
    onLoaded?.Invoke(loadedPrefab);
}

// 方式3：async/await（需要UniTask等库）
async UniTask<GameObject> LoadAsyncTask()
{
    var bundle = await AssetBundle.LoadFromFileAsync(path);
    var asset = await bundle.LoadAssetAsync<GameObject>(name);
    return asset as GameObject;
}

🔗 依赖管理机制

依赖的产生

当资源A引用了资源B，且A和B被打进了不同的AB包中，就会产生依赖关系。

prefab_player.ab
  └── 依赖 → materials_common.ab
                └── 依赖 → textures_shared.ab

依赖管理策略

// 获取依赖的几种方式

// 1. 直接依赖（一级依赖）
string[] directDeps = manifest.GetDirectDependencies("mybundle.ab");

// 2. 所有依赖（包含依赖的依赖）- 推荐使用
string[] allDeps = manifest.GetAllDependencies("mybundle.ab");

// 3. 编辑器中分析资源依赖
string[] deps = AssetDatabase.GetDependencies(assetPath, recursive: true);

🧠 内存管理与卸载

内存模型

┌─────────────────────────────────────────────┐
│  Native Memory                              │
│  ├── AssetBundle对象 (AB包本身)              │
│  ├── 序列化数据缓存                          │
│  └── 资源原始数据 (贴图、网格等)              │
├─────────────────────────────────────────────┤
│  Managed Memory                             │
│  ├── C#包装对象 (Texture2D, Mesh等)          │
│  └── 实例化的GameObject                      │
└─────────────────────────────────────────────┘

卸载策略

public class ABMemoryManager
{
    private Dictionary<string, BundleInfo> bundles = new();
    
    class BundleInfo
    {
        public AssetBundle Bundle;
        public int RefCount;
        public float LastAccessTime;
    }
    
    /// <summary>
    /// 基于LRU策略的自动卸载
    /// </summary>
    public void AutoUnloadUnused(float maxIdleTime = 300f)
    {
        float currentTime = Time.time;
        List<string> toUnload = new();
        
        foreach (var kvp in bundles)
        {
            if (kvp.Value.RefCount <= 0 && 
                currentTime - kvp.Value.LastAccessTime > maxIdleTime)
            {
                toUnload.Add(kvp.Key);
            }
        }
        
        foreach (string name in toUnload)
        {
            bundles[name].Bundle.Unload(true);
            bundles.Remove(name);
            Debug.Log($"自动卸载闲置AB包: {name}");
        }
    }
}

✨ 最佳实践总结

打包最佳实践

1. 重要公共资源单独打包，避免重复
2. 推荐使用LZ4压缩（ChunkBasedCompression）
3. 推荐开启DeterministicAssetBundle支持增量更新
4. 按功能/场景划分AB包粒度
5. Shader单独打包或加入Always Included
6. AB包命名使用小写，避免特殊字符
7. 建立资源版本管理和对比系统

加载最佳实践

1. 重要先加载Manifest，正确处理依赖
2. 重要缓存已加载的AB包，避免重复加载
3. 推荐大资源使用异步加载
4. 根据平台选择正确的加载方式
5. 实现加载失败的重试机制
6. 添加CRC校验保证资源完整性

内存管理最佳实践

1. 重要实现引用计数管理AB包生命周期
2. 场景切换时统一清理资源
3. 使用Profiler定期检查内存状态
4. 避免频繁加载卸载同一资源
5. 合理设置AB包的卸载时机

推荐的AB包管理器架构

/*
 * 推荐架构：
 * 
 * ┌──────────────────────────────────────────┐
 * │           ResourceManager               │  ← 对外接口层
 * │  LoadPrefab() / LoadTexture() / ...     │
 * ├──────────────────────────────────────────┤
 * │          AssetBundleManager             │  ← AB包管理层
 * │  LoadBundle() / UnloadBundle()          │
 * │  引用计数 / 依赖管理 / 缓存策略          │
 * ├──────────────────────────────────────────┤
 * │           ManifestManager               │  ← 清单管理层
 * │  GetDependencies() / GetHash()          │
 * ├──────────────────────────────────────────┤
 * │          DownloadManager                │  ← 下载管理层
 * │  Download() / CheckUpdate()             │
 * │  断点续传 / 并行下载 / 进度回调          │
 * └──────────────────────────────────────────┘
 */

📋 常用API速查表

打包相关（Editor）

加载相关（Runtime）

卸载相关