Java'da Base64 Çözme — getDecoder().decode() Rehberi

Java'da Base64 çözme işlemi, her birkaç günde bir başvurduğum bir şey — Kubernetes ortam değişkenlerinden gizli anahtarlar çekme, REST API'lerinden ikili yük okuma, hata ayıklama sırasında JWT token'larını inceleme. Java'nın yerleşik java.util.Base64 sınıfı (JDK 8'den itibaren) üç decoder çeşidi sunar: standart Base64 için getDecoder(), URL-safe girdi için getUrlDecoder() ve e-posta ekleri gibi satıra bölünmüş veriler için getMimeDecoder(). Kod yazmadan hızlıca kontrol etmek için ToolDeck'in Base64 decoder'ı tarayıcınızda anında sonuç verir. Bu kılavuz Java 8+'i hedefler ve üç decoder'ın tamamını, wrap(InputStream) ile akış işlemini, JWT yük çıkarmayı, dosya ve API yanıtı çözmeyi, Apache Commons Codec alternatifini ve üretimde hatalı çıktıya yol açan dört yaygın hatayı kapsar.

✓Base64.getDecoder().decode(s) standart yaklaşımdır — JDK 8'den itibaren java.util.Base64 içinde yerleşik olarak gelir, bağımlılık gerekmez.
✓JWT token'ları ve OAuth yükleri için getUrlDecoder() kullanın — bunlar + ve / yerine - ve _ alfabesini kullanır.
✓getMimeDecoder() satır sonlarını ve boşlukları yoksayar; e-posta ekleri ve PEM sertifikaları için doğru tercihtir.
✓decoder.wrap(InputStream) büyük dosyaları her şeyi belleğe yüklemeden anlık çözer.
✓Temel decoder katıdır — sondaki yeni satırlar, boşluklar veya yanlış alfabe karakterleri hemen IllegalArgumentException fırlatır.

Base64 Çözme Nedir?

Base64 kodlama, ikili veriyi yalnızca metin kabul eden kanallardan — JSON alanları, HTTP başlıkları, XML belgeleri, e-posta gövdeleri — güvenle geçebilmesi için 64 karakterlik bir ASCII gösterimine dönüştürür. Çözme bunun tersini yapar: her 4 Base64 karakteri, orijinal 3 byte'a geri dönüşür. Sondaki = dolgu, son grubu doldurmak için kaç byte eklendiğini belirtir. Base64 şifreleme değildir — herkes tersine çevirebilir. Amacı gizlilik değil, iletim güvenliğidir.

Tipik Java çözme senaryoları: Base64 ortam değişkenleri olarak enjekte edilen yapılandırma değerlerini çıkarma, bulut API yanıtlarından ikili dosya içeriğini açma, PEM kodlu sertifikaları okuma ve hata ayıklama sırasında JWT token yüklerini inceleme.

Before · text

After · text

ZGItcHJvZC51cy1lYXN0LTEuYW1hem9uYXdzLmNvbTo1NDMy

db-prod.us-east-1.amazonaws.com:5432

Base64.getDecoder().decode() — Standart Çözme Metodu

java.util.Base64sınıfı JDK 8'de eklendi ve herkesin bağımlı olduğu eski sun.misc.BASE64Decoder'ın yerini aldı. Harici bağımlılık gerekmez — sadece import java.util.Base64 yazın ve Base64.getDecoder().decode() çağırın. Metot hem String hem de byte[] kabul eder ve çözülmüş verinin byte[]'ini döndürür.

Minimal çalışan örnek

Java 8+

import java.util.Base64;
import java.nio.charset.StandardCharsets;

public class DecodeCredential {
    public static void main(String[] args) {
        // Kubernetes secret değeri, Base64 ile kodlanmış
        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
    }
}

String oluştururken her zaman StandardCharsets.UTF_8 belirtin. Bağımsız değişkensiz new String(bytes) yapıcısı platformun varsayılan kodlamasını kullanır ve bu sistemden sisteme değişir. Varsayılan olarak Cp1252 kullanan bir Windows sunucusunda, çok baytlı UTF-8 karakterler sessizce bozulur.

Gidiş-dönüş doğrulaması

Java 8+

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
    }
}

Önceden ayrılmış tampona çözme

Üç bağımsız değişkenli decode(byte[] src, byte[] dst) aşırı yüklemesi doğrudan bir hedef tampona yazar ve yazılan byte sayısını döndürür. Bu, yoğun çalışan kod yollarında ekstra bellek tahsisini önler:

Java 8+

import java.util.Base64;

public class DecodeToBuffer {
    public static void main(String[] args) {
        byte[] src = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=".getBytes();
        byte[] dst = new byte[1024]; // önceden ayrılmış

        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}
    }
}

Not:decode(), girdi Base64 alfabesi dışında karakterler içeriyorsa (satır sonları ve boşluklar dahil) IllegalArgumentException fırlatır. Girdinin boşluk içerebileceği durumlarda getMimeDecoder()'a geçin ya da çözmeden önce encoded.strip() ile temizleyin.

Standart Dışı Türler ve Özel Nesnelerle Base64 Çözme

decode()'dan dönen ham byte[] genellikle daha özgül bir şeye dönüşmesi gerekir: bir UUID, serileştirilmiş bir Java nesnesi, bir protobuf mesajı ya da zaman damgası. Decoder her zaman byte döndürür — alan türlerine dönüştürme sizin sorumluluğunuzdadır.

Base64'ten UUID'ye

Java 8+

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) {
        // Bir API yanıtından gelen kompakt Base64 kodlu UUID
        String encoded = "f47ac10b-58cc-4372-a567-0e02b2c3d479";
        UUID original = UUID.fromString(encoded);

        // Base64'e kodla (kompakt form — 36 yerine 22 karakter)
        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

        // Geri çöz
        UUID recovered = fromBase64(compact);
        System.out.println(recovered); // f47ac10b-58cc-4372-a567-0e02b2c3d479
    }
}

Base64'ten Jackson ile seri dışı bırakılmış JSON nesnesine

Java 8+

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 {
        // Mesaj kuyruğundan gelen Base64 kodlu JSON yükü
        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(); // JavaTimeModule'ü otomatik yükler
        DeployEvent event = mapper.readValue(jsonBytes, DeployEvent.class);

        System.out.println(event.service());   // payment-gateway
        System.out.println(event.deployedAt()); // 2026-03-15T14:30:00Z
    }
}

Uyarı:Güvenilmeyen Base64 verisini seri dışı bırakmak için ObjectInputStream kullanmayın. Java seri dışı bırakma saldırıları iyi belgelenmiştir — kodlanmış içerik harici bir kaynaktan geliyorsa, yerel Java serileştirmesi yerine JSON veya protobuf olarak ayrıştırın.

Base64.Decoder Metotları Referansı

Tüm metotlar java.util.Base64 ve iç sınıfı Base64.Decoder'a aittir. Base64 üzerindeki üç fabrika metodu farklı decoder örnekleri döndürür; decode() ve wrap() metotları Decoder örneği üzerinde bulunur.

Metot

Döndürür

Girdi Türü

Açıklama

getDecoder()

Base64.Decoder

—

Standart decoder (RFC 4648 §4, + ve / alfabesi, = dolgu)

getUrlDecoder()

Base64.Decoder

—

URL-safe decoder (RFC 4648 §5, - ve _ alfabesi, = dolgu)

getMimeDecoder()

Base64.Decoder

—

MIME decoder — satır ayırıcıları ve Base64 dışı karakterleri yoksayar

decode(String src)

byte[]

String

Girdi dizesini yeni bir byte dizisine çözer

decode(byte[] src)

byte[]

Girdi byte dizisini yeni bir byte dizisine çözer

decode(byte[] src, byte[] dst)

int

byte[] + byte[]

Önceden ayrılmış dst tamponuna çözer, yazılan byte sayısını döndürür

wrap(InputStream is)

InputStream

Base64 verisini okurken anlık olarak çözen bir akış döndürür

getMimeDecoder() — Satıra Bölünmüş ve MIME Base64 Çözme

Temel decoder, Base64 alfabesi dışındaki her şeyi reddeder — MIME kodlu içeriğin her zaman içerdiği \r\n satır sonları da dahil. E-posta ekleri, PEM sertifikaları ve bazı eski API yanıtları, Base64 çıktısını satır başına 76 karakterde sarar. getMimeDecoder() satır ayırıcılarını ve Base64 alfabesinde olmayan karakterleri sessizce yoksayar; bu sayede kullanıma hazır bir şekilde bu durumu ele alır.

Java 8+

import java.util.Base64;
import java.nio.charset.StandardCharsets;

public class MimeDecode {
    public static void main(String[] args) {
        // PEM sertifika gövdesi — 76 karakterde satıra bölünmüş
        String pemBody = "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0t\r\n"
            + "TUlJQm96Q0NBVWlnQXdJQkFnSUpBSXBhVDJU\r\n"
            + "aVFvZU1BMEdDU3FHU0liM0RRRU==";

        // getDecoder() burada IllegalArgumentException fırlatır
        byte[] decoded = Base64.getMimeDecoder().decode(pemBody);
        System.out.println(new String(decoded, StandardCharsets.UTF_8));
        // -----BEGIN CERTIFICATE-----
        // MIIBozCCAUigAwIBAgIJAIpaT2T...
    }
}

Not:getMimeDecoder() toleranslıdır: istisna fırlatmak yerine geçersiz karakterleri atlar. Bu, bilinen MIME verisi için uygundur; ancak rastgele girdideki bozulmayı sessizce yutabilir. Katı doğrulama istiyorsanız getDecoder() kullanın.

Dosya ve API Yanıtından Base64 Çözme

Diskten Base64 kodlu dosya okuma

İkili dosyalar (resimler, sertifikalar, şifreli bloblar) bazen diskde Base64 metni olarak saklanır. Dosyayı okuyun, çözün, ikili çıktıyı yazın:

Java 8+

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());
        }
    }
}

HTTP API yanıtından Base64 alanı çözme

Bulut API'leri (AWS KMS, GitHub Contents, Vault) sıklıkla JSON içindeki Base64 dizesi olarak ikili veri döndürür. Önce JSON'ı ayrıştırın, ardından hedef alanı çözün:

Java 11+

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 şunu döndürür: {"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());
        }
    }
}

Not:Decode çağrısını ağ hatalarından ayrı olarak kendi try-catch bloğuna alın ve IllegalArgumentException'ı ayrıca yakalayın. G/Ç istisnalarını çözme hatalarıyla karıştırmak hata ayıklamayı zorlaştırır — API'nin hatalı veri döndürüp döndürmediğini mi yoksa ağın mı başarısız olduğunu hemen anlamak istersiniz.

Komut Satırından Base64 Çözme

Her zaman bir Java programına ihtiyacınız olmaz. Her Linux ve macOS sisteminde base64 komutu vardır; JDK 9+ ise etkileşimli Java tek satırları için jshell ile gelir. Hata ayıklama sırasında hızlı inceleme için bunlar bir sınıf derlemeye göre çok daha hızlıdır.

bash

# Base64 dizesini çöz (Linux / macOS)
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode
# {"host":"10.0.1.50","port":8443}

# Çöz ve jq ile güzel yazdır
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode | jq .
# {
#   "host": "10.0.1.50",
#   "port": 8443
# }

# jshell ile hızlı çözme (JDK 9+)
echo 'System.out.println(new String(java.util.Base64.getDecoder().decode("c2VydmVyLWNvbmZpZw==")))' | jshell -
# server-config

# macOS'ta --decode yerine -D kullanılır
echo "c2VydmVyLWNvbmZpZw==" | base64 -D

Kodlanmış dizeleri doğrudan tarayıcıya yapıştırmak için ToolDeck'in Base64 decoder'ı herhangi bir kurulum gerektirmeden hem standart hem de URL-safe varyantları işler.

Yüksek Performanslı Alternatif: Apache Commons Codec

Java'nın yerleşik java.util.Base64 sınıfı zaten iyi optimize edilmiştir — JDK 11+, kodlama ve çözme için x86 üzerinde intrinsic kullanır. Çoğu uygulama için üçüncü taraf bir kütüphaneye başvurmak için hiçbir neden yoktur. Bununla birlikte, Apache Commons Codec eski kod tabanlarında popüler olmaya devam etmekte ve otomatik boşluk işleme ile akış çözme için Base64InputStream sunmaktadır.

XML (Maven)

<!-- pom.xml -->
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.17.0</version>
</dependency>

Java 8+

import org.apache.commons.codec.binary.Base64;

public class CommonsCodecDecode {
    public static void main(String[] args) {
        // Commons Codec daha toleranslıdır — boşluk ve satır sonlarını işler
        String encoded = "eyJob3N0IjoiMTAuMC4xLjUw\nIiwicG9ydCI6ODQ0M30=";
        byte[] decoded = Base64.decodeBase64(encoded);

        System.out.println(new String(decoded));
        // {"host":"10.0.1.50","port":8443}
    }
}

Commons Codec'in yerleşik API'ye göre temel avantajı, varsayılan olarak boşluklara karşı toleranslı olması ve Java'nın decoder.wrap()'inden önce gelen Base64InputStreamsınıfıdır. Java 8+'deyseniz yerleşik API, Commons Codec'in yaptığı her şeyi kapsar. Ben yalnızca proje zaten Commons Codec'e bağımlıysa ona başvururum.

decoder.wrap() ile Büyük Base64 Dosyalarını Akış Olarak İşleme

200 MB'lık bir Base64 dosyasını Files.readString() ile yükleyip ardından decode() çağırmak yaklaşık 350 MB heap ayırır: kodlanmış dize artı çözülmüş byte dizisi. decoder.wrap(InputStream) anlık olarak çözer ve bellek kullanımını sabit tutar.

Java 8+

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);
        }
    }
}

Java 9+'da okuma döngüsünü in.transferTo(out) ile değiştirebilirsiniz — aynı işi daha az kodla yapar. Dosya satır sonları içerebiliyorsa (PEM dosyaları, e-posta dışa aktarmaları) getDecoder().wrap() yerine getMimeDecoder().wrap() kullanın.

Java 9+

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+
        }
    }
}

Uyarı:getDecoder().wrap() akıştaki satır sonlarını tolere etmez. Base64 verisi yeni satır içeriyorsa (76 karakterde sarılmış), aksi takdirde akış tahmin edilemeyen bir okuma konumunda sessizce bozuk çıktı üretir veya istisna fırlatır; bu yüzden getMimeDecoder().wrap() kullanın.

Java'da JWT Kütüphanesi Olmadan Base64 JWT Yükü Çözme

JWT, nokta ile birleştirilmiş üç Base64url kodlu segmentten oluşur. Ortadaki segment yük kısmıdır — hata ayıklama sırasında önem taşıyan parçadır. jjwt veya Nimbus kütüphanesi olmadan çözebilirsiniz. . üzerinde bölün, ikinci parçayı getUrlDecoder()ile çözün ve elde edilen JSON'ı ayrıştırın:

Java 8+

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, dolgusuz URL-safe Base64 kullanır
        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"]}
    }
}

Yaygın Hatalar

Bu hatalarla kod incelemelerde defalarca karşılaştım; ilk ikisi Java servislerindeki Base64 ile ilgili üretim hatalarının büyük çoğunluğunun kaynağıdır.

❌ URL-safe girdide getDecoder() kullanmak

Sorun: JWT token'ları ve OAuth erişim token'ları URL-safe alfabeyi (- ve _) kullanır. Bunları getDecoder()'a geçirmek IllegalArgumentException fırlatır çünkü - standart Base64 alfabesinde yoktur.

Çözüm: Veri kaynağınızı kontrol edin: auth sistemlerinden gelen token'lar getUrlDecoder() gerektirir; MIME ekleri getMimeDecoder() gerektirir.

Before · Java

After · Java

// JWT başlığı — URL-safe, dolgu yok
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"}

❌ String oluştururken karakter seti belirtmemek

Sorun: new String(bytes) JVM'nin varsayılan karakter setini kullanır ve bu ortamlar arasında değişir. Linux CI sunucusu (UTF-8) ile Windows üretim sunucusu (Cp1252) aynı byte'lar için farklı sonuçlar üretir.

Çözüm: Her zaman ikinci bağımsız değişken olarak StandardCharsets.UTF_8 geçirin.

Before · Java

After · Java

byte[] decoded = Base64.getDecoder().decode(encoded);
String result = new String(decoded);
// platforma bağımlı — çok baytlı karakterleri bozabilir

byte[] decoded = Base64.getDecoder().decode(encoded);
String result = new String(decoded, StandardCharsets.UTF_8);
// tüm platformlarda tutarlı

❌ Sondaki boşluk içeren dizeyi çözmeye çalışmak

Sorun: Terminalden yapıştırılan veya yapılandırma dosyalarından okunan Base64 dizelerinin sıklıkla sondaki yeni satırları olur. Temel decoder, Base64 alfabesi dışındaki her karakteri reddeder.

Çözüm: Çözmeden önce girdi üzerinde .strip() çağırın ya da boşlukları yoksayan getMimeDecoder()'a geçin.

Before · Java

After · Java

// Ortam değişkeninden okundu — sondaki yeni satır var
String encoded = System.getenv("DB_PASSWORD_B64"); // "cG9zdGdyZXM=
"
byte[] decoded = Base64.getDecoder().decode(encoded);
// IllegalArgumentException: Illegal base64 character a

String encoded = System.getenv("DB_PASSWORD_B64");
byte[] decoded = Base64.getDecoder().decode(encoded.strip());
System.out.println(new String(decoded, StandardCharsets.UTF_8));
// postgres

❌ İkili veriyi String'e dönüştürmek

Sorun: İkili içerik (resimler, protobuf, şifreli bloblar) üzerinde new String(decoded) çağırmak geçersiz bir String üretir. Daha sonra tekrar byte'a dönüştürmek veriyi sessizce bozar çünkü String yapıcısı geçersiz UTF-8 dizilerini değiştirir.

Çözüm: İkili veriyi tüm işlem hattı boyunca byte[] olarak tutun. Yalnızca içeriğin metin olduğunu bildiğinizde String'e dönüştürün.

Before · Java

After · Java

byte[] decoded = Base64.getDecoder().decode(pngBase64);
String imageStr = new String(decoded); // ikiliyi bozar
Files.writeString(Path.of("image.png"), imageStr); // bozuk dosya

byte[] decoded = Base64.getDecoder().decode(pngBase64);
// Byte'ları doğrudan yaz — String dönüşümü yok
Files.write(Path.of("image.png"), decoded);

Metot Karşılaştırması

Yerleşik decoder'lar çoğu kullanım durumunu karşılar. Apache Commons Codec ve Guava, eski kod tabanlarında karşılaşabileceğiniz alternatiflerdir.

Metot

Kodlama Varyantı

Boşlukları Yoksayar

Akış

Özel Türler

Kurulum Gerektirir

Base64.getDecoder()

Standart (+, /)

✗

Hayır (JDK 8+)

Base64.getUrlDecoder()

URL-safe (-, _)

✗

Hayır (JDK 8+)

Base64.getMimeDecoder()

MIME (satır sonları tamam)

✓

✗

Hayır (JDK 8+)

decoder.wrap(InputStream)

Herhangi varyant

Decoder'a bağlıdır

✓

✗

Hayır (JDK 8+)

Apache Commons Base64InputStream

Standart / URL-safe

✓

✗

Evet (commons-codec)

Apache Commons Base64.decodeBase64()

Standart

✓

✗

Evet (commons-codec)

Guava BaseEncoding.base64().decode()

Standart

✗

Evet (guava)

JWT token'ları ve modern API yükleri için: getUrlDecoder(). E-posta ekleri ve PEM sertifikaları için: getMimeDecoder(). Belleğin önem taşıdığı büyük dosyalar için: decoder.wrap(InputStream). Bunların dışındaki her şey için: getDecoder(). Apache Commons Codec, yalnızca zaten bağımlılık ağacınızda bulunuyorsa tercih edilmeli.

Geliştirme sırasında hızlı doğrulama için çevrimiçi Base64 decoder tek kullanımlık bir sınıf yazmaktan çok daha hızlıdır.

Sıkça Sorulan Sorular

Java'da Base64 dizesi nasıl çözülür?

java.util.Base64 sınıfını içe aktarın ve Base64.getDecoder().decode(encodedString) çağrısını yapın. Geriye byte[] döner — okunabilir metin elde etmek için new String(bytes, StandardCharsets.UTF_8) ile sarın. URL-safe Base64 için (JWT'lerde kullanılır) getDecoder() yerine getUrlDecoder() kullanın.

Java 8+

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-config

Java'da getDecoder() ile getMimeDecoder() arasındaki fark nedir?

getDecoder() katıdır — satır sonları dahil Base64 alfabesi dışındaki her karakteri reddeder. getMimeDecoder() ise satır ayırıcılarını (\r\n) tolere eder ve Base64 dışındaki karakterleri yoksayar; bu da onu verinin 76 karakterde satıra bölündüğü e-posta ekleri ve PEM sertifikalarının çözülmesinde doğru tercih yapar.

Java 8+

String wrapped = "c2VydmVyLWNv\r\nbmZpZw==";

// getDecoder() IllegalArgumentException fırlatır
// Base64.getDecoder().decode(wrapped); // BAŞARISIZ

// getMimeDecoder() bunu işler
byte[] decoded = Base64.getMimeDecoder().decode(wrapped);
System.out.println(new String(decoded)); // server-config

Java'da URL-safe Base64 dizesi nasıl çözülür?

Base64.getUrlDecoder().decode(encoded) kullanın. URL decoder, + ve / yerine RFC 4648 §5'te tanımlanan - ve _ alfabesini bekler. JWT token'ları her zaman bu alfabeyi kullanır. Dolgu karakterleri (=) kaldırılmışsa (JWT'lerde yaygındır), Java'nın URL decoder'ı hem dolgulu hem dolgusuz girdiyi kabul eder.

Java 8+

import java.util.Base64;

// JWT başlığı — URL-safe, dolgu yok
String jwtHeader = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
byte[] decoded = Base64.getUrlDecoder().decode(jwtHeader);
System.out.println(new String(decoded));
// {"alg":"HS256","typ":"JWT"}

Java'da büyük bir Base64 dosyası akış olarak nasıl çözülür?

Bir FileInputStream'i sarmak için decoder.wrap(inputStream) kullanın. Dönen InputStream, byte okurken Base64'ü anlık olarak çözer; bu sayede bellek kullanımı dosya boyutundan bağımsız olarak sabit kalır. En iyi verim için bir BufferedInputStream üzerinden veya doğrudan Files.copy() ile bağlayın.

Java 8+

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);
}

Base64.getDecoder().decode() neden IllegalArgumentException fırlatıyor?

Temel decoder katıdır: satır sonları, boşluklar ve A-Za-z0-9+/= dışındaki her karakteri reddeder. Üç yaygın neden: girdinin sondaki yeni satırları var (strip() ile temizleyin), girdi - ve _ gibi URL-safe karakterler kullanıyor (getUrlDecoder()'a geçin) ya da girdi 76 karakterde satıra bölünmüş (getMimeDecoder()'a geçin). Hata mesajı belirsizse ham byte'ları incelemeyi ihmal etmeyin.

Java 8+

String raw = "c2VydmVyLWNvbmZpZw==\n"; // sondaki yeni satır

// 1. Seçenek: boşlukları temizle
byte[] decoded = Base64.getDecoder().decode(raw.strip());

// 2. Seçenek: boşlukları yoksayan MIME decoder kullan
byte[] decoded2 = Base64.getMimeDecoder().decode(raw);

Java'da java.util.Base64 kullanmadan Base64 çözebilir miyim?

Evet, ama Java 8+'de bunu yapmanın iyi bir nedeni yok. Java 8 öncesinde geliştiriciler sun.misc.BASE64Decoder (dahili, Java 9+'da kaldırıldı), javax.xml.bind.DatatypeConverter.parseBase64Binary() (Java 11'de kaldırıldı) veya Apache Commons Codec kullanırdı. Bu üçü ya kullanımdan kaldırılmış ya da ek bağımlılık gerektiriyor. java.util.Base64'e sadık kalın — daha hızlı, JDK ile birlikte geliyor ve üç varyantın tamamını (temel, URL-safe, MIME) kapsıyor.

İlgili Araçlar

Base64 Encoder — metin veya ikili veriyi tarayıcıda Base64'e kodlayın; Java birim testlerinize yapıştırmak için test verisi oluşturmada çok kullanışlı.
JWT Decoder — üç JWT segmentinin tamamını bir anda bölün ve çözün; alan bazlı yük incelemesiyle birlikte — sadece bir token okumak istediğinizde Java sınıfı yazmaktan çok daha hızlı.
URL Decoder — URL kodlu dizeleri percent-decode ile çözün; API yanıtları Base64url verisiyle percent-encoded sorgu parametrelerini bir arada içerdiğinde kullanışlıdır.
JSON Formatter — Base64 JWT yükünü veya API yapılandırmasını çözdükten sonra JSON'ı buraya yapıştırarak güzel yazdırın ve yapıyı doğrulayın.