深入理解Base64的用法和原理 Detail - base64,java,加密威哥愛編程 Blog

Base64 是一種編碼方法，用於將二進制數據轉換成64個可打印的ASCII字符的序列。這種編碼方式廣泛應用於在文本格式中存儲二進制數據，例如在 URL、文件名、或在 XML 和 JSON 文檔中。Java 中的 Base64 編碼和解碼通常可以通過 java.util.Base64 類實現，這個類在 Java 8 及以後的版本中提供。

以下是V 哥整理的 Java 中 java.util.Base64 類的核心組件，V 哥將重點介紹這些組件的原理和用法：

編碼器（Encoder）：
- getEncoder()：返回一個 Base64.Encoder 實例，用於將數據編碼為 Base64 格式。
解碼器（Decoder）：
- getDecoder()：返回一個 Base64.Decoder 實例，用於將 Base64 編碼的數據解碼回原始格式。
編碼表（Encoding Table）：
- Base64 編碼器使用一個靜態的編碼表來將字節映射到 Base64 字符。
解碼錶（Decoding Table）：
- Base64 解碼器使用一個靜態的解碼錶來將 Base64 字符映射回字節。
編碼模式（Encoding Mode）：
- BASE64：標準的 Base64 編碼模式。
- URL_SAFE：URL 和文件名安全的 Base64 編碼模式，使用 - 和 _ 代替標準模式中的 + 和 /。
行長度和填充：
- Base64 編碼輸出通常每76個字符會有一個換行符，但這可以通過 Encoder 的配置來改變。

示例代碼：

import java.util.Base64;
import java.nio.charset.StandardCharsets;

public class Base64Example {
    public static void main(String[] args) {
        String original = "Hello, VG!";
        byte[] encoded = Base64.getEncoder().encode(original.getBytes(StandardCharsets.UTF_8));
        System.out.println("Encoded: " + new String(encoded, StandardCharsets.UTF_8));

        byte[] decoded = Base64.getDecoder().decode(encoded);
        System.out.println("Decoded: " + new String(decoded, StandardCharsets.UTF_8));
    }
}

在上述代碼中，我們使用 Base64.getEncoder().encode() 方法將字符串 "Hello, VG!" 編碼為 Base64 格式，然後使用 Base64.getDecoder().decode() 方法將其解碼回原始字符串。

Base64 編碼和解碼的實現通常依賴於這些核心組件，它們提供了靈活的方式來處理不同場景下的編碼需求。

小試牛刀後，我們來一起詳細看看它們的實現原理。

1. 編碼器（Encoder）

在 Java 8 引入的 java.util.Base64 包中，Encoder 類是 Base64 類的一個內部類，用於實現 Base64 編碼功能。以下是 Encoder 類實現的詳細步驟和原理分析：

1. 初始化編碼器

首先，通過 Base64.getEncoder() 獲取 Encoder 對象的實例。這個實例包含了編碼過程中需要的所有配置，例如是否添加填充字符等。

Base64.Encoder encoder = Base64.getEncoder();

2. 準備編碼數據

將需要編碼的數據放入字節數組中。這些數據將作為輸入傳遞給編碼器。

byte[] dataToEncode = "beijing Hot".getBytes(StandardCharsets.UTF_8);

3. 編碼數據

使用 Encoder 實例的 encode 方法對數據進行編碼。這個方法會返回一個包含 Base64 編碼結果的字節數組。

byte[] encodedData = encoder.encode(dataToEncode);

4. 處理編碼結果

編碼後的字節數組可以轉換為字符串，或者直接寫入到輸出流中。

String encodedString = new String(encodedData, StandardCharsets.UTF_8);

編碼原理

Base64 字符集：
Base64 編碼使用一個包含 64 個字符的字符集，包括大寫字母 A-Z、a-z、數字 0-9、加號（+）和斜槓（/）。
3 字節到 4 字符的映射：
每次從輸入數據中讀取 3 個字節（24 位），然後將這 24 位分割成 4 個 6 位的組。每個 6 位組映射到一個 Base64 字符。
填充：
如果輸入數據的字節數不是 3 的倍數，在編碼的最後會添加一個或兩個 = 字符作為填充。
換行符：
在編碼過程中，可以根據配置在每 76 個字符後添加換行符，以確保編碼後的文本符合 MIME 的要求。
無填充模式：
使用 encoder.withoutPadding() 可以禁用自動填充，這樣編碼後的輸出就不會包含 = 字符。

源碼分析

在 Base64.Encoder 類中，編碼過程主要涉及以下幾個關鍵部分：

編碼表：ENCODE 數組定義瞭如何將 6 位二進制數映射到 Base64 字符集。
緩衝區：encoder 內部維護一個緩衝區，用於存儲待編碼的字節。
編碼方法：encode 方法實現具體的編碼邏輯，包括從緩衝區讀取字節、映射到 Base64 字符、處理剩餘字節和填充。

編碼步驟

填充緩衝區：將輸入數據寫入到 encoder 的內部緩衝區。
分組：將緩衝區中的字節按每 3 個字節分為一組。
映射字符：使用 ENCODE 表將每組的 24 位映射到 4 個 Base64 字符。
處理剩餘：如果最後一組不足 3 個字節，使用 = 作為填充，並相應調整映射的字符。
輸出結果：將映射後的字符輸出或轉換為字符串。

來一個示例代碼嘗試一下使用

public byte[] encode(byte[] input) {
    // 初始化輸出數組
    byte[] output = new byte[...];
    int outputPos = 0;

    for (int i = 0; i < input.length; i += 3) {
        // 讀取 3 個字節
        int threeBytes = ((input[i] & 0xFF) << 16) |
                         ((i + 1 < input.length) ? (input[i + 1] & 0xFF) << 8 : 0) |
                         ((i + 2 < input.length) ? (input[i + 2] & 0xFF) : 0);

        // 映射到 4 個 Base64 字符
        for (int j = 0; j < 4; j++) {
            int index = (threeBytes & (0xFF << (8 * (3 - j)))) >> (8 * (3 - j));
            output[outputPos++] = ENCODE[index];
        }
    }

    // 處理填充
    if (neededPadding) {
        output[outputPos++] = '=';
        // 可能還需要第二個 '='
    }

    return Arrays.copyOf(output, outputPos);
}

以上代碼演示了 Base64 編碼的基本邏輯，實際的 Encoder 類實現可能會包含更多的細節，例如處理換行符、無填充模式等。

2. 解碼器（Decoder）

在 Java 8 及以後的版本中，java.util.Base64 包中的 Decoder 類是 Base64 類的一個內部類，用於實現 Base64 解碼功能。以下是 Decoder 類實現的詳細步驟和原理分析：

1. 初始化解碼器

首先，通過 Base64.getDecoder() 獲取 Decoder 對象的實例。這個實例包含了解碼過程中需要的所有配置。

Base64.Decoder decoder = Base64.getDecoder();

2. 準備解碼數據

將需要解碼的 Base64 字符串轉換為字節數組。這些數據將作為輸入傳遞給解碼器。

String base64String = "SGVsbG8sIFdvcmxkIQ==";
byte[] dataToDecode = base64String.getBytes(StandardCharsets.UTF_8);

3. 解碼數據

使用 Decoder 實例的 decode 方法對 Base64 字符串進行解碼。這個方法會返回一個包含原始數據的字節數組。

byte[] decodedData = decoder.decode(dataToDecode);

4. 處理解碼結果

解碼後的字節數組可以轉換為字符串，或者直接用於其他需要原始數據的場合。

String decodedString = new String(decodedData, StandardCharsets.UTF_8);

解碼原理

Base64 字符集：
Base64 解碼使用與編碼相同的 64 個字符集，包括大寫字母 A-Z、a-z、數字 0-9、加號（+）和斜槓（/）。
4 字符到 3 字節的映射：
每次從 Base64 編碼的數據中讀取 4 個字符（24 位），然後將這 24 位分割成 3 個 8 位的組。每個 8 位的組映射回原始的字節。
處理填充：
如果編碼時使用了填充字符（=），解碼時需要識別並忽略這些字符。
異常處理：
如果輸入數據包含非法字符或格式不正確，解碼過程將拋出 IllegalArgumentException。

源碼分析

在 Base64.Decoder 類中，解碼過程主要涉及以下幾個關鍵部分：

解碼錶：DECODE 數組定義了 Base64 字符到 6 位二進制數的映射。
緩衝區：decoder 內部維護一個緩衝區，用於存儲待解碼的 Base64 字符。
解碼方法：decode 方法實現具體的解碼邏輯，包括從輸入讀取字符、映射回字節、處理填充和非法字符。

解碼步驟

填充緩衝區：將 Base64 編碼的字符串轉換為字節數組，並填充到 decoder 的內部緩衝區。
分組：將緩衝區中的 Base64 字符按每 4 個字符分為一組。
映射字節：使用 DECODE 表將每組的 24 位映射回 3 個字節。
處理填充：如果編碼時使用了填充，解碼時識別 = 字符並相應調整映射的字節。
輸出結果：將映射後的字節輸出或轉換為原始數據。

還是上示例看用法

public byte[] decode(byte[] input) {
    // 初始化輸出數組
    byte[] output = new byte[...];
    int outputPos = 0;

    for (int i = 0; i < input.length; i += 4) {
        // 讀取 4 個 Base64 字符
        int fourChars = (DECODE[input[i] & 0xFF] << 18) |
                        (DECODE[input[i + 1] & 0xFF] << 12) |
                        (DECODE[input[i + 2] & 0xFF] << 6) |
                        (DECODE[input[i + 3] & 0xFF]);

        // 映射回 3 個字節
        output[outputPos++] = (fourChars >> 16) & 0xFF;
        if (input[i + 2] != '=') {
            output[outputPos++] = (fourChars >> 8) & 0xFF;
        }
        if (input[i + 3] != '=') {
            output[outputPos++] = fourChars & 0xFF;
        }
    }

    return Arrays.copyOf(output, outputPos);
}

以上的代碼演示了 Base64 解碼的基本邏輯，實際的 Decoder 類實現可能會包含更多的細節，例如處理非法字符、解碼錶的初始化等。

通過這種方式，Base64.Decoder 提供了一種靈活且高效的方式來將 Base64 編碼的字符串解碼回原始的字節數據，適用於多種不同的解碼需求。

3. 編碼表（Encoding Table）

Base64 編碼表是 Base64 編碼和解碼過程中的核心組件之一。它是一個查找表，用於將 6 位二進制值映射到相應的 Base64 編碼字符。以下是 Base64 編碼表的源碼實現過程步驟和原理分析：

1. 定義 Base64 字符集

Base64 編碼使用 64 個可打印的 ASCII 字符來表示數據。這些字符包括大寫字母 A-Z（26 個）、小寫字母 a-z（26 個，但在標準 Base64 中通常使用大寫）、數字 0-9（10 個）、加號 + 和斜槓 /。此外，為了支持 URL 和文件名，還有一個變種使用 - 代替 + 和 _ 代替 /。

2. 初始化編碼表

在 Java 的 java.util.Base64 類中，編碼表通常是通過一個靜態初始化的數組來實現的。這個數組的長度為 64，正好對應於 Base64 字符集中的字符數量。

private static final char[] ENCODE = {
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
    // ... 省略中間字符
    'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '+', '/'
};

3. 使用編碼表進行編碼

在編碼過程中，原始數據被讀取並轉換為字節，然後每三個字節（24 位）被轉換為四個 6 位的組。每個 6 位組的值通過查找編碼表來找到對應的 Base64 字符。

4. 處理填充

如果原始數據的長度不是 3 的倍數，最後一組可能只有 1 或 2 個字節。在這種情況下，剩餘的位使用 = 字符填充。填充字符不通過編碼表映射，而是直接添加到輸出中。

5. 生成編碼字符串

將映射得到的 Base64 字符連接起來，形成最終的編碼字符串。

原理解釋

6 位映射：由於 Base64 編碼將 3 個字節（24 位）轉換為 4 個字符（每個字符 6 位），所以每個字符可以表示 6 位二進制數據。ENCODE 數組中的每個索引值對應一個 6 位的二進制數。
字符選擇：在編碼過程中，通過將字節數據的位操作結果作為索引，從 ENCODE 數組中選擇相應的字符。
性能優化：使用查找表可以快速地進行字符映射，避免了複雜的條件判斷或循環，從而提高了編碼的效率。

示例代碼

以下是如何使用編碼表進行 Base64 編碼的示例代碼：

public String encode(byte[] data) {
    StringBuilder encoded = new StringBuilder();
    int i = 0;

    while (i < data.length - 2) { // 處理完整組
        int threeBytes = ((data[i] & 0xFF) << 16) |
                         ((data[i + 1] & 0xFF) << 8) |
                         (data[i + 2] & 0xFF);
        // 將 24 位分為 4 個 6 位組
        for (int j = 0; j < 4; j++) {
            int index = (threeBytes >> (18 - j * 6)) & 0x3F;
            encoded.append(ENCODE[index]);
        }
        i += 3;
    }

    // 處理剩餘字節和填充
    if (i < data.length) {
        int remaining = data.length - i;
        int twoBytes = (data[i] & 0xFF) << (8 * (2 - remaining));
        for (int j = 0; j < remaining; j++) {
            int index = (twoBytes >> (16 - j * 8)) & 0xFF;
            encoded.append(ENCODE[index]);
        }
        // 添加填充字符
        while (encoded.length() % 4 != 0) {
            encoded.append('=');
        }
    }

    return encoded.toString();
}

這個偽代碼演示瞭如何使用 Base64 編碼表將字節數據編碼為 Base64 字符串。實際的 Base64.Encoder 類實現可能會包含更多的細節，例如處理換行符等。

4. 解碼錶（Decoding Table）

Base64 解碼錶是 Base64 編碼和解碼過程中的另一個核心組件。它用於將 Base64 編碼的字符映射回相應的 6 位二進制值。以下是 Base64 解碼錶的源碼實現過程步驟和原理分析：

1. 定義 Base64 字符集

與編碼表一樣，解碼錶依賴於 Base64 字符集，包括大寫字母 A-Z、小寫字母 a-z（在標準 Base64 中通常不使用）、數字 0-9、加號 + 和斜槓 /。對於 URL 安全的 Base64，使用 - 代替 + 和 _ 代替 /。

2. 初始化解碼錶

在 Java 的 java.util.Base64 類中，解碼錶通常是通過一個靜態初始化的數組來實現的。這個數組的長度為 128，覆蓋了所有可能的 ASCII 字符，因為標準 ASCII 字符集大小為 128 個字符。

private static final int[] DECODE = new int[128];

在靜態初始化塊中，解碼錶被填充。每個 Base64 字符都被賦予一個值，從 0 到 63，而非法字符則通常被賦予 -1 或其他表示無效的值。

static {
    for (int i = 0; i < DECODE.length; i++) {
        DECODE[i] = -1; // 初始值設為無效
    }
    // 為 Base64 字符賦值
    for (int i = 'A'; i <= 'Z'; i++) {
        DECODE[i] = i - 'A';
    }
    for (int i = 'a'; i <= 'z'; i++) {
        DECODE[i] = 26 + i - 'a';
    }
    for (int i = '0'; i <= '9'; i++) {
        DECODE[i] = 52 + i - '0';
    }
    DECODE['+'] = 62;
    DECODE['/'] = 63;
    // 對於 URL 安全的 Base64，可以添加以下賦值
    DECODE['-'] = 62;
    DECODE['_'] = 63;
}

3. 使用解碼錶進行解碼

在解碼過程中，Base64 編碼的字符串被逐個字符讀取，每個字符通過解碼錶轉換為其對應的 6 位二進制值。

4. 處理填充

Base64 編碼可能以 = 字符結尾，表示原始數據在編碼時不足 3 個字節。在解碼時，這些填充字符被忽略，不參與解碼過程。

5. 生成原始數據

將解碼得到的 6 位二進制值重新組合，轉換回原始的字節序列。

原理解釋

字符到值的映射：解碼錶提供了從 Base64 字符到其對應的 6 位二進制值的快速映射。這種映射是通過查找表實現的，其中每個可能的字符（128 個 ASCII 字符）都有一個與之對應的整數值。
忽略非法字符：解碼錶中的非法字符被賦予一個特殊值（如 -1），在解碼過程中，這些值被忽略或導致解碼失敗。
性能優化：使用查找表可以快速地進行字符到值的轉換，避免了複雜的條件判斷或循環，從而提高了解碼的效率。

上示例代碼

以下是如何使用解碼錶進行 Base64 解碼的示例代碼：

public byte[] decode(String encoded) {
    char[] chars = encoded.toCharArray();
    int[] decodeTable = getDecodeTable(); // 獲取初始化的解碼錶
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    
    for (int i = 0; i < chars.length;) {
        if (chars[i] == '=') { // 處理填充
            break;
        }
        int value = decodeTable[chars[i] & 0xFF];
        if (value == -1) { // 非法字符
            throw new IllegalArgumentException("Illegal character encountered");
        }
        // 將 4 個 Base64 字符轉換為 3 個字節
        int threeBytes = (value << 18) |
                         (decodeTable[chars[++i] & 0xFF] << 12) |
                         (decodeTable[chars[++i] & 0xFF] << 6) |
                         decodeTable[chars[++i] & 0xFF];
        output.write((threeBytes >> 16) & 0xFF);
        if (chars[++i] != '=') {
            output.write((threeBytes >> 8) & 0xFF);
        }
        if (chars[++i] != '=') {
            output.write(threeBytes & 0xFF);
        }
        i++; // 跳過最後一個字符，如果它是填充字符
    }
    
    return output.toByteArray();
}

以上代碼演示如何使用 Base64 解碼錶將 Base64 編碼的字符串解碼為原始字節數組。實際的 Base64.Decoder 類實現可能會包含更多的細節，例如處理不同編碼模式等。

5. 編碼模式（Encoding Mode）

在 Java 的 java.util.Base64 包中，編碼模式（Encoding Mode）決定了 Base64 編碼的行為，包括字符集的使用和是否添加換行符。以下是對編碼模式的源碼實現過程步驟和原理的詳細分析：

1. 定義編碼模式

Java 的 Base64 類提供了兩種編碼模式：

BASE64：標準的 Base64 編碼模式，使用 A-Z、a-z、0-9、+ 和 / 字符，並且可以在每 76 個字符後添加換行符。
URL_SAFE：URL 安全的 Base64 編碼模式，使用 A-Z、a-z、0-9、- 和 _ 字符，適用於 URL 和文件名，也不添加換行符。

2. 初始化編碼器

編碼器可以通過 Base64.getEncoder() 獲取，並根據需要選擇編碼模式。例如，使用 URL 安全模式可以通過 encoder = Base64.getUrlEncoder() 實現。

3. 配置編碼器

編碼器可以進一步配置以滿足特定的編碼需求，例如禁用換行符或填充字符。這些配置可以通過編碼器的方法鏈調用來完成。

Base64.Encoder encoder = Base64.getEncoder();
encoder = encoder.withoutPadding(); // 禁用填充

4. 編碼數據

使用配置好的編碼器對數據進行編碼。編碼過程會根據編碼模式使用不同的字符集，並根據配置決定是否添加換行符。

byte[] encodedData = encoder.encode(originalData);

5. 輸出編碼結果

編碼後的數據可以作為字節數組或轉換為字符串進行輸出。

String encodedString = new String(encodedData, StandardCharsets.UTF_8);

原理解釋

字符集選擇：不同的編碼模式使用不同的字符集。標準模式使用 + 和 /，而 URL 安全模式使用 - 和 _ 代替，以避免在 URL 中引起歧義。
換行符處理：在標準 Base64 編碼中，為了提高可讀性，每 76 個字符後可以添加一個換行符。在 URL 安全模式或當禁用換行符時，不添加換行符。
填充處理：當輸入數據不是 3 個字節的倍數時，Base64 編碼會在結果的末尾添加一個或兩個 = 字符作為填充。通過配置編碼器，可以禁用這種自動填充。

上示例代碼

以下是使用不同編碼模式進行 Base64 編碼的示例：

import java.util.Base64;

public class Base64EncodingExample {
    public static void main(String[] args) {
        byte[] data = "Some data to encode".getBytes(StandardCharsets.UTF_8);

        // 使用標準 Base64 編碼模式
        Base64.Encoder standardEncoder = Base64.getEncoder();
        String standardEncoded = new String(standardEncoder.encode(data));

        // 使用 URL 安全的 Base64 編碼模式
        Base64.Encoder urlSafeEncoder = Base64.getUrlEncoder().withoutPadding();
        String urlSafeEncoded = new String(urlSafeEncoder.encode(data));

        System.out.println("Standard Encoded: " + standardEncoded);
        System.out.println("URL Safe Encoded: " + urlSafeEncoded);
    }
}

在這個示例中，我們使用標準 Base64 編碼模式和 URL 安全 Base64 編碼模式對相同的數據進行編碼，並輸出編碼結果。

注意事項

編碼模式的選擇應根據數據的使用場景來決定。例如，當數據將被用於 URL 傳輸時，應使用 URL 安全模式。
配置編碼器時，應考慮到接收端的解碼能力，確保編碼和解碼使用相同的模式和配置。
禁用填充可能會影響某些協議或應用程序的兼容性，因為它們可能期望 Base64 編碼的數據以 = 字符結束。

通過這種方式，Base64 類的編碼模式提供了靈活性，以適應不同的編碼需求和使用場景。

6. 行長度和填充

在 Java 的 java.util.Base64 包中，行長度（line length）和填充（padding）是 Base64 編碼過程中的兩個可選配置，它們影響編碼輸出的格式。以下是行長度和填充的源碼實現過程步驟和原理分析：

1. 定義行長度和填充的默認行為

在 Base64 編碼中，可以設置每行的字符數（行長度），以及是否在編碼數據的末尾添加填充字符 =。

行長度：默認情況下，每行包含 76 個字符，這是為了確保編碼後的文本符合 MIME 的要求。
填充：如果編碼的數據不是 3 個字節的倍數，編碼後的輸出會在末尾添加一個或兩個 = 字符作為填充。

2. 配置編碼器

編碼器可以通過調用 Base64.getEncoder() 獲取，並使用 withoutPadding() 方法來配置不使用填充。

Base64.Encoder encoder = Base64.getEncoder().withoutPadding();

3. 實現自定義行分隔

雖然 Java 的 Base64.Encoder 沒有直接提供設置行長度的方法，但你可以通過自定義編碼邏輯來實現。例如，你可以在編碼後的結果上手動插入換行符。

4. 編碼數據

使用配置好的編碼器對數據進行編碼。編碼過程會根據是否配置了無填充來決定是否在輸出末尾添加 = 字符。

byte[] encodedData = encoder.encode(originalData);

5. 手動處理行分隔

如果你需要自定義行長度，可以在編碼後的結果上手動添加換行符。這可以通過遍歷編碼後的字節數組並每隔一定數量的字符插入一個換行符來實現。

原理解釋

行長度：設置行長度的目的是在編碼後的文本中添加可讀性，使其更適合在文本環境中展示和編輯。每 76 個 Base64 字符後添加一個換行符是 Base64 編碼的常見約定。
填充：Base64 編碼要求每三個字節的原始數據轉換為四個 Base64 字符。如果原始數據的字節數不是 3 的倍數，編碼器會在結果末尾添加一個或兩個 = 字符來填充。這表明編碼的數據不是原始數據的完整表示。
自定義行分隔：在某些情況下，你可能需要不同於默認行長度的編碼格式。通過在編碼後的字符串中手動插入換行符，可以實現自定義行分隔。

示例代碼

以下是如何使用 Base64.Encoder 進行編碼，並手動添加自定義行分隔的示例：

import java.util.Base64;
import java.io.ByteArrayOutputStream;

public class Base64CustomLineLength {
    public static void main(String[] args) {
        String original = "Some data to encode";
        byte[] data = original.getBytes(StandardCharsets.UTF_8);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        Base64.Encoder encoder = Base64.getEncoder().withoutPadding();

        try {
            encoder.encode(data, baos);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }

        String encoded = baos.toString();
        // 手動添加自定義行分隔，例如每 50 個字符
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < encoded.length(); i += 50) {
            sb.append(encoded, i, Math.min(i + 50, encoded.length()));
            if (i + 50 < encoded.length()) {
                sb.append("\n"); // 添加換行符
            }
        }
        encoded = sb.toString();

        System.out.println("Custom line length encoded: " + encoded);
    }
}

在這個示例中，我們使用 Base64.Encoder 對數據進行編碼，並在編碼後的結果上手動添加了每 50 個字符的換行符，實現了自定義行長度的效果。

注意事項

自定義行分隔可能會影響編碼數據的解碼，確保解碼時也考慮到了行分隔的處理。
禁用填充可能會影響某些協議或應用程序的兼容性，因為它們可能期望 Base64 編碼的數據以 = 字符結束。
在手動添加行分隔時，確保換行符的使用符合目標格式的要求。

最後

以上就是 Base64的核心類庫的全部介紹，瞭解 Base64的用法和原理，向高手靠近一點點。關注威哥愛編程。

威哥愛編程 Blog

@finally_m

Tags

前端 (1158)

Javascript (735)

後端 (618)

JAVA (556)

數據庫 (311)

MySQL (192)

算法 (135)

redis (93)

spring (87)

Nginx (75)

面試 (72)

SQL (72)

Stories

深入理解Base64的用法和原理 - Stories Detail

1. 編碼器（Encoder）

1. 初始化編碼器

2. 準備編碼數據

3. 編碼數據

4. 處理編碼結果

編碼原理

源碼分析

編碼步驟

來一個示例代碼嘗試一下使用

2. 解碼器（Decoder）

1. 初始化解碼器

2. 準備解碼數據

3. 解碼數據

4. 處理解碼結果

解碼原理

源碼分析

解碼步驟

還是上示例看用法

3. 編碼表（Encoding Table）

1. 定義 Base64 字符集

2. 初始化編碼表

3. 使用編碼表進行編碼

4. 處理填充

5. 生成編碼字符串

原理解釋

示例代碼

4. 解碼錶（Decoding Table）

1. 定義 Base64 字符集

2. 初始化解碼錶

3. 使用解碼錶進行解碼

4. 處理填充

5. 生成原始數據

原理解釋

上示例代碼

5. 編碼模式（Encoding Mode）

1. 定義編碼模式

2. 初始化編碼器

3. 配置編碼器

4. 編碼數據

5. 輸出編碼結果

原理解釋

上示例代碼

注意事項

6. 行長度和填充

1. 定義行長度和填充的默認行為

2. 配置編碼器

3. 實現自定義行分隔

4. 編碼數據

5. 手動處理行分隔

原理解釋

示例代碼

注意事項

最後

Add a new Comments