Base64-avkodning i Java är något jag återkommer till nästan varje dag — hämtar hemligheter från Kubernetes-miljövariabler, läser binära payloads från REST-API:er, granskar JWT-tokens under en debuggingssession. Javas inbyggda java.util.Base64-klass (sedan JDK 8) erbjuder tre avkodartyper: getDecoder() för standard Base64, getUrlDecoder() för URL-säker indata och getMimeDecoder() för radbruten data som e-postbilagor. För en snabb engångskontroll utan att skriva kod hanterar ToolDecks Base64-avkodare det direkt i webbläsaren. Den här guiden riktar sig mot Java 8+ och täcker alla tre avkodarna, streaming med wrap(InputStream), utläsning av JWT-payloads, avkodning av filer och API-svar, Apache Commons Codec som alternativ, och de fyra misstag som ger felaktig utdata i produktion.
- ✓Base64.getDecoder().decode(s) är standardmetoden — inbyggd i java.util.Base64 sedan JDK 8, inga beroenden krävs.
- ✓Använd getUrlDecoder() för JWT-tokens och OAuth-payloads — de använder alfabetet - och _, inte + och /.
- ✓getMimeDecoder() ignorerar radbrytningar och blanktecken, vilket gör den till rätt val för e-postbilagor och PEM-certifikat.
- ✓decoder.wrap(InputStream) avkodar i realtid för stora filer utan att läsa in allt i minnet.
- ✓Standardavkodaren är strikt — avslutande radbrytningar, mellanslag eller fel alfabetstecken kastar omedelbart IllegalArgumentException.
Vad är Base64-avkodning?
Base64-kodning omvandlar binärdata till en ASCII-representation med 64 tecken så att den kan transporteras säkert genom textbaserade kanaler — JSON-fält, HTTP-huvuden, XML-dokument, e-postkroppar. Avkodning vänder på detta: varje grupp om 4 Base64-tecken mappas tillbaka till 3 ursprungliga bytes. =-utfyllnaden i slutet anger hur många bytes som lades till för att fylla den sista gruppen. Base64 är inte kryptering — vem som helst kan reversera det. Syftet är transportsäkerhet, inte sekretess.
Typiska Java-avkodningsscenarier: extrahera konfigurationsvärden injicerade som Base64-miljövariabler, packa upp binärt filinnehåll från moln-API-svar, läsa PEM-kodade certifikat och granska JWT-token-payloads under debuggning.
ZGItcHJvZC51cy1lYXN0LTEuYW1hem9uYXdzLmNvbTo1NDMy
db-prod.us-east-1.amazonaws.com:5432
Base64.getDecoder().decode() — standardmetoden för avkodning
Klassen java.util.Base64 lades till i JDK 8 och ersatte den gamla sun.misc.BASE64Decoder som alla förlitade sig på tidigare. Inga externa beroenden behövs — bara import java.util.Base64 och anropa Base64.getDecoder().decode(). Metoden accepterar antingen en String eller ett byte[] och returnerar ett byte[] med avkodad data.
Minimalt fungerande exempel
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class DecodeCredential {
public static void main(String[] args) {
// Kubernetes-hemlighetsvärde, Base64-kodat
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
}
}Ange alltid StandardCharsets.UTF_8 när du konstruerar strängen. Konstruktorn utan argument new String(bytes) använder plattformens standardkodning, vilket varierar mellan system. På en Windows-server med Cp1252 som standard skadas multi-byte UTF-8-tecken tyst.
Verifiering av fram-och-tillbaka-omvandling
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
}
}Avkodning till en förallokerad buffer
Överlagringen med tre argument decode(byte[] src, byte[] dst) skriver direkt till en destinationsbuffer och returnerar antalet skrivna bytes. Detta undviker en extra allokering på kritiska vägar:
import java.util.Base64;
public class DecodeToBuffer {
public static void main(String[] args) {
byte[] src = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=".getBytes();
byte[] dst = new byte[1024]; // förallokerad
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() kastar IllegalArgumentException om indata innehåller tecken utanför Base64-alfabetet (inklusive radbrytningar och mellanslag). Om indata kan innehålla blanktecken, byt till getMimeDecoder() eller trimma det med encoded.strip() före avkodning.Avkodning av Base64 med icke-standardtyper och anpassade objekt
Rådata som byte[] från decode() behöver ofta bli något mer specifikt: ett UUID, ett serialiserat Java-objekt, ett protobuf-meddelande eller en tidsstämpel. Avkodaren returnerar alltid bytes — omvandlingen till domäntyper är ditt ansvar.
Base64 till 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) {
// Kompakt Base64-kodat UUID från ett API-svar
String encoded = "f47ac10b-58cc-4372-a567-0e02b2c3d479";
UUID original = UUID.fromString(encoded);
// Koda till Base64 (kompakt form — 22 tecken 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
// Avkoda tillbaka
UUID recovered = fromBase64(compact);
System.out.println(recovered); // f47ac10b-58cc-4372-a567-0e02b2c3d479
}
}Base64 till deserialiserat JSON-objekt med 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-kodad JSON-payload från en meddelandekö
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(); // hämtar upp 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 för att deserialisera opålitlig Base64-data. Java-deserialiseringsattacker är väldokumenterade — om det kodade innehållet kommer från en extern källa, parsa det som JSON eller protobuf i stället för att använda Javas inbyggda serialisering.Metodreferens för Base64.Decoder
Alla metoder tillhör java.util.Base64 och dess inre klass Base64.Decoder. De tre fabriksmetoderna på Base64 returnerar olika avkodarinstanser; metoderna decode() och wrap() finns på Decoder-instansen.
getMimeDecoder() — avkodning av radbruten och MIME-kodad Base64
Standardavkodaren avvisar allt utanför Base64-alfabetet — och det inkluderar de \r\n-radbrytningar som MIME-kodat innehåll alltid innehåller. E-postbilagor, PEM-certifikat och en del äldre API-svar bryter Base64-utdata vid 76 tecken per rad. getMimeDecoder() ignorerar tyst radbrytningar och alla tecken som inte tillhör Base64-alfabetet och hanterar detta utan extra konfiguration.
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class MimeDecode {
public static void main(String[] args) {
// PEM-certifikatkropp — radbruten vid 76 tecken
String pemBody = "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t\r\n"
+ "TUlJQm96Q0NBVWlnQXdJQkFnSUpBSXBhVDJU\r\n"
+ "aVFvZU1BMEdDU3FHU0liM0RRRU==";
// getDecoder() skulle kasta IllegalArgumentException här
byte[] decoded = Base64.getMimeDecoder().decode(pemBody);
System.out.println(new String(decoded, StandardCharsets.UTF_8));
// -----BEGIN CERTIFICATE-----
// MIIBozCCAUigAwIBAgIJAIpaT2T...
}
}getMimeDecoder() är tillåtande: den hoppar över ogiltiga tecken i stället för att kasta ett undantag. Det fungerar bra för känd MIME-data, men kan tyst dölja korruption i godtycklig indata. Använd getDecoder() när du vill ha strikt validering.Avkoda Base64 från fil och API-svar
Läs en Base64-kodad fil från disk
Binärfiler (bilder, certifikat, krypterade blobbar) lagras ibland på disk som Base64-text. Läs filen, avkoda och skriv det binära resultatet:
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());
}
}
}Avkoda ett Base64-fält från ett HTTP API-svar
Moln-API:er (AWS KMS, GitHub Contents, Vault) returnerar ofta binärdata som Base64-strängar inuti JSON. Parsa JSON:en först och avkoda sedan målfältet:
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 returnerar: {"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 separat från nätverksfelen. Att blanda I/O-undantag med avkodningsfel gör felsökning svårare — du vill omedelbart veta om API:et returnerade felaktig data eller om nätverket misslyckades.Base64-avkodning från kommandoraden
Du behöver inte alltid ett Java-program. Varje Linux- och macOS-system har ett base64-kommando, och JDK 9+ levereras med jshell för interaktiva Java-enradskommandon. Vid snabb inspektion under felsökning är dessa snabbare än att kompilera en klass.
# Avkoda en Base64-sträng (Linux / macOS)
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode
# {"host":"10.0.1.50","port":8443}
# Avkoda och formatera med jq
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode | jq .
# {
# "host": "10.0.1.50",
# "port": 8443
# }
# Snabb avkodning med jshell (JDK 9+)
echo 'System.out.println(new String(java.util.Base64.getDecoder().decode("c2VydmVyLWNvbmZpZw==")))' | jshell -
# server-config
# macOS använder -D i stället för --decode
echo "c2VydmVyLWNvbmZpZw==" | base64 -DFör att klistra in kodade strängar direkt i en webbläsare hanterar ToolDecks Base64-avkodare både standard- och URL-säkra varianter utan någon konfiguration.
Högpresterande alternativ: Apache Commons Codec
Javas inbyggda java.util.Base64 är redan väloptimerad — JDK 11+ använder intrinsics på x86 för kodning och avkodning. För de flesta applikationer finns det ingen anledning att använda ett tredjepartsbibliotek. Det sagt är Apache Commons Codec fortfarande populärt i äldre kodbasener och erbjuder Base64InputStream för strömningsavkodning med automatisk hantering av blanktecken.
<!-- 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 är mer tillåtande — hanterar blanktecken och radbrytningar
String encoded = "eyJob3N0IjoiMTAuMC4xLjUw\nIiwicG9ydCI6ODQ0M30=";
byte[] decoded = Base64.decodeBase64(encoded);
System.out.println(new String(decoded));
// {"host":"10.0.1.50","port":8443}
}
}Den främsta fördelen med Commons Codec jämfört med det inbyggda API:et är dess tillåtande hantering av blanktecken som standard och klassen Base64InputStream som föregick Javas decoder.wrap(). Är du på Java 8+ täcker det inbyggda API:et allt som Commons Codec gör. Jag väljer Commons Codec bara när projektet redan är beroende av det.
Strömningsavkodning av stora Base64-filer med decoder.wrap()
Att ladda en 200 MB Base64-fil med Files.readString() och sedan anropa decode() allokerar ungefär 350 MB heap: den kodade strängen plus det avkodade byte-arrayen. decoder.wrap(InputStream) avkodar i realtid och håller minnesanvändningen konstant.
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);
}
}
}På Java 9+ kan du ersätta läslopen med in.transferTo(out) — det gör samma sak med mindre kod. Använd getMimeDecoder().wrap() i stället för getDecoder().wrap() om filen kan innehålla radbrytningar (PEM-filer, e-postexporter).
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() tolererar inte radbrytningar i strömmen. Om Base64-datan har radbrytningar (radbruten vid 76 tecken) ska du använda getMimeDecoder().wrap() i stället — annars producerar strömmen tyst korrupt utdata eller kastar vid en oförutsägbar läsposition.Avkoda Base64 JWT-payload i Java utan ett JWT-bibliotek
En JWT består av tre Base64url-kodade segment separerade med punkter. Det mittersta segmentet är payloaden — den del du bryr dig om vid felsökning. Du kan avkoda den utan att dra in jjwt eller Nimbus. Dela på ., avkoda den andra delen med getUrlDecoder() och parsa den resulterande JSON:en:
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 använder URL-säker Base64 utan utfyllnad
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"]}
}
}Vanliga misstag
Jag har stött på vart och ett av dessa i kodgranskningar, och de två första svarar för den stora majoriteten av Base64-relaterade produktionsfel i Java-tjänster.
Problem: JWT-tokens och OAuth-åtkomsttokens använder URL-säkert alfabet (- och _). Skickar man dem till getDecoder() kastas IllegalArgumentException eftersom - inte finns i standard Base64-alfabetet.
Lösning: Kontrollera datakällan: tokens från autentiseringssystem behöver getUrlDecoder(); MIME-bilagor behöver getMimeDecoder().
// JWT-huvud — URL-säker, utan utfyllnad 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"}Problem: new String(bytes) använder JVM:ens standardteckenkodning, som skiljer sig mellan miljöer. En Linux CI-server (UTF-8) och en Windows-produktionsserver (Cp1252) ger olika resultat för samma bytes.
Lösning: Ange alltid StandardCharsets.UTF_8 som andra argument.
byte[] decoded = Base64.getDecoder().decode(encoded); String result = new String(decoded); // plattformsberoende — kan skada multi-byte-tecken
byte[] decoded = Base64.getDecoder().decode(encoded); String result = new String(decoded, StandardCharsets.UTF_8); // konsekvent på alla plattformar
Problem: Base64-strängar inklistrade från terminaler eller lästa från konfigurationsfiler har ofta avslutande radbrytningar. Standardavkodaren avvisar alla tecken utanför Base64-alfabetet.
Lösning: Anropa .strip() på indata före avkodning, eller byt till getMimeDecoder() som ignorerar blanktecken.
// Läst från miljövariabel — har en avslutande radbrytning
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));
// postgresProblem: Att anropa new String(decoded) på binärt innehåll (bilder, protobuf, krypterade blobbar) ger en ogiltig String. Att omvandla den tillbaka till bytes senare skadas data tyst eftersom String-konstruktorn ersätter ogiltiga UTF-8-sekvenser.
Lösning: Behåll binärdata som byte[] genom hela din pipeline. Omvandla till String bara när du vet att innehållet är text.
byte[] decoded = Base64.getDecoder().decode(pngBase64);
String imageStr = new String(decoded); // skadar binärdata
Files.writeString(Path.of("image.png"), imageStr); // trasig filbyte[] decoded = Base64.getDecoder().decode(pngBase64);
// Skriv bytes direkt — ingen String-omvandling
Files.write(Path.of("image.png"), decoded);Metodjämförelse
De inbyggda avkodarna täcker de flesta användningsfall. Apache Commons Codec och Guava är alternativ du kan stöta på i äldre kodbasener.
För JWT-tokens och moderna API-payloads: getUrlDecoder(). För e-postbilagor och PEM-certifikat: getMimeDecoder(). För stora filer där minne spelar roll: decoder.wrap(InputStream). Allt annat: getDecoder(). Apache Commons Codec är motiverat bara om det redan finns i ditt beroendetre.
För snabb verifiering under utveckling är den online Base64-avkodaren snabbare än att skriva en engångsklass.
Vanliga frågor
Hur avkodar jag en Base64-sträng i Java?
Importera java.util.Base64 och anropa Base64.getDecoder().decode(encodedString). Metoden returnerar ett byte[] — omvandla det med new String(bytes, StandardCharsets.UTF_8) för att få läsbar text. För URL-säker Base64 (som används i JWT:er) byter du ut getDecoder() mot 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-configVad är skillnaden mellan getDecoder() och getMimeDecoder() i Java?
getDecoder() är strikt — den avvisar alla tecken utanför Base64-alfabetet, inklusive radbrytningar. getMimeDecoder() tolererar radbrytningar (\r\n) och ignorerar tecken som inte tillhör Base64-alfabetet, vilket gör den till rätt val för att avkoda e-postbilagor och PEM-certifikat där datan är radbruten vid 76 tecken.
String wrapped = "c2VydmVyLWNv\r\nbmZpZw=="; // getDecoder() kastar IllegalArgumentException // Base64.getDecoder().decode(wrapped); // MISSLYCKAS // getMimeDecoder() hanterar det byte[] decoded = Base64.getMimeDecoder().decode(wrapped); System.out.println(new String(decoded)); // server-config
Hur avkodar jag en URL-säker Base64-sträng i Java?
Använd Base64.getUrlDecoder().decode(encoded). URL-avkodaren förväntar sig alfabetet - och _ som definieras i RFC 4648 §5, i stället för + och /. JWT-token använder alltid detta alfabet. Om utfyllnadstecknen (=) har tagits bort (vanligt i JWT:er) hanterar URL-avkodaren det ändå — Javas URL-avkodare accepterar både utfylld och icke-utfylld indata.
import java.util.Base64;
// JWT-huvud — URL-säker, utan utfyllnad
String jwtHeader = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
byte[] decoded = Base64.getUrlDecoder().decode(jwtHeader);
System.out.println(new String(decoded));
// {"alg":"HS256","typ":"JWT"}Hur strömmavkodar jag en stor Base64-fil i Java?
Använd decoder.wrap(inputStream) för att wrappa en FileInputStream. Den returnerade InputStream:en avkodar Base64 i realtid medan du läser bytes, så minnesanvändningen förblir konstant oavsett filstorlek. Led det vidare genom en BufferedInputStream eller direkt till Files.copy() för bästa genomströmning.
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);
}Varför kastar Base64.getDecoder().decode() IllegalArgumentException?
Standardavkodaren är strikt: den avvisar radbrytningar, mellanslag och alla tecken utanför A-Za-z0-9+/=. Tre vanliga orsaker: indata har avslutande radbrytningar (trimma dem), indata använder URL-säkra tecken som - och _ (byt till getUrlDecoder()), eller indata är radbruten vid 76 tecken (byt till getMimeDecoder()). Inspektera alltid de råa bytesen om felmeddelandet är otydligt.
String raw = "c2VydmVyLWNvbmZpZw==\n"; // avslutande radbrytning // Alternativ 1: trimma blanktecken byte[] decoded = Base64.getDecoder().decode(raw.strip()); // Alternativ 2: använd MIME-avkodaren som ignorerar blanktecken byte[] decoded2 = Base64.getMimeDecoder().decode(raw);
Kan jag avkoda Base64 i Java utan java.util.Base64?
Ja, men det finns ingen anledning att göra det på Java 8+. Innan Java 8 använde utvecklare sun.misc.BASE64Decoder (intern, borttagen i Java 9+), javax.xml.bind.DatatypeConverter.parseBase64Binary() (borttagen i Java 11), eller Apache Commons Codec. Alla tre är antingen föråldrade eller kräver ett extra beroende. Håll dig till java.util.Base64 — den är snabbare, medföljer JDK och täcker alla tre varianterna (standard, URL-säker, MIME).
Relaterade verktyg
- Base64 Encoder — koda text eller binärdata till Base64 i webbläsaren, praktiskt för att generera testfixtures att klistra in i dina Java-enhetstester.
- JWT Decoder — dela upp och avkoda alla tre JWT-segment på en gång, med fältvis inspektion av payloaden — snabbare än att skriva en Java-klass när du bara behöver läsa en token.
- URL Decoder — procentavkoda URL-kodade strängar, användbart när API-svar kombinerar Base64url-data med procentkodade frågeparametrar.
- JSON Formatter — efter att ha avkodat en Base64 JWT-payload eller API-konfiguration kan du klistra in JSON:en här för att formatera och validera strukturen.