Nehmen Sie den Zeichenstrom von Java zum Lesen von Dateien: Er kann nur Zeichen zwischen 0 und 65535 lesen. Es ist ersichtlich, dass die Zeichen alle positiv sind Zahlen. Aber binäre Bytes können negativ sein. Beim Lesen wird es jedoch als positive Zahl gelesen, oder ein Zeichen, das nicht in der Codierungstabelle gefunden werden kann, gibt ein seltsames Symbol zurück (vielleicht haben Sie dieses seltsame „?“ gesehen).
Aber in manchen Fällen müssen Zeichen verwendet werden, um Binärdaten anzuzeigen, und es gibt keine Möglichkeit, eine unserer Methoden einzuführen – die Base64-Kodierung.
Base64 ist eine der gängigen Kodierungsmethoden zur Übertragung von 8-Bit-Bytecode im Internet. Base64 ist eine Methode zur Darstellung von Binärdaten basierend auf 64 druckbaren Zeichen. Bei der Base64-Kodierung handelt es sich um einen Prozess von Binär- zu Zeichen, der zur Übertragung längerer Identifikationsinformationen in einer HTTP-Umgebung verwendet werden kann. Die Base64-Kodierung ist nicht lesbar und muss dekodiert werden, bevor sie gelesen werden kann. Sein chinesischer Name basiert auf 64 druckbaren Zeichen zur Darstellung binärer Daten.
1. Konvertieren Sie 3 Bytes in 4 Bytes
2. Nicht mehr als 76 Zeichen plus ein Zeilenumbruchzeichen.
3. Der endgültige Terminator muss ebenfalls verarbeitet werden.
Aus den Codierungsregeln geht hervor, dass Base64 alle drei 8-Bit-Bytes in vier 6-Bit-Zeichen (38 = 46 = 24) konvertieren und dann zwei High-Bit-0s zum 6-Bit hinzufügen muss. bestehend aus vier 8Bit Bytes. Mit anderen Worten: Die konvertierte Zeichenfolge ist theoretisch 1/3 (33 %) länger als die ursprüngliche.
Hier finden Sie eine Einführung in ein Konzept und detailliertere Inhalte. Wenn Sie interessiert sind, können Sie es sammeln, um mehr zu erfahren.
Die Base64-Toolklasse von Java bietet eine Reihe statischer Methoden, um die folgenden drei BASE64-Codecs zu erhalten:
Grundlegend: Die Ausgabe wird einem Zeichensatz A-Za-z0-9 + zugeordnet /, die Kodierung fügt keine Zeilenmarkierungen hinzu und die Ausgabedekodierung unterstützt nur A-Za-z0-9+/.
URL: Die Ausgabe wird einem Zeichensatz A-Za-z0-9+_ zugeordnet, die Ausgabe ist eine URL und eine Datei.
MIME: Die Ausgabe wird implizit einem MIME-freundlichen Format zugeordnet. Die Ausgabe sollte nicht länger als 76 Zeichen pro Zeile sein und durch „r“ gefolgt von „n“ getrennt werden. Die codierte Ausgabe weist keine Zeilenaufteilung auf.
entspricht den folgenden Methoden:
Encoder basicEncoder = Base64.getEncoder(); Encoder mimeEncoder = Base64.getMimeEncoder(); Encoder urlEncoder = Base64.getUrlEncoder();
Ich habe eine einfache Toolklasse geschrieben, um den Basic-Encoder zu testen. .
package com.dragon;
import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.Base64;
import java.util.Base64.Decoder;
import java.util.Base64.Encoder;
/**
* @author Alfred
* */
public class Base64Util {
private static Encoder encoder = Base64.getEncoder();
private static Decoder decoder = Base64.getDecoder();
private static String ENCODE = "UTF-8";
private static int LENGTH = 1024;
/**
* 静态方法：
* 将文件等二进制数据（文本和非文本都可以）
* 转为base64字符串。
* @throws IOException
* @throws FileNotFoundException
*
* */
public static String dataToBase64(File src) throws FileNotFoundException, IOException {
Encoder encoder = Base64.getEncoder();
int len = (int)src.length();
byte[] bar = new byte[(int)len];
int hasRead = 0;
byte[] b = new byte[LENGTH];
//使用专门处理 byte 的IO流比较方便，一次性读取较大文件对内存压力较大
try (InputStream in = new BufferedInputStream(new FileInputStream(src));
ByteArrayOutputStream bos = new ByteArrayOutputStream(len)) {
while ((hasRead = in.read(b)) != -1) {
bos.write(b, 0, hasRead);
}
bar = bos.toByteArray();
}
return encoder.encodeToString(bar);
}
public static String dataToBase64(String src) throws UnsupportedEncodingException {
return encoder.encodeToString(src.getBytes(ENCODE));
}
public static byte[] base64ToData(String src) {
return decoder.decode(src);
}
}import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.nio.file.Path;
import java.nio.file.Paths;
public class Base64Test {
public static void main(String[] args) throws FileNotFoundException, IOException {
testPic();
}
static void testPic() throws FileNotFoundException, IOException {
// 测试图片文件。
Path picPath = Paths.get("./src/com/dragon/001.jpg");
File picFile = picPath.toFile();
String picToBase64 = Base64Util.dataToBase64(picFile);
System.out.println(picToBase64);
long oldSize = picFile.length();
long newSize = picToBase64.getBytes("UTF-8").length;
System.out.println("图片原始大小（字节）：" + oldSize);
System.out.println("转换后数据大小（字节）：" + newSize);
System.out.println("转换后比原来扩大的比例为：" + (double)(newSize-oldSize)/(double)oldSize + " %");
//将数据写入文件
try (Writer writer = new BufferedWriter(new FileWriter("./src/com/dragon/002.txt"))) {
writer.write(picToBase64);
}
//从文件中读取数据
String line = null;
try (BufferedReader reader = new BufferedReader(new FileReader("./src/com/dragon/002.txt"))){
line = reader.readLine();
}
System.out.println(picToBase64.equals(line));
}
}Screenshot ausführen
Beschreibung: Nachdem Sie das Bild in eine Base64-Zeichenfolge konvertiert haben, verwenden Sie den Zeichenstrom, um eine Textdatei zu schreiben, und verwenden Sie dann den Zeichenstrom ausgelesen und dann mit der Originalzeichenfolge verglichen wird, ist das Ergebnis wahr. Damit ist das Lesen der Bilddaten abgeschlossen. Vielleicht haben Sie hier gesagt, dass Sie nicht die Binärdaten des Bildes lesen, aber tatsächlich sind alle Dateien binär gespeichert! Darüber hinaus kann dieser Base64-String auch direkt als Bild verwendet werden.
Hinweis: Ich habe hier ein sehr kleines Bild ausgewählt. Sie können sehen, dass die Originalgröße nur 3639 Byte beträgt, was weniger als 4 KB ist, aber wenn es in Text umgewandelt wird, wird es viel sein (Also, es wird sehr lang, sehr lang erscheinen ).
Testbild
Dann fragen Sie sich vielleicht, wie man beweisen kann, dass es sich bei dieser Zeichenfolge um das Bild oben handelt? Dies ist auch einfach. Wenn Sie etwas über das Frontend wissen, sollten Sie wissen, dass die Frontend-Bilder durch Base64-Strings dargestellt werden können.
image.html
<!DOCTYPE>
<html>
<head>
<meta charset="UTF-8"/>
<title>base测试</title>
</head>
<body>
<img src="data:image/jpeg;base64,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"/>
</body>
<html>Öffnen Sie den Browser, um es zu testen
Anleitung: Die spezifische Verwendung ist wie folgt:
<img src="https://img-blog.csdnimg.cn/2022010703315790409.jpeg">
Die Größe des Bildes ist im Vergleich zu den Zeichen tatsächlich sehr groß . Der HTML-Code, den ich hier habe, ist die Base64-codierte Zeichenfolge des gesamten Bildes, und dann wird die Wortzahl meines Blogs viel größer.
public class Base64Test {
public static void main(String[] args) throws FileNotFoundException, IOException {
testStr("I love you yesterday and today!");
}
static void testStr(String src) throws UnsupportedEncodingException {
//测试文本数据。
String strToBase64 = Base64Util.dataToBase64(src);
System.out.println("base64编码：" + strToBase64);
String base64ToStr = new String(Base64Util.base64ToData(strToBase64));
System.out.println("base64解码：" + base64ToStr);
}
}Test-Screenshots
Base64 wird häufig zur Darstellung, Übertragung und Speicherung einiger Binärdaten in Situationen verwendet, in denen normalerweise Textdaten verarbeitet werden. Einschließlich MIME-E-Mail, E-Mail über MIME, Speicherung komplexer Daten in XML. Hinweis 1: Es gibt auch viele Websites im Internet, die es kodieren und dekodieren können. Wenn Sie es verwenden müssen, können Sie es ausprobieren.
注2：可以观察一下这个base64字符串的特点，我上次学习Java爬虫的时候，爬了一个网站，发现这个网站的一个 script 脚本中，含有一个json对象，其中有一个属性是 url，但是对应的链接却看不懂（base64字符串是不可读的），但是我感觉它就是base64字符串，所以我利用base64编解码网站解码一看，真的是一个网站的地址。然后，就可以写一个解码方法，当爬到这个数据时，给它解码了，哈哈。
举一个简单的例子：
{"url":"aHR0cHMlM0ElMkYlMkZ3d3cuYmFpZHUuY29tJTJG"}import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Base64;
import java.util.Base64.Decoder;
import java.util.Base64.Encoder;
public class TestALittle {
public static void main(String[] args) throws UnsupportedEncodingException {
String base64Str = "aHR0cHMlM0ElMkYlMkZ3d3cuYmFpZHUuY29tJTJG";
String de_str = base64ToUrlEncoderToURL(base64Str);
System.out.println("解码：" + de_str);
}
//base64解密为urlencoder，再解码为url
public static String base64ToUrlEncoderToURL(String base64Str) throws UnsupportedEncodingException {
Decoder decoder = Base64.getDecoder();
byte[] bt = decoder.decode(base64Str);
String en_str = new String(bt, 0, bt.length);
return URLDecoder.decode(en_str, "UTF-8");
}
}
说明： 这个例子中的 url 进行了两次编码，第一次是将url中的非西欧字符编码（可以去了解一下为什么这么做？），然后再使用base64编码。但是，如果你掌握了解码技术，解码也是很简单的。（但是如果你看不出来它是base64编码，那估计就没有办法了！）
Das obige ist der detaillierte Inhalt vonSo verwenden Sie den Zeichenstrom zum Lesen und Schreiben von Nicht-Textdateien in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
