La decodifica Base64 in Java è qualcosa a cui ricorro ogni pochi giorni — per estrarre segreti dalle variabili d'ambiente di Kubernetes, leggere payload binari da REST API, ispezionare token JWT durante una sessione di debug. La classe java.util.Base64 integrata in Java (dal JDK 8) offre tre varianti di decoder: getDecoder() per Base64 standard, getUrlDecoder() per input URL-safe e getMimeDecoder() per dati mandati a capo come gli allegati email. Per una verifica rapida senza scrivere codice, il decodificatore Base64 di ToolDeck lo gestisce istantaneamente nel browser. Questa guida è rivolta a Java 8+ e copre tutti e tre i decoder, lo streaming con wrap(InputStream), l'estrazione del payload JWT, la decodifica di file e risposte API, Apache Commons Codec come alternativa, e i quattro errori che producono output corrotto in produzione.
- ✓Base64.getDecoder().decode(s) è l'approccio standard — integrato in java.util.Base64 dal JDK 8, senza dipendenze.
- ✓Usa getUrlDecoder() per token JWT e payload OAuth — utilizzano l'alfabeto - e _, non + e /.
- ✓getMimeDecoder() ignora a capo e spazi, rendendolo la scelta giusta per allegati email e certificati PEM.
- ✓decoder.wrap(InputStream) decodifica al volo per file di grandi dimensioni senza caricare tutto in memoria.
- ✓Il decoder di base è rigido — newline in coda, spazi o caratteri dell'alfabeto errato lanciano immediatamente IllegalArgumentException.
Cos'è la decodifica Base64?
La codifica Base64 converte dati binari in una rappresentazione ASCII a 64 caratteri in modo che possano transitare in sicurezza attraverso canali solo testo — campi JSON, header HTTP, documenti XML, corpo delle email. La decodifica inverte questo processo: ogni 4 caratteri Base64 corrispondono a 3 byte originali. Il padding = alla fine segnala quanti byte sono stati aggiunti per completare l'ultimo gruppo. Base64 non è crittografia — chiunque può invertirlo. Il suo scopo è la sicurezza del trasporto, non la segretezza.
Scenari tipici di decodifica in Java: estrarre valori di configurazione iniettati come variabili d'ambiente Base64, spacchettare contenuti di file binari da risposte di cloud API, leggere certificati PEM codificati e ispezionare payload di token JWT durante il debug.
ZGItcHJvZC51cy1lYXN0LTEuYW1hem9uYXdzLmNvbTo1NDMy
db-prod.us-east-1.amazonaws.com:5432
Base64.getDecoder().decode() — Il metodo di decodifica standard
La classe java.util.Base64 è stata aggiunta nel JDK 8 e ha sostituito il vecchio sun.misc.BASE64Decoder su cui tutti facevano affidamento. Nessuna dipendenza esterna necessaria — basta import java.util.Base64 e chiamare Base64.getDecoder().decode(). Il metodo accetta una String o un byte[] e restituisce un byte[] con i dati decodificati.
Esempio minimale funzionante
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class DecodeCredential {
public static void main(String[] args) {
// Valore segreto di Kubernetes, codificato in Base64
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
}
}Specifica sempre StandardCharsets.UTF_8 quando costruisci la String. Il costruttore new String(bytes) senza argomenti usa la codifica predefinita della piattaforma, che varia tra sistemi. Su un server Windows con Cp1252 come default, i caratteri UTF-8 multi-byte vengono silenziosamente corrotti.
Verifica del round-trip
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
}
}Decodifica in un buffer pre-allocato
L'overload a tre argomenti decode(byte[] src, byte[] dst)scrive direttamente in un buffer di destinazione e restituisce il numero di byte scritti. Questo evita un'allocazione aggiuntiva sui percorsi critici:
import java.util.Base64;
public class DecodeToBuffer {
public static void main(String[] args) {
byte[] src = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=".getBytes();
byte[] dst = new byte[1024]; // pre-allocato
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() lancia IllegalArgumentExceptionse l'input contiene caratteri fuori dall'alfabeto Base64 (inclusi a capo e spazi). Se il tuo input potrebbe avere spazi, passa a getMimeDecoder() oppure rimuovili con encoded.strip() prima della decodifica.Decodifica Base64 con tipi non standard e oggetti personalizzati
Il byte[] grezzo restituito da decode() spesso deve diventare qualcosa di più specifico: un UUID, un oggetto Java serializzato, un messaggio protobuf o un timestamp. Il decoder restituisce sempre byte — la conversione in tipi di dominio è responsabilità tua.
Da Base64 a 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) {
// UUID compatto codificato in Base64 da una risposta API
String encoded = "f47ac10b-58cc-4372-a567-0e02b2c3d479";
UUID original = UUID.fromString(encoded);
// Codifica in Base64 (forma compatta — 22 caratteri 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
// Decodifica di ritorno
UUID recovered = fromBase64(compact);
System.out.println(recovered); // f47ac10b-58cc-4372-a567-0e02b2c3d479
}
}Da Base64 a oggetto JSON deserializzato con 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 {
// Payload JSON codificato in Base64 da una coda di messaggi
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
}
}ObjectInputStream per deserializzare dati Base64 non attendibili. Gli attacchi di deserializzazione Java sono ben documentati — se il contenuto codificato proviene da una fonte esterna, analizzalo come JSON o protobuf invece di usare la serializzazione nativa Java.Riferimento ai metodi di Base64.Decoder
Tutti i metodi appartengono a java.util.Base64 e alla sua classe interna Base64.Decoder. I tre metodi factory su Base64 restituiscono istanze di decoder diverse; i metodi decode() e wrap() si trovano sull'istanza Decoder.
getMimeDecoder() — Decodifica di Base64 MIME e mandato a capo
Il decoder di base rifiuta qualsiasi cosa fuori dall'alfabeto Base64 — e questo include i caratteri \r\nche il contenuto MIME contiene sempre. Allegati email, certificati PEM e alcune risposte API più vecchie mandano a capo l'output Base64 ogni 76 caratteri per riga. getMimeDecoder()ignora silenziosamente i separatori di riga e qualsiasi carattere non nell'alfabeto Base64, gestendolo senza configurazioni aggiuntive.
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class MimeDecode {
public static void main(String[] args) {
// Corpo di certificato PEM — mandato a capo ogni 76 caratteri
String pemBody = "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t\r\n"
+ "TUlJQm96Q0NBVWlnQXdJQkFnSUpBSXBhVDJU\r\n"
+ "aVFvZU1BMEdDU3FHU0liM0RRRU==";
// getDecoder() lancerebbe IllegalArgumentException qui
byte[] decoded = Base64.getMimeDecoder().decode(pemBody);
System.out.println(new String(decoded, StandardCharsets.UTF_8));
// -----BEGIN CERTIFICATE-----
// MIIBozCCAUigAwIBAgIJAIpaT2T...
}
}getMimeDecoder()è permissivo: salta i caratteri non validi invece di lanciare un'eccezione. Va bene per dati MIME noti, ma può inghiottire silenziosamente corruzione in input arbitrario. Usa getDecoder() quando vuoi una validazione rigorosa.Decodifica Base64 da file e risposta API
Lettura di un file codificato in Base64 dal disco
I file binari (immagini, certificati, blob cifrati) vengono a volte salvati su disco come testo Base64. Leggi il file, decodifica, scrivi l'output binario:
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());
}
}
}Decodifica di un campo Base64 da una risposta API HTTP
Le cloud API (AWS KMS, GitHub Contents, Vault) restituiscono spesso dati binari come stringhe Base64 all'interno di JSON. Analizza prima il JSON, poi decodifica il campo target:
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());
// L'API restituisce: {"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());
}
}
}try-catch per IllegalArgumentExceptionseparatamente dagli errori di rete. Mescolare eccezioni I/O con errori di decodifica rende il debug più difficile — vuoi sapere immediatamente se l'API ha restituito dati errati o se la rete ha fallito.Decodifica Base64 dalla riga di comando
Non sempre serve un programma Java. Ogni sistema Linux e macOS ha un comando base64, e JDK 9+ include jshell per one-liner Java interattivi. Per una rapida ispezione durante il debug, questi sono più veloci che compilare una classe.
# Decodifica una stringa Base64 (Linux / macOS)
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode
# {"host":"10.0.1.50","port":8443}
# Decodifica e formatta con jq
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode | jq .
# {
# "host": "10.0.1.50",
# "port": 8443
# }
# Decodifica rapida con jshell (JDK 9+)
echo 'System.out.println(new String(java.util.Base64.getDecoder().decode("c2VydmVyLWNvbmZpZw==")))' | jshell -
# server-config
# macOS usa -D invece di --decode
echo "c2VydmVyLWNvbmZpZw==" | base64 -DPer incollare stringhe codificate direttamente nel browser, il decodificatore Base64 di ToolDeck gestisce sia la variante standard che quella URL-safe senza alcuna configurazione.
Alternativa ad alte prestazioni: Apache Commons Codec
Il java.util.Base64integrato in Java è già ben ottimizzato — JDK 11+ usa le istruzioni intrinseche x86 per codifica e decodifica. Per la maggior parte delle applicazioni, non c'è motivo di ricorrere a una libreria di terze parti. Detto questo, Apache Commons Codec rimane popolare nelle codebase legacy e offre Base64InputStream per la decodifica in streaming con gestione automatica degli spazi.
<!-- 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 è più permissivo — gestisce spazi e a capo
String encoded = "eyJob3N0IjoiMTAuMC4xLjUw\nIiwicG9ydCI6ODQ0M30=";
byte[] decoded = Base64.decodeBase64(encoded);
System.out.println(new String(decoded));
// {"host":"10.0.1.50","port":8443}
}
}Il principale vantaggio di Commons Codec rispetto all'API integrata è la sua permissività con gli spazi per default e la classe Base64InputStream che precede il decoder.wrap()di Java. Se sei su Java 8+, l'API integrata copre tutto ciò che fa Commons Codec. Ricorro a Commons Codec solo quando il progetto ne dipende già.
Streaming di file Base64 di grandi dimensioni con decoder.wrap()
Caricare un file Base64 da 200 MB con Files.readString() e poi chiamare decode()alloca circa 350 MB di heap: la stringa codificata più l'array di byte decodificato. decoder.wrap(InputStream)decodifica al volo, mantenendo l'utilizzo della memoria costante.
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);
}
}
}Su Java 9+ puoi sostituire il ciclo di lettura con in.transferTo(out) — fa la stessa cosa con meno codice. Usa getMimeDecoder().wrap() invece di getDecoder().wrap() se il file potrebbe contenere a capo (file PEM, export email).
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() non tollera a capo nello stream. Se i dati Base64 contengono newline (mandati a capo ogni 76 caratteri), usa getMimeDecoder().wrap()— altrimenti lo stream produce output corrotto silenziosamente o lancia un'eccezione in una posizione di lettura imprevedibile.Decodifica del payload JWT Base64 in Java senza una libreria JWT
Un JWT è composto da tre segmenti codificati in Base64url separati da punti. Il segmento centrale è il payload — la parte che ti interessa durante il debug. Puoi decodificarlo senza importare jjwt o Nimbus. Dividi su ., decodifica la seconda parte con getUrlDecoder() e analizza il JSON risultante:
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 usa Base64 URL-safe senza 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"]}
}
}Errori comuni
Ho incontrato ognuno di questi in code review, e i primi due rappresentano la grande maggioranza dei bug in produzione legati a Base64 nei servizi Java.
Problema: I token JWT e i token di accesso OAuth usano l'alfabeto URL-safe (- e _). Passarli a getDecoder() lancia IllegalArgumentException perché - non è nell'alfabeto Base64 standard.
Soluzione: Controlla la fonte dei dati: i token dei sistemi di autenticazione richiedono getUrlDecoder(); gli allegati MIME richiedono getMimeDecoder().
// JWT header — URL-safe, senza 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"}Problema: new String(bytes) usa il charset predefinito della JVM, che differisce tra ambienti. Un server CI Linux (UTF-8) e un host di produzione Windows (Cp1252) producono risultati diversi per gli stessi byte.
Soluzione: Passa sempre StandardCharsets.UTF_8 come secondo argomento.
byte[] decoded = Base64.getDecoder().decode(encoded); String result = new String(decoded); // dipende dalla piattaforma — può corrompere i caratteri multi-byte
byte[] decoded = Base64.getDecoder().decode(encoded); String result = new String(decoded, StandardCharsets.UTF_8); // consistente su tutte le piattaforme
Problema: Le stringhe Base64 incollate da terminali o lette da file di configurazione spesso hanno newline in coda. Il decoder di base rifiuta qualsiasi carattere fuori dall'alfabeto Base64.
Soluzione: Chiama .strip() sull'input prima della decodifica, oppure passa a getMimeDecoder() che ignora gli spazi.
// Letto da variabile d'ambiente — ha un newline in coda
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));
// postgresProblema: Chiamare new String(decoded) su contenuto binario (immagini, protobuf, blob cifrati) produce una String non valida. Riconvertirla in byte in seguito corrompe silenziosamente i dati perché il costruttore String sostituisce le sequenze UTF-8 non valide.
Soluzione: Mantieni i dati binari come byte[] lungo tutta la pipeline. Converti in String solo quando sai che il contenuto è testo.
byte[] decoded = Base64.getDecoder().decode(pngBase64);
String imageStr = new String(decoded); // corrompe il binario
Files.writeString(Path.of("image.png"), imageStr); // file danneggiatobyte[] decoded = Base64.getDecoder().decode(pngBase64);
// Scrivi i byte direttamente — nessuna conversione a String
Files.write(Path.of("image.png"), decoded);Confronto tra metodi
I decoder integrati coprono la maggior parte dei casi d'uso. Apache Commons Codec e Guava sono alternative che potresti trovare in codebase più vecchie.
Per token JWT e payload API moderni: getUrlDecoder(). Per allegati email e certificati PEM: getMimeDecoder(). Per file di grandi dimensioni dove la memoria è un fattore: decoder.wrap(InputStream). Per tutto il resto: getDecoder(). Apache Commons Codec ha senso solo se è già nel tuo albero delle dipendenze.
Per una verifica rapida durante lo sviluppo, il decodificatore Base64 online è più veloce che scrivere una classe usa e getta.
Domande frequenti
Come si decodifica una stringa Base64 in Java?
Importa java.util.Base64 e chiama Base64.getDecoder().decode(encodedString). Restituisce un byte[] — avvolgilo con new String(bytes, StandardCharsets.UTF_8) per ottenere testo leggibile. Per Base64 URL-safe (usato nei JWT), sostituisci getDecoder() con 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-configQual è la differenza tra getDecoder() e getMimeDecoder() in Java?
getDecoder() è rigido — rifiuta qualsiasi carattere fuori dall'alfabeto Base64, inclusi gli a capo. getMimeDecoder() tollera i separatori di riga (\r\n) e ignora i caratteri non Base64, rendendolo la scelta giusta per decodificare allegati email e certificati PEM in cui i dati sono mandati a capo ogni 76 caratteri.
String wrapped = "c2VydmVyLWNv\r\nbmZpZw=="; // getDecoder() lancia IllegalArgumentException // Base64.getDecoder().decode(wrapped); // FALLISCE // getMimeDecoder() lo gestisce correttamente byte[] decoded = Base64.getMimeDecoder().decode(wrapped); System.out.println(new String(decoded)); // server-config
Come si decodifica una stringa Base64 URL-safe in Java?
Usa Base64.getUrlDecoder().decode(encoded). Il decoder URL si aspetta l'alfabeto - e _ definito in RFC 4648 §5 al posto di + e /. I token JWT usano sempre questo alfabeto. Se i caratteri di padding (=) sono stati rimossi (comune nei JWT), il decoder URL lo gestisce comunque — il decoder URL di Java accetta input sia con che senza padding.
import java.util.Base64;
// JWT header — URL-safe, senza padding
String jwtHeader = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
byte[] decoded = Base64.getUrlDecoder().decode(jwtHeader);
System.out.println(new String(decoded));
// {"alg":"HS256","typ":"JWT"}Come si decodifica in streaming un file Base64 di grandi dimensioni in Java?
Usa decoder.wrap(inputStream) per avvolgere un FileInputStream. L'InputStream restituito decodifica il Base64 al volo mentre leggi i byte, quindi l'utilizzo della memoria rimane costante indipendentemente dalla dimensione del file. Convoglialo attraverso un BufferedInputStream o direttamente in Files.copy() per la massima efficienza.
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);
}Perché Base64.getDecoder().decode() lancia IllegalArgumentException?
Il decoder di base è rigido: rifiuta a capo, spazi e qualsiasi carattere fuori dall'alfabeto A-Za-z0-9+/=. Tre cause comuni: l'input ha newline in coda (usa trim), l'input usa caratteri URL-safe come - e _ (passa a getUrlDecoder()), oppure l'input era mandato a capo ogni 76 caratteri (passa a getMimeDecoder()). Ispeziona sempre i byte grezzi se il messaggio di errore non è chiaro.
String raw = "c2VydmVyLWNvbmZpZw==\n"; // newline in coda // Opzione 1: rimuovi gli spazi byte[] decoded = Base64.getDecoder().decode(raw.strip()); // Opzione 2: usa il decoder MIME che ignora gli spazi byte[] decoded2 = Base64.getMimeDecoder().decode(raw);
Si può decodificare Base64 in Java senza java.util.Base64?
Sì, ma non c'è alcun motivo valido per farlo su Java 8+. Prima di Java 8, gli sviluppatori usavano sun.misc.BASE64Decoder (interno, rimosso in Java 9+), javax.xml.bind.DatatypeConverter.parseBase64Binary() (rimosso in Java 11), o Apache Commons Codec. Tutti e tre sono deprecati o richiedono una dipendenza aggiuntiva. Usa java.util.Base64 — è più veloce, è incluso nel JDK e copre tutte e tre le varianti (basic, URL-safe, MIME).
Strumenti correlati
- Codificatore Base64 — codifica testo o dati binari in Base64 nel browser, utile per generare fixture di test da incollare nei tuoi unit test Java.
- Decodificatore JWT — divide e decodifica tutti e tre i segmenti JWT in una volta, con ispezione campo per campo del payload — più veloce che scrivere una classe Java quando devi solo leggere un token.
- Decodificatore URL — decodifica stringhe con percent-encoding, utile quando le risposte API combinano dati Base64url con parametri di query percent-encoded.
- Formattatore JSON — dopo aver decodificato un payload JWT Base64 o una configurazione API, incolla il JSON qui per formattarlo e validarne la struttura.