Le décodage Base64 en Java est quelque chose que j'utilise quasi quotidiennement — pour extraire des secrets depuis des variables d'environnement Kubernetes, lire des payloads binaires provenant d'API REST, ou inspecter des tokens JWT lors d'une session de débogage. La classe java.util.Base64intégrée à Java (depuis le JDK 8) propose trois variantes de décodeurs : getDecoder() pour le Base64 standard, getUrlDecoder() pour les entrées URL-safe, et getMimeDecoder()pour les données découpées en lignes comme les pièces jointes d'e-mails. Pour une vérification rapide sans écrire de code, le décodeur Base64 de ToolDeck le fait instantanément dans votre navigateur. Ce guide cible Java 8+ et couvre les trois décodeurs, le streaming avec wrap(InputStream), l'extraction de payloads JWT, le décodage de fichiers et de réponses API, Apache Commons Codec comme alternative, et les quatre erreurs qui produisent des données corrompues en production.
- ✓Base64.getDecoder().decode(s) est l'approche standard — intégrée à java.util.Base64 depuis le JDK 8, aucune dépendance requise.
- ✓Utilisez getUrlDecoder() pour les tokens JWT et les payloads OAuth — ils utilisent l'alphabet - et _, pas + et /.
- ✓getMimeDecoder() ignore les sauts de ligne et les espaces, ce qui en fait le bon choix pour les pièces jointes MIME et les certificats PEM.
- ✓decoder.wrap(InputStream) décode à la volée pour les grands fichiers sans tout charger en mémoire.
- ✓Le décodeur de base est strict — les retours à la ligne, les espaces ou les mauvais caractères d'alphabet lancent immédiatement une IllegalArgumentException.
Qu'est-ce que le décodage Base64 ?
L'encodage Base64 convertit des données binaires en une représentation ASCII de 64 caractères afin qu'elles puissent transiter en toute sécurité par des canaux textuels — champs JSON, en-têtes HTTP, documents XML, corps d'e-mails. Le décodage inverse ce processus : chaque groupe de 4 caractères Base64 correspond à 3 octets originaux. Le rembourrage =en fin de chaîne indique combien d'octets ont été ajoutés pour compléter le dernier groupe. Le Base64 n'est pas du chiffrement — n'importe qui peut l'inverser. Son rôle est la sécurité du transport, pas la confidentialité.
Scénarios Java typiques : extraction de valeurs de configuration injectées sous forme de variables d'environnement Base64, décompression du contenu binaire de fichiers issu de réponses d'API cloud, lecture de certificats encodés PEM, et inspection des payloads de tokens JWT lors du débogage.
ZGItcHJvZC51cy1lYXN0LTEuYW1hem9uYXdzLmNvbTo1NDMy
db-prod.us-east-1.amazonaws.com:5432
Base64.getDecoder().decode() — La méthode de décodage standard
La classe java.util.Base64a été ajoutée dans le JDK 8 et a remplacé l'ancien sun.misc.BASE64Decodersur lequel tout le monde s'appuyait. Aucune dépendance externe nécessaire — importez simplement java.util.Base64 et appelez Base64.getDecoder().decode(). La méthode accepte une String ou un byte[] et retourne un byte[] des données décodées.
Exemple minimal fonctionnel
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class DecodeCredential {
public static void main(String[] args) {
// Kubernetes secret value, Base64-encoded
String encoded = "ZGItcHJvZC51cy1lYXN0LTEuYW1hem9uYXdzLmNvbTo1NDMy";
byte[] decodedBytes = Base64.getDecoder().decode(encoded);
String connectionString = new String(decodedBytes, StandardCharsets.UTF_8);
System.out.println(connectionString);
// db-prod.us-east-1.amazonaws.com:5432
}
}Spécifiez toujours StandardCharsets.UTF_8 lors de la construction de la String. Le constructeur new String(bytes)sans argument utilise l'encodage par défaut de la plateforme, qui varie selon les systèmes. Sur un serveur Windows avec Cp1252 comme encodage par défaut, les caractères UTF-8 multi-octets se corrompent silencieusement.
Vérification aller-retour
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class RoundTrip {
public static void main(String[] args) {
String original = "redis://cache-prod.internal:6379/session-store";
String encoded = Base64.getEncoder().encodeToString(
original.getBytes(StandardCharsets.UTF_8)
);
System.out.println(encoded);
// cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==
byte[] decoded = Base64.getDecoder().decode(encoded);
String recovered = new String(decoded, StandardCharsets.UTF_8);
System.out.println(recovered.equals(original)); // true
}
}Décodage dans un buffer pré-alloué
La surcharge à trois arguments decode(byte[] src, byte[] dst)écrit directement dans un buffer de destination et retourne le nombre d'octets écrits. Cela évite une allocation supplémentaire sur les chemins critiques :
import java.util.Base64;
public class DecodeToBuffer {
public static void main(String[] args) {
byte[] src = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=".getBytes();
byte[] dst = new byte[1024]; // pre-allocated
int len = Base64.getDecoder().decode(src, dst);
String result = new String(dst, 0, len);
System.out.println(result);
// {"host":"10.0.1.50","port":8443}
}
}decode() lance une IllegalArgumentExceptionsi l'entrée contient des caractères hors de l'alphabet Base64 (y compris les sauts de ligne et les espaces). Si votre entrée peut contenir des espaces, passez à getMimeDecoder() ou supprimez-les avec encoded.strip() avant le décodage.Décodage Base64 avec des types non standard et des objets personnalisés
Le byte[] brut retourné par decode()doit souvent être converti en quelque chose de plus précis : un UUID, un objet Java sérialisé, un message protobuf, ou un horodatage. Le décodeur retourne toujours des octets — la conversion en types métier est de votre responsabilité.
Base64 vers UUID
import java.util.Base64;
import java.nio.ByteBuffer;
import java.util.UUID;
public class DecodeUUID {
public static UUID fromBase64(String encoded) {
byte[] bytes = Base64.getUrlDecoder().decode(encoded);
ByteBuffer bb = ByteBuffer.wrap(bytes);
return new UUID(bb.getLong(), bb.getLong());
}
public static void main(String[] args) {
// Compact Base64-encoded UUID from an API response
String encoded = "f47ac10b-58cc-4372-a567-0e02b2c3d479";
UUID original = UUID.fromString(encoded);
// Encode to Base64 (compact form — 22 chars vs 36)
ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
bb.putLong(original.getMostSignificantBits());
bb.putLong(original.getLeastSignificantBits());
String compact = Base64.getUrlEncoder().withoutPadding()
.encodeToString(bb.array());
System.out.println(compact); // 9HrBC1jMQ3KlZw4CssPUeQ
// Decode back
UUID recovered = fromBase64(compact);
System.out.println(recovered); // f47ac10b-58cc-4372-a567-0e02b2c3d479
}
}Base64 vers objet JSON désérialisé avec Jackson
import java.util.Base64;
import java.nio.charset.StandardCharsets;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.time.Instant;
public class DecodeJsonPayload {
record DeployEvent(String service, String region, Instant deployedAt, int replicas) {}
public static void main(String[] args) throws Exception {
// Base64-encoded JSON payload from a message queue
String encoded = "eyJzZXJ2aWNlIjoicGF5bWVudC1nYXRld2F5Iiwi"
+ "cmVnaW9uIjoiZXUtd2VzdC0xIiwiZGVwbG95ZWRBdCI6"
+ "IjIwMjYtMDMtMTVUMTQ6MzA6MDBaIiwicmVwbGljYXMiOjR9";
byte[] jsonBytes = Base64.getDecoder().decode(encoded);
String json = new String(jsonBytes, StandardCharsets.UTF_8);
System.out.println(json);
// {"service":"payment-gateway","region":"eu-west-1",
// "deployedAt":"2026-03-15T14:30:00Z","replicas":4}
ObjectMapper mapper = new ObjectMapper();
mapper.findAndRegisterModules(); // picks up JavaTimeModule
DeployEvent event = mapper.readValue(jsonBytes, DeployEvent.class);
System.out.println(event.service()); // payment-gateway
System.out.println(event.deployedAt()); // 2026-03-15T14:30:00Z
}
}ObjectInputStreampour désérialiser des données Base64 non fiables. Les attaques de désérialisation Java sont bien documentées — si le contenu encodé provient d'une source externe, parsez-le en JSON ou protobuf plutôt que d'utiliser la sérialisation Java native.Référence des méthodes Base64.Decoder
Toutes les méthodes appartiennent à java.util.Base64 et à sa classe interne Base64.Decoder. Les trois méthodes factory sur Base64 retournent des instances de décodeur différentes ; les méthodes decode() et wrap() se trouvent sur l'instance Decoder.
getMimeDecoder() — Décodage du Base64 MIME et découpé en lignes
Le décodeur de base rejette tout ce qui est hors de l'alphabet Base64 — y compris les sauts de ligne \r\nque le contenu encodé MIME contient toujours. Les pièces jointes d'e-mails, les certificats PEM et certaines anciennes réponses API découpent la sortie Base64 à 76 caractères par ligne. getMimeDecoder()ignore silencieusement les séparateurs de ligne et tout caractère absent de l'alphabet Base64, ce qui lui permet de gérer cela nativement.
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class MimeDecode {
public static void main(String[] args) {
// PEM certificate body — line-wrapped at 76 characters
String pemBody = "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t\r\n"
+ "TUlJQm96Q0NBVWlnQXdJQkFnSUpBSXBhVDJU\r\n"
+ "aVFvZU1BMEdDU3FHU0liM0RRRU==";
// getDecoder() would throw IllegalArgumentException here
byte[] decoded = Base64.getMimeDecoder().decode(pemBody);
System.out.println(new String(decoded, StandardCharsets.UTF_8));
// -----BEGIN CERTIFICATE-----
// MIIBozCCAUigAwIBAgIJAIpaT2T...
}
}getMimeDecoder()est tolérant : il passe au-dessus des caractères invalides sans lancer d'exception. C'est acceptable pour des données MIME connues, mais cela peut silencieusement avaler des corruptions dans une entrée arbitraire. Utilisez getDecoder() quand vous voulez une validation stricte.Décoder du Base64 depuis un fichier et une réponse API
Lecture d'un fichier encodé en Base64 depuis le disque
Les fichiers binaires (images, certificats, blobs chiffrés) sont parfois stockés sur disque sous forme de texte Base64. Lisez le fichier, décodez-le, puis écrivez la sortie binaire :
import java.util.Base64;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
public class DecodeFile {
public static void main(String[] args) {
Path inputPath = Path.of("tls-cert.pem.b64");
Path outputPath = Path.of("tls-cert.pem");
try {
String encoded = Files.readString(inputPath).strip();
byte[] decoded = Base64.getMimeDecoder().decode(encoded);
Files.write(outputPath, decoded);
System.out.printf("Decoded %d bytes → %s%n", decoded.length, outputPath);
} catch (IOException e) {
System.err.println("File error: " + e.getMessage());
} catch (IllegalArgumentException e) {
System.err.println("Invalid Base64: " + e.getMessage());
}
}
}Décodage d'un champ Base64 depuis une réponse d'API HTTP
Les API cloud (AWS KMS, GitHub Contents, Vault) retournent fréquemment des données binaires sous forme de chaînes Base64 dans du JSON. Parsez d'abord le JSON, puis décodez le champ cible :
import java.util.Base64;
import java.nio.charset.StandardCharsets;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class DecodeApiResponse {
public static void main(String[] args) {
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/secrets/db-password"))
.header("Authorization", "Bearer sk-prod-9f8e7d6c")
.build();
try {
HttpResponse<String> response = client.send(
request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() != 200) {
System.err.printf("Unexpected status: %d%n", response.statusCode());
return;
}
ObjectMapper mapper = new ObjectMapper();
JsonNode root = mapper.readTree(response.body());
// API returns: {"name":"db-password","value":"cG9zdGdyZXM6eGs5...","version":3}
String encodedValue = root.get("value").asText();
byte[] decoded = Base64.getDecoder().decode(encodedValue);
String secret = new String(decoded, StandardCharsets.UTF_8);
System.out.println("Secret: " + secret);
// Secret: postgres:xk9mP2qR@db-prod:5432/orders
} catch (Exception e) {
System.err.println("Failed to fetch secret: " + e.getMessage());
}
}
}IllegalArgumentException séparément des erreurs réseau. Mélanger les exceptions I/O avec les échecs de décodage complique le débogage — vous voulez savoir immédiatement si l'API a retourné des données invalides ou si le réseau a échoué.Décodage Base64 en ligne de commande
Vous n'avez pas toujours besoin d'un programme Java. Chaque système Linux et macOS dispose d'une commande base64, et le JDK 9+ embarque jshellpour des one-liners Java interactifs. Pour une inspection rapide lors du débogage, c'est plus rapide que de compiler une classe.
# Decode a Base64 string (Linux / macOS)
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode
# {"host":"10.0.1.50","port":8443}
# Decode and pretty-print with jq
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode | jq .
# {
# "host": "10.0.1.50",
# "port": 8443
# }
# Quick decode with jshell (JDK 9+)
echo 'System.out.println(new String(java.util.Base64.getDecoder().decode("c2VydmVyLWNvbmZpZw==")))' | jshell -
# server-config
# macOS uses -D instead of --decode
echo "c2VydmVyLWNvbmZpZw==" | base64 -DPour coller des chaînes encodées directement dans un navigateur, le décodeur Base64 de ToolDeck gère à la fois les variantes standard et URL-safe sans aucune configuration.
Alternative performante : Apache Commons Codec
Le java.util.Base64intégré à Java est déjà bien optimisé — le JDK 11+ utilise des intrinsics x86 pour l'encodage et le décodage. Pour la plupart des applications, il n'y a aucune raison de recourir à une bibliothèque tierce. Cela dit, Apache Commons Codec reste populaire dans les codebases legacy et offre Base64InputStream pour le décodage en streaming avec gestion automatique des espaces blancs.
<!-- pom.xml -->
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.17.0</version>
</dependency>import org.apache.commons.codec.binary.Base64;
public class CommonsCodecDecode {
public static void main(String[] args) {
// Commons Codec is more lenient — handles whitespace and line breaks
String encoded = "eyJob3N0IjoiMTAuMC4xLjUw\nIiwicG9ydCI6ODQ0M30=";
byte[] decoded = Base64.decodeBase64(encoded);
System.out.println(new String(decoded));
// {"host":"10.0.1.50","port":8443}
}
}Le principal avantage de Commons Codec par rapport à l'API intégrée est sa tolérance aux espaces blancs par défaut et sa classe Base64InputStream qui précède le decoder.wrap()de Java. Si vous êtes sur Java 8+, l'API intégrée couvre tout ce que fait Commons Codec. Je ne recours à Commons Codec que si le projet en dépend déjà.
Streaming de grands fichiers Base64 avec decoder.wrap()
Charger un fichier Base64 de 200 Mo avec Files.readString() puis appeler decode()alloue environ 350 Mo de heap : la chaîne encodée plus le tableau d'octets décodés. decoder.wrap(InputStream)décode à la volée et maintient l'utilisation mémoire constante.
import java.util.Base64;
import java.io.*;
import java.nio.file.*;
public class StreamDecode {
public static void main(String[] args) throws IOException {
Path src = Path.of("database-dump.sql.b64");
Path dst = Path.of("database-dump.sql");
try (InputStream in = Base64.getMimeDecoder().wrap(
new BufferedInputStream(Files.newInputStream(src)));
OutputStream out = new BufferedOutputStream(Files.newOutputStream(dst))) {
byte[] buffer = new byte[8192];
int bytesRead;
long total = 0;
while ((bytesRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
total += bytesRead;
}
System.out.printf("Decoded %d bytes → %s%n", total, dst);
}
}
}Sur Java 9+, vous pouvez remplacer la boucle de lecture par in.transferTo(out) — cela fait la même chose avec moins de code. Utilisez getMimeDecoder().wrap() plutôt que getDecoder().wrap()si le fichier peut contenir des sauts de ligne (fichiers PEM, exports d'e-mails).
import java.util.Base64;
import java.io.*;
import java.nio.file.*;
public class StreamDecodeSimple {
public static void main(String[] args) throws IOException {
try (InputStream in = Base64.getMimeDecoder().wrap(
new BufferedInputStream(Files.newInputStream(Path.of("backup.tar.b64"))));
OutputStream out = Files.newOutputStream(Path.of("backup.tar"))) {
in.transferTo(out); // Java 9+
}
}
}getDecoder().wrap() ne tolère pas les sauts de ligne dans le flux. Si les données Base64 contiennent des retours à la ligne (découpées à 76 caractères), utilisez getMimeDecoder().wrap() à la place — sinon le flux produit silencieusement une sortie corrompue ou lance une exception à une position de lecture imprévisible.Décoder le payload Base64 d'un JWT en Java sans bibliothèque JWT
Un JWT est composé de trois segments encodés en Base64url réunis par des points. Le segment du milieu est le payload — la partie qui vous intéresse lors du débogage. Vous pouvez le décoder sans ajouter jjwt ou Nimbus. Découpez sur ., décodez la deuxième partie avec getUrlDecoder(), et parsez le JSON résultant :
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class JWTInspect {
public static String decodeJwtPayload(String token) {
String[] parts = token.split("\\.");
if (parts.length != 3) {
throw new IllegalArgumentException(
"Invalid JWT: expected 3 segments, got " + parts.length);
}
// JWT uses URL-safe Base64 without padding
byte[] payload = Base64.getUrlDecoder().decode(parts[1]);
return new String(payload, StandardCharsets.UTF_8);
}
public static void main(String[] args) {
String token = "eyJhbGciOiJSUzI1NiJ9"
+ ".eyJzdWIiOiJ1c3ItNjcyIiwiaXNzIjoiYXV0aC5leGFtcGxlLmNvbSIs"
+ "ImV4cCI6MTc0MTk1NjgwMCwicm9sZXMiOlsiYWRtaW4iLCJiaWxsaW5nIl19"
+ ".SIGNATURE_PLACEHOLDER";
String payload = decodeJwtPayload(token);
System.out.println(payload);
// {"sub":"usr-672","iss":"auth.example.com",
// "exp":1741956800,"roles":["admin","billing"]}
}
}Erreurs courantes
J'ai rencontré chacune de ces erreurs lors de revues de code, et les deux premières représentent la grande majorité des bugs Base64 en production dans les services Java.
Problème : Les tokens JWT et les tokens d'accès OAuth utilisent l'alphabet URL-safe (- et _). Les passer à getDecoder() lance une IllegalArgumentException car - n'est pas dans l'alphabet Base64 standard.
Solution : Vérifiez la source de vos données : les tokens des systèmes d'authentification nécessitent getUrlDecoder() ; les pièces jointes MIME nécessitent getMimeDecoder().
// JWT header — URL-safe, no padding String header = "eyJhbGciOiJSUzI1NiJ9"; byte[] decoded = Base64.getDecoder().decode(header); // IllegalArgumentException: Illegal base64 character 2d
String header = "eyJhbGciOiJSUzI1NiJ9";
byte[] decoded = Base64.getUrlDecoder().decode(header);
System.out.println(new String(decoded));
// {"alg":"RS256"}Problème : new String(bytes) utilise le charset par défaut de la JVM, qui diffère selon les environnements. Un serveur CI Linux (UTF-8) et un hôte de production Windows (Cp1252) produisent des résultats différents pour les mêmes octets.
Solution : Passez toujours StandardCharsets.UTF_8 comme second argument.
byte[] decoded = Base64.getDecoder().decode(encoded); String result = new String(decoded); // platform-dependent — may corrupt multi-byte characters
byte[] decoded = Base64.getDecoder().decode(encoded); String result = new String(decoded, StandardCharsets.UTF_8); // consistent across all platforms
Problème : Les chaînes Base64 collées depuis des terminaux ou lues depuis des fichiers de configuration ont souvent des retours à la ligne en fin de chaîne. Le décodeur de base rejette tout caractère hors de l'alphabet Base64.
Solution : Appelez .strip() sur l'entrée avant le décodage, ou passez à getMimeDecoder() qui ignore les espaces blancs.
// Read from environment variable — has a trailing newline
String encoded = System.getenv("DB_PASSWORD_B64"); // "cG9zdGdyZXM=
"
byte[] decoded = Base64.getDecoder().decode(encoded);
// IllegalArgumentException: Illegal base64 character aString encoded = System.getenv("DB_PASSWORD_B64");
byte[] decoded = Base64.getDecoder().decode(encoded.strip());
System.out.println(new String(decoded, StandardCharsets.UTF_8));
// postgresProblème : Appeler new String(decoded) sur du contenu binaire (images, protobuf, blobs chiffrés) produit une String invalide. La reconvertir ensuite en octets corrompt silencieusement les données car le constructeur String remplace les séquences UTF-8 invalides.
Solution : Conservez les données binaires sous forme de byte[] tout au long de votre pipeline. Convertissez en String uniquement lorsque vous savez que le contenu est du texte.
byte[] decoded = Base64.getDecoder().decode(pngBase64);
String imageStr = new String(decoded); // corrupts binary
Files.writeString(Path.of("image.png"), imageStr); // broken filebyte[] decoded = Base64.getDecoder().decode(pngBase64);
// Write bytes directly — no String conversion
Files.write(Path.of("image.png"), decoded);Comparaison des méthodes
Les décodeurs intégrés couvrent la plupart des cas d'usage. Apache Commons Codec et Guava sont des alternatives que vous pouvez rencontrer dans des codebases anciens.
Pour les tokens JWT et les payloads d'API modernes : getUrlDecoder(). Pour les pièces jointes d'e-mails et les certificats PEM : getMimeDecoder(). Pour les grands fichiers où la mémoire est un enjeu : decoder.wrap(InputStream). Pour tout le reste : getDecoder(). Apache Commons Codec n'a de sens que s'il est déjà dans votre arbre de dépendances.
Pour une vérification rapide pendant le développement, le décodeur Base64 en ligne est plus rapide qu'écrire une classe à usage unique.
Questions fréquentes
Comment décoder une chaîne Base64 en Java ?
Importez java.util.Base64 et appelez Base64.getDecoder().decode(encodedString). La méthode retourne un byte[] — enveloppez-le avec new String(bytes, StandardCharsets.UTF_8) pour obtenir du texte lisible. Pour le Base64 URL-safe (utilisé dans les JWT), remplacez getDecoder() par getUrlDecoder().
import java.util.Base64;
import java.nio.charset.StandardCharsets;
byte[] decoded = Base64.getDecoder().decode("c2VydmVyLWNvbmZpZw==");
String result = new String(decoded, StandardCharsets.UTF_8);
System.out.println(result); // server-configQuelle est la différence entre getDecoder() et getMimeDecoder() en Java ?
getDecoder() est strict — il rejette tout caractère hors de l'alphabet Base64, y compris les sauts de ligne. getMimeDecoder() tolère les séparateurs de ligne (\r\n) et ignore les caractères non-Base64, ce qui en fait le bon choix pour décoder les pièces jointes d'e-mails et les certificats PEM dont les données sont découpées à 76 caractères par ligne.
String wrapped = "c2VydmVyLWNv\r\nbmZpZw=="; // getDecoder() throws IllegalArgumentException // Base64.getDecoder().decode(wrapped); // FAILS // getMimeDecoder() handles it byte[] decoded = Base64.getMimeDecoder().decode(wrapped); System.out.println(new String(decoded)); // server-config
Comment décoder une chaîne Base64 URL-safe en Java ?
Utilisez Base64.getUrlDecoder().decode(encoded). Le décodeur URL attend l'alphabet - et _ défini par la RFC 4648 §5 au lieu de + et /. Les tokens JWT utilisent toujours cet alphabet. Si les caractères de rembourrage (=) ont été supprimés (courant dans les JWT), le décodeur URL gère quand même l'entrée — le décodeur URL de Java accepte à la fois les entrées avec et sans rembourrage.
import java.util.Base64;
// JWT header — URL-safe, no padding
String jwtHeader = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
byte[] decoded = Base64.getUrlDecoder().decode(jwtHeader);
System.out.println(new String(decoded));
// {"alg":"HS256","typ":"JWT"}Comment décoder en streaming un large fichier Base64 en Java ?
Utilisez decoder.wrap(inputStream) pour envelopper un FileInputStream. L'InputStream retourné décode le Base64 à la volée au fur et à mesure de la lecture des octets, de sorte que l'utilisation mémoire reste constante quelle que soit la taille du fichier. Enchaînez-le avec un BufferedInputStream ou directement avec Files.copy() pour de meilleures performances.
import java.util.Base64;
import java.io.*;
import java.nio.file.*;
try (InputStream in = Base64.getDecoder().wrap(
new BufferedInputStream(new FileInputStream("payload.b64")));
OutputStream out = new FileOutputStream("payload.bin")) {
in.transferTo(out);
}Pourquoi Base64.getDecoder().decode() lance-t-il une IllegalArgumentException ?
Le décodeur de base est strict : il rejette les sauts de ligne, les espaces et tout caractère hors de A-Za-z0-9+/=. Trois causes fréquentes : l'entrée contient des retours à la ligne en fin de chaîne (utilisez trim()), l'entrée utilise des caractères URL-safe comme - et _ (passez à getUrlDecoder()), ou l'entrée a été découpée à 76 caractères (passez à getMimeDecoder()). Inspectez toujours les octets bruts si le message d'erreur n'est pas clair.
String raw = "c2VydmVyLWNvbmZpZw==\n"; // trailing newline // Option 1: trim whitespace byte[] decoded = Base64.getDecoder().decode(raw.strip()); // Option 2: use MIME decoder which ignores whitespace byte[] decoded2 = Base64.getMimeDecoder().decode(raw);
Puis-je décoder du Base64 en Java sans java.util.Base64 ?
Oui, mais il n'y a aucune bonne raison de le faire sur Java 8+. Avant Java 8, les développeurs utilisaient sun.misc.BASE64Decoder (interne, supprimé dans Java 9+), javax.xml.bind.DatatypeConverter.parseBase64Binary() (supprimé dans Java 11), ou Apache Commons Codec. Ces trois options sont soit dépréciées, soit nécessitent une dépendance supplémentaire. Restez avec java.util.Base64 — c'est plus rapide, livré avec le JDK, et couvre les trois variantes (basic, URL-safe, MIME).
Outils associés
- Encodeur Base64 — encodez du texte ou des données binaires en Base64 dans le navigateur, pratique pour générer des fixtures de test à coller dans vos tests unitaires Java.
- Décodeur JWT — découpez et décodez les trois segments JWT en une seule fois, avec inspection champ par champ du payload — plus rapide qu'écrire une classe Java quand vous avez juste besoin de lire un token.
- Décodeur URL — décodez les chaînes encodées par percent-encoding, utile quand les réponses API combinent des données Base64url avec des paramètres de requête percent-encodés.
- Formateur JSON — après avoir décodé un payload JWT ou une config API en Base64, collez le JSON ici pour l'afficher joliment et valider la structure.