本文介绍了如何实现自定义的Base64编码集，包括自动生成自定义Base64字符表、将数据编码为自定义Base64字符串以及解码自定义Base64字符串为原始数据等操作。通过Java后端实现，展示了自定义Base64编码字符表的生成、数据编码和解码过程。

image

实现自定义base64编码集

java后端实现

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class CustomBase64Encoder {
    public static void main(String[] args) {
        String data = "Hello, World!";

        // 自定义的Base64编码字符表
        String customBase64Chars =
//                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
                CustomBase64Encoder.generateRandomBase64Chars();
        System.out.println("customBase64Chars : " + customBase64Chars);

        // 将原始数据编码为自定义Base64字符串
        String encodedData = CustomBase64Encoder.encodeToCustomBase64(data.getBytes(StandardCharsets.UTF_8), customBase64Chars);
        System.out.println("Encoded data: " + encodedData);

        // 解码自定义Base64字符串为原始数据
        byte[] decodedData = CustomBase64Encoder.decodeFromCustomBase64(encodedData, customBase64Chars);
        String decodedString = new String(decodedData, StandardCharsets.UTF_8);
        System.out.println("Decoded data: " + decodedString);
    }

    public static String encodeToCustomBase64(byte[] dataBytes, String customBase64Chars) {
        StringBuilder encodedBuilder = new StringBuilder();

        int dataIndex = 0;
        int value = 0;
        int bitsRemaining = 0;

        for (byte dataByte : dataBytes) {
            value <<= 8;
            value |= dataByte & 0xFF;
            bitsRemaining += 8;

            while (bitsRemaining >= 6) {
                int index = (value >> (bitsRemaining - 6)) & 0x3F;
                encodedBuilder.append(customBase64Chars.charAt(index));
                bitsRemaining -= 6;
            }
        }

        // 处理剩余的数据和填充字符
        if (bitsRemaining > 0) {
            value <<= 6 - bitsRemaining;
            int index = (value & 0x3F);
            encodedBuilder.append(customBase64Chars.charAt(index));
        }

        int paddingCount = (encodedBuilder.length() % 4 == 0) ? 0 : (4 - encodedBuilder.length() % 4);
        for (int i = 0; i < paddingCount; i++) {
            encodedBuilder.append('=');
        }

        return encodedBuilder.toString();
    }

    public static String generateRandomBase64Chars() {
        List<Character> base64Chars = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            base64Chars.add((char) ('A' + i));
        }
        for (int i = 0; i < 26; i++) {
            base64Chars.add((char) ('a' + i));
        }
        for (int i = 0; i < 10; i++) {
            base64Chars.add((char) ('0' + i));
        }
        base64Chars.add('+');
        base64Chars.add('/');

        Collections.shuffle(base64Chars, new Random());

        StringBuilder builder = new StringBuilder();
        for (char c : base64Chars) {
            builder.append(c);
        }

        return builder.toString();
    }

    /**
     * 解码自定义Base64字符串
     * @param customBase64String  Base64字符串
     * @param customBase64Chars 自定义的Base64编码字符表
     * @return
     */
    public static byte[] decodeFromCustomBase64(String customBase64String, String customBase64Chars) {
        int length = customBase64String.length();
        int paddingCount = 0;

        // 计算原始数据长度
        if (customBase64String.charAt(length - 1) == '=') {
            paddingCount++;
            if (customBase64String.charAt(length - 2) == '=') {
                paddingCount++;
            }
        }
        int originalLength = (length * 6) / 8 - paddingCount;

        byte[] result = new byte[originalLength];
        int resultIndex = 0;
        int buffer = 0;
        int bufferLength = 0;

        // 解码自定义Base64字符串
        for (int i = 0; i < length; i++) {
            char c = customBase64String.charAt(i);
            int value = customBase64Chars.indexOf(c);

            // 忽略填充字符 '='
            if (value != -1) {
                buffer = (buffer << 6) | value;
                bufferLength += 6;

                while (bufferLength >= 8) {
                    result[resultIndex++] = (byte) ((buffer >> (bufferLength - 8)) & 0xFF);
                    bufferLength -= 8;
                }
            }
        }

        return result;
    }
}

js前端实现

function customBase64Encode(data, customBase64Chars) {
  // 使用标准的 Base64 编码器进行 Base64 编码
  var base64EncodedData = btoa(data);

  // 替换 Base64 编码字符为自定义字符
  var encodedData = replaceBase64Chars(base64EncodedData, customBase64Chars);

  return encodedData;
}
function customBase64Decode(data, customBase64Chars) {
  // 替换 Base64 编码字符为自定义字符
  var encodedData = backBase64Chars(data, customBase64Chars);
  // 使用标准的 Base64 编码器进行 Base64 解码
  var base64EncodedData = atob(encodedData);
  return base64EncodedData ;
}

function backBase64Chars(base64EncodedData, customBase64Chars) {
  var result = "";

  for (var i = 0; i < base64EncodedData.length; i++) {
    var index = customBase64Chars.indexOf(base64EncodedData.charAt(i));
    result += "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(index);
  }

  return result;
}
function replaceBase64Chars(base64EncodedData, customBase64Chars) {
  var result = "";

  for (var i = 0; i < base64EncodedData.length; i++) {
    var index = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".indexOf(base64EncodedData.charAt(i));
    result += customBase64Chars.charAt(index);
  }

  return result;
}
function generateRandomBase64Charset() {
  // 所有可能的Base64字符
  var base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

  // 随机打乱字符顺序
  var shuffledChars = shuffleArray(base64Chars.split('')).join('');

  // 自定义Base64编码字符集
  var customBase64Chars = shuffledChars.slice(0, 64);

  return customBase64Chars;
}

function shuffleArray(array) {
  var currentIndex = array.length;
  var temporaryValue, randomIndex;

  while (currentIndex !== 0) {
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;

    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }

  return array;
}






// 测试示例
var data = "Hello, World!";
// 生成随机的自定义Base64编码字符集
var customBase64Chars = generateRandomBase64Charset();
//var customBase64Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
console.log('Custom Base64 Charset:', customBase64Chars);
var encodedData = customBase64Encode(data, customBase64Chars);
console.log("Encoded data: " + encodedData);
// 解码自定义Base64字符串为原始数据
var  decodedData = customBase64Decode(encodedData, customBase64Chars);
console.log("Decoded data: " + decodedData);