Dekódování Base64 v Javě je něco, po čem sáhnu každých pár dní — vytahuji tajemství z Kubernetes proměnných prostředí, čtu binární payloady z REST API, při ladění prozkoumávám JWT tokeny. Vestavěná třída java.util.Base64 (od JDK 8) poskytuje tři varianty dekodéru: getDecoder() pro standardní Base64, getUrlDecoder() pro URL-safe vstup a getMimeDecoder() pro zalomená data jako e-mailové přílohy. Pro rychlou jednorázovou kontrolu bez psaní kódu zvládne Base64 dekodér ToolDecku vše okamžitě v prohlížeči. Tento průvodce cílí na Java 8+ a pokrývá všechny tři dekodéry, streaming přes wrap(InputStream), extrakci JWT payloadů, dekódování souborů a odpovědí API, Apache Commons Codec jako alternativu a čtyři chyby, které způsobují nesmyslný výstup v produkci.
- ✓Base64.getDecoder().decode(s) je standardní přístup — zabudovaný v java.util.Base64 od JDK 8, bez potřeby závislostí.
- ✓Pro JWT tokeny a OAuth payloady použijte getUrlDecoder() — ty používají abecedu - a _, nikoliv + a /.
- ✓getMimeDecoder() ignoruje zalomení řádků a mezery, takže je správnou volbou pro e-mailové přílohy a PEM certifikáty.
- ✓decoder.wrap(InputStream) dekóduje průběžně za běhu pro velké soubory bez načítání všeho do paměti.
- ✓Základní dekodér je striktní — závěrečné znaky nového řádku, mezery nebo znaky ze špatné abecedy okamžitě vyhodí IllegalArgumentException.
Co je dekódování Base64?
Base64 kódování převádí binární data do 64-znakové ASCII reprezentace, aby mohla bezpečně procházet textovými kanály — JSON poli, HTTP hlavičkami, XML dokumenty, těly e-mailů. Dekódování toto obrátí: každé 4 Base64 znaky se mapují zpět na 3 původní bajty. Padding = na konci signalizuje, kolik bajtů bylo přidáno k doplnění poslední skupiny. Base64 není šifrování — kdokoliv ho může obrátit. Jeho účelem je bezpečnost přenosu, nikoliv utajení.
Typické scénáře dekódování v Javě: extrakce konfiguračních hodnot vložených jako Base64 proměnné prostředí, rozbalení binárního obsahu souborů z odpovědí cloudových API, čtení PEM kódovaných certifikátů a prozkoumávání JWT token payloadů při ladění.
ZGItcHJvZC51cy1lYXN0LTEuYW1hem9uYXdzLmNvbTo1NDMy
db-prod.us-east-1.amazonaws.com:5432
Base64.getDecoder().decode() — Standardní metoda dekódování
Třída java.util.Base64 byla přidána v JDK 8 a nahradila starý sun.misc.BASE64Decoder, na který se všichni spoléhali. Nejsou potřeba žádné externí závislosti — stačí import java.util.Base64 a zavolat Base64.getDecoder().decode(). Metoda přijímá buď String nebo byte[] a vrací byte[] dekódovaných dat.
Minimální funkční příklad
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
}
}Při konstruování String vždy zadejte StandardCharsets.UTF_8. Konstruktor new String(bytes) bez argumentu používá výchozí kódování platformy, které se liší mezi systémy. Na Windows serveru s Cp1252 jako výchozím se vícebajtové UTF-8 znaky potichu poškodí.
Ověření 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
}
}Dekódování do předem alokovaného bufferu
Přetížení se třemi argumenty decode(byte[] src, byte[] dst) zapisuje přímo do cílového bufferu a vrací počet zapsaných bajtů. Tím se vyhne extra alokaci na kritických cestách:
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() hází IllegalArgumentException, pokud vstup obsahuje znaky mimo Base64 abecedu (včetně zalomení řádků a mezer). Pokud váš vstup může obsahovat mezery, přepněte na getMimeDecoder() nebo je odstraňte pomocí encoded.strip() před dekódováním.Dekódování Base64 s nestandardními typy a vlastními objekty
Surové byte[] z decode() je často potřeba převést na něco konkrétnějšího: UUID, serializovaný Java objekt, protobuf zprávu nebo timestamp. Dekodér vždy vrací bajty — převod na doménové typy je vaší odpovědností.
Base64 na 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 na deserializovaný JSON objekt pomocí 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
}
}ObjectInputStream k deserializaci nedůvěryhodných Base64 dat. Java deserializační útoky jsou dobře zdokumentované — pokud kódovaný obsah pochází z externího zdroje, parsujte ho jako JSON nebo protobuf místo nativní Java serializace.Přehled metod Base64.Decoder
Všechny metody patří do java.util.Base64 a jeho vnitřní třídy Base64.Decoder. Tři tovární metody na Base64 vrací různé instance dekodéru; metody decode() a wrap() jsou na instanci Decoder.
getMimeDecoder() — Dekódování zalomených a MIME Base64 dat
Základní dekodér odmítá cokoliv mimo Base64 abecedu — a to zahrnuje zalomení řádků \r\n, která MIME kódovaný obsah vždy obsahuje. E-mailové přílohy, PEM certifikáty a některé starší API odpovědi zalamují Base64 výstup po 76 znacích na řádek. getMimeDecoder() tiše ignoruje oddělovače řádků a jakýkoliv znak mimo Base64 abecedu, takže to zvládá přímo ze škatulky.
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() je benevolentní: přeskakuje neplatné znaky místo házení výjimky. To je v pořádku pro známá MIME data, ale může tiše pohltit poškození v libovolném vstupu. Použijte getDecoder(), pokud chcete striktní validaci.Dekódování Base64 ze souboru a odpovědi API
Čtení Base64 kódovaného souboru z disku
Binární soubory (obrázky, certifikáty, šifrované bloby) jsou někdy uloženy na disku jako Base64 text. Přečtěte soubor, dekódujte ho a zapište binární výstup:
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());
}
}
}Dekódování Base64 pole z odpovědi HTTP API
Cloudová API (AWS KMS, GitHub Contents, Vault) často vracejí binární data jako Base64 řetězce uvnitř JSON. Nejprve parsujte JSON, pak dekódujte cílové pole:
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 odděleně od síťových chyb. Míchání I/O výjimek s chybami dekódování ztěžuje ladění — chcete okamžitě vědět, zda API vrátilo špatná data nebo selhala síť.Dekódování Base64 z příkazové řádky
Java program nepotřebujete vždy. Každý Linux a macOS systém má příkaz base64 a JDK 9+ dodává jshell pro interaktivní Java jednořádkové příkazy. Při rychlé inspekci během ladění jsou tyto nástroje rychlejší než kompilace třídy.
# 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 -DPro vkládání kódovaných řetězců přímo do prohlížeče Base64 dekodér ToolDecku zvládá standardní i URL-safe varianty bez jakéhokoliv nastavování.
Výkonná alternativa: Apache Commons Codec
Vestavěný java.util.Base64 v Javě je již dobře optimalizovaný — JDK 11+ používá intrinsics na x86 pro kódování a dekódování. Pro většinu aplikací není důvod sahat po knihovně třetí strany. Apache Commons Codec nicméně zůstává populární v legacy kódových základnách a nabízí Base64InputStream pro streamové dekódování s automatickým zpracováním mezer.
<!-- 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}
}
}Hlavní výhodou Commons Codec oproti vestavěnému API je jeho výchozí benevolence vůči mezerám a třída Base64InputStream, která předchází decoder.wrap() z Javy. Pokud jste na Java 8+, vestavěné API pokrývá vše, co Commons Codec umí. Po Commons Codec sáhnu jen tehdy, když na něm projekt již závisí.
Streamování velkých Base64 souborů pomocí decoder.wrap()
Načtení 200 MB Base64 souboru přes Files.readString() a následné volání decode() alokuje zhruba 350 MB haldy: kódovaný řetězec plus dekódované byte pole. decoder.wrap(InputStream) dekóduje průběžně za běhu a udržuje spotřebu paměti konstantní.
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);
}
}
}Na Java 9+ můžete nahradit smyčku čtení pomocí in.transferTo(out) — dělá totéž s méně kódem. Použijte getMimeDecoder().wrap() místo getDecoder().wrap(), pokud soubor může obsahovat zalomení řádků (PEM soubory, e-mailové exporty).
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() netoleruje zalomení řádků ve streamu. Pokud Base64 data obsahují nové řádky (zalomení po 76 znacích), použijte getMimeDecoder().wrap() — jinak stream tiše produkuje poškozený výstup nebo hází výjimku na nepředvídatelné pozici čtení.Dekódování Base64 JWT payloadu v Javě bez JWT knihovny
JWT je tři Base64url kódované segmenty spojené tečkami. Prostřední segment je payload — ta část, která vás při ladění zajímá. Můžete ho dekódovat bez přidání závislosti na jjwt nebo Nimbus. Rozdělte token na ., dekódujte druhý segment pomocí getUrlDecoder() a parsujte výsledný JSON:
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"]}
}
}Časté chyby
Na každou z těchto chyb jsem narazil při code review a první dvě tvoří drtivou většinu produkčních bugů souvisejících s Base64 v Java službách.
Problém: JWT tokeny a OAuth přístupové tokeny používají URL-safe abecedu (- a _). Jejich předání do getDecoder() hází IllegalArgumentException, protože - není ve standardní Base64 abecedě.
Řešení: Zkontrolujte zdroj dat: tokeny z auth systémů potřebují getUrlDecoder(); MIME přílohy potřebují 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ém: new String(bytes) používá výchozí charset JVM, který se liší mezi prostředími. Linux CI server (UTF-8) a Windows produkční host (Cp1252) produkují pro stejné bajty různé výsledky.
Řešení: Vždy předávejte StandardCharsets.UTF_8 jako druhý 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ém: Base64 řetězce vložené z terminálů nebo načtené z konfiguračních souborů mají často závěrečné znaky nového řádku. Základní dekodér odmítá jakýkoliv znak mimo Base64 abecedu.
Řešení: Zavolejte .strip() na vstupu před dekódováním nebo přepněte na getMimeDecoder(), který ignoruje mezery.
// 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ém: Volání new String(decoded) na binárním obsahu (obrázky, protobuf, šifrované bloby) produkuje neplatný String. Jeho pozdější zpětný převod na bajty tiše poškodí data, protože konstruktor String nahrazuje neplatné UTF-8 sekvence.
Řešení: Udržujte binární data jako byte[] v celém vašem pipeline. Převádějte na String pouze tehdy, když víte, že obsah je text.
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);Porovnání metod
Vestavěné dekodéry pokrývají většinu použití. Apache Commons Codec a Guava jsou alternativy, se kterými se můžete setkat ve starších kódových základnách.
Pro JWT tokeny a moderní API payloady: getUrlDecoder(). Pro e-mailové přílohy a PEM certifikáty: getMimeDecoder(). Pro velké soubory, kde záleží na paměti: decoder.wrap(InputStream). Pro vše ostatní: getDecoder(). Apache Commons Codec dává smysl jen tehdy, když je již ve vašem stromu závislostí.
Pro rychlé ověření při vývoji je online Base64 dekodér rychlejší než psaní jednorázové třídy.
Často kladené otázky
Jak dekóduji Base64 řetězec v Javě?
Importujte java.util.Base64 a zavolejte Base64.getDecoder().decode(encodedString). Metoda vrací byte[] — obalte ho pomocí new String(bytes, StandardCharsets.UTF_8), abyste získali čitelný text. Pro URL-safe Base64 (používaný v JWTs) nahraďte getDecoder() za 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-configJaký je rozdíl mezi getDecoder() a getMimeDecoder() v Javě?
getDecoder() je striktní — odmítá jakýkoliv znak mimo Base64 abecedu, včetně zalomení řádků. getMimeDecoder() toleruje oddělovače řádků (\r\n) a ignoruje jakékoliv znaky mimo Base64 abecedu. Je to správná volba pro dekódování e-mailových příloh a PEM certifikátů, kde jsou data zalomená každých 76 znaků.
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
Jak dekóduji URL-safe Base64 řetězec v Javě?
Použijte Base64.getUrlDecoder().decode(encoded). URL dekodér očekává abecedu - a _ definovanou v RFC 4648 §5 místo + a /. JWT tokeny vždy používají tuto abecedu. Pokud byly padding znaky (=) odstraněny (běžné v JWTs), URL dekodér to zvládne — Java URL dekodér přijímá vstup jak s paddingem, tak bez něj.
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"}Jak streamovat dekódování velkého Base64 souboru v Javě?
Použijte decoder.wrap(inputStream) pro obalení FileInputStream. Vrácený InputStream dekóduje Base64 průběžně za běhu čtení bajtů, takže spotřeba paměti zůstává konstantní bez ohledu na velikost souboru. Propojte ho přes BufferedInputStream nebo přímo do Files.copy() pro nejlepší výkon.
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);
}Proč Base64.getDecoder().decode() hází IllegalArgumentException?
Základní dekodér je striktní: odmítá zalomení řádků, mezery a jakýkoliv znak mimo A-Za-z0-9+/=. Tři časté příčiny: vstup má závěrečné znaky nového řádku (ořízněte ho), vstup používá URL-safe znaky jako - a _ (přepněte na getUrlDecoder()), nebo byl vstup zalomen po 76 znacích (přepněte na getMimeDecoder()). Pokud je chybová zpráva nejasná, vždy zkontrolujte surové bajty.
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);
Mohu dekódovat Base64 v Javě bez java.util.Base64?
Ano, ale na Java 8+ k tomu není dobrý důvod. Před Java 8 vývojáři používali sun.misc.BASE64Decoder (interní, odstraněno v Java 9+), javax.xml.bind.DatatypeConverter.parseBase64Binary() (odstraněno v Java 11) nebo Apache Commons Codec. Všechny tři jsou buď zastaralé, nebo vyžadují extra závislost. Držte se java.util.Base64 — je rychlejší, dodává se s JDK a pokrývá všechny tři varianty (základní, URL-safe, MIME).
Související nástroje
- Base64 Encoder — zakódujte text nebo binární data do Base64 v prohlížeči; hodí se pro generování testovacích dat k vložení do Java unit testů.
- JWT Decoder — rozdělte a dekódujte všechny tři JWT segmenty najednou s inspekcí payloadu pole po poli — rychlejší než psaní Java třídy, když jen potřebujete přečíst token.
- URL Decoder — percent-dekódujte URL kódované řetězce; užitečné, když API odpovědi kombinují Base64url data s percent-kódovanými query parametry.
- JSON Formatter — po dekódování Base64 JWT payloadu nebo API konfigurace vložte JSON sem pro hezké formátování a ověření struktury.