Mengapa menggunakan Opsional di Java 8+ alih-alih pemeriksaan pointer nol tradisional?

Kami baru saja pindah ke Java 8. Sekarang, saya melihat aplikasi dibanjiri Optionalobjek.

Sebelum Java 8 (Gaya 1)

Employee employee = employeeServive.getEmployee();

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

After Java 8 (Gaya 2)

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

Saya tidak melihat nilai tambah Optional<Employee> employeeOptional = employeeService.getEmployee();ketika layanan itu sendiri kembali opsional:

Berasal dari latar belakang Java 6, saya melihat Style 1 lebih jelas dan dengan lebih sedikit baris kode. Apakah ada keuntungan nyata yang saya lewatkan di sini?

Dikonsolidasikan dari pemahaman dari semua jawaban dan penelitian lebih lanjut di blog

Style 2 tidak akan cukup Java 8 untuk melihat manfaat penuh. Anda tidak menginginkannya if ... usesama sekali. Lihat contoh Oracle . Mengambil saran mereka, kami mendapatkan:

Gaya 3

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

Atau cuplikan yang lebih panjang

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

Jika Anda menggunakan Optionalsebagai "kompatibilitas" lapisan antara API yang lebih tua yang mungkin masih kembali null, mungkin akan membantu untuk membuat (non-kosong) Opsional pada tahap terbaru yang Anda yakin memiliki sesuatu. Misalnya, di mana Anda menulis:

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

Saya akan memilih:

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

Intinya adalah Anda tahu bahwa ada layanan karyawan yang tidak nol , sehingga Anda dapat membungkusnya Optionaldengan Optional.of(). Kemudian, ketika Anda memanggil getEmployee()itu, Anda mungkin atau mungkin tidak mendapatkan karyawan. Karyawan itu mungkin (atau, mungkin, mungkin tidak) memiliki ID. Kemudian, jika Anda berakhir dengan ID, Anda ingin mencetaknya.

Tidak perlu secara eksplisit memeriksa adanya null, kehadiran, dll., Dalam kode ini.

Di samping tidak ada nilai tambah dalam memiliki Optionalnilai tunggal. Seperti yang Anda lihat, itu hanya mengganti cek nulldengan cek keberadaan.

Ada besar nilai tambah dalam memiliki Collectionhal-hal seperti itu. Semua metode streaming yang diperkenalkan untuk menggantikan loop tingkat rendah gaya lama memahami Optionalhal-hal dan melakukan hal yang benar tentang mereka (tidak memprosesnya atau akhirnya mengembalikan yang tidak disetel Optional). Jika Anda berurusan dengan n item lebih sering daripada dengan item individual (dan 99% dari semua program realistis melakukannya), maka itu adalah peningkatan besar untuk memiliki dukungan bawaan untuk hal-hal yang ada secara opsional. Dalam kasus ideal Anda tidak perlu memeriksa null atau hadir.

Selama Anda menggunakan Optionalseperti API mewah untuk isNotNull(), maka ya, Anda tidak akan menemukan perbedaan dengan hanya memeriksa null.

Hal-hal yang TIDAK boleh Anda gunakan Optionaluntuk

Menggunakan Optionalhanya untuk memeriksa keberadaan suatu nilai adalah 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());
}  

Hal-hal yang harus Anda gunakan Optionaluntuk

Hindari nilai yang tidak ada, dengan memproduksinya jika perlu saat menggunakan metode API pengembalian-nol:

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

Atau, jika membuat Karyawan baru terlalu mahal:

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

Juga, buat semua orang tahu bahwa metode Anda mungkin tidak mengembalikan nilai (jika, karena alasan apa pun, Anda tidak dapat mengembalikan nilai default seperti di atas):

// 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.

Dan akhirnya, ada semua metode seperti aliran yang telah dijelaskan dalam jawaban lain, meskipun itu tidak benar-benar Anda memutuskan untuk menggunakan Optionaltetapi memanfaatkan yang Optionaldisediakan oleh orang lain.

Poin utama bagi saya dalam menggunakan Opsional adalah tetap jelas ketika pengembang perlu memeriksa apakah fungsi mengembalikan nilai atau tidak.

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

Kesalahan utama Anda adalah Anda masih berpikir dalam istilah yang lebih prosedural. Ini tidak dimaksudkan sebagai kritik terhadap Anda sebagai pribadi, itu hanya sebuah pengamatan. Berpikir dalam istilah yang lebih fungsional datang dengan waktu dan latihan, dan oleh karena itu metodenya hadir dan terlihat seperti hal-hal yang paling jelas benar untuk memanggil Anda. Kesalahan kecil sekunder Anda adalah membuat Opsional di dalam metode Anda. Opsional dimaksudkan untuk membantu mendokumentasikan bahwa sesuatu mungkin atau tidak dapat mengembalikan nilai. Anda mungkin tidak mendapatkan apa-apa.

Ini telah menyebabkan Anda menulis kode yang terbaca dengan sempurna yang tampaknya masuk akal, tetapi Anda tergoda oleh temptresses kembar yang kejam yang didapat dan hadir.

Tentu saja pertanyaannya dengan cepat menjadi "mengapa ada dan hadir di sana?"

Satu hal yang banyak orang lewatkan adalah isPresent () adalah bahwa itu bukan sesuatu yang dibuat untuk kode baru yang ditulis oleh orang-orang sepenuhnya di papan dengan bagaimana lambda sangat berguna, dan yang menyukai hal fungsional.

Namun demikian, memberi kami beberapa (dua) manfaat (?) Baik, bagus, glamourous:

• Ini memudahkan transisi kode lama untuk menggunakan fitur-fitur baru.
• Ini memudahkan kurva belajar Opsional.

Yang pertama agak sederhana.

Bayangkan Anda memiliki API yang terlihat seperti ini:

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

Dan Anda memiliki kelas lama menggunakan ini seperti itu (isi bagian yang kosong):

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

Contoh dibuat-buat untuk memastikan. Tapi bersabarlah di sini.

Java 8 sekarang telah diluncurkan dan kami berusaha keras untuk naik. Jadi salah satu hal yang kami lakukan adalah kami ingin mengganti antarmuka lama kami dengan sesuatu yang mengembalikan Opsional. Mengapa? Karena seperti orang lain telah dengan anggun menyebutkan: Ini mengeluarkan dugaan apakah sesuatu bisa batal atau tidak. Ini sudah ditunjukkan oleh orang lain. Tapi sekarang kita punya masalah. Bayangkan kita punya (maafkan saya ketika saya menekan alt + F7 pada metode yang tidak bersalah), 46 tempat di mana metode ini disebut dalam kode warisan yang teruji dengan baik yang melakukan pekerjaan yang sangat baik. Sekarang Anda harus memperbarui semua ini.

INI adalah tempat dimana Hadir bersinar.

Karena sekarang: Snickers lastSnickers = snickersCounter.lastConsumedSnickers (); if (null == lastSnickers) {melempar NoSuchSnickersException baru (); } else {consumer.giveDiabetes (lastSnickers); }

menjadi:

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

Dan ini adalah perubahan sederhana yang dapat Anda berikan kepada junior baru: Dia dapat melakukan sesuatu yang bermanfaat, dan dia akan menjelajahi basis kode pada saat yang sama. menang-menang. Bagaimanapun, sesuatu yang mirip dengan pola ini cukup luas. Dan sekarang Anda tidak perlu menulis ulang kode untuk menggunakan lambdas atau apa pun. (Dalam kasus khusus ini akan sepele, tetapi saya meninggalkan contoh pemikiran di mana itu akan sulit sebagai latihan untuk pembaca.)

Perhatikan bahwa ini berarti cara Anda melakukannya pada dasarnya adalah cara untuk menangani kode lawas tanpa melakukan penulisan ulang yang mahal. Jadi bagaimana dengan kode baru?

Nah, dalam kasus Anda, di mana Anda hanya ingin mencetak sesuatu, Anda cukup melakukan:

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

Yang cukup sederhana, dan sangat jelas. Titik yang perlahan menggelegak ke permukaan kemudian, adalah bahwa ada kasus penggunaan untuk get () dan isPresent (). Mereka ada di sana untuk memungkinkan Anda memodifikasi kode yang ada secara mekanis untuk menggunakan tipe yang lebih baru tanpa terlalu memikirkannya. Karena itu, apa yang Anda lakukan salah arah dengan cara berikut:

• Anda memanggil metode yang dapat mengembalikan nol. Gagasan yang benar adalah bahwa metode mengembalikan nol.
• Anda menggunakan metode bandaid lawas untuk menangani opsi ini, alih-alih menggunakan metode baru yang lezat yang mengandung keanggunan lambda.

Jika Anda ingin menggunakan Opsional sebagai pemeriksaan keamanan-nol sederhana, yang harus Anda lakukan hanyalah ini:

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

Tentu saja, versi tampan ini terlihat seperti:

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

Ngomong-ngomong, meskipun tidak diperlukan, saya merekomendasikan penggunaan baris baru per operasi, sehingga lebih mudah dibaca. Mudah dibaca dan dimengerti ketukan setiap hari dalam seminggu.

Ini tentu saja merupakan contoh yang sangat sederhana di mana mudah untuk memahami semua yang kami coba lakukan. Tidak selalu sesederhana ini di kehidupan nyata. Tetapi perhatikan bagaimana dalam contoh ini, apa yang kami ungkapkan adalah niat kami. Kami ingin MENDAPATKAN karyawan, DAPATKAN ID-nya, dan jika mungkin, cetaklah. Ini adalah kemenangan besar kedua dengan Opsional. Itu memungkinkan kita membuat kode yang lebih jelas. Saya juga berpikir bahwa melakukan hal-hal seperti membuat metode yang melakukan banyak hal sehingga Anda dapat memasukkannya ke peta secara umum adalah ide yang bagus.

Saya tidak melihat manfaat dalam Gaya 2. Anda masih perlu menyadari bahwa Anda memerlukan pemeriksaan nol dan sekarang lebih besar, sehingga kurang dapat dibaca.

Gaya yang lebih baik adalah, jika employeeServive.getEmployee () akan mengembalikan Opsional dan kemudian kode tersebut menjadi:

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

Dengan cara ini Anda tidak dapat memanggilemployeeServive.getEmployee (). GetId () dan Anda melihat bahwa Anda harus menangani valoue opsional entah bagaimana. Dan jika dalam seluruh metode basis kode Anda tidak pernah mengembalikan nol (atau hampir tidak pernah dengan terkenal ke pengecualian tim Anda untuk aturan ini), itu akan meningkatkan keamanan terhadap NPE.

Saya pikir manfaat terbesar adalah bahwa jika tanda tangan metode Anda mengembalikan EmployeeAnda tidak memeriksa nol. Anda tahu dari tanda tangan itu bahwa dijamin akan mengembalikan seorang karyawan. Anda tidak perlu menangani kasus kegagalan. Dengan opsional, Anda tahu Anda melakukannya.

Dalam kode yang saya lihat ada cek nol yang tidak akan pernah gagal karena orang tidak ingin melacak kode untuk menentukan apakah nol itu mungkin, sehingga mereka melempar cek nol ke mana-mana secara defensif. Ini membuat kode sedikit lebih lambat, tetapi yang lebih penting itu membuat kode lebih ribut.

Namun, agar ini berfungsi, Anda perlu menerapkan pola ini secara konsisten.

Jawaban saya adalah: Jangan. Setidaknya pikirkan dua kali tentang apakah itu benar-benar perbaikan.

Ekspresi (diambil dari jawaban lain) seperti

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

tampaknya menjadi cara fungsional yang tepat untuk menangani metode pengembalian yang semula nullable. Kelihatannya bagus, tidak pernah melempar dan tidak pernah membuat Anda berpikir untuk menangani kasus "absen".

Itu terlihat lebih baik daripada cara gaya lama

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

yang membuatnya jelas bahwa mungkin ada elseklausa.

Gaya fungsional

• terlihat sangat berbeda (dan tidak dapat dibaca untuk orang yang tidak terbiasa)
• adalah sakit untuk di-debug
• tidak dapat dengan mudah diperpanjang untuk menangani kasus "absen" ( orElsetidak selalu memadai)
• menyesatkan untuk mengabaikan kasus "absen"

Dalam hal apapun itu tidak harus digunakan sebagai obat mujarab. Jika itu berlaku secara universal, maka semantik .operator harus diganti dengan semantik ?.operator , NPE dilupakan dan semua masalah diabaikan.

Sementara menjadi penggemar Java yang besar, saya harus mengatakan bahwa gaya fungsional hanyalah pengganti pernyataan orang Jawa yang buruk

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

terkenal dari bahasa lain. Apakah kita setuju dengan pernyataan ini?

• tidak (benar-benar) fungsional?
• sangat mirip dengan kode gaya lama, hanya jauh lebih sederhana?
• jauh lebih mudah dibaca daripada gaya fungsional?
• apakah ramah debugger?

Opsional adalah konsep (tipe urutan lebih tinggi) yang berasal dari pemrograman fungsional. Menggunakannya tidak jauh dengan pemeriksaan null bersarang dan menyelamatkan Anda dari piramida malapetaka.