Ich hatte die Möglichkeit, Bilddaten in JSON und Base64-Codierung / -Decodierung einzubetten, sodass ich das, was ich überprüft habe, als Memorandum aufzeichnen werde.
Ich werde diesen Artikel zitieren, weil er leicht verständlich erklärt wurde. https://qiita.com/PlanetMeron/items/2905e2d0aa7fe46a36d4 Der Base64-Konvertierungsalgorithmus wird als Referenz sorgfältig und leicht verständlich beschrieben.
Einfach gesagt ・ A-z (26 Zeichen) ・ A-Z (26 Zeichen) ・ 0-9 (10 Zeichen) ・ ＋ ・ / ・ = (Wird als Füllzeichen am Ende verwendet, um die Datenlänge auszurichten) Es scheint, dass es sich um eine Codierungsmethode handelt, die mit insgesamt 65 Zeichen ausgedrückt wird. * Das letzte "=" ist ein 64-stelliger Ausdruck, wenn kein Auffüllen erforderlich ist.
Binärdaten usw. können in 64 (oder 65) Zeichenfolgen konvertiert werden, sodass Sonderzeichen nicht in JSON enthalten sind und Daten sicher gesendet und empfangen werden können. Da es nur mit 64 (oder 65) Zeichentypen ausgedrückt wird, ist es auch ein Merkmal, dass sich die Datenmenge um das 1,3-fache (133%) erhöht.
Wenn die Base64-Codierung als MIME-Format für E-Mails verwendet wird, wird gemäß dem MIME-Standard alle 76 Zeichen ein Zeilenvorschubcode (CRLF) eingegeben. Einschließlich dieser 2 Bytes beträgt die Datenmenge etwa 137%.
Die Base64-Formate sind in die folgenden drei Muster unterteilt.
gu2CoIKigqSCpoKogqmCq4Ktgq+CsYKzgrWCt4K5gruCvYK/gsKCxILGgsiCyYLKgsuCzILNgtCC04LWgtmC3ILdgt6C34LggqCCoA==
・ Die letzten 2 Zeichen, die ein Vielfaches von 4 sind, sind Füllzeichen "=" ・ Enthält +, / Symbole (* Wenn dies in einer URL verwendet wird, unterliegt es einer prozentualen Codierung.)
gu2CoIKigqSCpoKogqmCq4Ktgq+CsYKzgrWCt4K5gruCvYK/gsKCxILGgsiCyYLKgsuCzILNgtCC
04LWgtmC3ILdgt6C34LggqCCoA==
・ Die letzten 2 Zeichen, die ein Vielfaches von 4 sind, sind Füllzeichen "=" ・ Enthält +, / Symbole (* Wenn dies in einer URL verwendet wird, unterliegt es einer prozentualen Codierung.)
gu2CoIKigqSCpoKogqmCq4Ktgq-CsYKzgrWCt4K5gruCvYK_gsKCxILGgsiCyYLKgsuCzILNgtCC04LWgtmC3ILdgt6C34LggqCCoA
-URL unsichere Symbole wurden konvertiert. Entfernen Sie "+" → "-", "/" → "_", "="
Java8～ Seit Java8 oder höher bietet der JDK-Standard ein Dienstprogramm von java.util.Base64, daher scheint es gut, dieses zu verwenden. Java 8 oder höher wurde auf dem tatsächlichen Computer nicht überprüft. Dies ist ein sehr einfaches und leicht verständliches Codebeispiel, daher war es hilfreich. https://gist.github.com/komiya-atsushi/d878e6e4bf9ba6dae8fa
Java7 So handhaben Sie Base64 mit Java7 ...
--Verwenden Sie den Apache Commons Codec --Verwenden Sie javax.mail (mit JavaMails MimeUtility) --Verwenden von Seasar2s Base64Util --Mach dein eigenes
Und so weiter. Dieses Mal möchte ich die beiden besten "Apache Commons Codec" und "javax.mail" verwenden, die ich zum Codieren / Decodieren von Base64 zur Verfügung hatte. Die Implementierung hier implementiert ein Beispiel, das Binärdaten (Byte []) in eine Base64-Zeichenfolge (Zeichenfolge) codiert / decodiert.
Apache Commons Codec Version: Validiert mit 1.11.
public static String encodeBase64(byte[] data) {
return Base64.encodeBase64String(data);
}
⇒ `` `Base64 # encodeBase64String``` wird verwendet.
public static String encodeBase64Chunked(byte[] data) {
byte[] encoded = Base64.encodeBase64Chunked(data);
return new String(encoded);
}
⇒ `` `Base64 # encodeBase64Chunked``` wird verwendet. Eine Schnittstelle zum Zuweisen von Zeilenvorschubcodes wurde vorbereitet.
public static String encodeBase64URLSafe(byte[] data) {
return Base64.encodeBase64URLSafeString(data);
}
⇒ `` `Base64 # encodeBase64URLSafeString``` wird verwendet. Es gab eine spezielle Schnittstelle für URL-Safe.
public static byte[] decodeBase64(String data) {
return Base64.decodeBase64(data);
}
⇒ Es scheint, dass die Dekodierung damit einheitlich erfolgen kann.
javax.mail Version: Verifiziert mit 1.4.6
private static String trimCRLF(ByteArrayOutputStream encodedCRLF) {
byte inputArray[] = encodedCRLF.toByteArray();
byte outputArray[] = new byte[encodedCRLF.size()];
// CR(0x0d)、LF(0x0a)Überspringen Sie das Teil und kopieren Sie es in das Ausgabearray
int n = 0;
for (int i = 0; i < encodedCRLF.size() - 1; i++) {
if (inputArray[i] == 0x0d) {// CR
if (inputArray[i + 1] == 0x0a) {// LF
i++;
continue;
}
}
outputArray[n] = inputArray[i];
n++;
}
return new String(outputArray, 0, n);
}
public static String encodeBase64(byte[] data) {
try (ByteArrayOutputStream encodedChunked = new ByteArrayOutputStream()) {
try (OutputStream os = MimeUtility.encode(encodedChunked, "base64")) {
os.write(data);
os.flush();
}
//Zeilenumbruchzeichen entfernen
String encodedStr = trimCRLF(encodedChunked);
return encodedStr;
} catch (IOException e) {
e.printStackTrace();
return "Bad Encryption";
} catch (MessagingException e) {
e.printStackTrace();
return "Bad Encryption";
}
}
⇒MimeUtility scheint in der Lage zu sein, mit MimeUtility.encode zu codieren. Standardmäßig liegt es in einem MIME-basierten Format vor, das Zeilenumbrüche enthält. Daher wird der Zeilenvorschubcode entfernt, um Zeilenumbrüche zu vermeiden.
public static String encodeBase64Chunked(byte[] data) {
try (ByteArrayOutputStream encodedChunked = new ByteArrayOutputStream()) {
try (OutputStream os = MimeUtility.encode(encodedChunked, "base64")) {
os.write(data);
os.flush();
}
return encodedChunked.toString();
} catch (IOException e) {
e.printStackTrace();
return "Bad Encryption";
} catch (MessagingException e) {
e.printStackTrace();
return "Bad Encryption";
}
}
⇒ Ich verwende MimeUtility.encode.
private static String urlSafeEncode(ByteArrayOutputStream encodedCRLF) {
byte inputArray[] = encodedCRLF.toByteArray();
byte outputArray[] = new byte[encodedCRLF.size()];
// CR(0x0d)、LF(0x0a)Überspringen Sie das Teil und kopieren Sie es in das Ausgabearray
int n = 0;
for (int i = 0; i < encodedCRLF.size() - 1; i++) {
if (inputArray[i] == 0x0d) {// CR
if (inputArray[i + 1] == 0x0a) {// LF
i++;
continue;
}
}
// URL-In Safe konvertieren
if (inputArray[i] == 0x2b) {// 「+」
outputArray[n] = 0x2d;// 「-」
}
else if (inputArray[i] == 0x2f) {// 「/」
outputArray[n] = 0x5f;// 「_」
}
else if (inputArray[i] == 0x3d) {// 「=」
continue;
}
else {
outputArray[n] = inputArray[i];
}
n++;
}
return new String(outputArray, 0, n);
}
public static String encodeBase64URLSafe(byte[] data) {
try (ByteArrayOutputStream encodedChunked = new ByteArrayOutputStream()) {
try (OutputStream os = MimeUtility.encode(encodedChunked, "base64")) {
os.write(data);
os.flush();
}
//URL mit entferntem Zeilenvorschubzeichen-Mach es sicher
String encodedURLSafe = urlSafeEncode(encodedChunked);
return encodedURLSafe;
} catch (IOException e) {
e.printStackTrace();
return "Bad Encryption";
} catch (MessagingException e) {
e.printStackTrace();
return "Bad Encryption";
}
⇒ Um URL-sicher zu machen, werden die Symbole "+", "/" und "=" zusätzlich zum Entfernen des Zeilenvorschubcodes konvertiert. Es ist sehr lang. ..
public static byte[] decodeBase64(String data) {
byte[] urlsafe = data.getBytes();
int mod = urlsafe.length % 4;
byte[] nosafe = new byte[urlsafe.length + mod];
for (int i = 0; i < urlsafe.length; i++) {
if (urlsafe[i] == 0x2d) {// 「-」
nosafe[i] = 0x2b;// 「+」
}
else if (urlsafe[i] == 0x5f) {// 「_」
nosafe[i] = 0x2f;// 「/」
}
else {
nosafe[i] = urlsafe[i];
}
}
//Diejenigen, die kleiner als ein Vielfaches der festen Länge sind 4=Polsterung mit
for (int i = urlsafe.length + mod - 1; i >= urlsafe.length; i--) {
nosafe[i] = 0x3d;// 「=」
}
ByteArrayInputStream from = new ByteArrayInputStream(nosafe);
try (InputStream is = MimeUtility.decode(from, "base64"); ByteArrayOutputStream to = new ByteArrayOutputStream()) {
byte[] buf = new byte[8192];
int readCnt;
while ((readCnt = is.read(buf)) != -1) {
to.write(buf, 0, readCnt);
}
to.flush();
return to.toByteArray();
} catch (MessagingException | IOException e) {
e.printStackTrace();
return "Bad Decryption".getBytes();
}
}
⇒ Es ist gewaltsam. .. Beim Dekodieren wird es wieder in URL-UnSafe konvertiert, unter der Annahme, dass die konvertierte Zeichenfolge in URL-Safe eingegeben wird. Nach dem Auffüllen von "=" entsprechend der Anzahl der Ziffern mit einem Vielfachen von 4 wird MimeUtility.decode zum Decodieren verwendet. Ich glaube nicht, dass ich normalerweise diese Art von Code schreibe.
das ist alles.
Recommended Posts