Geleneksel boş işaretçi denetimleri yerine neden Java 8+ sürümünde İsteğe Bağlı kullanılır?

Geçenlerde Java 8'e geçtik. Şimdi, Optionalnesnelerle dolu uygulamaları görüyorum .

Java 8'den Önce (Stil 1)

Employee employee = employeeServive.getEmployee();

if(employee!=null){
    System.out.println(employee.getId());
}

Java 8'den Sonra (Stil 2)

Optional<Employee> employeeOptional = Optional.ofNullable(employeeService.getEmployee());
if(employeeOptional.isPresent()){
    Employee employee = employeeOptional.get();
    System.out.println(employee.getId());
}

Optional<Employee> employeeOptional = employeeService.getEmployee();Hizmetin kendisinin isteğe bağlı olarak döndüğü zaman hiçbir katma değer göremiyorum :

Bir Java 6 arka planından gelince, Stil 1'i daha net ve daha az kod satırıyla görüyorum. Burada kaçırdığım herhangi bir gerçek avantaj var mı?

Tüm cevapların anlaşılmasından ve blogda daha fazla araştırma yapılmasından konsolide

Stil 2, tam yararı görecek kadar Java 8'e gitmiyor. Sen hiç istemiyorsun if ... use. Oracle'ın örneklerine bakın . Onların tavsiyelerine göre, biz:

Stil 3

// Changed EmployeeServive to return an optional, no more nulls!
Optional<Employee> employee = employeeServive.getEmployee();
employee.ifPresent(e -> System.out.println(e.getId()));

Veya daha uzun bir snippet

Optional<Employee> employee = employeeServive.getEmployee();
// Sometimes an Employee has forgotten to write an up-to-date timesheet
Optional<Timesheet> timesheet = employee.flatMap(Employee::askForCurrentTimesheet); 
// We don't want to do the heavyweight action of creating a new estimate if it will just be discarded
client.bill(timesheet.orElseGet(EstimatedTimesheet::new));

OptionalHala dönebilecek eski bir API arasında "uyumluluk" katmanı olarak kullanıyorsanız null, en son aşamada bir şeyiniz olduğundan emin olduğunuz (boş olmayan) İsteğe Bağlı bir seçeneği oluşturmak yararlı olabilir . Örneğin, yazdığınız yer:

Optional<Employee> employeeOptional = Optional.ofNullable(employeeService.getEmployee());
if(employeeOptional.isPresent()){
    Employee employeeOptional= employeeOptional.get();
    System.out.println(employee.getId());
}

Ben doğru tercih ederim:

Optional.of(employeeService)                 // definitely have the service
        .map(EmployeeService::getEmployee)   // getEmployee() might return null
        .map(Employee::getId)                // get ID from employee if there is one
        .ifPresent(System.out::println);     // and if there is an ID, print it

Nokta olduğunu biliyoruz boş olmayan bir çalışanın var ki servis , buna bağlı olarak bir o paketleyebilirim Optionalile Optional.of(). Daha sonra, onu aradığınızda getEmployee(), bir çalışanınız olabilir veya olmayabilir. Bu çalışanın kimliği olabilir (veya olabilir). Daha sonra bir kimliğiniz olursa, yazdırmak istersiniz.

Açıkça kontrol etmek gerek yoktur herhangi Bu kodda, vb boş, varlığı.

OptionalTek bir değere sahip olmanın katma değeri yoktur . Gördüğünüz gibi, bu sadece nullvarlığını kontrol eden bir çekin yerine geçer .

Bunlardan birine sahip olmanın çok büyük katma değeri var Collection. Eski stil düşük seviye döngülerinin yerini almak üzere sunulan tüm akış yöntemleri bir Optionalşeyleri anlar ve bunlar hakkında doğru olanı yapar (onları işleme koymayıp sonuçta başka bir küme döndürmez Optional). N öğelerini tek tek öğelere kıyasla (ve tüm gerçekçi programların% 99'unu yaparsanız) daha fazla ele alırsanız , isteğe bağlı olarak sunulan şeylere yönelik yerleşik desteğe sahip olmak büyük bir gelişmedir. İdeal durumda, hiçbir zaman kontrol etmeniz null veya varlığınız olması gerekmez .

OptionalSadece bir fantezi API gibi kullandığınız sürece isNotNull(), evet, sadece kontrol ederken hiçbir fark bulamazsınız null.

Eğer KULLANMAYIN gerekenler Optionaliçin

OptionalSadece bir değerin varlığını kontrol etmek için kullanma Bad Code ™:

// BAD CODE ™ --  just check getEmployee() != null  
Optional<Employee> employeeOptional =  Optional.ofNullable(employeeService.getEmployee());  
if(employeeOptional.isPresent()) {  
    Employee employee = employeeOptional.get();  
    System.out.println(employee.getId());
}  

Kullanmanız gereken şeyler Optionaliçin

Null döndüren API yöntemleri kullanılırken gerektiğinde bir tane üreterek, mevcut olmayan bir değerden kaçının:

Employee employee = Optional.ofNullable(employeeService.getEmployee())
                            .orElseGet(Employee::new);
System.out.println(employee.getId());

Veya, yeni bir Çalışan oluşturmak çok pahalıysa:

Optional<Employee> employee = Optional.ofNullable(employeeService.getEmployee());
System.out.println(employee.map(Employee::getId).orElse("No employee found"));

Ayrıca, herkesi yöntemlerin bir değer getirmeyebileceğinin farkına varma (eğer, hangi nedenle olursa olsun yukarıdaki gibi bir varsayılan değer döndüremezseniz):

// Your code without Optional
public Employee getEmployee() {
    return someCondition ? null : someEmployee;
}
// Someone else's code
Employee employee = getEmployee(); // compiler doesn't complain
// employee.get...() -> NPE awaiting to happen, devs criticizing your code

// Your code with Optional
public Optional<Employee> getEmployee() {
    return someCondition ? Optional.empty() : Optional.of(someEmployee);
}
// Someone else's code
Employee employee = getEmployee(); // compiler complains about incompatible types
// Now devs either declare Optional<Employee>, or just do employee = getEmployee().get(), but do so consciously -- not your fault.

O gerçekten olmasalar da Ve son olarak, zaten başka cevaplar açıklandığı olan tüm akışı benzeri yöntemler var sen kullanmaya karar Optionalancak yararlanarak Optionalbaşkası tarafından sağlanan.

İsteğe Bağlı seçeneğini kullanmamda kilit nokta, geliştiricinin işlev dönüş değeri olup olmadığını kontrol etmesi gerektiğinde açık tutmaktır.

//service 1
Optional<Employee> employeeOptional = employeeService.getEmployee();
if(employeeOptional.isPresent()){
    Employee employeeOptional= employeeOptional.get();
    System.out.println(employee.getId());
}

//service 2
Employee employee = employeeService.getEmployeeXTPO();
System.out.println(employee.getId());

Asıl hata, hala daha usule uygun şekilde düşündüğün. Bu bir kişi olarak sizi eleştirmek anlamına gelmez, sadece bir gözlemdir. Daha işlevsel terimlerle düşünmek zaman ve pratikle gelir ve bu nedenle bu yöntemler sizin için en açık ve doğru şeylere benziyor. İkincil küçük hata ise, İsteğe Bağlı yönteminizi yönteminizde oluşturmaktır. İsteğe Bağlı, bir şeyin bir değer getirebileceğini veya vermeyeceğini belgelemeye yardımcı olmak içindir. Hiçbir şey alamayabilirsin.

Bu, size makul derecede makul görünen mükemmel okunaklı kodlar yazmanıza neden oldu, ancak aldığınız ve isPresent olan aşağılık ikiz baştan çıkarıcıları tarafından baştan çıktınız.

Tabii ki hızlı bir şekilde soru, "Neden Hazır ve Oraya Gidiyor?"

Buradaki birçok kişinin özlediği şey şudur: isPresent (), insanlar tarafından gemide yazılan yeni kod için yapılmış olan ve faydalı lambdaların ne kadar işe yaradığı ve işlevsel olanı sevenler için yapılan bir şey değildir.

Ancak, bize birkaç (iki) iyi, harika, çekici (?) Yarar sağlar:

• Yeni özellikleri kullanmak için eski kod geçişini kolaylaştırır.
• İsteğe bağlı öğrenme eğrilerini kolaylaştırır.

İlki oldukça basittir.

Buna benzeyen bir API'niz olduğunu hayal edin:

public interface SnickersCounter {
  /** 
   * Provides a proper count of how many snickers have been consumed in total.
   */
  public SnickersCount howManySnickersHaveBeenEaten();

  /**
    * returns the last snickers eaten.<br>
    * If no snickers have been eaten null is returned for contrived reasons.
    */
  public Snickers lastConsumedSnickers();
}

Ve bunu kullanarak eski bir sınıfınız vardı (boşlukları doldurun):

Snickers lastSnickers = snickersCounter.lastConsumedSnickers();
if(null == lastSnickers) {
  throw new NoSuchSnickersException();
}
else {
  consumer.giveDiabetes(lastSnickers);
}

Emin olmak için kesin bir örnek. Ama burada benimle ayı.

Java 8 şimdi başlattı ve gemiye girmek için çabalıyoruz. Dolayısıyla yaptığımız şeylerden biri, eski arayüzümüzü İsteğe Bağlı olan bir şeyle değiştirmek istediğimizdir. Neden? Çünkü başkası nezaketle bahsetmişken: Bu, bir şeyin null olabileceği ya da olmama tahminini ortadan kaldırır. Bu, başkaları tarafından çoktan işaret edilmiştir. Ama şimdi bir sorunumuz var. (Masum bir yöntemde alt + F7'ye çarptığım için afedersiniz), bu yöntemin 46 mükemmel şekilde işin iyi yapıldığını söyleyen eski kodda çağrıldığı bir yer olduğunu hayal edin. Şimdi bunların hepsini güncellemelisiniz.

BU, Present'in parladığı yerdir.

Çünkü şimdi: Snickers lastSnickers = snickersCounter.lastConsumedSnickers (); if (null == lastSnickers) {yeni NoS BusesnickersException () at; } else {consumer.giveDiabetes (lastSnickers); }

dönüşür:

Optional<Snickers> lastSnickers = snickersCounter.lastConsumedSnickers();
if(!lastSnickers.isPresent()) {
  throw new NoSuchSnickersException();
}
else {
  consumer.giveDiabetes(lastSnickers.get());
}

Ve bu yeni küçük çocuğa verebileceğiniz basit bir değişiklik: O yararlı bir şeyler yapabilir ve aynı zamanda kod tabanını da keşfedecektir. kazan-kazan. Sonuçta, bu stile benzer bir şey oldukça yaygın. Ve şimdi, lambda veya başka bir şey kullanmak için kodu yeniden yazmak zorunda değilsiniz. (Bu özel durumda önemsiz olurdu, ancak okuyucunun alıştırması yapmanın zor olacağı örnekleri düşünerek bırakıyorum.)

Bunun, sizin yaptığınız yolun, esasen pahalı yeniden yazma yapmadan eski kodlarla başa çıkmanın bir yolu olduğu anlamına geldiğine dikkat edin. Peki ya yeni kod?

Durumunda, sadece bir şeyi basmak istediğin yerde, yapardın:

. SnickersCounter.lastConsumedSnickers () ifPresent (System.out :: println);

Hangi oldukça basit ve tamamen açık. O zaman yavaşça yüzeye sıçrayan nokta, get () ve isPresent () için kullanım durumları olduğudur. Daha fazla düşünmeden yeni türleri kullanmak için var olan kodu mekanik olarak değiştirmenize izin vermek için oradalar. Yaptıklarınız bu nedenle aşağıdaki şekillerde yanlış yönlendirilmişlerdir:

• Siz null dönebilecek bir yöntem çağırıyorsunuz. Doğru fikir, yöntemin null değerini döndürdüğüdür.
• Bu isteğe bağlı ile baş etmek için miras bandajı yöntemleri içeren lezzetli yeni yöntemleri kullanmak yerine eski bandaj yöntemlerini kullanıyorsunuz.

Optional'ı basit bir sıfır güvenlik kontrolü olarak kullanmak istiyorsanız, yapmanız gereken şey şudur:

new Optional.ofNullable(employeeServive.getEmployee())
    .map(Employee::getId)
    .ifPresent(System.out::println);

Tabii ki, bu iyi görünümlü versiyonu gibi görünüyor:

employeeService.getEmployee()
    .map(Employee::getId)
    .ifPresent(System.out::println);

Bu arada, hiçbir zorunluluk olmasa da, okuma başına daha kolay olması için işlem başına yeni bir satır kullanmanızı öneririm. Okuması ve anlaşılması kolay, haftanın herhangi bir günü özlülük yener.

Elbette, yapmaya çalıştığımız her şeyi anlamanın kolay olduğu çok basit bir örnek. Gerçek hayatta her zaman bu kadar basit değildir. Ancak, bu örnekte, ifade ettiğimiz şeyin niyetlerimizin ne kadar olduğuna dikkat edin. Çalışanı almak, kimliğini almak ve mümkünse yazdırmak istiyoruz. Bu, Optional ile ikinci büyük galibiyet. Daha net bir kod oluşturmamızı sağlar. Ayrıca bir harita üzerinde besleyebilmeniz için bir sürü şey yapan bir yöntem yapmak gibi şeyler yapmanın genel olarak iyi bir fikir olduğunu düşünüyorum.

Stil 2'de fayda göremiyorum. Boş denetime ihtiyacınız olduğunu ve şimdi daha da büyük, dolayısıyla daha az okunabilir olduğunu fark etmeniz gerekiyor.

WorkerServive.getEmployee (), Optional öğesini döndürür ve ardından kod şöyle olur: Daha iyi bir stil olurdu.

Optional<Employee> employeeOptional = employeeServive.getEmployee();
if(employeeOptional.isPresent()){
    Employee employee= employeeOptional.get();
    System.out.println(employee.getId());
}

Bu şekilde callemployeeServive.getEmployee (). GetId () yöntemini kullanamazsınız ve bir şekilde isteğe bağlı valoue almanız gerektiğini fark edersiniz. Ve tüm kod temeli metotlarınızda asla boşa dönmezseniz (ya da bu kuralın istisnaları dışında ekibiniz tarafından iyi bilinmediğinde), NPE'ye karşı güvenliği artıracaktır.

Ben en büyük yararı, yöntem imzası bir dönerse olduğunu düşünüyorum EmployeeEğer yok boş olup olmadığını kontrol edin. Bu imza ile bir çalışanın iadesinin garanti edildiğini biliyorsunuz. Bir arıza vakası ele almanıza gerek yok. İsteğe bağlı olarak yaptığınızı biliyorsunuz.

Gördüğüm kodda, insanlar null mümkün olup olmadığını belirlemek için kodu izlemek istemedikleri için hiçbir zaman başarısız olmayacak boş denetimler var, bu yüzden her yerde savunmasız boş denetimler atıyorlar. Bu, kodu biraz yavaşlatır, ancak daha da önemlisi kodu çok gürültülü yapar.

Bununla birlikte, bunun çalışması için, bu kalıbı tutarlı bir şekilde uygulamanız gerekir.

Cevabım: Sadece yapma. En azından gerçekten bir gelişme olup olmadığını iki kere düşünün.

(Başka bir cevaptan alınan) gibi bir ifade

Optional.of(employeeService)                 // definitely have the service
        .map(EmployeeService::getEmployee)   // getEmployee() might return null
        .map(Employee::getId)                // get ID from employee if there is one
        .ifPresent(System.out::println);     // and if there is an ID, print it

başlangıçta nULL olabilecek geri dönüş yöntemleri ile başa çıkmak için doğru fonksiyonel yol gibi görünüyor. Güzel gözüküyor, asla fırlatmıyor ve asla "devamsız" olayı ele almayı düşünmüyor.

Eski tarz yoldan daha iyi görünüyor

Employee employee = employeeService.getEmployee();
if (employee != null) {
    ID id = employee.getId();
    if (id != null) {
        System.out.println(id);
    }
}

Bu da, elsecümlelerin olabileceğini açıkça ortaya koyuyor .

Fonksiyonel tarzı

• Tamamen farklı görünüyor (ve kullanılmayan insanlar için okunamıyor)
• hata ayıklamak için bir acı
• "devamsız" durum için kolay genişletilemez ( orElseher zaman yeterli değildir)
• "yok" vakasını görmezden gelme yanıltıcı

Hiçbir durumda, derde deva olarak kullanılmamalıdır. Eğer evrensel olarak uygulanabilirse, .operatörün semantiği, ?.operatörün semantiği , NPE'nin unutması ve tüm sorunların göz ardı edilmesi ile değiştirilmelidir.

Büyük bir Java hayranı olurken, işlevsel stilin yalnızca zayıf bir Java adamı ifadesinin yerine geçtiğini söylemeliyim.

employeeService
.getEmployee()
?.getId()
?.apply(id => System.out.println(id));

diğer dillerden iyi biliniyor. Bu ifadeye katılıyor muyuz?

• (gerçekten) işlevsel değil mi?
• Eski stil koduna çok benzer, sadece çok daha basit?
• işlevsel stilden çok daha okunabilir mi?
• hata ayıklayıcı dostu nedir?

İsteğe bağlı, işlevsel programlamadan gelen bir kavramdır (daha üst düzey bir tür). İçiçe boş null kontrolü yapmaktan kaçınır ve sizi kıyamet piramidinden kurtarır.