Kodierung als Base64 in Java

Question

Ich muss einige Daten in der Base64-Kodierung in Java kodieren. Wie kann ich das tun? Wie lautet der Name der Klasse, die einen Base64-Encoder bereitstellt?

---

Ich habe versucht, die sun.misc.BASE64Encoder Klasse, ohne Erfolg. Ich habe die folgende Zeile von Java 7 Code:

wr.write(new sun.misc.BASE64Encoder().encode(buf));

Ich verwende Eclipse. Eclipse markiert diese Zeile als einen Fehler. Ich habe die erforderlichen Bibliotheken importiert:

import sun.misc.BASE64Encoder;
import sun.misc.BASE64Decoder;

Aber auch hier werden beide als Fehler angezeigt. Ich fand ein ähnlicher Beitrag hier .

Ich habe Apache Commons als die von including vorgeschlagene Lösung verwendet:

import org.apache.commons.*;

und importieren die heruntergeladenen JAR-Dateien: http://commons.apache.org/codec/

Aber das Problem besteht weiterhin. Eclipse zeigt immer noch die bereits erwähnten Fehler an. Was sollte ich tun?

Answer 1

Eclipse gibt eine Fehlermeldung/Warnung aus, weil Sie versuchen, interne Klassen zu verwenden, die für einen JDK-Anbieter spezifisch und nicht Teil der öffentlichen API sind. Jakarta Commons bietet eine eigene Implementierung von base64-Codecs, die sich natürlich in einem anderen Paket befinden. Löschen Sie diese Importe und lassen Sie Eclipse die richtigen Commons-Klassen für Sie importieren.

Answer 2

Para Java 6 -7 ist die beste Option, Code aus dem Android-Repository zu leihen. Es gibt keine Abhängigkeiten.

https://github.com/Android/platform_frameworks_base/blob/master/core/java/Android/util/Base64.java

Answer 3

Java 8 enthält eine eigene Implementierung von Base64 . Ich habe jedoch einen leicht beunruhigenden Unterschied festgestellt. Zur Veranschaulichung werde ich ein Code-Beispiel geben:

Mein Codec-Wrapper:

public interface MyCodec
{
  static String apacheDecode(String encodedStr)
  {
    return new String(Base64.decodeBase64(encodedStr), Charset.forName("UTF-8"));
  }

  static String apacheEncode(String decodedStr)
  {
    byte[] decodedByteArr = decodedStr.getBytes(Charset.forName("UTF-8"));
    return Base64.encodeBase64String(decodedByteArr);
  }

  static String javaDecode(String encodedStr)
  {
    return new String(java.util.Base64.getDecoder().decode(encodedStr), Charset.forName("UTF-8"));
  }

  static String javaEncode(String decodedStr)
  {
    byte[] decodedByteArr = decodedStr.getBytes(Charset.forName("UTF-8"));
    return java.util.Base64.getEncoder().encodeToString(decodedByteArr);
  }
}

Testklasse:

public class CodecDemo
{
  public static void main(String[] args)
  {
    String decodedText = "Hello World!";

    String encodedApacheText = MyCodec.apacheEncode(decodedText);
    String encodedJavaText = MyCodec.javaEncode(decodedText);

    System.out.println("Apache encoded text: " + MyCodec.apacheEncode(encodedApacheText));
    System.out.println("Java encoded text: " + MyCodec.javaEncode(encodedJavaText));

    System.out.println("Encoded results equal: " + encodedApacheText.equals(encodedJavaText));

    System.out.println("Apache decode Java: " + MyCodec.apacheDecode(encodedJavaText));
    System.out.println("Java decode Java: " + MyCodec.javaDecode(encodedJavaText));

    System.out.println("Apache decode Apache: " + MyCodec.apacheDecode(encodedApacheText));
    System.out.println("Java decode Apache: " + MyCodec.javaDecode(encodedApacheText));
  }
}

OUTPUT:

Apache encoded text: U0dWc2JHOGdWMjl5YkdRaA0K

Java encoded text: U0dWc2JHOGdWMjl5YkdRaA==
Encoded results equal: false
Apache decode Java: Hello World!
Java decode Java: Hello World!
Apache decode Apache: Hello World!
Exception in thread "main" java.lang.IllegalArgumentException: Illegal base64 character d
    at java.util.Base64$Decoder.decode0(Base64.java:714)
    at java.util.Base64$Decoder.decode(Base64.java:526)
    at java.util.Base64$Decoder.decode(Base64.java:549)

Beachten Sie, dass der Apache-kodierte Text am Ende zusätzliche Zeilenumbrüche (Leerzeichen) enthält. Damit mein Codec unabhängig von der Base64-Implementierung das gleiche Ergebnis liefert, musste ich also trim() auf den Apache-kodierten Text. In meinem Fall fügte ich einfach den oben erwähnten Methodenaufruf zu meinem Codec hinzu apacheDecode() wie folgt:

return Base64.encodeBase64String(decodedByteArr).trim();

Nachdem diese Änderung vorgenommen wurde, sind die Ergebnisse so, wie ich sie zu Beginn erwartet hatte:

Apache encoded text: U0dWc2JHOGdWMjl5YkdRaA==
Java encoded text: U0dWc2JHOGdWMjl5YkdRaA==
Encoded results equal: true
Apache decode Java: Hello World!
Java decode Java: Hello World!
Apache decode Apache: Hello World!
Java decode Apache: Hello World!

SCHLUSSFOLGERUNG : Wenn Sie von Apache Base64 zu Java wechseln wollen, müssen Sie dies tun:

1. Dekodieren Sie verschlüsselten Text mit Ihrem Apache-Decoder.
2. Verschlüsseln Sie den resultierenden (einfachen) Text mit Java.

Wenn Sie umsteigen, ohne diese Schritte zu befolgen, werden Sie höchstwahrscheinlich auf Probleme stoßen. So habe ich diese Entdeckung gemacht.

Answer 4

Um dies zu konvertieren, benötigen Sie einen Encoder und Decoder, den Sie von Base64Coder - ein quelloffener Base64-Kodierer/Dekodierer in Java . Es ist eine Datei Base64Coder.java werden Sie benötigen.

Um auf diese Klasse zuzugreifen, benötigen Sie die folgende Klasse:

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Base64 {

    public static void main(String args[]) throws IOException {
        /*
         * if (args.length != 2) {
         *     System.out.println(
         *         "Command line parameters: inputFileName outputFileName");
         *     System.exit(9);
         * } encodeFile(args[0], args[1]);
         */
        File sourceImage = new File("back3.png");
        File sourceImage64 = new File("back3.txt");
        File destImage = new File("back4.png");
        encodeFile(sourceImage, sourceImage64);
        decodeFile(sourceImage64, destImage);
    }

    private static void encodeFile(File inputFile, File outputFile) throws IOException {
        BufferedInputStream in = null;
        BufferedWriter out = null;
        try {
            in = new BufferedInputStream(new FileInputStream(inputFile));
            out = new BufferedWriter(new FileWriter(outputFile));
            encodeStream(in, out);
            out.flush();
        }
        finally {
            if (in != null)
                in.close();
            if (out != null)
                out.close();
        }
    }

    private static void encodeStream(InputStream in, BufferedWriter out) throws IOException {
        int lineLength = 72;
        byte[] buf = new byte[lineLength / 4 * 3];
        while (true) {
            int len = in.read(buf);
            if (len <= 0)
                break;
            out.write(Base64Coder.encode(buf, 0, len));
            out.newLine();
        }
    }

    static String encodeArray(byte[] in) throws IOException {
        StringBuffer out = new StringBuffer();
        out.append(Base64Coder.encode(in, 0, in.length));
        return out.toString();
    }

    static byte[] decodeArray(String in) throws IOException {
        byte[] buf = Base64Coder.decodeLines(in);
        return buf;
    }

    private static void decodeFile(File inputFile, File outputFile) throws IOException {
        BufferedReader in = null;
        BufferedOutputStream out = null;
        try {
            in = new BufferedReader(new FileReader(inputFile));
            out = new BufferedOutputStream(new FileOutputStream(outputFile));
            decodeStream(in, out);
            out.flush();
        }
        finally {
            if (in != null)
                in.close();
            if (out != null)
                out.close();
        }
    }

    private static void decodeStream(BufferedReader in, OutputStream out) throws IOException {
        while (true) {
            String s = in.readLine();
            if (s == null)
                break;
            byte[] buf = Base64Coder.decodeLines(s);
            out.write(buf);
        }
    }
}

In Android können Sie Ihre Bitmap in Base64 konvertieren, um sie auf einen Server oder Webdienst hochzuladen.

Bitmap bmImage = //Data
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bmImage.compress(Bitmap.CompressFormat.JPEG, 100, baos);
byte[] imageData = baos.toByteArray();
String encodedImage = Base64.encodeArray(imageData);

Dieses "encodedImage" ist die Textdarstellung Ihres Bildes. Sie können dies entweder zum Hochladen oder zum direkten Einfügen in eine HTML-Seite wie unten ( Referenz ):

<img alt="" src="data:image/png;base64,<?php echo $encodedImage; ?>" width="100px" />
<img alt="" src="data:image/png;base64,/9j/4AAQ...........1f/9k=" width="100px" />

Dokumentation: http://dwij.co.in/java-base64-image-encoder

Answer 5

Unter Android verwenden Sie die statischen Methoden der Android.util.Base64 Hilfsklasse. In der referenzierten Dokumentation heißt es, dass die Base64-Klasse in API-Level 8 hinzugefügt wurde ( Android 2.2 (Froyo)).

import android.util.Base64;

byte[] encodedBytes = Base64.encode("Test".getBytes());
Log.d("tag", "encodedBytes " + new String(encodedBytes));

byte[] decodedBytes = Base64.decode(encodedBytes);
Log.d("tag", "decodedBytes " + new String(decodedBytes));