Base64编码

最新推荐文章于 2024-11-29 12:10:31 发布
原创 最新推荐文章于 2024-11-29 12:10:31 发布 · 475 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了Base64编码及其在不同场景的应用，提供了Java和JavaScript实现的编码与解码代码，同时解释了其在HTTP环境下传递标识信息的作用。

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

Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，大家可以查看RFC2045～RFC2049，上面有MIME的详细规范。Base64编码可用于在HTTP环境下传递较长的标识信息。例如，在Java Persistence系统Hibernate中，就采用了Base64来将一个较长的唯一标识符（一般为128-bit的UUID）编码为一个字符串，用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base64编码不仅比较简短，同时也具有不可读性，即所编码的数据不会被人用肉眼所直接看到。

下面代码则为java和jsBase64代码转化代码，以备不时之需：

public class Base64 {
    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) '/'
        };
    private static final byte[] decodingTable;
    static {
        decodingTable = new byte[128];
        for (int i = 0; i < 128; i++) {
            decodingTable[i] = (byte) -1;
        }
        for (int i = 'A'; i <= 'Z'; i++) {
            decodingTable[i] = (byte) (i - 'A');
        }
        for (int i = 'a'; i <= 'z'; i++) {
            decodingTable[i] = (byte) (i - 'a' + 26);
        }
        for (int i = '0'; i <= '9'; i++) {
            decodingTable[i] = (byte) (i - '0' + 52);
        }
        decodingTable['+'] = 62;
        decodingTable['/'] = 63;
    }
    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) throws Exception{
        String data = "select 用户名 from 用户";
        byte[] result = Base64.encode(data.getBytes("utf-8"));
        System.out.println(data);
        System.out.println(new String(result));
        System.out.println(new String(Base64.decode(new String(result))));
    }
}


 

JS:

<script type="text/javascript">
<!--
var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
//将Ansi编码的字符串进行Base64编码
function encode64(input) {
	var output = "";
	var chr1, chr2, chr3 = "";
	var enc1, enc2, enc3, enc4 = "";
	var i = 0;
	do {
		chr1 = input.charCodeAt(i++);
		chr2 = input.charCodeAt(i++);
		chr3 = input.charCodeAt(i++);
		enc1 = chr1 >> 2;
		enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
		enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
		enc4 = chr3 & 63;
		if (isNaN(chr2)) {
			enc3 = enc4 = 64;
		} else if (isNaN(chr3)) {
			enc4 = 64;
		}
		output = output + keyStr.charAt(enc1) + keyStr.charAt(enc2)
				+ keyStr.charAt(enc3) + keyStr.charAt(enc4);
		chr1 = chr2 = chr3 = "";
		enc1 = enc2 = enc3 = enc4 = "";
	} while (i < input.length);
	return output;
}
//将Base64编码字符串转换成Ansi编码的字符串
function decode64(input) {
	var output = "";
	var chr1, chr2, chr3 = "";
	var enc1, enc2, enc3, enc4 = "";
	var i = 0;

	if (input.length % 4 != 0) {
		return "";
	}
	var base64test = /[^A-Za-z0-9\+\/\=]/g;
	if (base64test.exec(input)) {
		return "";
	}
	do {
		enc1 = keyStr.indexOf(input.charAt(i++));
		enc2 = keyStr.indexOf(input.charAt(i++));
		enc3 = keyStr.indexOf(input.charAt(i++));
		enc4 = keyStr.indexOf(input.charAt(i++));
		chr1 = (enc1 << 2) | (enc2 >> 4);
		chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
		chr3 = ((enc3 & 3) << 6) | enc4;

		output = output + String.fromCharCode(chr1);
		if (enc3 != 64) {
			output += String.fromCharCode(chr2);
		}
		if (enc4 != 64) {
			output += String.fromCharCode(chr3);
		}
		chr1 = chr2 = chr3 = "";
		enc1 = enc2 = enc3 = enc4 = "";
	} while (i < input.length);
	return output;
}

function utf16to8(str) {
  var out, i, len, c;

  out = "";
  len = str.length;
  for(i = 0; i < len; i++) {
    c = str.charCodeAt(i);
    if ((c >= 0x0001) && (c <= 0x007F)) {
      out += str.charAt(i);
    } else if (c > 0x07FF) {
      out += String.fromCharCode(0xE0 | ((c >> 12) & 0x0F));
      out += String.fromCharCode(0x80 | ((c >>  6) & 0x3F));
      out += String.fromCharCode(0x80 | ((c >>  0) & 0x3F));
    } else {
      out += String.fromCharCode(0xC0 | ((c >>  6) & 0x1F));
      out += String.fromCharCode(0x80 | ((c >>  0) & 0x3F));
    }
  }
  return out;
}

function utf8to16(str) {
  var out, i, len, c;
  var char2, char3;

  out = "";
  len = str.length;
  i = 0;
  while(i < len) {
    c = str.charCodeAt(i++);
    switch(c >> 4) {
      case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
        // 0xxxxxxx
        out += str.charAt(i-1);
        break;
      case 12: case 13:
        // 110x xxxx   10xx xxxx
        char2 = str.charCodeAt(i++);
        out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
        break;
      case 14:
        // 1110 xxxx  10xx xxxx  10xx xxxx
        char2 = str.charCodeAt(i++);
        char3 = str.charCodeAt(i++);
        out += String.fromCharCode(((c & 0x0F) << 12) |
        ((char2 & 0x3F) << 6) |
        ((char3 & 0x3F) << 0));
        break;
    }
  }
  return out;
}

// 测试代码 开始
var de = encode64(utf16to8("select 用户名 from 用户"));
document.writeln(de+"<br>");
var ee = utf8to16(decode64(de))
document.writeln(ee);

</script>


 

Java 实现 Base64 加密&解密方法
JavaMonsterr的博客
06-04 3万+
Base64 编码是程序开发中比较常用的一种编码算法，是常用来存储或传输一些二进制数据的方法，也是 MIME（多用途互联网邮件扩展）中的一种编码方法 。Base64 可以实现将任何数据转换为可打印字符表示的字符串，避免数据在传输过程中失真，Base64 最开始用来在邮件发送中将非 ASCLL 字符内容转换为 ASCLL字符。标准 Base64 是一种用于传输 8Bit 字节码的编码方式之一，基于 64 个可打印字符来表示二进制数据，使用的可打印字符包括有：A-Z、a-z、0-9、+、/ 共 64 个。Url
base64
wanzzg的专栏
01-18 98
base64的java实现 public class BASE64 { private static final String TAG = "BASE64"; public static final byte[] encodingTable = { (byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', ...
java base64 编码 类_java版base64编码解码类
weixin_36145673的博客
02-13 178
较早的java版本没有直接提供base64编码处理的类，都是通过其他类库的附加功能实现。而对于android平台，又有自己的base64支持类， 导致代码影响跨平台。所以就自己写了个base64编码处理的类，这样就可以同一套代码运行在android平台和se平台了。packagecom.hoverlees.utils;/***@authorhoverleeshttp://www.hoverlees...
Base64编码类
A___B___C的博客
05-07 535
package com.rd.p2p.common.util.code;import java.io.IOException;import java.io.OutputStream;/** * &lt;p&gt; * Description:base64编码类 * &lt;/p&gt; */public class BASE64Encoder extends CharacterEncoder { ...
详解Java中的Base64原理跟用法
无聊的大鱼
06-20 1万+
简介 Base64编码，是我们程序开发中经常使用到的编码方法。它是一种基于用64个可打印字符来表示二进制数据的表示方法。它通常用作存储、传输一些二进制数据编码方法, 也是MIME（多用途互联网邮件扩展，主要用作电子邮件标准）中一种可打印字符表示二进制数据的常见编码方法。它其实只是定义用可打印字符传输内容一种方法，并不会产生新的字符集。严格来说Base64并不是一种加密/解密算法...
10.Java 常用类之其他常用类（Base64、Locale、ImageIO）
最新发布
weixin_52173250的博客
11-29 982
10.Java 常用类之其他常用类（Base64、Locale、ImageIO）
labview 图片缩放 base64编码base64解码
08-07
在这个特定的场景中，我们关注的是如何在LabVIEW中处理图片，包括图片的缩放、Base64编码和解码。 1. **图片缩放**： 在LabVIEW中，你可以使用图像处理库来实现图片的缩放功能。这个库提供了各种图像操作函数，...
Base64编码解码工具
04-05
Base64编码基于64个字符的字符集，这个字符集包括26个小写字母、26个大写字母、10个数字以及两个特殊字符“+”和“/”。每个64个字符代表一个6位的二进制数，这意味着每个64字符可以表示2^6 = 64种不同的值。由于...
微信小程序base64编码，解决传递中文乱码问题
10-08
微信小程序中的base64编码技术能够有效解决在数据传输过程中出现的中文乱码问题。在互联网通信中，中文字符常常因为编码不统一而导致接收端无法正确解析，尤其是在不同的操作系统或应用中。在微信小程序的开发过程中...
适用于批量将任意文件转为base64编码的工具.zip
01-10
在IT领域，Base64是一种常见的数据编码方法，它用于将二进制数据转换成ASCII字符串，以便在电子邮件系统或类似限制非ASCII字符的环境中传输。这个“适用于批量将任意文件转为base64编码的工具”正是针对这一需求而...
易语言 base64编码转图片 如何 提高转换速度.zip
09-30
在IT行业中，Base64编码是一种常见的数据编码方式，它将二进制数据转化为可打印的ASCII字符，常用于在网络上传输图片、音频或视频等非文本数据。易语言作为一款中国本土化的编程语言，提供了处理Base64编码的功能。...
Java8中的Base64工具使用
ifever的博客
07-06 3335
在之前的项目中因为使用了Base64编码，而导入了sun.misc.Base64Encoder这个包，每次在使用maven打包时控制台总输出警告：Base64Encoder这个API将会在未来的版本中移除。查阅资料后发现自Java9开始已经不支持这个API，应使用java.util.Base64这个包代替。...
Base64工具类（加密、解密）
Thancks
08-09 1万+
package com.yunerp.base.utils.base; import java.io.*; /** * Created by User on 2018/8/9. */ public class Base64Utils { public Base64Utils() { } /** * 功能：编码字符串 * * @aut...
Base64Utils加密，解密工具类
热门推荐
小敷的博客
05-29 1万+
写一个Base64Utils工具类： import org.springframework.util.Base64Utils; public class Base64Util { /** * BASE64解密 * * @param key * @return * @throws Exception */ publi...
Base64 四种方式的编码和解码
添砖加瓦
10-14 7714
base64与字符串String之间的相互转换 package com.wzq; import javax.xml.bind.DatatypeConverter; import java.io.UnsupportedEncodingException; import java.util.Base64; /** * @ClassName Base64Utils * @Descriptio...
Base64加密和解密
人生就像一场戏
06-11 625
import java.io.*; /** * @author liuminglin * @date 2021/6/11 17:59 * @description: TODO */ public class Base64 { private Base64() { } /** * 功能：加密字符串 * * @param data 源字符串 * @return String */ public static St..
python-数据传输和加密（json\hashlib\base64）
北冥有鱼的博客
10-29 2320
json Json（JavaScript Object Notation）是JavaScript对象表示法，是一种轻量级的文本数据交换格式，数据由键值对的形式组成，和python中字典一样，数据写在大括号中，每组键值对之间用逗号隔开，数组数据写在中括号中，字符串数据必须使用双引号，不能使用单引号。一个json对象为一个整体的字符型存在。 python和json中的数据类型 Python Json 字典 对象 列
Base64实现加密、解密
Share
07-02 2323
package zxBank.Controller; import java.io.UnsupportedEncodingException; import sun.misc.*; public class Base64 { // 加密 public static String getBase64(String str) { byte[]
Base64处理类
一线工作者的所见、所闻......
03-05 1万+
import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.OutputStream; import java.util.Hashtable; import org.apache.commons.codec.binary.Base64; i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值