Encodage en Base64 en Java

J'ai besoin d'encoder certaines données dans l'encodage Base64 en Java. Comment je fais ça? Quel est le nom de la classe qui fournit un encodeur Base64?

J'ai essayé d'utiliser la sun.misc.BASE64Encoderclasse, sans succès. J'ai la ligne suivante de code Java 7:

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

J'utilise Eclipse. Eclipse marque cette ligne comme une erreur. J'ai importé les bibliothèques requises:

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

Mais encore une fois, les deux sont affichés comme des erreurs. J'ai trouvé un article similaire ici .

J'ai utilisé Apache Commons comme solution suggérée en incluant:

import org.apache.commons.*;

et importation des fichiers JAR téléchargés depuis: http://commons.apache.org/codec/

Mais le problème existe toujours. Eclipse affiche toujours les erreurs mentionnées précédemment. Que devrais-je faire?

Vous devez modifier l'importation de votre classe:

import org.apache.commons.codec.binary.Base64;

Et puis changez votre classe pour utiliser la classe Base64.

Voici un exemple de code:

byte[] encodedBytes = Base64.encodeBase64("Test".getBytes());
System.out.println("encodedBytes " + new String(encodedBytes));
byte[] decodedBytes = Base64.decodeBase64(encodedBytes);
System.out.println("decodedBytes " + new String(decodedBytes));

Lisez ensuite pourquoi vous ne devriez pas utiliser les packages sun. * .

Mise à jour (2016-12-16)

Vous pouvez maintenant l'utiliser java.util.Base64avec Java 8. D'abord, importez-le comme vous le faites normalement:

import java.util.Base64;

Utilisez ensuite les méthodes statiques Base64 comme suit:

byte[] encodedBytes = Base64.getEncoder().encode("Test".getBytes());
System.out.println("encodedBytes " + new String(encodedBytes));
byte[] decodedBytes = Base64.getDecoder().decode(encodedBytes);
System.out.println("decodedBytes " + new String(decodedBytes));

Si vous souhaitez directement coder une chaîne et obtenir le résultat sous forme de chaîne codée, vous pouvez utiliser ceci:

String encodeBytes = Base64.getEncoder().encodeToString((userName + ":" + password).getBytes());

Voir la documentation Java pour Base64 pour plus.

Utilisez la classe jamais trop tardive pour participer à l'amusement de Java 8: java.util.Base64

new String(Base64.getEncoder().encode(bytes));

En Java 8, cela peut être fait comme: Base64.getEncoder (). EncodeToString (string.getBytes (StandardCharsets.UTF_8))

Voici un court exemple complet et autonome:

import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Temp {
    public static void main(String... args) throws Exception {
        final String s = "old crow medicine show";
        final byte[] authBytes = s.getBytes(StandardCharsets.UTF_8);
        final String encoded = Base64.getEncoder().encodeToString(authBytes);
        System.out.println(s + " => " + encoded);
    }
}

Production:

old crow medicine show => b2xkIGNyb3cgbWVkaWNpbmUgc2hvdw==

Vous pouvez également convertir en utilisant l'encodage Base64. Pour ce faire, vous pouvez utiliser lejavax.xml.bind.DatatypeConverter#printBase64Binary méthode.

Par exemple:

byte[] salt = new byte[] { 50, 111, 8, 53, 86, 35, -19, -47 };
System.out.println(DatatypeConverter.printBase64Binary(salt));

Google Guava est un autre choix pour encoder et décoder les données Base64:

Configuration POM:

<dependency>
   <artifactId>guava</artifactId>
   <groupId>com.google.guava</groupId>
   <type>jar</type>
   <version>14.0.1</version>
</dependency>

Exemple de code:

String inputContent = "Hello Việt Nam";
String base64String = BaseEncoding.base64().encode(inputContent.getBytes("UTF-8"));

// Decode
System.out.println("Base64:" + base64String); // SGVsbG8gVmnhu4d0IE5hbQ==
byte[] contentInBytes = BaseEncoding.base64().decode(base64String);
System.out.println("Source content: " + new String(contentInBytes, "UTF-8")); // Hello Việt Nam

Eclipse vous donne une erreur / un avertissement car vous essayez d'utiliser des classes internes spécifiques à un fournisseur JDK et ne faisant pas partie de l'API publique. Jakarta Commons fournit sa propre implémentation de codecs base64, qui résident bien sûr dans un package différent. Supprimez ces importations et laissez Eclipse importer les classes Commons appropriées pour vous.

Pour convertir cela, vous avez besoin d'un encodeur et d'un décodeur que vous obtiendrez de Base64Coder - un encodeur / décodeur Base64 open source en Java . C'est le fichier Base64Coder.java dont vous aurez besoin.

Maintenant, pour accéder à cette classe selon vos besoins, vous aurez besoin de la classe ci-dessous:

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);
        }
    }
}

Dans Android, vous pouvez convertir votre bitmap en Base64 pour le télécharger sur un serveur ou un service Web.

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

Cette «encodedImage» est une représentation textuelle de votre image. Vous pouvez l'utiliser pour télécharger ou pour afficher directement dans une page HTML comme ci-dessous ( référence ):

<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" />

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

Pour Java 6 -7, la meilleure option consiste à emprunter du code à partir du référentiel Android. Il n'a pas de dépendances.

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

Voici mes deux cents ... Java 8 contient sa propre implémentation de Base64 . Cependant, j'ai trouvé une différence légèrement inquiétante. Pour illustrer, je vais fournir un exemple de code:

Mon wrapper de codec:

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);
  }
}

Classe de test:

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));
  }
}

PRODUCTION:

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)

Notez que le texte codé Apache contient des sauts de ligne supplémentaires (espaces blancs) à la fin. Par conséquent, pour que mon codec donne le même résultat quelle que soit l'implémentation Base64, j'ai dû faire appel trim()au texte codé Apache. Dans mon cas, j'ai simplement ajouté l'appel de méthode susmentionné à mon codec apacheDecode()comme suit:

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

Une fois ce changement effectué, les résultats sont ceux que j'attendais au départ:

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!

CONCLUSION : Si vous souhaitez passer d'Apache Base64 à Java, vous devez:

1. Décodez le texte encodé avec votre décodeur Apache.
2. Encode le texte (brut) résultant avec Java.

Si vous passez sans suivre ces étapes, vous rencontrerez très probablement des problèmes. C'est ainsi que j'ai fait cette découverte.

Sur Android, utilisez les méthodes statiques de la classe d'utilitaires android.util.Base64 . La documentation référencée indique que la classe Base64 a été ajoutée dans l'API niveau 8 ( 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));

Apache Commons a une belle implémentation de Base64. Vous pouvez le faire aussi simplement que:

// Encrypt data on your side using BASE64
byte[] bytesEncoded = Base64.encodeBase64(str .getBytes());
System.out.println("ecncoded value is " + new String(bytesEncoded));

// Decrypt data on other side, by processing encoded data
byte[] valueDecoded= Base64.decodeBase64(bytesEncoded );
System.out.println("Decoded value is " + new String(valueDecoded));

Vous pouvez trouver plus de détails sur l'encodage base64 à l'encodage Base64 en utilisant Java et JavaScript .

Si vous utilisez Spring Framework au moins la version 4.1, vous pouvez utiliser la classe org.springframework.util.Base64Utils :

byte[] raw = { 1, 2, 3 };
String encoded = Base64Utils.encodeToString(raw);
byte[] decoded = Base64Utils.decodeFromString(encoded);

Il sera délégué à Base64 de Java 8, Codec Apache Commons ou JAXB DatatypeConverter, selon ce qui est disponible.

Exemple simple avec Java 8:

import java.util.Base64;

String str = "your string";
String encodedStr = Base64.getEncoder().encodeToString(str.getBytes("utf-8"));

Dans Java 7, j'ai codé cette méthode

import javax.xml.bind.DatatypeConverter;

public static String toBase64(String data) {
    return DatatypeConverter.printBase64Binary(data.getBytes());
}

Si vous êtes bloqué sur une version antérieure de Java à 8 mais que vous utilisez déjà AWS SDK pour Java , vous pouvez utiliser com.amazonaws.util.Base64 .

J'ai essayé avec l'extrait de code suivant. Cela a bien fonctionné. :-)

com.sun.org.apache.xml.internal.security.utils.Base64.encode("The string to encode goes here");

public String convertImageToBase64(String filePath) {
    byte[] fileContent = new byte[0];
    String base64encoded = null;
    try {
        fileContent = FileUtils.readFileToByteArray(new File(filePath));
    } catch (IOException e) {
        log.error("Error reading file: {}", filePath);
    }
    try {
        base64encoded = Base64.getEncoder().encodeToString(fileContent);
    } catch (Exception e) {
        log.error("Error encoding the image to base64", e);
    }
    return base64encoded;
}