BASE64加密算法的java实现

最新推荐文章于 2025-07-13 13:49:42 发布
转载 最新推荐文章于 2025-07-13 13:49:42 发布 · 352 阅读 · 0

本文详细介绍了Base64编码解码的基本原理，包括编码和解码规则，并提供了Java实现示例。此外还展示了如何使用Apache Commons Codec库简化Base64操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转载自： https://blog.youkuaiyun.com/zyhlwzy/article/details/77964763

Base64加密算法编码规则

Base64编码的思想是采用64个基本的ASCII码字符对数据进行重新编码。他将需要编码的数据拆分成字节数组，以三个字节为一组。按顺序排列24位数据，再把这24位数据分成四组，即每组6位。再在每组的最高位前补两个0凑足一个字节。这样就把一个3字节为一组的数据重新编码成了4个字节。当所要编码的数据的字节数不是3的整数倍，也就是说在分组时最后一组不足3个字节。这时在最后一组填充1到2个0字节。并在最后编码完成后在结尾添加1到2个‘=’。

例如：将RON进行Base64编码：

首先取RON对应的ASCII码值：R(82)O(79)N(78)；
再取二进制值：R(01010010)O(01001111)N(01001110)；
然后把这三个字节的二进制码接起来（010100100100111101001110）；
再以6位为单位分成4个数据块,并在最高位填充两个0后形成4个字节的编码后的值，(00010100)(00100100)(00111101)(00001110)；
再把这四个字节转换为10进制数据得到：(20)(36)(61)(14)，这里算出来的值实际上是数据在字符表中的索引。
最后根据BASE64给出的64个基本字符表，查出对应的ASCII码字符：(U)(k)(9)(O)。

注：BASE64字符表：ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=

Base64加密算法解码规则

解码过程就是把4个字节再还原成3个字节再根据不同的数据形式把字节数组重新整理成数据。

例如：将Uk9O解码

首先取Uk9O在编码表中的索引：U(20)k(36)9(61)O(14)；
再取二进制值：U(00010100)k(00100100)9(00111101)O(00001110)；
然后将四个字节的二进制码高位两个0去掉然后拼接起来：（010100100100111101001110）
再以8位为单位分成3个数据块：(01010010)(01001111)(01001110);
再把3个字节转换为10进制数据得到：(82)(79)(78)，得到的十进制数据即为字符的ASCII码。
根据ASCII码查出字符：RON，这里是ASCII码表中的实际字符，并非我们定义的由65个字符组成的编码表。

Base64编码解码java实现

package ron.blog.blog_common.custom;

/**

  • @Comment 自定义实现BASE64编码和解码

  • @Author Ron

  • @Date 2017年9月13日 上午9:53:39

  • @return
    */
    public class CustomBase64 {

    /**

    • 编码表
      */
      private static final byte[] encodingTable = {
      (byte) ‘A’, (byte) ‘B’, (byte) ‘C’, (byte) ‘D’, (byte) ‘E’, (byte) ‘F’, (byte) ‘G’, (byte) ‘H’, (byte) ‘I’, (byte) ‘J’,
      (byte) ‘K’, (byte) ‘L’, (byte) ‘M’, (byte) ‘N’, (byte) ‘O’, (byte) ‘P’, (byte) ‘Q’, (byte) ‘R’, (byte) ‘S’, (byte) ‘T’,
      (byte) ‘U’, (byte) ‘V’, (byte) ‘W’, (byte) ‘X’, (byte) ‘Y’, (byte) ‘Z’, (byte) ‘a’, (byte) ‘b’, (byte) ‘c’, (byte) ‘d’,
      (byte) ‘e’, (byte) ‘f’, (byte) ‘g’, (byte) ‘h’, (byte) ‘i’, (byte) ‘j’, (byte) ‘k’, (byte) ‘l’, (byte) ‘m’, (byte) ‘n’,
      (byte) ‘o’, (byte) ‘p’, (byte) ‘q’, (byte) ‘r’, (byte) ‘s’, (byte) ‘t’, (byte) ‘u’, (byte) ‘v’, (byte) ‘w’, (byte) ‘x’,
      (byte) ‘y’, (byte) ‘z’, (byte) ‘0’, (byte) ‘1’, (byte) ‘2’, (byte) ‘3’, (byte) ‘4’, (byte) ‘5’, (byte) ‘6’, (byte) ‘7’,
      (byte) ‘8’, (byte) ‘9’, (byte) ‘+’, (byte) ‘/’, (byte) ‘=’
      };

    /**

    • 解码表
      */
      private static final byte[] decodingTable;

    static {
    decodingTable = new byte[128];
    for (int i = 0; i < encodingTable.length; i++) {
    decodingTable[encodingTable[i]] = (byte) i;
    }
    }

    /**

    • @Comment BASE64编码
    • @Author Ron
    • @Date 2017年9月13日 上午9:56:02
    • @return
      /
      public static byte[] encode(byte[] data) {
      byte[] bytes;
      int modulus = data.length % 3;
      if (modulus == 0) {
      bytes = new byte[(4 * data.length) / 3];
      } else {
      bytes = new byte[4 * ((data.length / 3) + 1)];
      }
      int dataLength = (data.length - modulus);
      int a1;
      int a2;
      int a3;
      for (int i = 0, j = 0; i < dataLength; i += 3, j += 4) {
      a1 = data[i] & 0xff;
      a2 = data[i + 1] & 0xff;
      a3 = data[i + 2] & 0xff;
      bytes[j] = encodingTable[(a1 >>> 2) & 0x3f];
      bytes[j + 1] = encodingTable[((a1 << 4) | (a2 >>> 4)) & 0x3f];
      bytes[j + 2] = encodingTable[((a2 << 2) | (a3 >>> 6)) & 0x3f];
      bytes[j + 3] = encodingTable[a3 & 0x3f];
      }
      int b1;
      int b2;
      int b3;
      int d1;
      int d2;
      switch (modulus) {
      case 0: /       nothing left to do */
      break;
      case 1:
      d1 = data[data.length - 1] & 0xff;
      b1 = (d1 >>> 2) & 0x3f;
      b2 = (d1 << 4) & 0x3f;
      bytes[bytes.length - 4] = encodingTable[b1];
      bytes[bytes.length - 3] = encodingTable[b2];
      bytes[bytes.length - 2] = (byte) ‘=’;
      bytes[bytes.length - 1] = (byte) ‘=’;
      break;
      case 2:
      d1 = data[data.length - 2] & 0xff;
      d2 = data[data.length - 1] & 0xff;
      b1 = (d1 >>> 2) & 0x3f;
      b2 = ((d1 << 4) | (d2 >>> 4)) & 0x3f;
      b3 = (d2 << 2) & 0x3f;
      bytes[bytes.length - 4] = encodingTable[b1];
      bytes[bytes.length - 3] = encodingTable[b2];
      bytes[bytes.length - 2] = encodingTable[b3];
      bytes[bytes.length - 1] = (byte) ‘=’;
      break;
      }
      return bytes;
      }

    public static byte[] decode(byte[] data) {
    byte[] bytes;
    byte b1;
    byte b2;
    byte b3;
    byte b4;
    data = discardNonBase64Bytes(data);
    if (data[data.length - 2] == ‘=’) {
    bytes = new byte[(((data.length / 4) - 1) * 3) + 1];
    } else if (data[data.length - 1] == ‘=’) {
    bytes = new byte[(((data.length / 4) - 1) * 3) + 2];
    } else {
    bytes = new byte[((data.length / 4) * 3)];
    }
    for (int i = 0, j = 0; i < (data.length - 4); i += 4, j += 3) {
    b1 = decodingTable[data[i]];
    b2 = decodingTable[data[i + 1]];
    b3 = decodingTable[data[i + 2]];
    b4 = decodingTable[data[i + 3]];
    bytes[j] = (byte) ((b1 << 2) | (b2 >> 4));
    bytes[j + 1] = (byte) ((b2 << 4) | (b3 >> 2));
    bytes[j + 2] = (byte) ((b3 << 6) | b4);
    }
    if (data[data.length - 2] == ‘=’) {
    b1 = decodingTable[data[data.length - 4]];
    b2 = decodingTable[data[data.length - 3]];
    bytes[bytes.length - 1] = (byte) ((b1 << 2) | (b2 >> 4));
    } else if (data[data.length - 1] == ‘=’) {
    b1 = decodingTable[data[data.length - 4]];
    b2 = decodingTable[data[data.length - 3]];
    b3 = decodingTable[data[data.length - 2]];
    bytes[bytes.length - 2] = (byte) ((b1 << 2) | (b2 >> 4));
    bytes[bytes.length - 1] = (byte) ((b2 << 4) | (b3 >> 2));
    } else {
    b1 = decodingTable[data[data.length - 4]];
    b2 = decodingTable[data[data.length - 3]];
    b3 = decodingTable[data[data.length - 2]];
    b4 = decodingTable[data[data.length - 1]];
    bytes[bytes.length - 3] = (byte) ((b1 << 2) | (b2 >> 4));
    bytes[bytes.length - 2] = (byte) ((b2 << 4) | (b3 >> 2));
    bytes[bytes.length - 1] = (byte) ((b3 << 6) | b4);
    }
    return bytes;
    }

    public static byte[] decode(String data) {
    byte[] bytes;
    byte b1;
    byte b2;
    byte b3;
    byte b4;
    data = discardNonBase64Chars(data);
    if (data.charAt(data.length() - 2) == ‘=’) {
    bytes = new byte[(((data.length() / 4) - 1) * 3) + 1];
    } else if (data.charAt(data.length() - 1) == ‘=’) {
    bytes = new byte[(((data.length() / 4) - 1) * 3) + 2];
    } else {
    bytes = new byte[((data.length() / 4) * 3)];
    }
    for (int i = 0, j = 0; i < (data.length() - 4); i += 4, j += 3) {
    b1 = decodingTable[data.charAt(i)];
    b2 = decodingTable[data.charAt(i + 1)];
    b3 = decodingTable[data.charAt(i + 2)];
    b4 = decodingTable[data.charAt(i + 3)];
    bytes[j] = (byte) ((b1 << 2) | (b2 >> 4));
    bytes[j + 1] = (byte) ((b2 << 4) | (b3 >> 2));
    bytes[j + 2] = (byte) ((b3 << 6) | b4);
    }
    if (data.charAt(data.length() - 2) == ‘=’) {
    b1 = decodingTable[data.charAt(data.length() - 4)];
    b2 = decodingTable[data.charAt(data.length() - 3)];
    bytes[bytes.length - 1] = (byte) ((b1 << 2) | (b2 >> 4));
    } else if (data.charAt(data.length() - 1) == ‘=’) {
    b1 = decodingTable[data.charAt(data.length() - 4)];
    b2 = decodingTable[data.charAt(data.length() - 3)];
    b3 = decodingTable[data.charAt(data.length() - 2)];
    bytes[bytes.length - 2] = (byte) ((b1 << 2) | (b2 >> 4));
    bytes[bytes.length - 1] = (byte) ((b2 << 4) | (b3 >> 2));
    } else {
    b1 = decodingTable[data.charAt(data.length() - 4)];
    b2 = decodingTable[data.charAt(data.length() - 3)];
    b3 = decodingTable[data.charAt(data.length() - 2)];
    b4 = decodingTable[data.charAt(data.length() - 1)];
    bytes[bytes.length - 3] = (byte) ((b1 << 2) | (b2 >> 4));
    bytes[bytes.length - 2] = (byte) ((b2 << 4) | (b3 >> 2));
    bytes[bytes.length - 1] = (byte) ((b3 << 6) | b4);
    }
    return bytes;
    }

    private static byte[] discardNonBase64Bytes(byte[] data) {
    byte[] temp = new byte[data.length];
    int bytesCopied = 0;
    for (int i = 0; i < data.length; i++) {
    if (isValidBase64Byte(data[i])) {
    temp[bytesCopied++] = data[i];
    }
    }
    byte[] newData = new byte[bytesCopied];
    System.arraycopy(temp, 0, newData, 0, bytesCopied);
    return newData;
    }

    private static String discardNonBase64Chars(String data) {
    StringBuffer sb = new StringBuffer();
    int length = data.length();
    for (int i = 0; i < length; i++) {
    if (isValidBase64Byte((byte) (data.charAt(i)))) {
    sb.append(data.charAt(i));
    }
    }
    return sb.toString();
    }

    private static boolean isValidBase64Byte(byte b) {
    if (b == ‘=’) {
    return true;
    } else if ((b < 0) || (b >= 128)) {
    return false;
    } else if (decodingTable[b] == -1) {
    return false;
    }
    return true;
    }

    public static void main(String[] args) {
    String codeStr = “RON”;
    byte[] codeByteArr = codeStr.getBytes();
    byte[] encodeByteArr = CustomBase64.encode(codeByteArr);
    String encodeStr = new String(encodeByteArr);
    byte[] decodeByteArr = CustomBase64.decode(encodeByteArr);
    String decodeStr = new String(decodeByteArr);
    System.out.println(“Source:” + codeStr);
    System.out.println(“自己实现编码:” + encodeStr);
    System.out.println(“自己实现解码:” + decodeStr);
    }
    }

以上仅仅只是根据算法的实现原理，我们对Base64编码解码做了一个简单的实现。但是在实际的应用过程中，我们并不用关心具体的实现方案，我们直接引入org.apache.commons.codec.binary.Base64包，调用已经实现的编码解码方法即可。

/**

  • @Comment Base64解码
  • @Author Ron
  • @Date 2017年9月12日 下午4:45:19
  • @return
    */
    public static byte[] decryptBASE64(String key) {
    return Base64.decodeBase64(key);
    }

/**

  • @Comment Base64编码
  • @Author Ron
  • @Date 2017年9月12日 下午4:47:55
  • @return
    */
    public static String encryptBASE64(byte[] bytes) {
    return Base64.encodeBase64String(bytes);
    }
利用Base64加密算法将数据加密解密
2302_80372340的博客
03-23 3934
Base64准确来说并不像是一种加密算法，而更像是一种编码标准。我们知道现在最为流行的编码标准就是ASCLL，它用八个二进制位（一个char的大小）表示了127个字符，任何二进制序列都可以用这127个字符表示出来。而Base64则是用6个二进制位表示了64个字符，也就是说，任何的二进制序列也都可以用这64个字符表示出来，这也是其名称的来源。我们加密的方法，就是将原来的信息以ACSLL的标准转化为二进制序列（如果不是6的倍数，就用0补齐），然后按照Base64的标准，将其转化为该标准下的字符。
16位或32位密钥的AES-128 + BASE64加密算法 java实现
人真正变得强大，不是因为守护着自尊心，而是抛开自尊心的时候。
04-07 4946
此次算法支持16位密钥和32位密钥加密，需要更新加密包， 不清楚的请查看另一篇文章，在此不再赘述 如果只需要看AES128加密则只需要下面这个方法就可以了 /** * AES128加密 * @param src 加密原串 * @param key 密钥 * @return */ public static String aesEncrypt(String src, String key) { try{ if (key == null || key.equals(""))
5、Base64加密算法
Ron.Zheng
09-13 4247
Base64加密算法编码规则Base64编码的思想是采用64个基本的ASCII码字符对数据进行重新编码。他将需要编码的数据拆分成字节数组，以三个字节为一组。按顺序排列24位数据，再把这24位数据分成四组，即每组6位。再在每组的最高位前补两个0凑足一个字节。这样就把一个3字节为一组的数据重新编码成了4个字节。当所要编码的数据的字节数不是3的整数倍，也就是说在分组时最后一组不足3个字节。这时在最后一组填
掌握Base64编码：原理与Java实现
最新发布
weixin_42596214的博客
07-13 260
尽管Java内置和第三方库提供了实现Base64编码器和解码器的工具，但在某些情况下，开发者可能需要自定义实现。一个常见的自定义编码器的需求是扩展Base64的字符集，例如，当默认的64个字符不能满足特定需求时。以下是一个简化的Base64编码器实现，我们创建一个简单的类来处理编码逻辑：int i = 0;j >= 0;j >= 6;j -= 6) {
Android数据加密之Base64编码算法
09-21 312
前言： 前面学习总结了平时开发中遇见的各种数据加密方式，最终都会对加密后的二进制数据进行Base64编码，起到一种二次加密的效果，其实呢Base64从严格意义上来说的话不是一种加密算法，而是一种编码算法，为何要使用Base64编码呢？它解决了什么问题？这也是本文探讨的东西？ 其他几种加密方式： Android数据加密之Rsa加密 Androi...
如何对数据进行Base64编码（转载）
64M便当的专栏
08-22 1788
                            浅谈Base64编码来源：CSTC 作者：朱岩 我打赌当你见到Base64这个词的时候你会觉得在哪里见过，因为在你能够上网看到这篇文章的时候你已经在后台使用它了。如果您对二进制数有所了解，你就可以开始读它了。打开一封Email，查看其原始信息（您可以通过收取、导出该邮件用文本编辑器查看）。你会看到类似这样的一个效果： Date: Thu, 2
Java实现Base64算法
funcy的专栏
07-10 4262
Base64是一种基于64个字符的编码算法，经过Base64编码的数据会比原始数据略长，为原来长度的4/3倍。Base64算法中，等号用来补位。 URLBase64算法主要是将"+"和"/"替换成了"-"和"_"符号，对于补符"="，一种建议是使用"."符号，另一种是建议使用"~"。 Base64算法并不能叫做加密算法，充当密钥的字符映射表公开，直接违反了柯克霍夫原则，且Base64算法的加密
Java实现的Base64加密算法示例
08-27
Java语言提供了多种实现Base64加密算法的方式，本文将详细介绍Java实现的Base64加密算法的示例，包括JDK、Commons Codec和Bouncy Castle等实现方式。 Base64加密算法的特点是使用64个可打印字符来表示二进制数据，...
java实现Base64加密解密算法
09-02
在Java中实现Base64编码解码的方法相对简单，可以利用Java标准库中的类，如`java.util.Base64`，或者第三方库，如Apache Commons Codec，以及文章中提及的`sun.misc.BASE64Encoder`和`sun.misc.BASE64Decoder`。...
java使用Base64实现文件加密解密
08-26
下面详细解释一下Java使用Base64实现文件加密解密的过程和代码含义： 1. 文件到Base64编码字符串的转换： 文件被读取为字节数组后，可以使用BASE64Encoder类的encode方法将字节数组转换为Base64编码的字符串。这个...
Base64加密算法java版
09-18
Base64加密算法java版
Base64 加密算法
12-27
算法类base64 的操作 字符串的加密技术，算法类base64 的操作 字符串的加密技术 as 版本
Base64加密算法C语言代码实现
09-26
配套文章解析：https://blog.youkuaiyun.com/u013469753/article/details/108320098 Base64编码的核心原理是将二进制数据进行分组，每24Bit(3字节)为一个大组，再把一个大组的数据分成4个6Bit的小分组。由于6Bit数据只能表示64个不同的字符(2^6=64)，所以这也是Base64的名字由来。
base64加密方式
11-28
base64的加密方法，直接放入项目中即可引用，注意传入加密参数
加密算法-BASE64
MonKee的博客
02-28 1628
基本的单向加密算法： 1.BASE64 ——严格地说，属于编码格式，而非加密算法 2.MD5——Message Digest algorithm 5，信息摘要算法 3.SHA——Secure Hash Algorithm，安全散列算法 4.HMAC——Hash Message Authentication Code，散列消息鉴别码         MD5、SHA、H
base64加密算法
火火火
06-27 139
package com.dream.util; import org.apache.commons.codec.binary.Base64; import sun.misc.BASE64Decoder; import sun.misc.BASE64Encoder; import junit.framework.TestCase; /** * @author zxg * ba...
Base64加密算法
sunny_sailor的专栏
04-17 654
import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.OutputStream; public class Base64 {       private static final char[] legalChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZa
Base64加密算法(一)
xiaofengtoo的专栏
08-06 269
Base64加密算法 原理：       Base64 使用US-ASCII子集的64个字符,即大小写的26个英文字母，0－9，＋，/。编码总是基于3个字符，每个字符用8位二进制表示，因此一共24位，再分为4四组，每组6位，表示一个Base64的值。如下："A", "B", "C", "D", "E", "F", "G", &q
Java实现Base64加密算法源码解析
"这篇PDF文档主要讲解了Java...这个Java版的Base64实现包含了完整的编码和解码功能，适用于对二进制数据进行Base64的转换。通过阅读和理解这段源码，开发者可以更好地掌握Base64的工作原理，并将其应用到实际项目中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值