romegames 1
romegames
Reklam vermek için turkmmo@gmail.com

Java Optional Kullanarak NullPointerException Hatalarının Önüne Geçmek

image453b6030abaaadf7.jpg


Optional Hangi İhtiyaca Yanıt Veriyor?

Bir işlemin sonucunda değer dönmeme ihtimali varsa, Java'da eskiden beri sıkıntılı bir yöntem izlenirdi: null döndürüp çağrıyı yapan kişinin bu durumu kontrol etmesini ummak. Ne var ki bu kontroller çoğunlukla unutulur ve kodun bambaşka bir yerinde patlayan NullPointerException hataları ortaya çıkar.

Optional<T> yapısı, içerisinde bir veri taşıyabilen ya da tamamen boş durabilen korumalı bir kapsüldür. Bir metot User tipi yerine Optional<User> döndürdüğünde, geliştiriciye daha en başından "bu işlemin sonucunda veri bulunamayabilir" mesajını verir. Böylece derleyici, yazılımcıyı bu ihtimali değerlendirmeye zorlar.

Java:
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> found = Optional.of("Ada");
        Optional<String> missing = Optional.empty();

        System.out.println(found.isPresent());   // true
        System.out.println(missing.isPresent());  // false
    }
}

Optional Nesnesi Oluşturma Yolları

Bu yapıyı oluştururken kullanabileceğiniz üç farklı fabrika metodu bulunur ve senaryoya uygun olanı seçmek kritiktir:

• Optional.of(value) - Gönderilen değer kesinlikle null olmamalıdır; aksi halde anında NullPointerException hatası alırsınız.
• Optional.ofNullable(value) - Verilen değer null ise boş bir kutu, dolu ise veriyi içeren bir yapı döndürür. Null gelme ihtimali olan verilerde bu tercih edilmelidir.
• Optional.empty() - İçeriği boş bir optional oluşturur.

Java:
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String maybeNull = System.getenv("DOES_NOT_EXIST");  // null döndürür

        Optional<String> safe = Optional.ofNullable(maybeNull);
        System.out.println(safe.isPresent());  // false, istisna yok

        // Optional.of(maybeNull) burada NullPointerException fırlatırdı
        Optional<String> sure = Optional.of("definitely here");
        System.out.println(sure.isPresent());  // true
    }
}

Sıkça yapılan hatalardan biri, null olma riski taşıyan bir değişkeni Optional.of(x) ile sarmalamaktır. Bu durum mekanizmanın amacını bozar ve engellemeye çalıştığınız hataya doğrudan sebebiyet verir. Kararsız kaldığınız anlarda ofNullable kullanabilirsiniz.

Kutudaki Veriye Güvenli Şekilde Erişmek

Optional kullanırken ana hedef, değerin varlığından emin olmadan ona doğrudan ulaşmaya çalışmamaktır. Doğrudan veri çekmeye yarayan get() komutu oldukça risklidir ve zorunlu kalmadıkça tercih edilmemelidir:

Java:
Optional<String> name = Optional.empty();
String value = name.get();   // NoSuchElementException fırlatır - kılık değiştirmiş NPE

Bunun yerine, verinin olmaması durumunda devreye girecek bir alternatif belirlemeli veya verinin varlığına göre hareket etmelisiniz. orElse metodu veri yoksa varsayılan bir değer sunarken; ifPresent sadece veri mevcut olduğunda ilgili kod bloğunu çalıştırır:

Java:
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("Grace");
        Optional<String> blank = Optional.empty();

        System.out.println(name.orElse("anonymous"));   // Grace
        System.out.println(blank.orElse("anonymous"));  // anonymous

        name.ifPresent(n -> System.out.println("Hello, " + n));
        blank.ifPresent(n -> System.out.println("never prints"));
    }
}

Eğer varsayılan değeri üretmek maliyetli bir işlem gerektiriyorsa orElse yerine orElseGet(supplier) kullanmalısınız. Çünkü orElse içerisine yazılan ifade optional dolu olsa bile hesaplanırken, supplier sadece optional boş olduğunda tetiklenir.

Zorunlu Durumlarda orElseThrow Kullanımı

Bazı senaryolarda verinin bulunmaması doğrudan bir hata anlamına gelir; örneğin sistem için kritik bir konfigürasyon parametresi veya veritabanında mutlaka bulunması gereken bir kayıt gibi. Bu gibi durumlarda orElseThrow, boş bir optional yapısını belirlediğiniz özel bir istisnaya dönüştürmenizi sağlar:

Java:
import java.util.Optional;

public class Main {
    static Optional<Integer> parsePort(String raw) {
        try {
            return Optional.of(Integer.parseInt(raw));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        int port = parsePort("8080")
            .orElseThrow(() -> new IllegalStateException("port must be a number"));
        System.out.println("listening on " + port);

        try {
            parsePort("nope")
                .orElseThrow(() -> new IllegalStateException("port must be a number"));
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
        }
    }
}

Bu kullanım, if (opt.isPresent()) kontrolleri yazmaktan çok daha okunaklıdır ve hatanın nerede gerçekleştiğini net bir şekilde ortaya koyar.

map ve filter ile Veri İşleme

Bu yapının gerçek gücü zincirleme işlemlerde ortaya çıkar. map fonksiyonu, tanımlanan işlemi sadece değer varsa uygular; optional boşsa hiçbir şey yapmadan boş bir optional döndürür. Böylece null kontrolleriyle uğraşmadan veri dönüşümü yapabilirsiniz. filter ise belirlediğiniz koşula uymayan değerleri eler.

Java:
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> raw = Optional.of("  Coddy  ");

        String result = raw
            .map(String::trim)          // "Coddy"
            .filter(s -> !s.isEmpty())  // yalnızca boş olmayanı tut
            .map(String::toUpperCase)   // "CODDY"
            .orElse("EMPTY");

        System.out.println(result);  // CODDY

        // Boş bir optional dokunulmadan akar - NPE yok, dallanma yok
        String none = Optional.<String>empty()
            .map(String::trim)
            .orElse("EMPTY");
        System.out.println(none);    // EMPTY
    }
}

Eşleme yaptığınız fonksiyonun kendisi de bir Optional döndürüyorsa, iç içe geçmiş Optional<Optional<T>> yapısıyla karşılaşmamak için map yerine flatMap tercih etmelisiniz. Stream yapılarındaki map/flatMap mantığı burada da geçerlidir; bir Optional nesnesini tek elemanlı ya da boş bir stream gibi düşünebilirsiniz.

Optional Kullanım Alanları ve Kaçınılması Gereken Yerler

Optional yapısının temel tasarım amacı, bir değer üretmeme ihtimali bulunan metotlarda dönüş tipi olarak görev yapmaktır. Örneğin Stream.findFirst() kullanımı, arama işlemleri veya veri dönüştürme fonksiyonları buna mükemmel birer örnektir. Bu tür yerlerde kullanıldığında API'niz verinin bulunamayabileceğini açıkça belirtmiş olur.

Ancak şu durumlarda tercih edilmemelidir:

• Sınıf alanları (fields). Serileştirilebilir (Serializable) yapıda değillerdir ve nesne maliyetini artırırlar. Bunların yerine standart referanslar kullanıp denetimi constructor içinde yapmalısınız.
• Metot parametreleri. Çağrıyı yapan tarafı sürekli Optional.of(...) yazmaya zorlar. Bu durum, metot aşırı yükleme (overloading) veya doğrudan null kabul eden parametreler kullanmaktan daha karmaşık bir kod yapısı oluşturur.
• Koleksiyon tipleri. Optional<List> şeklinde bir kullanım yerine doğrudan boş bir List döndürmelisiniz. Zaten boş bir koleksiyon verinin olmadığını ifade eder.

Sadece metot dönüşlerinde doğru şekilde yararlanıldığında Optional, fark edilmeyen null hatalarını daha kod derlenirken çözülmesi gereken birer uyarıya dönüştürür.

Gelecek Konu: İstisnalar (Exceptions)

Optional yapısı, verinin bulunmaması gibi olağan durumları zarifçe yönetir. Fakat sistemsel sorunlar, okunamayan dosyalar, kopan ağ bağlantıları veya hatalı girdiler gibi durumlar gerçek birer istisnadır. Java'nın bu durumları yönetmek için sunduğu istisna mekanizmasını bir sonraki derste inceleyeceğiz.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst