Unity AssetBundle打包实战：从资源标记到LZ4压缩的完整工作流

1. 项目概述：为什么AssetBundle打包是Unity开发者的必修课？

如果你在Unity项目里做过资源管理，大概率听过AssetBundle这个名字，也大概率被它折腾过。从新手到老手，几乎每个Unity开发者都会经历一个从“手动拖拽资源”到“必须上AB包”的认知转变。这玩意儿说白了，就是Unity官方提供的一套资源分包、动态加载的解决方案。它的核心价值在于，能把你的游戏资源（模型、贴图、音频、预制体等）从主包（APK/IPA）里剥离出来，变成一个个可以独立下载、更新、加载的小包裹。

听起来很美，对吧？但实际操作起来，坑多到你怀疑人生。最经典的场景就是热更新：游戏上线后发现一个UI图标错了，或者一个角色模型穿模了。如果没有AssetBundle，你得让所有玩家重新下载整个几个G的游戏安装包，这简直是运营灾难。而有了AB包，你只需要把出错的资源重新打包，上传到服务器，玩家下次启动游戏时自动下载这个几十K的小包替换掉就行，用户体验丝滑无比。

另一个刚需是资源按需加载。想象一下你做一个开放世界游戏，不可能把整个地图的所有高清贴图和模型一次性全塞进内存，那手机直接就闪退了。你需要的是玩家走到森林区域，才加载树木和野兽的AB包；走到城镇，再加载建筑和NPC的AB包。AssetBundle就是实现这套“用啥加载啥”机制的基础。

所以，无论你是为了热更新、减小初始包体、还是实现动态资源加载，掌握AssetBundle的打包都是绕不开的一步。今天这篇，我就结合自己趟过的无数坑，把从资源标记到批量打包，再到关键的LZ4压缩配置，给你拆解得明明白白。目标很明确：让你在5分钟内，掌握一套稳定、高效、可复用的AB打包工作流。

2. 核心思路拆解：从资源标记到打包输出的完整逻辑

在动手写代码之前，我们必须把AssetBundle的工作流在脑子里过一遍。很多新手一上来就搜“打包代码”，复制粘贴，结果打包出来的东西要么加载不了，要么冗余巨大，根本原因就是没理解背后的逻辑链条。一个完整的AssetBundle工作流，其实就三步：标记 -> 构建 -> 加载。我们今天聚焦前两步，这是所有问题的源头。

2.1 资源标记：给资源“上户口”

这是第一步，也是最容易出错的一步。Unity不会自动知道哪些资源该打到一个包里。你需要手动（或通过脚本）为资源设置一个“AssetBundle Name”和一个可选的“Variant”。你可以把它理解为给资源上户口，名字（AssetBundle Name）决定了它属于哪个家庭（哪个AB包），变体（Variant）则像是这个家庭里的双胞胎，用于区分不同分辨率或语言的同一份资源。

这里有个至关重要的原则：依赖关系决定打包结果。比如，一个Prefab（预制体）引用了一张Texture（贴图）。如果你只把Prefab标记为包A，而贴图没标记任何包名，那么Unity在打包时，会发现Prefab依赖了一个“无主”的贴图。这时Unity会怎么做？它会自动把这张贴图复制一份，打进包A里。如果另一个Prefab也引用了同一张贴图，但被打进了包B，那么这张贴图又会被复制一份打进包B。结果就是，同一张图片在多个AB包里重复存在，极大地浪费了下载流量和内存。

正确的做法是，要么把有依赖关系的资源标记到同一个AB包里，要么把公共资源（如公共贴图、材质、Shader）专门标记到一个公共包（如“shared_assets”）里。这样，无论多少个Prefab引用它，它在磁盘和内存中都只存在一份。

2.2 构建打包：参数里的门道

标记好后，我们通过BuildPipeline.BuildAssetBundles这个API来触发打包。这个API有一堆参数，每个都直接影响打包结果。

• 输出路径：打包后的.manifest和.ab文件放哪里。
• 构建选项：这是重头戏，通过BuildAssetBundleOptions枚举来设置。
  • None：默认选项，使用LZMA压缩。
  • UncompressedAssetBundle：不压缩。包体最大，但加载时无需解压，速度最快。适合本地存储、对包体大小不敏感但对加载速度要求极高的场景（如一些主机游戏）。
  • ChunkBasedCompression：使用LZ4压缩。这是目前移动端和大多数情况下的推荐选项，我们后面会详细讲。
  • ForceRebuildAssetBundle：强制重新构建所有AB包。不清空输出目录时，Unity只会构建有变化的包，这个选项可以强制全量重建，用于确保打包一致性。
  • AppendHashToAssetBundleName：在AB文件名后附加哈希值。这是做增量更新和版本管理的神器，能避免CDN缓存问题。
• 目标平台：BuildTarget.StandaloneWindows、BuildTarget.Android、BuildTarget.iOS等。AB包是平台相关的，给Android打的包不能在iOS上用，切记。

理解了这些，你的打包脚本就不会是一团乱麻了。接下来，我们进入实战环节，看看怎么把这些思路变成代码。

3. 实战：5分钟搭建自动化打包流水线

光说不练假把式。下面我给出一个经过多个项目验证的、增强版的打包脚本。这个脚本不仅完成了基础打包，还集成了自动清理、依赖检查、打包报告等实用功能。你可以把它放在项目的Editor文件夹下，比如Assets/Editor/AssetBundleBuilder.cs。

using UnityEngine; using UnityEditor; using System.IO; using System.Collections.Generic; using System.Linq; public class AssetBundleBuilder : EditorWindow { // 输出路径，默认放在项目根目录的 AssetBundles 文件夹下，按平台区分 private string outputPath = Path.Combine(Directory.GetCurrentDirectory(), "AssetBundles", EditorUserBuildSettings.activeBuildTarget.ToString()); // 打包选项 private BuildAssetBundleOptions buildOptions = BuildAssetBundleOptions.ChunkBasedCompression; // 是否强制重建 private bool forceRebuild = false; // 是否附加哈希值到文件名 private bool appendHash = true; // 是否在打包后生成一份资源清单（用于运行时加载） private bool generateManifest = true; [MenuItem("Tools/AssetBundle/打包工具")] public static void ShowWindow() { GetWindow<AssetBundleBuilder>("AB打包工具"); } void OnGUI() { GUILayout.Label("基础设置", EditorStyles.boldLabel); EditorGUILayout.HelpBox("输出路径: " + outputPath, MessageType.Info); if (GUILayout.Button("选择输出路径")) { string selectedPath = EditorUtility.OpenFolderPanel("选择AB包输出目录", "", ""); if (!string.IsNullOrEmpty(selectedPath)) { outputPath = selectedPath; } } buildOptions = (BuildAssetBundleOptions)EditorGUILayout.EnumFlagsField("打包选项", buildOptions); forceRebuild = EditorGUILayout.Toggle("强制重建", forceRebuild); appendHash = EditorGUILayout.Toggle("附加哈希值", appendHash); generateManifest = EditorGUILayout.Toggle("生成运行时清单", generateManifest); EditorGUILayout.Space(20); if (GUILayout.Button("开始打包", GUILayout.Height(40))) { BuildAllAssetBundles(); } // 一些快捷操作按钮 EditorGUILayout.Space(10); GUILayout.Label("快捷操作", EditorStyles.boldLabel); if (GUILayout.Button("清空所有AB标记")) { ClearAllAssetBundleNames(); } if (GUILayout.Button("打开输出目录")) { EditorUtility.RevealInFinder(outputPath); } } // 核心打包方法 void BuildAllAssetBundles() { // 1. 检查并创建输出目录 if (!Directory.Exists(outputPath)) { Directory.CreateDirectory(outputPath); } else { // 如果强制重建，先清空旧目录（危险操作，实际项目可注释掉，或做备份） // Directory.Delete(outputPath, true); // Directory.CreateDirectory(outputPath); } // 2. 组合构建选项 BuildAssetBundleOptions options = buildOptions; if (forceRebuild) { options |= BuildAssetBundleOptions.ForceRebuildAssetBundle; } if (appendHash) { options |= BuildAssetBundleOptions.AppendHashToAssetBundleName; } // 3. 开始打包 Debug.Log($"开始构建AssetBundle，目标平台：{EditorUserBuildSettings.activeBuildTarget}， 输出路径：{outputPath}"); try { BuildPipeline.BuildAssetBundles(outputPath, options, EditorUserBuildSettings.activeBuildTarget); Debug.Log("AssetBundle构建完成！"); // 4. （可选）生成一份给运行时用的简化清单 if (generateManifest) { GenerateRuntimeManifest(); } // 5. 刷新编辑器，确保能看到新文件 AssetDatabase.Refresh(); // 6. 打印打包报告 PrintBuildReport(); } catch (System.Exception e) { Debug.LogError($"AssetBundle构建失败: {e.Message}"); EditorUtility.DisplayDialog("错误", $"打包失败：{e.Message}", "确定"); } } // 清空所有资源的AB标记（防止残留标记导致打包混乱） void ClearAllAssetBundleNames() { string[] allAssetPaths = AssetDatabase.GetAllAssetPaths(); int clearedCount = 0; foreach (var assetPath in allAssetPaths) { // 只处理Assets目录下的资源，排除Meta文件和编辑器脚本等 if (assetPath.StartsWith("Assets/") && !assetPath.Contains("/Editor/")) { var importer = AssetImporter.GetAtPath(assetPath); if (importer != null && !string.IsNullOrEmpty(importer.assetBundleName)) { importer.assetBundleName = null; clearedCount++; } } } AssetDatabase.RemoveUnusedAssetBundleNames(); AssetDatabase.Refresh(); Debug.Log($"已清空 {clearedCount} 个资源的AssetBundle标记。"); } // 生成一份给运行时加载用的清单文件（例如JSON格式） void GenerateRuntimeManifest() { // 这里只是示例，实际项目中你可能需要记录包名、哈希值、大小、依赖关系等 // 更复杂的实现可以读取打包生成的 *.manifest 文件来提取信息 Debug.Log("生成运行时清单功能需根据项目需求自定义实现。"); // 示例：创建一个字典记录所有AB包信息 // Dictionary<string, BundleInfo> manifest = new Dictionary<string, BundleInfo>(); // ... 遍历outputPath下的所有.manifest文件，解析信息 ... // string json = JsonUtility.ToJson(manifest); // File.WriteAllText(Path.Combine(outputPath, "bundle_manifest.json"), json); } // 打印简单的打包报告 void PrintBuildReport() { if (!Directory.Exists(outputPath)) return; var abFiles = Directory.GetFiles(outputPath, "*.ab"); var manifestFiles = Directory.GetFiles(outputPath, "*.manifest"); long totalSize = 0; foreach (var file in abFiles) { FileInfo fi = new FileInfo(file); totalSize += fi.Length; } Debug.Log($"打包报告："); Debug.Log($" 生成AB包数量：{abFiles.Length}"); Debug.Log($" 生成清单文件数量：{manifestFiles.Length}"); Debug.Log($" AB包总大小：{FormatBytes(totalSize)}"); Debug.Log($" 输出目录：{outputPath}"); } string FormatBytes(long bytes) { string[] suffixes = { "B", "KB", "MB", "GB" }; int counter = 0; decimal number = bytes; while (Math.Round(number / 1024) >= 1) { number /= 1024; counter++; } return string.Format("{0:n2} {1}", number, suffixes[counter]); } }

这个脚本提供了一个简单的编辑器窗口，让你可以可视化地操作打包流程。点击“开始打包”按钮，它就会按照你的设置执行。PrintBuildReport方法会在打包结束后给你一个清晰的概览，包括生成了多少个包、总大小是多少，这对于资源管理非常重要。

注意：ClearAllAssetBundleNames这个功能要慎用，特别是在团队协作中。它会把项目中所有资源的AB标记清空。建议只在项目初期规范打包策略，或者确定打包出现混乱时使用。更安全的做法是编写脚本，只清理特定目录或特定类型的资源。

4. 资源标记的批量操作与规范管理

手动在Inspector窗口里一个个设置AB名字，在小型项目里还行，一旦资源成百上千，这就是个体力活，而且极易出错。我们必须借助脚本进行批量、规范化的管理。

4.1 基于文件夹结构的批量标记

一个最常用且清晰的策略是按文件夹划分AB包。例如，Assets/Arts/UI/目录下的所有资源打成一个ui包，Assets/Arts/Characters/Hero/下的资源打成character_hero包。

using UnityEditor; using UnityEngine; using System.IO; public class AssetBundleMarker : EditorWindow { private string folderPath = "Assets/"; [MenuItem("Tools/AssetBundle/批量标记工具")] public static void ShowWindow() { GetWindow<AssetBundleMarker>("AB批量标记"); } void OnGUI() { GUILayout.Label("按文件夹批量标记", EditorStyles.boldLabel); folderPath = EditorGUILayout.TextField("目标文件夹路径:", folderPath); if (GUILayout.Button("选择文件夹")) { folderPath = EditorUtility.OpenFolderPanel("选择要标记的文件夹", "Assets", ""); // 将绝对路径转换为相对于项目的路径 if (folderPath.StartsWith(Application.dataPath)) { folderPath = "Assets" + folderPath.Substring(Application.dataPath.Length); } } EditorGUILayout.HelpBox($"将标记文件夹: {folderPath}\n规则：以文件夹名（小写）作为AB包名。", MessageType.Info); if (GUILayout.Button("执行标记")) { MarkAssetBundlesByFolder(folderPath); } } void MarkAssetBundlesByFolder(string rootFolder) { if (!Directory.Exists(Path.Combine(Application.dataPath, rootFolder.Replace("Assets/", "")))) { Debug.LogError($"文件夹不存在: {rootFolder}"); return; } // 获取该文件夹下所有符合规则的资源路径（排除.meta文件） string[] assetGUIDs = AssetDatabase.FindAssets("", new[] { rootFolder }); int processedCount = 0; foreach (var guid in assetGUIDs) { string assetPath = AssetDatabase.GUIDToAssetPath(guid); // 跳过文件夹本身和.meta文件 if (Directory.Exists(assetPath) || assetPath.EndsWith(".meta")) continue; var importer = AssetImporter.GetAtPath(assetPath); if (importer != null) { // 关键：根据资源所在文件夹的层级结构来命名AB包 // 例如 Assets/Arts/UI/Button.prefab -> ab包名为 "arts_ui" // 这里简化处理，直接使用rootFolder的最后一层目录名 string bundleName = Path.GetFileName(rootFolder).ToLower(); // 更复杂的规则：可以取从Assets后开始的相对路径，并把‘/’替换为‘_’ // string relativePath = assetPath.Replace("Assets/", "").ToLower(); // string bundleName = Path.GetDirectoryName(relativePath).Replace(Path.DirectorySeparatorChar, '_'); // 避免包名中有非法字符 bundleName = bundleName.Replace(" ", "_").Replace("-", "_"); importer.assetBundleName = bundleName; // 变体（Variant）通常用于区分高清/标清，这里先留空 importer.assetBundleVariant = ""; processedCount++; } } AssetDatabase.RemoveUnusedAssetBundleNames(); AssetDatabase.Refresh(); Debug.Log($"批量标记完成。共处理 {processedCount} 个资源。根文件夹AB包名为：{Path.GetFileName(rootFolder).ToLower()}"); } }

这个脚本允许你选择一个文件夹，并将其下的所有资源标记为同一个AB包（以文件夹命名）。这是一种粗粒度的管理方式，简单高效，适合UI图集、场景区块等资源集合。

4.2 基于规则和依赖分析的精细标记

对于更复杂的项目，我们需要更精细的控制。比如，所有Shader打成一个shaders包，所有公共的材质球打成common_materials包，然后每个角色预制体及其独有的贴图和动画，打成独立的包如char_warrior、char_mage。

这需要编写更复杂的编辑器脚本，可能还需要分析资源之间的引用关系。一个常见的做法是，先通过AssetDatabase.GetDependencies获取一个预制体的所有依赖资源，然后判断这些依赖资源是否已经被其他包标记过，如果没有，则将其与预制体标记到同一个包中。

// 示例：为一个选中的Prefab及其独有依赖创建AB包 [MenuItem("Assets/标记Prefab及其独有依赖")] static void MarkPrefabAndUniqueDependencies() { var selected = Selection.activeObject; if (selected == null) return; string assetPath = AssetDatabase.GetAssetPath(selected); if (!assetPath.EndsWith(".prefab")) return; // 获取所有依赖 string[] dependencies = AssetDatabase.GetDependencies(assetPath, true); string bundleName = Path.GetFileNameWithoutExtension(assetPath).ToLower(); // 先标记主资源 AssetImporter mainImporter = AssetImporter.GetAtPath(assetPath); mainImporter.assetBundleName = bundleName; // 遍历依赖资源 foreach (var depPath in dependencies) { // 跳过自己，跳过脚本、dll等非AB资源 if (depPath == assetPath || depPath.EndsWith(".cs") || depPath.EndsWith(".dll")) continue; AssetImporter depImporter = AssetImporter.GetAtPath(depPath); // 如果该依赖资源还没有被标记到任何AB包，就把它标记到当前包 if (depImporter != null && string.IsNullOrEmpty(depImporter.assetBundleName)) { depImporter.assetBundleName = bundleName; } // 如果已经被标记了，说明它是公共资源，我们就不动它 // else { Debug.Log($"依赖资源 {depPath} 已属于包 {depImporter.assetBundleName}，跳过。"); } } AssetDatabase.RemoveUnusedAssetBundleNames(); AssetDatabase.Refresh(); Debug.Log($"已为Prefab {selected.name} 创建AB包: {bundleName}"); }

实操心得：在实际项目中，我强烈建议将AB包的命名规则写入项目规范文档。例如，规定所有UI资源包以ui_开头，角色包以char_开头，场景包以scene_开头。这样在打包脚本和后续的加载代码中，都能保持一致性，减少混乱。同时，要定期使用AssetDatabase.GetUnusedAssetBundleNames和AssetDatabase.RemoveUnusedAssetBundleNames来清理那些已经没有任何资源引用的、残留的AB包名，保持项目的整洁。

5. LZ4压缩配置详解：为什么它是移动端的首选？

打包选项里的压缩格式选择，直接影响到包体大小、加载速度和内存占用。Unity主要提供三种选择：不压缩、LZMA和LZ4。很多人对它们之间的区别一知半解，我们彻底讲清楚。

5.1 三种压缩格式的深度对比

为了让你有最直观的认识，我列了一个对比表格：

LZMA就像是一个压缩得非常紧实的拉链文件。你要用里面的一张图片，必须把整个压缩包解压开才行。这对于从网络下载很友好（文件小），但加载体验很差，尤其是对于大的AB包，解压时会造成卡顿和内存飙升。

LZ4则像一个带索引的活页夹。它把AB包分成了很多个小块（Chunk）。当你想加载里面的一张图片时，系统只会找到存放这张图片的那个小块，把它解压出来。其他不相关的部分依然保持压缩状态躺在磁盘或内存里。这种“按需解压”的特性，完美契合了移动端内存紧张、需要快速响应的需求。

5.2 如何正确配置LZ4压缩？

在打包脚本中，配置LZ4压缩非常简单，就是在BuildAssetBundleOptions中加上ChunkBasedCompression标志位。

BuildAssetBundleOptions options = BuildAssetBundleOptions.ChunkBasedCompression; // 通常还会结合其他选项，比如强制重建和附加哈希 // options |= BuildAssetBundleOptions.ForceRebuildAssetBundle | BuildAssetBundleOptions.AppendHashToAssetBundleName; BuildPipeline.BuildAssetBundles(outputPath, options, BuildTarget.Android);

这里有一个极其重要的坑需要提醒你：Unity编辑器在播放模式下加载AB包时，对于LZ4压缩包的处理，和真机运行时可能不一致！

在编辑器环境下，为了开发便利，Unity有时会绕过LZ4的按需加载机制。这可能导致你在编辑器里测试加载速度很快、内存正常，但打到真机上后发现加载变慢或者内存表现不符合预期。所以，任何关于AB包加载性能的测试，一定要在真机上进行。

5.3 缓存与压缩的联动

当你使用UnityWebRequest或旧的WWW类从网络下载AB包时，Unity会自动管理一个磁盘缓存。这里又涉及到一个设置：Caching.compressionEnabled。

• 如果Caching.compressionEnabled = true（默认），下载的LZMA包在写入磁盘缓存时，会被重压缩为LZ4格式。这样，下次加载时就是从LZ4缓存读取，享受快速加载的好处。
• 如果设置为false，则缓存里存的就是原始的LZMA格式，每次加载都需要完整解压。

所以，对于热更新资源，通常的流程是：服务器提供LZMA压缩的AB包（最小化下载流量） -> 客户端下载后，Unity自动将其以LZ4格式缓存到本地-> 后续游戏运行从本地LZ4缓存加载（最快速度）。这是一个在下载大小和加载速度之间取得的完美平衡。

注意事项：使用AssetBundle.LoadFromFile接口时，它的行为取决于文件本身。如果文件是LZ4压缩的，它支持流式加载；如果是LZMA压缩的，它会在内存中完整解压。因此，对于热更新下来的资源，更推荐使用UnityWebRequestAssetBundle来加载，因为它能正确利用缓存系统。

6. 常见问题排查与实战技巧实录

即使流程都对了，实际操作中还是会遇到各种稀奇古怪的问题。下面是我总结的几个高频问题和解决思路。

6.1 打包后资源丢失或引用断裂

问题描述：打包后，在运行时加载Prefab，发现材质是粉色的（丢失），或者脚本引用为null。

根本原因：这是依赖关系没处理好。你的Prefab引用了一个Material，但这个Material被打到了另一个AB包（比如shared_mat包）里，而你在加载Prefab的包（比如ui_panel包）时，并没有先加载shared_mat包。

解决方案：

1. 手动管理依赖：在加载一个AB包之前，先加载它所依赖的所有AB包。Unity打包时会为每个AB包生成一个同名的.manifest文件，里面以文本形式记录了该包的依赖信息。你可以在打包后解析这个文件，或者在打包时自己生成一份依赖关系配置文件，在运行时根据配置来顺序加载。
2. 使用AssetBundleManifest：Unity打包会在输出目录生成一个总的AssetBundles文件（名字取决于输出目录名）和一个AssetBundles.manifest。你可以通过AssetBundle.LoadFromFile加载这个总的AB包，然后从中获取一个AssetBundleManifest对象。这个对象有一个GetAllDependencies方法，可以查询任意AB包的所有依赖包名。

   // 加载总的Manifest文件 AssetBundle mainAB = AssetBundle.LoadFromFile(Path.Combine(ABPath, "AssetBundles")); AssetBundleManifest manifest = mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest"); // 获取某个包的所有依赖 string[] dependencies = manifest.GetAllDependencies("ui_panel"); foreach (string depName in dependencies) { // 先加载依赖包 AssetBundle.LoadFromFile(Path.Combine(ABPath, depName)); } // 再加载目标包 AssetBundle.LoadFromFile(Path.Combine(ABPath, "ui_panel"));

6.2 打包时间过长，增量打包不生效

问题描述：项目资源很多，每次打包都要等十几分钟，效率低下。

原因分析：Unity的增量打包机制依赖于资源的哈希值。如果你清空了输出目录，或者资源本身的元数据（如import settings）发生了改变，即使资源内容没变，也会触发重新打包。

优化技巧：

1. 不要轻易清空输出目录：让Unity自己去判断哪些包需要重建。
2. 使用BuildAssetBundleOptions.AppendHashToAssetBundleName：这个选项会把内容的哈希值附加到文件名上（如ui.ab->ui_abc123def456.ab）。这样，当资源内容变化时，会生成一个全新的文件，旧文件依然存在。这非常利于做版本管理和差分更新，但注意，这需要你有一套运行时根据哈希名加载AB的机制。
3. 拆分AB包：不要把所有资源打成一个巨无霸AB包。按照功能模块、场景、资源类型进行合理拆分。这样，当你只修改了UI资源时，只有UI相关的包需要重建，其他包可以跳过。
4. 编写智能打包脚本：可以记录上次打包的资源哈希列表，本次打包前先对比，只对发生变化的资源所在的AB包进行标记重建。这需要较复杂的脚本实现，但对于超大型项目是值得的。

6.3 “The AssetBundle ‘xxx’ can‘t be loaded because another AssetBundle with the same files is already loaded.”

问题描述：加载AB包时报这个错。

根本原因：同一个资源被加载了两次。这通常发生在你把同一个资源打到了两个不同的AB包里，然后你又试图同时加载这两个包。Unity在内存中不允许同一份资源有两份实例。

排查与解决：

1. 使用编辑器菜单Window -> Analysis -> AssetBundle Browser（需要先从Package Manager安装此工具）。这是Unity官方提供的AB包分析神器，它可以直观地展示所有AB包的构成、大小以及资源冗余情况。红色高亮的部分就是重复资源，一目了然。
2. 根据分析结果，调整你的资源标记策略，确保公共资源只存在于一个公共AB包中。
3. 在加载逻辑上，确保公共包只加载一次，并被所有依赖它的模块共享。

6.4 真机上报错“Unable to open archive file”

问题描述：在编辑器里运行正常，打到真机（尤其是Android）上后，加载AB包失败。

可能原因：

1. 路径问题：在Android上，Application.streamingAssetsPath和Application.persistentDataPath的路径格式不同。如果你用的是file://协议，在Android上可能需要写成jar:file://。最稳妥的方式是使用UnityWebRequest，它能自动处理不同平台的路径差异。

   // 使用 UnityWebRequest 加载，更通用 UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(bundleUrl); yield return request.SendWebRequest(); AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(request);

2. AB包平台不匹配：给iOS打的包不能用在Android上。确保打包时的BuildTarget和目标平台一致。
3. 文件不存在或损坏：检查AB包是否成功复制到了真机的指定目录。对于热更新，下载完成后最好对文件进行MD5校验，确保完整性。

6.5 内存管理：卸载与泄漏

问题描述：AB包加载的资源越来越多，内存持续上涨，即使切换场景也不释放。

核心原则：Unity中资源加载和卸载是分离的。AssetBundle.LoadAsset加载资源到内存，Resources.UnloadUnusedAssets卸载没有被引用的资源。而AB包本身也是一个对象，需要手动卸载。

正确的卸载流程：

1. 卸载资源：当你确定不再需要某个AB包中的资源时（例如，关闭了一个UI界面），先调用Resources.UnloadUnusedAssets()。或者，更精确地，对加载出来的特定资源调用Resources.UnloadAsset(asset)，但这只适用于非GameObject和Component的资源（如Texture、Material）。
2. 卸载AB包：在确保该AB包加载的所有资源都已经被卸载后，调用AssetBundle.Unload(true)。参数为true表示同时卸载所有从该包加载的资产对象；为false则只卸载AB包文件本身，内存中的资源对象保留（但你会失去再次加载同名资源的能力，容易导致资源丢失）。
3. 关于AssetBundle.Unload(false)的坑：如果你选择false，之后又加载了同一个AB包的新实例，那么内存中会存在两份相同的资源（旧实例加载的+新实例加载的），导致内存泄漏。除非你非常清楚自己在做什么，否则建议在大多数情况下使用Unload(true)。

一个安全的模式是采用引用计数来管理AB包。每个AB包维护一个被引用的次数，当某个游戏模块需要资源时，增加计数并确保AB包已加载；当模块关闭时，减少计数，当计数为0时，触发Unload(true)。