1. 项目缘起：为什么需要处理B站的视频ID？

如果你经常和B站的视频数据打交道，无论是做数据分析、内容爬取，还是开发一些与B站相关的工具，肯定会遇到一个头疼的问题：视频ID的格式不统一。有时候你拿到的是一个以“BV”开头的字符串，比如BV1GJ411x7h7；有时候又遇到一个纯数字的“AV”号，比如av170001。这两种ID指向的是同一个视频，但在不同的接口、不同的历史时期，B站使用了不同的标识符。

这就带来了一个非常实际的开发需求：如何在代码里方便地进行这两种ID格式的互转？比如，用户输入一个BV号，你的程序需要调用一个只接受AV号的旧接口；或者你从数据库里读出了一堆AV号，但前端展示需要更现代的BV号格式。手动去网页上查？效率太低。写个正则胡乱处理？容易出错。

这个需求背后，其实是B站技术演进的一个小缩影。早期的B站视频统一使用纯数字的AV号（Archive Video），但随着视频数量的爆炸式增长，纯数字ID在可读性、防爬取和容量方面都显现出不足。于是，B站推出了一套新的编码方案——BV号（Bilibili Video），它由大小写字母和数字组成，看起来像一串“乱码”，但其实内含了一套精巧的编码算法。理解并实现这套算法，不仅能解决实际问题，也是一个挺有意思的编程练习。

网上能找到的代码片段不少，但很多只是机械的翻译，缺少对算法原理的剖析和实际应用中的“坑点”提示。今天，我就结合自己的几次踩坑经历，手把手带你从零实现一个健壮、高效的BV/AV互转工具类，并聊聊在真实项目里集成它时需要注意的那些事儿。

2. 核心算法拆解：BV号到底是怎么编出来的？

要实现互转，首先得弄明白BV号的编码规则。B站官方并没有公开详细的算法文档，但社区大神们通过逆向工程已经总结得非常清晰了。我们可以把BV号理解成AV号的一种“带校验的、混淆后的”表现形式。

一个标准的BV号，例如BV1GJ411x7h7，其核心是去掉“BV”前缀后的那串字符1GJ411x7h7。这串字符使用了58个字符的“字母表”进行编码，这个字母表是：fZodR9XQDSUm21yCkr6zBqiveYah8bt4xsWpHnJE7jL5VG3guMTKNPAwcF

注意，这不是标准的Base58编码（Base58的字母表不同），这是B站自定义的一套。更有趣的是，BV号的字符位置是固定的，并且与AV号的二进制位有特定的映射关系，而不是简单的顺序编码。

经过分析，已知的映射关系如下：

1. BV字符串的长度固定为10个字符。
2. 这10个字符的位置是固定的，其下标（从0开始）为：[6, 2, 4, 8, 5, 9, 3, 7, 1, 0]。
3. 只有这10个位置上的字符是有效编码信息，其余位置（实际上BV号只有这10位）的字符是“占位符”或经过特定算法计算得出的。
4. 将AV号（一个长整数）与一个常数XOR_AID = 177451812进行异或运算，然后加上另一个常数ADD_AID = 8728348608L，最后将这个结果按照上述位置映射，用58进制表示出来。

等等，是不是有点绕？我们用一个更直观的“解码”视角来看，从BV到AV的步骤反而更容易理解：

BV -> AV 的解码过程：

1. 初始化一个长度为10的数组，对应BV号的10个字符。
2. 准备一个反向查找表：将58个字符的字母表，建立从“字符”到“十进制值”的映射。例如，字母表第一个字符'f'对应值0，'Z'对应1，以此类推。
3. 遍历BV号的10个字符，利用反向查找表，得到每个字符对应的十进制值（0-57）。
4. 根据固定的位置映射关系[6, 2, 4, 8, 5, 9, 3, 7, 1, 0]，将这些十进制值“摆放”到正确的位置上，组合成一个58进制的数字。
5. 将这个58进制的数字，先减去常数ADD_AID，再与常数XOR_AID进行异或运算，得到的结果就是原始的AV号（长整数）。

AV -> BV 的编码过程就是上述过程的逆运算。

为什么要这么设计？我推测有几个原因：一是增加逆向难度，防止简单的爬虫直接遍历AV号；二是通过固定的字符位置和异或运算，使得生成的BV号看起来更随机，避免了连续编号的可预测性；三是58进制的编码比纯数字能表示更大的数据范围，且比标准的Base64少了容易混淆的字符（如0/O, I/l）。

理解了原理，我们就可以动手实现了。但先别急，在写代码之前，有几个关键的细节必须提前确定，否则很容易写出有Bug的实现。

注意：算法中的常数和字母表是固定的，任何实现都必须严格使用这些值，一个字符都不能错。网上有些早期文章给出的字母表或常数有细微差别，会导致转换失败。

3. 从零构建：Java实现的核心代码与逐行解析

下面，我将给出一个完整、健壮的BvAvConverter工具类。这个类包含了核心的转换逻辑、必要的校验以及一些方便使用的工具方法。我会在关键代码后面加上详细的注释，解释每一行在做什么，以及为什么这么做。

import java.util.HashMap; import java.util.Map; /** * B站BV号与AV号互相转换工具类 * 核心算法参考自社区逆向工程成果 */ public class BvAvConverter { // B站定义的58进制编码字母表，顺序固定 private static final String BASE58_ALPHABET = "fZodR9XQDSUm21yCkr6zBqiveYah8bt4xsWpHnJE7jL5VG3guMTKNPAwcF"; // 异或运算的常数 private static final long XOR_AID = 177451812L; // 加法运算的常数 private static final long ADD_AID = 8728348608L; // BV号固定长度 private static final int BV_LENGTH = 10; // 字符位置映射关系：index[i] 表示BV字符串中第i个字符在58进制数中的权重位置 private static final int[] POS_MAPPING = {6, 2, 4, 8, 5, 9, 3, 7, 1, 0}; // 反向映射，用于编码时根据权重位置找到字符下标 private static final int[] REV_POS_MAPPING = new int[BV_LENGTH]; // 字符到值的快速查找表（Map） private static final Map<Character, Integer> DECODE_MAP = new HashMap<>(); // 值到字符的快速查找表（数组） private static final char[] ENCODE_ARRAY = BASE58_ALPHABET.toCharArray(); // 静态初始化块，用于构建查找表和反向位置映射 static { // 初始化解码Map：字符 -> 十进制值 (0-57) for (int i = 0; i < BASE58_ALPHABET.length(); i++) { DECODE_MAP.put(BASE58_ALPHABET.charAt(i), i); } // 初始化反向位置映射 // POS_MAPPING[i] = j 表示：权重位置j的字符，在BV字符串中排在第i位。 // 那么 REV_POS_MAPPING[j] = i 就是反过来：给定权重位置j，找到它在BV字符串中的下标i。 for (int i = 0; i < BV_LENGTH; i++) { REV_POS_MAPPING[POS_MAPPING[i]] = i; } } /** * 将BV号转换为AV号（长整型） * @param bvId 完整的BV号字符串，如 "BV1GJ411x7h7"，大小写敏感 * @return 对应的AV号，如 170001 * @throws IllegalArgumentException 如果输入格式无效 */ public static long bvToAv(String bvId) { // 1. 基础校验 if (bvId == null || bvId.length() != BV_LENGTH + 2) { // +2 是"BV"前缀 throw new IllegalArgumentException("BV号格式错误，应为类似 'BV1GJ411x7h7' 的12位字符串"); } if (!bvId.startsWith("BV")) { throw new IllegalArgumentException("BV号必须以'BV'开头"); } String bvCode = bvId.substring(2); // 去掉"BV"前缀 if (bvCode.length() != BV_LENGTH) { throw new IllegalArgumentException("BV号主体长度必须为10位"); } // 2. 解码：将BV字符串转换为一个长整数（58进制 -> 10进制） long encodedValue = 0L; for (int i = 0; i < BV_LENGTH; i++) { char c = bvCode.charAt(i); Integer digit = DECODE_MAP.get(c); if (digit == null) { // 遇到了字母表中不存在的字符 throw new IllegalArgumentException("BV号包含非法字符: '" + c + "'"); } // 核心步骤：根据位置映射，将字符对应的值加到正确的位置上 // POS_MAPPING[i] 表示当前字符在58进制数中的权重位置（从0开始，个位是0） // 因此，该字符的实际贡献值是 digit * (58 ^ POS_MAPPING[i]) encodedValue += digit * pow58(POS_MAPPING[i]); } // 3. 逆向运算：减去加常数，再异或 long av = (encodedValue - ADD_AID) ^ XOR_AID; return av; } /** * 计算58的n次方，使用预计算或快速幂避免重复计算（这里用循环实现，对于n<=9可直接计算） */ private static long pow58(int n) { long result = 1L; for (int i = 0; i < n; i++) { result *= 58L; } return result; } /** * 将AV号转换为BV号 * @param avId AV号（长整型） * @return 对应的完整BV号字符串，如 "BV1GJ411x7h7" */ public static String avToBv(long avId) { // 1. 正向运算：先异或，再加常数 long x = (avId ^ XOR_AID) + ADD_AID; // 2. 初始化一个长度为10的字符数组，用于存放BV主体，先填充占位符（这里用字母表第一个字符） char[] bvChars = new char[BV_LENGTH]; // 先全部初始化为字母表的第一个字符，方便后续覆盖。也可以初始化为任意字符。 for (int i = 0; i < BV_LENGTH; i++) { bvChars[i] = ENCODE_ARRAY[0]; } // 3. 将计算出的长整数x转换为58进制，并按照反向位置映射填入数组 for (int i = 0; i < BV_LENGTH; i++) { // 计算x在58进制下，第i位的值（从低位到高位） // 这里 i 对应的是58进制数的权重位置（个位是0，十位是1...） long divisor = pow58(i); // 取得该权重位置上的数字（0-57） int digit = (int) ((x / divisor) % 58); // 关键：根据反向位置映射 REV_POS_MAPPING，找到这个权重位置i对应的字符在BV字符串中的下标 int posInBv = REV_POS_MAPPING[i]; // 将数字转换为对应的字符，填入BV字符数组的对应位置 bvChars[posInBv] = ENCODE_ARRAY[digit]; } // 4. 组合成最终字符串 return "BV" + new String(bvChars); } /** * 便捷方法：处理带"av"前缀的字符串输入 * @param avStr 如 "av170001" 或 "170001" * @return 对应的BV号 * @throws IllegalArgumentException 如果数字格式错误或超出范围 */ public static String avStrToBv(String avStr) { if (avStr == null || avStr.trim().isEmpty()) { throw new IllegalArgumentException("AV字符串不能为空"); } String numStr = avStr.trim().toLowerCase(); // 去除可能的"av"前缀 if (numStr.startsWith("av")) { numStr = numStr.substring(2); } try { long avId = Long.parseLong(numStr); if (avId <= 0) { throw new IllegalArgumentException("AV号必须为正整数"); } return avToBv(avId); } catch (NumberFormatException e) { throw new IllegalArgumentException("无效的AV号格式: " + avStr, e); } } /** * 便捷方法：将BV号转换为带"av"前缀的字符串 * @param bvId 完整的BV号 * @return 如 "av170001" */ public static String bvToAvStr(String bvId) { long av = bvToAv(bvId); return "av" + av; } // 简单的测试用例 public static void main(String[] args) { // 测试用例1：经典案例 String bv = "BV1GJ411x7h7"; long av = bvToAv(bv); System.out.println(bv + " -> av" + av); // 应输出 av170001 String convertedBv = avToBv(av); System.out.println("av" + av + " -> " + convertedBv); // 应输出原BV号 System.out.println("转换一致性检查: " + bv.equals(convertedBv)); // 测试用例2：使用便捷方法 System.out.println(avStrToBv("av170001")); // 应输出 BV1GJ411x7h7 System.out.println(bvToAvStr("BV1GJ411x7h7")); // 应输出 av170001 // 测试用例3：错误输入 try { bvToAv("BV1GJ411x7h"); // 长度错误 } catch (IllegalArgumentException e) { System.out.println("预期错误: " + e.getMessage()); } } }

关键代码解析与设计考量：

1. 常量定义：所有魔法数字（字母表、常数、长度、映射）都定义为static final常量，这是良好实践，避免硬编码，也便于修改和验证。
2. 查找表优化：在静态初始化块中，我们构建了两个关键的数据结构：
   • DECODE_MAP(字符 -> 值)：用于BV转AV时，快速将字符映射到其对应的十进制值（0-57）。使用HashMap实现O(1)时间复杂度的查找，比每次遍历字母表快得多。
   • REV_POS_MAPPING(权重位置 -> BV字符串下标)：用于AV转BV时，根据计算出的58进制各位的值，快速定位它应该放在结果字符串的哪个位置。这是正向映射POS_MAPPING的逆运算，预计算可以避免在循环中重复计算。
3. 输入校验：在bvToAv方法中，我们对输入进行了严格的校验：非空、长度、前缀、字符合法性。这对于一个工具类至关重要，可以尽早暴露调用方的错误，避免产生令人困惑的中间结果或异常。
4. 幂运算优化：pow58方法简单使用循环计算。因为n最大为9，计算量很小，这样写清晰明了。如果追求极致性能，可以预计算一个长度为10的long[] POW58_CACHE数组，直接查表。
5. 便捷方法：提供了avStrToBv和bvToAvStr方法，它们处理了带“av”前缀的字符串，使得工具类更贴近实际使用场景（用户输入或数据库存储的格式）。
6. 异常处理：统一抛出IllegalArgumentException并附带清晰的错误信息，方便上层调用者捕获和处理。

这个实现已经具备了生产环境的可用性。但直接拿去用，你可能还会遇到一些意想不到的问题。

4. 实战中的坑与进阶优化

在实际项目集成这个工具类时，我踩过几个坑，也做了一些优化，这里分享给你。

坑点一：AV号的范围与溢出问题B站的AV号是一个不断增长的正整数。我们的算法使用long类型来存储AV号和中间运算结果。long的最大值是9223372036854775807，这远远超过目前B站AV号的数量级，短期内完全够用。但是，在avToBv方法中，我们进行了(avId ^ XOR_AID) + ADD_AID运算。ADD_AID本身是一个87亿左右的大数，如果avId也很大，相加结果有可能接近Long.MAX_VALUE，但仍在安全范围内。更需要注意的是pow58(9)这个值，58的9次方是一个非常大的数，在与digit相乘时，要确保encodedValue不会溢出。在Java中，两个long相乘，如果结果超出Long.MAX_VALUE，会直接溢出变成负数，导致计算错误。虽然以目前B站的AV号规模，远未达到溢出的临界点，但为了代码的健壮性，我们可以添加一个范围检查，或者使用BigInteger进行安全运算。对于绝大多数场景，long足矣。

坑点二：字母表的大小写敏感性B站的BV号是大小写敏感的！字母表中包含大写和小写字母。这意味着BV1GJ411x7h7和bv1gj411x7h7是不同的字符串，后者是无法解码的。我们的DECODE_MAP的键是Character，它是区分大小写的。这一点在文档和错误信息中必须明确告知使用者。在bvToAv的校验中，我们只检查了前缀"BV"是大写的，但主体部分的大小写由解码Map自然校验。

坑点三：性能考量与缓存如果你需要在一个循环中高频次地转换成千上万个ID（比如处理一个大的视频列表），那么每次转换都重新计算pow58和进行Map查找可能会成为瓶颈。我们可以进行如下优化：

• 预计算58的幂：如前所述，用一个静态数组long[] POW58 = new long[10]在静态块中初始化好58^0到58^9的值。
• 避免装箱拆箱：DECODE_MAP的get方法返回Integer，赋值给int时会自动拆箱。对于超高频场景，可以考虑使用int[]数组来实现字符到值的映射，因为字符范围是有限的（ASCII）。但实现起来稍复杂，需要处理字符到数组下标的转换。对于绝大多数应用，HashMap的性能已经足够。

优化示例：预计算幂值

private static final long[] POW58_CACHE = new long[BV_LENGTH]; static { // ... 其他初始化代码 long value = 1L; for (int i = 0; i < BV_LENGTH; i++) { POW58_CACHE[i] = value; value *= 58L; } } // 然后修改 bvToAv 中的循环 encodedValue += digit * POW58_CACHE[POS_MAPPING[i]]; // 同时修改 avToBv 中的循环 long divisor = POW58_CACHE[i];

坑点四：与网络请求和数据库的集成在实际项目中，这个工具类常常用于处理从B站API返回的数据或数据库中存储的数据。这里有几个小贴士：

1. API响应解析：B站的新版API返回的视频ID字段可能是bvid(BV号) 和aid(AV号)。你的实体类（如Video）可以同时存储这两个字段，并在需要时用工具类进行转换或校验一致性。
2. 数据库存储：建议同时存储aid(长整型) 和bvid(字符串)，并建立索引。根据查询需求（如按时间范围查aid是连续的，可能更快；按bvid精确查找）来决定使用哪个字段。工具类可以用于在数据入库时由其中一个生成另一个。
3. URL处理：用户可能输入完整的B站视频链接，如https://www.bilibili.com/video/BV1GJ411x7h7或https://www.bilibili.com/video/av170001。你需要先编写一个简单的正则表达式或字符串处理逻辑来提取出纯粹的BV号或AV号，再交给工具类处理。

public static String extractVideoIdFromUrl(String url) { if (url == null) return null; // 简单匹配，实际应用可能需要更健壮的正则 if (url.contains("/BV")) { int start = url.indexOf("BV"); if (start != -1 && start + 12 <= url.length()) { return url.substring(start, start + 12); // 返回 "BV1GJ411x7h7" } } else if (url.contains("/av")) { int start = url.indexOf("av"); if (start != -1) { // 提取从"av"开始到下一个非数字字符之前的部分 String sub = url.substring(start); java.util.regex.Matcher m = java.util.regex.Pattern.compile("av(\\d+)").matcher(sub); if (m.find()) { return m.group(0); // 返回 "av170001" } } } return null; }

把这些边界情况都处理好，你的工具类才能真正称得上“健壮”。

5. 测试驱动：确保转换的绝对正确性

对于这样一个核心工具，编写全面的单元测试是必不可少的。测试不仅要覆盖正常的功能点，还要覆盖边界情况和异常情况。这里我给出一个基于JUnit 5的测试类示例。

import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; class BvAvConverterTest { @Test void testBvToAv_KnownCase() { // 已知的对照关系 assertEquals(170001L, BvAvConverter.bvToAv("BV1GJ411x7h7")); assertEquals(999999L, BvAvConverter.bvToAv("BV1mK4y1C7Bz")); // 可以找一些已知对 assertEquals(1L, BvAvConverter.bvToAv("BV1xx411c7mQ")); // AV1 对应的BV号 } @Test void testAvToBv_KnownCase() { assertEquals("BV1GJ411x7h7", BvAvConverter.avToBv(170001L)); assertEquals("BV1mK4y1C7Bz", BvAvConverter.avToBv(999999L)); assertEquals("BV1xx411c7mQ", BvAvConverter.avToBv(1L)); } @Test void testBvToAvAndBack_Consistency() { // 随机测试一些ID，确保转换可逆 long[] testAvs = {1L, 100L, 10000L, 1000000L, 999999999L}; for (long av : testAvs) { String bv = BvAvConverter.avToBv(av); long convertedAv = BvAvConverter.bvToAv(bv); assertEquals(av, convertedAv, "AV " + av + " 转换不一致"); } } @Test void testAvStrToBv() { assertEquals("BV1GJ411x7h7", BvAvConverter.avStrToBv("av170001")); assertEquals("BV1GJ411x7h7", BvAvConverter.avStrToBv("170001")); assertEquals("BV1xx411c7mQ", BvAvConverter.avStrToBv("av1")); } @Test void testBvToAvStr() { assertEquals("av170001", BvAvConverter.bvToAvStr("BV1GJ411x7h7")); assertEquals("av1", BvAvConverter.bvToAvStr("BV1xx411c7mQ")); } @Test void testBvToAv_InvalidInput() { // 测试异常情况 assertThrows(IllegalArgumentException.class, () -> BvAvConverter.bvToAv(null)); assertThrows(IllegalArgumentException.class, () -> BvAvConverter.bvToAv("")); assertThrows(IllegalArgumentException.class, () -> BvToAv("Bv1GJ411x7h7")); // 前缀小写v assertThrows(IllegalArgumentException.class, () -> BvToAv("AV1GJ411x7h7")); // 错误前缀 assertThrows(IllegalArgumentException.class, () -> BvToAv("BV1GJ411x7h")); // 长度短 assertThrows(IllegalArgumentException.class, () -> BvToAv("BV1GJ411x7h78")); // 长度长 assertThrows(IllegalArgumentException.class, () -> BvToAv("BV1GJ411x7h!")); // 非法字符 } @Test void testAvStrToBv_InvalidInput() { assertThrows(IllegalArgumentException.class, () -> BvAvConverter.avStrToBv(null)); assertThrows(IllegalArgumentException.class, () -> BvAvConverter.avStrToBv("")); assertThrows(IllegalArgumentException.class, () -> BvAvConverter.avStrToBv("av")); assertThrows(IllegalArgumentException.class, () -> BvAvConverter.avStrToBv("avnotnumber")); assertThrows(IllegalArgumentException.class, () -> BvAvConverter.avStrToBv("av0")); // 非正整数 assertThrows(IllegalArgumentException.class, () -> BvAvConverter.avStrToBv("av-100")); } }

运行这些测试，如果全部通过，就能给你的代码质量带来极大的信心。特别是“可逆性”测试，它能有效验证你的编码和解码逻辑是严格互逆的，这是算法正确性的核心证明。

6. 扩展思考：在真实业务场景下的应用

掌握了核心转换，我们可以看看它能在哪些实际场景中发挥作用。

场景一：数据迁移与清洗假设你有一个旧系统，里面存储了大量的B站视频AV号。现在前端全面改版，要求展示BV号。你可以写一个简单的数据库脚本，利用这个工具类，遍历表中的aid字段，计算出对应的bvid并更新到新字段中，完成数据的批量迁移。

场景二：统一视频标识符处理在你的视频处理流水线中，可能上游系统传来的是BV号，下游某个老旧服务只认AV号。你可以在接入层做一个统一的适配器，利用工具类进行转换，对业务逻辑透明，避免在每个业务点都写重复的转换代码。

场景三：爬虫与去重写B站爬虫时，你可能会从不同来源（如分享链接、API、网页源码）获取视频ID，格式混杂。你可以将所有ID统一转换为AV号（长整型）进行存储和去重比较，因为数字比字符串比较更快，且作为主键更高效。或者在展示时，统一转换为BV号，保持对外格式的一致性。

场景四：缓存键生成如果你需要缓存视频信息，可以用”video_info:” + avId或”video_info:” + bvId作为缓存键。工具类可以帮你确保即使用户用不同格式的ID请求同一资源，你也能计算出唯一的缓存键，避免重复缓存。

最后，虽然这个算法目前是稳定的，但任何依赖于第三方未公开规则的技术都有潜在风险。B站未来如果再次升级视频ID编码规则（虽然概率很小），我们的代码就需要同步更新。因此，在系统设计上，最好将ID转换服务抽象成一个接口，并将当前的实现作为默认实现。这样即使未来算法变化，我们也只需要更换接口的实现即可，核心业务逻辑不受影响。

代码本身不长，但把前后的坑都趟平、把性能优化做好、把测试写全、把应用场景想清楚，这才是一个合格的、可以放心交给团队使用的工具组件。希望这篇从原理到实战的解析，能帮你彻底搞定B站视频ID转换这个小而重要的需求。