Encodage Base64 en Java

Utilisation de Java 8-jamais-trop-tard-pour-rejoindre-dans-le-fun classe: java.util.Base64

vous pouvez également convertir en utilisant l'encodage base64. Pour ce faire, vous pouvez utiliser javax.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));

en Java 8 Il peut être fait comme

Base64.getEncoder().encodeToString(string.getBytes(StandardCharsets.UTF_8))

voici un exemple complet, court et complet

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

donne la sortie

old crow medicine show => b2xkIGNyb3cgbWVkaWNpbmUgc2hvdw==

Google Guava est un bon choix pour encoder et décoder des données base64:

POM config:

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

code échantillon:

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/avertissement parce que vous essayez d'utiliser des classes internes qui sont spécifiques à un fournisseur JDK et ne font pas partie de l'API publique. Jakarta Commons fournit sa propre implémentation des codecs base64, qui résident bien sûr dans un paquet différent. Supprimez ces importations et laissez Eclipse importer les classes Commons appropriées pour vous.

pour convertir ce que vous avez besoin Encoder & décoder que vous obtiendrez de http://www.source-code.biz/base64coder/java / . Il S'agit du fichier Base64Coder.java vous aurez besoin.

maintenant pour accéder à cette classe comme vous l'avez 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échargement vers le serveur/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);

Ce "encodedImage" est une représentation textuelle de votre Image. Vous pouvez l'utiliser soit pour télécharger objet ou pour envoyer directement dans la 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 est d'emprunter le code du dépôt Android. Il n'a pas de dépendances.

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

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 à http://faisalbhagat.blogspot.com/2014/06/base64-encoding-using-java-and.html

Voici mes deux cents... Java 8 contient sa propre implémentation de Base64 . Cependant, j'ai trouvé une différence un peu troublante. Pour illustrer, je vais donner un exemple de code:

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

Classe D'Essai:

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

sortie:

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 L'Apache le texte encodé contient des sauts de ligne supplémentaires (espaces blancs) à la fin. Par conséquent, pour que mon CODEC produise le même résultat quelle que soit L'implémentation de Base64, j'ai dû appeler trim() sur le texte encodé D'Apache. Dans mon cas, j'ai simplement ajouté l'appel de méthode ci-dessus à mon CODEC apacheDecode() comme suit:

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

une fois que ce changement a été fait, les résultats sont ce que je m'attendais à commencer par:

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!

peut-être quelqu'un pourrait nous dire pourquoi, mais j'ai trouvé ma solution de contournement comme un compromis acceptable.

sur Android, Utilisez les méthodes statiques du android.util.Base64 utilitaire de la classe. La documentation référencée indique que la classe Base64 a été ajoutée au niveau 8 de L'API (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));

exemple Simple avec Java 8:

import java.util.Base64;

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

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

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

il déléguera à Java 8 Base64, Apache Commons Codec ou JAXB DatatypeConverter, selon ce qui est disponible.

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

en Java 7 j'ai codé cette méthode

import javax.xml.bind.DatatypeConverter;

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

j'ai essayé avec le code suivant. Il a bien fonctionné. :- )

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