Base65与QP编码

最新推荐文章于 2023-12-22 16:58:40 发布
最新推荐文章于 2023-12-22 16:58:40 发布
阅读量5.1k 收藏 1
点赞数
分类专栏： Java学习 文章标签： byte exception string buffer encoding hex
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laowantong06/article/details/2646300
版权
     最近学了一下MIME,里面有两种主要的编码方式,Base64和QP编码.现简单介绍一下这种编码规则.然后提供一段JAVA代码,用来解析和编码BASE64以及QB编码.    1.BASE64编码 href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_filelist.xml" rel="File-List" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_themedata.thmx" rel="themeData" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_colorschememapping.xml" rel="colorSchemeMapping" />

   按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把 任意序列的8位字节描述为一种不易被人直接识别的形式。（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）

   编码原理: href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_themedata.thmx" rel="themeData" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_colorschememapping.xml" rel="colorSchemeMapping" /> 将3个字节转换成4个字节( (3 X 8) = 24 = (4 X 6) )先读入3个字节,每读一个字节,左移8位,再右移四次,每次6位,这样就有4个字节了.

href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_filelist.xml" rel="File-List" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_themedata.thmx" rel="themeData" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_colorschememapping.xml" rel="colorSchemeMapping" />

   解码原理:将4个字节转换成3个字节. 先读入4个6位(用或运算),每次左移6位,再右移3次,每次8位.这样就还原了.

   编码规则: href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_filelist.xml" rel="File-List" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_themedata.thmx" rel="themeData" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_colorschememapping.xml" rel="colorSchemeMapping" /> 用“A…Za…z0…9+/”64个字符来表示6位长度的二进制数值，该数值从0至63依次对应从“A”至“/”的字符，编码时3个字节3个字节进行编码，每3个字节(24位)以最高两位补0的形式分成四个字节，这样每个字节的值刚好能与“A…Za…z0…9+/”64个字符一一对应，当最后没有三个字节时，编码后则用”=“号补足四个字节。BASE64编码每行不得超过76个字符(不包含最后的“/r/n”两个字符)，否则必须换行，换行方法是：在结尾处加上“/r/n ”.   2.QP编码 href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_filelist.xml" rel="File-List" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_themedata.thmx" rel="themeData" /> href="file:///C:/DOCUME~1/Billie/LOCALS~1/Temp/msohtmlclip1/01/clip_colorschememapping.xml" rel="colorSchemeMapping" />    规则 1 ：除了换行符，其它任何 8 位长度的字节必须被表示成一个“ = ”号加上高四位的十六进制数和低四位的十六进制数，十六进制数是用“ 0123456789ABCDEF ”的 ASCII 字符码表示，其中“ ABCDEF ”都必须是大写；    规则 2 ：当 8 位长度的字节值在 33 至 66( 包括 33 和 60) ， 62 至 126( 包括 62 和 126) 之间时，直接用该数据对应的 ASCII 码来表示；   规则 3 ：当 8 位长度的字节值是 9 和 32 时，用该数据对应的 ASCII 码 (9 ： TAB(HT) ， 32 ： SPACE) 来表示，但若是出现在行尾则必须按规则 1 进行转换 ;    规则 4 ：对于 CRLF 换行符必须用“ =0D= 0A ”来代替；    规则 5 ： QP 编码每行不得超过 76 个字符 ( 不包含最后的“ /r/n ”两个字符 ) ，否则必须换行，换行方法是：在结尾处加上“ =/r/n ”；    其它：符号“ - ”不用进行 QP 编码，所以不要用“ - ”符号来表示实体之间的分界，最好用“ =_”来代替，对于“!”#$[/]^’{|}~”这些字符必须按规则1进行转换.

在网上找了不少介绍,现在给代码了.代码中使用的字符集是UTF-8,可根据需要去修改.代码是根据Apache一个开源包里的代码修改的. 
package test;



import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.util.BitSet;



/**

 * @author Bill

 * @version Date：Jul 11, 2008 9:28:07 AM

 *          <p>

 *          Encode an decode for base64 and qb

 */

public class CodeConversion {

	private static final String CHARSET_UTF8 = "UTF-8";

	private static final String CHARSET_ASCII = "US-ASCII";

	private static final byte ESCAPE_CHAR = '=';

	private static final BitSet PRINTABLE_CHARS = new BitSet(256);

	private static byte TAB = 9;

	private static byte SPACE = 32;



	static final int CHUNK_SIZE = 76;



	/**

	 * Chunk separator per RFC 2045 section 2.1.

	 * 

	 * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 2.1</a>

	 */

	static final byte[] CHUNK_SEPARATOR = "/r/n".getBytes();



	/**

	 * The base length.

	 */

	static final int BASELENGTH = 255;



	/**

	 * Lookup length.

	 */

	static final int LOOKUPLENGTH = 64;



	/**

	 * Used to calculate the number of bits in a byte.

	 */

	static final int EIGHTBIT = 8;



	/**

	 * Used when encoding something which has fewer than 24 bits.

	 */

	static final int SIXTEENBIT = 16;



	/**

	 * Used to determine how many bits data contains.

	 */

	static final int TWENTYFOURBITGROUP = 24;



	/**

	 * Used to get the number of Quadruples.

	 */

	static final int FOURBYTE = 4;



	/**

	 * Used to test the sign of a byte.

	 */

	static final int SIGN = -128;



	// Create arrays to hold the base64 characters and a

	// lookup for base64 chars

	private static byte[] base64Alphabet = new byte[BASELENGTH];

	private static byte[] lookUpBase64Alphabet = new byte[LOOKUPLENGTH];



	// Populating the lookup and character arrays

	static {

		for (int i = 0; i < BASELENGTH; i++) {

			base64Alphabet[i] = (byte) -1;

		}

		for (int i = 'Z'; i >= 'A'; i--) {

			base64Alphabet[i] = (byte) (i - 'A');

		}

		for (int i = 'z'; i >= 'a'; i--) {

			base64Alphabet[i] = (byte) (i - 'a' + 26);

		}

		for (int i = '9'; i >= '0'; i--) {

			base64Alphabet[i] = (byte) (i - '0' + 52);

		}



		base64Alphabet['+'] = 62;

		base64Alphabet['/'] = 63;



		for (int i = 0; i <= 25; i++) {

			lookUpBase64Alphabet[i] = (byte) ('A' + i);

		}



		for (int i = 26, j = 0; i <= 51; i++, j++) {

			lookUpBase64Alphabet[i] = (byte) ('a' + j);

		}



		for (int i = 52, j = 0; i <= 61; i++, j++) {

			lookUpBase64Alphabet[i] = (byte) ('0' + j);

		}



		lookUpBase64Alphabet[62] = (byte) '+';

		lookUpBase64Alphabet[63] = (byte) '/';

	}



	static {

		for (int i = 33; i <= 60; i++) {

			PRINTABLE_CHARS.set(i);

		}

		for (int i = 62; i <= 126; i++) {

			PRINTABLE_CHARS.set(i);

		}

		PRINTABLE_CHARS.set(TAB);

		PRINTABLE_CHARS.set(SPACE);

	}



	public CodeConversion() {



	}



	/**

	 * Convert a String to QP code

	 * 

	 * @param qStr

	 * @return

	 * @throws Exception

	 */

	public static String encodeQP(String str) throws Exception {

		int count = 0;

		if (str == null) {

			return null;

		}

		byte[] bytes = str.getBytes(CHARSET_UTF8);

		ByteArrayOutputStream buffer = new ByteArrayOutputStream();

		for (int i = 0; i < bytes.length; i++) {

			int b = bytes[i];

			if (b < 0) {

				b = 256 + b;

			}

			count++;

			if (PRINTABLE_CHARS.get(b)) {

				if (count == 76) {

					count = 0;

					count++;

					buffer.write(ESCAPE_CHAR);

					buffer.write(CHUNK_SEPARATOR);

				}

				buffer.write(b);

			} else {

				count = encodeQuotedPrintable(b, buffer, count);

			}

		}



		return new String(buffer.toByteArray(), CHARSET_ASCII);

	}



	/**

	 * Encodes byte into its quoted-printable representation.

	 * 

	 * @param b

	 * @param buffer

	 * @throws IOException

	 */

	private static final int encodeQuotedPrintable(int b,

			ByteArrayOutputStream buffer, int count) throws IOException {

		if (count == 76) {

			count = 0;

			count++;

			buffer.write(ESCAPE_CHAR);

			buffer.write(CHUNK_SEPARATOR);

		}

		buffer.write(ESCAPE_CHAR);

		char hex1 = Character.toUpperCase(Character

				.forDigit((b >> 4) & 0xF, 16));

		char hex2 = Character.toUpperCase(Character.forDigit(b & 0xF, 16));

		count++;

		if (count == 76) {

			count = 0;

			count++;

			buffer.write(ESCAPE_CHAR);

			buffer.write(CHUNK_SEPARATOR);



		}

		buffer.write(hex1);

		count++;

		if (count == 76) {

			count = 0;

			count++;

			buffer.write(ESCAPE_CHAR);

			buffer.write(CHUNK_SEPARATOR);



		}

		buffer.write(hex2);

		return count;

	}



	/**

	 * Convert a qp string to a normal string

	 * 

	 * @param qpStr

	 * @return

	 * @throws Exception

	 */

	public static String decodeQP(String qpStr) throws Exception {

		if (qpStr == null) {

			return null;

		}

		qpStr = qpStr.replaceAll("=/r/n", "");

		byte[] bytes = qpStr.getBytes(CHARSET_ASCII);

		ByteArrayOutputStream buffer = new ByteArrayOutputStream();

		for (int i = 0; i < bytes.length; i++) {

			int b = bytes[i];

			if (b == ESCAPE_CHAR) {

				try {

					int u = Character.digit((char) bytes[++i], 16);

					int l = Character.digit((char) bytes[++i], 16);

					if (u == -1 || l == -1) {

						throw new Exception("Invalid quoted-printable encoding");

					}

					buffer.write((char) ((u << 4) + l));

				} catch (ArrayIndexOutOfBoundsException e) {

					throw new Exception("Invalid quoted-printable encoding");

				}

			} else {

				buffer.write(b);

			}

		}



		return new String(buffer.toByteArray(), CHARSET_UTF8);

	}



	/**

	 * Convert a normal string to Base64 code format string

	 * 

	 * @param str

	 * @return

	 */

	public static String encodeBase64(String str) throws Exception {

		byte[] binaryData = str.getBytes(CHARSET_UTF8);

		int lengthDataBits = binaryData.length * EIGHTBIT;

		int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;

		int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;

		byte encodedData[] = null;

		int encodedDataLength = 0;

		int nbrChunks = 0;



		if (fewerThan24bits != 0) {

			// data not divisible by 24 bit

			encodedDataLength = (numberTriplets + 1) * 4;

		} else {

			// 16 or 8 bit

			encodedDataLength = numberTriplets * 4;

		}



		nbrChunks = (CHUNK_SEPARATOR.length == 0 ? 0 : (int) Math

				.ceil((float) encodedDataLength / CHUNK_SIZE));

		encodedDataLength += nbrChunks * CHUNK_SEPARATOR.length;



		encodedData = new byte[encodedDataLength];



		byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;



		int encodedIndex = 0;

		int dataIndex = 0;

		int i = 0;

		int nextSeparatorIndex = CHUNK_SIZE;

		int chunksSoFar = 0;



		for (i = 0; i < numberTriplets; i++) {

			dataIndex = i * 3;

			b1 = binaryData[dataIndex];

			b2 = binaryData[dataIndex + 1];

			b3 = binaryData[dataIndex + 2];



			l = (byte) (b2 & 0x0f);

			k = (byte) (b1 & 0x03);



			byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

					: (byte) ((b1) >> 2 ^ 0xc0);

			byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4)

					: (byte) ((b2) >> 4 ^ 0xf0);

			byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6)

					: (byte) ((b3) >> 6 ^ 0xfc);



			encodedData[encodedIndex] = lookUpBase64Alphabet[val1];

			encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2

					| (k << 4)];

			encodedData[encodedIndex + 2] = lookUpBase64Alphabet[(l << 2)

					| val3];

			encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 & 0x3f];



			encodedIndex += 4;



			if (encodedIndex == nextSeparatorIndex) {

				System.arraycopy(CHUNK_SEPARATOR, 0, encodedData, encodedIndex,

						CHUNK_SEPARATOR.length);

				chunksSoFar++;

				nextSeparatorIndex = (CHUNK_SIZE * (chunksSoFar + 1))

						+ (chunksSoFar * CHUNK_SEPARATOR.length);

				encodedIndex += CHUNK_SEPARATOR.length;

			}

		}



		// form integral number of 6-bit groups

		dataIndex = i * 3;



		if (fewerThan24bits == EIGHTBIT) {

			b1 = binaryData[dataIndex];

			k = (byte) (b1 & 0x03);

			// log.debug("b1=" + b1);

			// log.debug("b1<<2 = " + (b1>>2) );

			byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

					: (byte) ((b1) >> 2 ^ 0xc0);

			encodedData[encodedIndex] = lookUpBase64Alphabet[val1];

			encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k << 4];

			encodedData[encodedIndex + 2] = ESCAPE_CHAR;

			encodedData[encodedIndex + 3] = ESCAPE_CHAR;

		} else if (fewerThan24bits == SIXTEENBIT) {



			b1 = binaryData[dataIndex];

			b2 = binaryData[dataIndex + 1];

			l = (byte) (b2 & 0x0f);

			k = (byte) (b1 & 0x03);



			byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

					: (byte) ((b1) >> 2 ^ 0xc0);

			byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4)

					: (byte) ((b2) >> 4 ^ 0xf0);



			encodedData[encodedIndex] = lookUpBase64Alphabet[val1];

			encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2

					| (k << 4)];

			encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2];

			encodedData[encodedIndex + 3] = ESCAPE_CHAR;

		}



		// we also add a separator to the end of the final chunk.

		if (chunksSoFar < nbrChunks) {

			System.arraycopy(CHUNK_SEPARATOR, 0, encodedData, encodedDataLength

					- CHUNK_SEPARATOR.length, CHUNK_SEPARATOR.length);

		}



		return new String(encodedData);

	}



	/**

	 * Convert a base64 string to a normal string

	 * 

	 * @param bStr

	 * @return

	 * @throws Exception

	 */

	public static String decodeBase64(String bStr) throws Exception {

		byte[] base64Data = bStr.getBytes();

		base64Data = discardNonBase64(base64Data);



		// handle the edge case, so we don't have to worry about it later

		if (base64Data.length == 0) {

			return null;

		}



		int numberQuadruple = base64Data.length / FOURBYTE;

		byte decodedData[] = null;

		byte b1 = 0, b2 = 0, b3 = 0, b4 = 0, marker0 = 0, marker1 = 0;



		// Throw away anything not in base64Data



		int encodedIndex = 0;

		int dataIndex = 0;

		{

			// this sizes the output array properly - rlw

			int lastData = base64Data.length;

			// ignore the '=' padding

			while (base64Data[lastData - 1] == ESCAPE_CHAR) {

				if (--lastData == 0) {

					return null;

				}

			}

			decodedData = new byte[lastData - numberQuadruple];

		}



		for (int i = 0; i < numberQuadruple; i++) {

			dataIndex = i * 4;

			marker0 = base64Data[dataIndex + 2];

			marker1 = base64Data[dataIndex + 3];



			b1 = base64Alphabet[base64Data[dataIndex]];

			b2 = base64Alphabet[base64Data[dataIndex + 1]];



			if (marker0 != ESCAPE_CHAR && marker1 != ESCAPE_CHAR) {

				b3 = base64Alphabet[marker0];

				b4 = base64Alphabet[marker1];



				decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);

				decodedData[encodedIndex + 1] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

				decodedData[encodedIndex + 2] = (byte) (b3 << 6 | b4);

			} else if (marker0 == ESCAPE_CHAR) {

				decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);

			} else if (marker1 == ESCAPE_CHAR) {

				b3 = base64Alphabet[marker0];



				decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);

				decodedData[encodedIndex + 1] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

			}

			encodedIndex += 3;

		}

		return new String(decodedData, CHARSET_UTF8);

	}



	private static byte[] discardNonBase64(byte[] data) {

		byte groomedData[] = new byte[data.length];

		int bytesCopied = 0;



		for (int i = 0; i < data.length; i++) {

			if (isBase64(data[i])) {

				groomedData[bytesCopied++] = data[i];

			}

		}



		byte packedData[] = new byte[bytesCopied];



		System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);



		return packedData;

	}



	/**

	 * Test the byte

	 * 

	 * @param octect

	 * @return

	 */

	private static boolean isBase64(byte octect) {

		if (octect == ESCAPE_CHAR) {

			return true;

		} else if (base64Alphabet[octect] == -1) {

			return false;

		} else {

			return true;

		}

	}


}
laowantong06
关注
专栏目录
【MIME协议】base64编码与quoted-printable编码
种花家的兔子
05-12 2203
文章目录MIME概述base64编码基本原理具体步骤例题quoted-printable编码基本步骤例题ASCLL字符代码表 MIME概述 电子邮件协议SMTP通过连接建立、邮件传送、连接释放三个阶段实现发送方和接收方之间的通信。 不过SMTP有很多的缺点： SMTP不能传送可执行文件或其他的二进制对象。 SMTP限于传送7位的ASCLL码很多非英语语言无法传送。 SMTP服务器会拒绝超过一定长度的邮件。 某些SMTP的实现并没有完全按照SMTP的互联网标准。如： 回车、换行的删除和增加 超过76个字符
Python使用base64模块进行二进制数据编码详解
09-20
- **QP编码**：适用于包含非US-ASCII字符的文本内容，比如中文文档。其规则是对于7位字符不做额外编码，仅对8位字符进行转换。 - **Base64编码**：适合处理二进制文件。它会将整个文件重新编码为7位字符。 在实际...
base64、utf-8、二进制有什么关系？
好好学习，天天向上
11-08 3403
Base64 是一种基于 64 个可打印字符来表示二进制数据的表示方法。由于 2^6=64，所以每 6 个比特为一个单元，对应某个可打印字符。3 个字节有 24 个比特，对应于 4 个 Base64 单元，即 3 个字节可由 4 个可打印字符来表示。它不是一种加解密技术，是一种简单的编解码技术。Base64 常用于表示、传输、存储二进制数据，也可以用于将一些含有特殊字符的文本内容编码，以便传输。
矛与盾的较量——奇妙的Base64编码 【 矛盾系列的一篇 挺不错的 】
FreeXploiT
07-14 2273
原文： http://www.luocong.com/articles/show_article.asp?Article_ID=17  下载本节例子程序 (6.93 KB) 各位看官应该都是资深的网虫了，小弟斗胆在此问问大家，平时上网时，除了泡MM、到论坛灌水、扔版砖……之外，进行的最多的是
html base65 图片原理,base64原理是什么？
weixin_33089349的博客
05-31 675
Base64编码由来为什么会有Base64编码呢？因为有些网络传送渠道并不支持所有的字节，例如传统的邮件只支持可见字符的传送，像ASCII码的控制字符就 不能通过邮件传送。这样用途就受到了很大的限制，比如图片二进制流的每个字节不可能全部是可见字符，所以就传送不了。最好的方法就是在不改变传统协议的情 况下，做一种扩展方案来支持二进制文件的传送。把不可打印的字符也能用可打印字符来表示，问题就解决了。B...
【from Spark！】音视频中的码率控制（CBR、VBR、CVBR、FIXQP）
holly的专栏
07-29 5110
音视频中的码率控制（CBR、VBR、CVBR、FIXQP）
Base64加密和解密工具类
HZMand1的专栏
08-02 240
简单的Base64 的 工具类， package com.example.demo.util; import sun.misc.BASE64Decoder; import sun.misc.BASE64Encoder; import java.io.IOException; public class Base64Util { public static byte[] decry...
邮件编码解码工具 md5,base64，qp编码解码，非常小巧有用
09-18
md5,base64，qp编码解码，非常小巧有用
qp.rar_mime QP_qp_quoted printable_字节base64_邮件 ASCII
09-20
同Base64一样，它也将输入的字符串或数据编码成全是ASCII码的可打印字符串。 Quoted-Printable编码的基本方法是：输入数据在33-60、62-126范围内的，直接输出；其它的需编码为“=”加两个字节的HEX码(大写)。为...
base系列加密解密.md
06-13
BASE系列是加密算法，其实挺好区分的，也很常用。
crypto：Quoted-printable
sleepywin的博客
09-26 229
QP介绍Quoted-Printable编码可译为“可打印字符引用编码”，或者“使用可打印字符的编码通常我们接收电子邮件，查看电子邮件原始信息，经常会看到这种类型的编码，电子邮件信头显示：Content-Transfer-Encoding:它是多用途互联网邮件扩展（MIME)一种实现方式。其中MIME是一个互联网标准，它扩展了电子邮件标准，致力于使其能够支持非ASCII字符、二进制格式附件等多种格式的邮件消息。目前http协议中，很多采用MIME框架！就是说。
常用编码说明-MIME&QP
weixin_43914798的博客
11-14 447
2.4.2 MIME 编码介绍 2.4.2.1 BASE64 Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，它是一种基于64个可打印字符来表示二进制数据的方法。其原理很简单，就是把三个Byte的数据用 4 个Byte表示，然后把6Bit再添两位高位0。这样，这4个Byte中，实际用到的都只有前面6 bit，这样就不存在只能传输 7bit 的字符的问题了。BASE64字母表如下： 2.4.2.2 QP(Quote-Printable) Quoted-printable可译为“可打印字符引
邮件收发系统的实现
最新发布
qq_61141142的博客
12-22 818
1.1.1 JSP是什么JSP是JAVA Server Pages的简称，顾名思义是服务器的一种基于JAVA语言的网页技术。JSP正式发布与1999年6月，它是美国SUN公司倡导，多家公司合作建立的一种功能强大的动态网页技术标准，用于创建可支持平台跨WEB服务器的动态网页。1.1.2 JSP技术的特点JSP提供了一种简单快速的建立基于动态内容显示的技术。它能很好的兼顾开发效率和运行效率，同时满足分布式事件的处理功能，并且具有强大的扩展功能，在不同的系统间的移植性也相当的好。将内容的生成和显示相分离。
DES 加密 解密 iOS Android PHP
eric的博客
05-20 2945
PHP代码 和 iOS 代码 摘自 http://blog.toright.com/posts/2657/ios-objective-c-與-php-des-加解密演算法實作.html 三个平台共用 一个密匙，尽量为8的倍数 1.php代码 <?php /** * PHP DES 加密程式 * * @param $key 密鑰（八個字元內） * @param $encrypt 要加密
Base64加密与解密的三种方法
热门推荐
BobZhangfighting的博客
08-31 1万+
前言： 加密与解密一直是程序猿经常需要面对的东东，下面了解一下常见的base64的三种加密与解密的方法。 public static final String str=&quot;zhangtao&quot;; 1. 基于JDK public static void JdkBase64(){ try { //加密 BASE64Encoder...
【深度学习】详解 CLIP
闻韶
12-01 9873
【深度学习】详解 CLIP - Learning Transferable Visual Models From Natural Language Supervision
使用memset要小心
吴遥的专栏
12-17 1334
Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE
vCard 3.0学习笔记
堆烟·雷云纹
09-03 4833
原文： Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值