Java实现BASE64加解密算法的示例代码

public static String encode(byte[] data, boolean urlSafe);
public static byte[] decode(String b64);

int b0 = data[i]   & 0xFF;
int b1 = data[i+1] & 0xFF;
int b2 = data[i+2] & 0xFF;
// 组合为 24 位：(b0<<16)|(b1<<8)|b2
// 依次提取 6 位输出

private static final char[] ENC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
private static final char[] ENC_URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".toCharArray();

private static final byte[] DEC = new byte[128]; // 初始化为 -1
// 遍历 ENC，DEC[ENC[i]] = (byte)i
// 同时为 URL 变体字符赋值

public class Base64Util {
    public static String encode(byte[] data);
    public static String encodeUrlSafe(byte[] data);
    public static byte[] decode(String b64) throws Base64Exception;
}

// ==================== 文件：Base64Exception.java ====================
package com.example.base64;
 
/**
 * Base64 编解码异常
 */
public class Base64Exception extends RuntimeException {
    public Base64Exception(String message) {
        super(message);
    }
    public Base64Exception(String message, Throwable cause) {
        super(message, cause);
    }
}
 
// ==================== 文件：Base64Util.java ====================
package com.example.base64;
 
import java.util.Arrays;
 
/**
 * 基于查表法的 Base64 编解码工具，支持标准与 URL 安全模式
 */
public class Base64Util {
    // 标准 Base64 编码表
    private static final char[] ENC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
    // URL 安全 Base64 编码表
    private static final char[] ENC_URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".toCharArray();
    // 解码查表，-1 表示非法字符
    private static final byte[] DEC = new byte[128];
    static {
        Arrays.fill(DEC, (byte)-1);
        for (int i = 0; i < ENC.length; i++) {
            DEC[ENC[i]] = (byte)i;
        }
        for (int i = 0; i < ENC_URL.length; i++) {
            DEC[ENC_URL[i]] = (byte)i;
        }
        DEC['='] = 0;
    }
 
    /**
     * 标准 Base64 编码
     */
    public static String encode(byte[] data) {
        return encode(data, false);
    }
 
    /**
     * URL 安全 Base64 编码（无填充）
     */
    public static String encodeUrlSafe(byte[] data) {
        return encode(data, true);
    }
 
    private static String encode(byte[] data, boolean urlSafe) {
        if (data == null || data.length == 0) return "";
        char[] table = urlSafe ? ENC_URL : ENC;
        int len = data.length;
        int fullGroups = len / 3;
        int remainder = len - 3 * fullGroups;
        int outLen = 4 * ((len + 2) / 3);
        StringBuilder sb = new StringBuilder(outLen);
        int idx = 0;
        // 主循环，每次处理 3 字节
        for (int i = 0; i < fullGroups; i++) {
            int b0 = data[idx++] & 0xFF;
            int b1 = data[idx++] & 0xFF;
            int b2 = data[idx++] & 0xFF;
            sb.append(table[b0 >>> 2]);
            sb.append(table[((b0 & 0x3) << 4) | (b1 >>> 4)]);
            sb.append(table[((b1 & 0xF) << 2) | (b2 >>> 6)]);
            sb.append(table[b2 & 0x3F]);
        }
        // 处理尾部
        if (remainder == 1) {
            int b0 = data[idx++] & 0xFF;
            sb.append(table[b0 >>> 2]);
            sb.append(table[(b0 & 0x3) << 4]);
            if (!urlSafe) {
                sb.append("==");
            }
        } else if (remainder == 2) {
            int b0 = data[idx++] & 0xFF;
            int b1 = data[idx++] & 0xFF;
            sb.append(table[b0 >>> 2]);
            sb.append(table[((b0 & 0x3) << 4) | (b1 >>> 4)]);
            sb.append(table[(b1 & 0xF) << 2]);
            if (!urlSafe) {
                sb.append('=');
            }
        }
        return sb.toString();
    }
 
    /**
     * 自动识别标准或 URL 安全 Base64，解码为原始字节
     */
    public static byte[] decode(String b64) {
        if (b64 == null || b64.isEmpty()) return new byte[0];
        // 去除空白
        String s = b64.trim().replaceAll("\\s", "");
        int len = s.length();
        if ((len & 3) != 0) {
            throw new Base64Exception("Base64 长度非 4 的倍数: " + len);
        }
        // 计算填充数量
        int pad = 0;
        if (len > 0 && s.charAt(len - 1) == '=') pad++;
        if (len > 1 && s.charAt(len - 2) == '=') pad++;
        int outLen = (len * 3) / 4 - pad;
        byte[] out = new byte[outLen];
        int outIdx = 0;
        int inIdx = 0;
        // 主循环，每次处理 4 字符
        for (int i = 0; i < len; i += 4) {
            int c0 = charToValue(s.charAt(i));
            int c1 = charToValue(s.charAt(i+1));
            int c2 = charToValue(s.charAt(i+2));
            int c3 = charToValue(s.charAt(i+3));
            int triple = (c0 << 18) | (c1 << 12) | (c2 << 6) | c3;
            if (outIdx < outLen) out[outIdx++] = (byte)(triple >> 16);
            if (outIdx < outLen) out[outIdx++] = (byte)(triple >> 8);
            if (outIdx < outLen) out[outIdx++] = (byte)triple;
        }
        return out;
    }
 
    private static int charToValue(char c) {
        if (c >= DEC.length || DEC[c] < 0) {
            throw new Base64Exception("非法 Base64 字符: " + c);
        }
        return DEC[c];
    }
}
 
// ==================== 文件：TestBase64Util.java ====================
package com.example.base64;
 
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
 
/**
 * JUnit 单元测试：验证 Base64 编解码功能
 */
public class TestBase64Util {
 
    @Test
    public void testStandardEncodeDecode() {
        String text = "Hello, 世界!";
        byte[] raw = text.getBytes(java.nio.charset.StandardCharsets.UTF_8);
        String enc = Base64Util.encode(raw);
        byte[] dec = Base64Util.decode(enc);
        Assertions.assertEquals(text, new String(dec, java.nio.charset.StandardCharsets.UTF_8));
    }
 
    @Test
    public void testUrlSafe() {
        String text = "abc+/";
        byte[] raw = text.getBytes(java.nio.charset.StandardCharsets.UTF_8);
        String encUrl = Base64Util.encodeUrlSafe(raw);
        Assertions.assertFalse(encUrl.contains("+") || encUrl.contains("/"));
        byte[] dec = Base64Util.decode(encUrl);
        Assertions.assertEquals(text, new String(dec, java.nio.charset.StandardCharsets.UTF_8));
    }
 
    @Test
    public void testEmpty() {
        Assertions.assertArrayEquals(new byte[0], Base64Util.decode(""));
        Assertions.assertEquals("", Base64Util.encode(new byte[0]));
    }
 
    @Test
    public void testInvalid() {
        Assertions.assertThrows(Base64Exception.class, () -> Base64Util.decode("abcd*"));
        Assertions.assertThrows(Base64Exception.class, () -> Base64Util.decode("abc"));
    }
}