TOC

Encodage et décodage Java Base64

Encodage et décodage Java Base64

1. Vue d'ensemble

Dans ce didacticiel, nous allons explorer les différents utilitaires qui fournissent des fonctionnalités d'encodage et de décodage Base64 en Java.

Nous allons principalement illustrer les nouvelles API Java 8 ainsi que les API utilitaires issues d'Apache Commons.

Lectures complémentaires:

Guide de codage / décodage d'URL Java

L'article traite du codage d'URL en Java, de certains pièges et de la façon de les éviter.

Read more →

SHA-256 et SHA3-256 Hashing en Java

Un guide rapide et pratique sur le hachage SHA-256 en Java

Read more →

Nouveau stockage de mots de passe dans Spring Security 5

Un guide rapide pour comprendre le chiffrement de mot de passe dans Spring Security 5 et migrer vers de meilleurs algorithmes de chiffrement.

Read more →

2. Java 8 pour Base 64

Java 8 has finally added Base64 capabilities à l'API standard, via lesjava.util.Base64 utility class.

Commençons par examiner un processus d'encodage de base.

2.1. Java 8 Basic Base64

Le codeur de base garde la simplicité et encode l’entrée telle quelle, sans séparation des lignes.

La sortie est mappée à un jeu de caractères dans le jeu de caractèresA-Za-z0-9+/ et le décodeur rejette tout caractère en dehors de ce jeu.

Commençons parencode a simple String: 

String originalInput = "test input";
String encodedString = Base64.getEncoder().encodeToString(originalInput.getBytes());

Notez comment nous récupérons l'API Encoder complète via la méthode utilitaire simplegetEncoder().

Décodons maintenant cette chaîne sous sa forme d'origine: 

byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
String decodedString = new String(decodedBytes);

2.2. Encodage Java 8 Base64 sans remplissage

En codage Base64, la longueur de la chaîne codée en sortie doit être un multiple de 3. Si ce n’est pas le cas, la sortie sera complétée par des caractères de pad supplémentaires (=).

Lors du décodage, ces caractères de remplissage supplémentaires seront supprimés. Pour approfondir le rembourrage en Base64, consultezthis detailed answer over on StackOverflow.

Si vous avez besoin deskip the padding of the output - peut-être, parce que la chaîne résultante ne sera jamais décodée en arrière - vous pouvez simplement choisirencode without padding: 

String encodedString =
  Base64.getEncoder().withoutPadding().encodeToString(originalInput.getBytes());

2.3. Encodage d'URL Java 8

Le codage d'URL est très similaire au codeur de base que nous avons vu ci-dessus. Il utilise l'alphabet Base64 sécurisé des noms de fichier et d'URL et n'ajoute aucune séparation de ligne: 

String originalUrl = "https://www.google.co.nz/?gfe_rd=cr&ei=dzbFV&gws_rd=ssl#q=java";
String encodedUrl = Base64.getUrlEncoder().encodeToString(originalURL.getBytes());

Le décodage se produit à peu près de la même manière - la méthode utilitairegetUrlDecoder() renvoie unjava.util.Base64.Decoder qui est ensuite utilisé pour décoder l'URL: 

byte[] decodedBytes = Base64.getUrlDecoder().decode(encodedUrl);
String decodedUrl = new String(decodedBytes);

2.4. Encodage MIME Java 8

Commençons par générer une entrée MIME de base à encoder: 

private static StringBuilder getMimeBuffer() {
    StringBuilder buffer = new StringBuilder();
    for (int count = 0; count < 10; ++count) {
        buffer.append(UUID.randomUUID().toString());
    }
    return buffer;
}

L'encodeur MIME génère une sortie encodée en Base64 en utilisant l'alphabet de base mais dans un format convivial MIME: chaque ligne de la sortie ne dépasse pas 76 caractères et se termine par un retour chariot suivi d'un saut de ligne ( ): 

StringBuilder buffer = getMimeBuffer();
byte[] encodedAsBytes = buffer.toString().getBytes();
String encodedMime = Base64.getMimeEncoder().encodeToString(encodedAsBytes);

La méthode utilitairegetMimeDecoder() renvoie unjava.util.Base64.Decoder qui est ensuite utilisé dans le processus de décodage: 

byte[] decodedBytes = Base64.getMimeDecoder().decode(encodedMime);
String decodedMime = new String(decodedBytes);

3. Encoding/Decoding Using Apache Commons Code

Tout d'abord, nous devons définir la dépendance commons-codec dans lespom.xml: 


    commons-codec
    commons-codec
    1.10

Notez que vous pouvez vérifier si des versions plus récentes de la bibliothèque ont été publiées surMaven central.

L'API principale est la classeorg.apache.commons.codec.binary.Base64 - qui peut être paramétrée avec différents constructeurs:

  • Base64(boolean urlSafe) - crée l'API Base64 en contrôlant le mode de sécurité URL - activé ou désactivé

  • Base64 (int lineLength) - crée l'API Base64 dans un mode URL unsafe et contrôle la longueur de la ligne (default est 76)

  • ”)

Sur l’API Base64 créée, l’encodage et le décodage sont simples: 

String originalInput = "test input";
Base64 base64 = new Base64();
String encodedString = new String(base64.encode(originalInput.getBytes()));

La méthodedecode() de la classeBase64 renvoie la chaîne décodée: 

String decodedString = new String(base64.decode(encodedString.getBytes()));

Une autre option simple estusing the static API of Base64 au lieu de créer une instance: 

String originalInput = "test input";
String encodedString = new String(Base64.encodeBase64(originalInput.getBytes()));
String decodedString = new String(Base64.decodeBase64(encodedString.getBytes()));

4. Conversion d'unString en un tableaubyte

Parfois, nous devons convertir unString enbyte[]. Le moyen le plus simple de le faire est d'utiliser la méthodeStringgetBytes(): 

String originalInput = "test input";
byte[] result = originalInput.getBytes();

assertEquals(originalInput.length(), result.length);

Il est préférable de fournir également le codage et de ne pas dépendre du codage par défaut car il dépend du système: 

String originalInput = "test input";
byte[] result = originalInput.getBytes(StandardCharsets.UTF_16);

assertTrue(originalInput.length() < result.length);

Si notre chaîne est encodée enBase64, nous pouvons utiliser le décodeurthe Base64: 

String originalInput = "dGVzdCBpbnB1dA==";
byte[] result = Base64.getDecoder().decode(originalInput);

assertEquals("test input", new String(result));

Nous pouvons également utiliser la méthodeDatatypeConverter parseBase64Binary(): 

String originalInput = "dGVzdCBpbnB1dA==";
byte[] result = DatatypeConverter.parseBase64Binary(originalInput);

assertEquals("test input", new String(result));

Enfin, nous pouvons convertir unString hexadécimal en unbyte[] en utilisant la méthodeDatatypeConverter: 

String originalInput = "7465737420696E707574";
byte[] result = DatatypeConverter.parseHexBinary(originalInput);

assertEquals("test input", new String(result));

5. Conclusion

Cet article explique les principes de base de l'encodage et du décodage Base64 en Java, à l'aide des nouvelles API introduites dans Java 8 et Apache Commons.

Enfin, il existe quelques autres API qui méritent d'être mentionnées pour fournir des fonctionnalités similaires - par exemplejava.xml.bind.DataTypeConverter avecprintHexBinary etparseBase64Binary.

Des extraits de code peuvent être trouvésover on GitHub.

Related