Tại sao sử dụng Tùy chọn trong Java 8+ thay vì kiểm tra con trỏ null truyền thống?

Gần đây chúng tôi đã chuyển sang Java 8. Bây giờ, tôi thấy các ứng dụng tràn ngập Optionalcác đối tượng.

Trước Java 8 (Kiểu 1)

Employee employee = employeeServive.getEmployee();

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

Sau Java 8 (Kiểu 2)

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

Tôi thấy không có giá trị gia tăng Optional<Employee> employeeOptional = employeeService.getEmployee();nào khi dịch vụ tự trả về tùy chọn:

Đến từ nền Java 6, tôi thấy Style 1 rõ ràng hơn và có ít dòng mã hơn. Có bất kỳ lợi thế thực sự tôi đang thiếu ở đây?

Hợp nhất từ ​​sự hiểu biết từ tất cả các câu trả lời và nghiên cứu thêm tại blog

Kiểu 2 không phải là Java 8 đủ để thấy toàn bộ lợi ích. Bạn không muốn if ... usechút nào. Xem ví dụ của Oracle . Theo lời khuyên của họ, chúng tôi nhận được:

Phong cách 3

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

Hoặc một đoạn dài hơn

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

Nếu bạn đang sử dụng Optionallàm lớp "tương thích" giữa API cũ vẫn có thể quay lại null, có thể hữu ích để tạo Tùy chọn (không trống) ở giai đoạn mới nhất mà bạn chắc chắn rằng mình có thứ gì đó. Ví dụ, nơi bạn đã viết:

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

Tôi muốn chọn:

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

Vấn đề là bạn biết rằng có một dịch vụ nhân viên không có giá trị , vì vậy bạn có thể kết hợp nó Optionalvới một Optional.of(). Sau đó, khi bạn gọi getEmployee()vào đó, bạn có thể hoặc không thể có được một nhân viên. Nhân viên đó có thể (hoặc, có thể, có thể không) có ID. Sau đó, nếu bạn đã kết thúc với một ID, bạn muốn in nó.

Không cần phải kiểm tra rõ ràng bất kỳ null, sự hiện diện, vv, trong mã này.

Bên cạnh không có giá trị gia tăng nào khi có một Optionalgiá trị duy nhất. Như bạn đã thấy, chỉ cần thay thế một kiểm tra nullbằng một kiểm tra cho sự hiện diện.

Có giá trị gia tăng rất lớn khi có một Collectiontrong những điều như vậy. Tất cả các phương thức phát trực tuyến được giới thiệu để thay thế các vòng lặp cấp thấp kiểu cũ đều hiểu Optionalmọi thứ và thực hiện đúng về chúng (không xử lý chúng hoặc cuối cùng trả lại một unset khác Optional). Nếu bạn xử lý n mục thường xuyên hơn so với các mục riêng lẻ (và 99% tất cả các chương trình thực tế làm), thì đó là một cải tiến lớn để có hỗ trợ tích hợp cho các mục trình bày tùy ý. Trong trường hợp lý tưởng bạn không bao giờ phải kiểm tra null hoặc hiện diện.

Miễn là bạn sử dụng Optionalgiống như một API ưa thích isNotNull(), thì có, bạn sẽ không tìm thấy bất kỳ sự khác biệt nào nếu chỉ kiểm tra null.

Những thứ bạn KHÔNG nên sử dụng Optionalcho

OptionalChỉ sử dụng để kiểm tra sự hiện diện của một giá trị là 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());
}  

Những thứ bạn nên sử dụng Optionalcho

Tránh một giá trị không có mặt, bằng cách tạo một giá trị khi cần thiết khi sử dụng các phương thức API trả về null:

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

Hoặc, nếu tạo Nhân viên mới quá tốn kém:

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

Ngoài ra, làm cho mọi người biết rằng các phương thức của bạn có thể không trả về giá trị (nếu vì lý do nào đó, bạn không thể trả về giá trị mặc định như trên):

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

Và cuối cùng, có tất cả các phương thức giống như luồng đã được giải thích trong các câu trả lời khác, mặc dù những phương pháp đó không thực sự khiến bạn quyết định sử dụng Optionalmà sử dụng phương thức Optionalđược cung cấp bởi người khác.

Điểm mấu chốt đối với tôi khi sử dụng Tùy chọn là giữ rõ ràng khi nhà phát triển cần kiểm tra xem hàm có trả về giá trị hay không.

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

Sai lầm chính của bạn là bạn vẫn đang suy nghĩ theo các thuật ngữ thủ tục hơn. Điều này không có nghĩa là một lời chỉ trích bạn như một người, nó chỉ là một quan sát. Suy nghĩ theo các thuật ngữ chức năng hơn đi kèm với thời gian và thực hành, và do đó các phương pháp là Hiện diện và có được vẻ như là những điều chính xác rõ ràng nhất để gọi cho bạn. Lỗi nhỏ thứ cấp của bạn là tạo Tùy chọn bên trong phương thức của bạn. Tùy chọn có nghĩa là để giúp tài liệu rằng một cái gì đó có thể hoặc không thể trả về một giá trị. Bạn có thể không nhận được gì.

Điều này đã dẫn đến việc bạn viết mã hoàn toàn dễ đọc có vẻ hoàn toàn hợp lý, nhưng bạn đã bị quyến rũ bởi những cám dỗ song sinh tệ hại có được và có mặt.

Tất nhiên câu hỏi nhanh chóng trở thành "tại sao isPftime và thậm chí đến đó?"

Một điều mà nhiều người ở đây bỏ lỡ đó là isPftime () là nó không phải là thứ được tạo ra cho mã mới được viết bởi những người hoàn toàn trên tàu với cách thức lambdas hữu ích, và những người thích chức năng này.

Tuy nhiên, nó mang lại cho chúng ta một vài (hai) lợi ích tốt, tuyệt vời, quyến rũ (?):

• Nó giúp giảm bớt sự chuyển đổi của mã kế thừa để sử dụng các tính năng mới.
• Nó làm giảm các đường cong học tập của Tùy chọn.

Cái đầu tiên khá đơn giản.

Hãy tưởng tượng bạn có một API trông như thế này:

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

Và bạn đã có một lớp kế thừa bằng cách sử dụng này (điền vào chỗ trống):

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

Một ví dụ giả định để chắc chắn. Nhưng hãy chịu đựng tôi ở đây.

Java 8 hiện đã được khởi chạy và chúng tôi đang tranh giành để có được. Vì vậy, một trong những điều chúng tôi làm là chúng tôi muốn thay thế giao diện cũ của mình bằng một cái gì đó trả về Tùy chọn. Tại sao? Bởi vì như một người khác đã đề cập một cách ân cần: Điều này đưa ra phỏng đoán về việc liệu thứ gì đó có thể là null hay không. Điều này đã được những người khác chỉ ra. Nhưng bây giờ chúng tôi có một vấn đề. Hãy tưởng tượng chúng ta có (xin lỗi trong khi tôi nhấn alt + F7 bằng một phương thức vô tội), 46 vị trí mà phương thức này được gọi là mã kế thừa được kiểm tra tốt, thực hiện một công việc tuyệt vời khác. Bây giờ bạn phải cập nhật tất cả những điều này.

ĐÂY là nơi tỏa sáng.

Bởi vì bây giờ: Snickers lastSnickers = snickersC gặp.lastConsumedSnickers (); if (null == lastSnickers) {ném NoSuchSnickersException () mới; } other {Consumer.giveDzheim (LastSnickers); }

trở thành:

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

Và đây là một thay đổi đơn giản mà bạn có thể cung cấp cho đàn em mới: Anh ấy có thể làm điều gì đó hữu ích, và anh ấy sẽ được khám phá cơ sở mã hóa cùng một lúc. đôi bên cùng có lợi Rốt cuộc, một cái gì đó giống với mô hình này là khá phổ biến. Và bây giờ bạn không phải viết lại mã để sử dụng lambdas hay bất cứ thứ gì. (Trong trường hợp cụ thể này sẽ là chuyện nhỏ, nhưng tôi để lại những ví dụ về việc nó sẽ khó khăn như một bài tập cho người đọc.)

Lưu ý rằng điều này có nghĩa là cách bạn đã làm về cơ bản là một cách để xử lý mã kế thừa mà không phải viết lại tốn kém. Vậy còn mã mới thì sao?

Chà, trong trường hợp của bạn, nơi bạn chỉ muốn in ra một cái gì đó, bạn chỉ cần làm:

snickersC gặp.lastConsumedSnickers (). ifPftime (System.out :: println);

Đó là khá đơn giản, và hoàn toàn rõ ràng. Điểm mà từ từ nổi lên trên bề mặt sau đó, là có các trường hợp sử dụng cho get () và isPftime (). Họ ở đó để cho phép bạn sửa đổi mã hiện có một cách máy móc để sử dụng các loại mới hơn mà không phải suy nghĩ quá nhiều về nó. Do đó, những gì bạn đang làm là sai lầm theo những cách sau:

• Bạn đang gọi một phương thức có thể trả về null. Ý tưởng đúng sẽ là phương thức trả về null.
• Bạn đang sử dụng các phương thức băng bó kế thừa để đối phó với tùy chọn này, thay vì sử dụng các phương thức mới ngon miệng có chứa lambda fanciness.

Nếu bạn muốn sử dụng Tùy chọn dưới dạng kiểm tra an toàn null đơn giản, điều bạn nên làm chỉ đơn giản là:

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

Tất nhiên, phiên bản ưa nhìn của nó trông giống như:

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

Nhân tiện, mặc dù không có nghĩa là bắt buộc, tôi khuyên bạn nên sử dụng một dòng mới cho mỗi thao tác để dễ đọc hơn. Dễ đọc và hiểu nhịp đập bất kỳ ngày nào trong tuần.

Tất nhiên đây là một ví dụ rất đơn giản, nơi dễ hiểu mọi thứ chúng tôi đang cố gắng thực hiện. Nó không phải lúc nào cũng đơn giản trong cuộc sống thực. Nhưng hãy chú ý làm thế nào trong ví dụ này, những gì chúng tôi thể hiện là ý định của chúng tôi. Chúng tôi muốn NHẬN nhân viên, NHẬN ID của anh ấy và nếu có thể, hãy in nó. Đây là chiến thắng lớn thứ hai với Tùy chọn. Nó cho phép chúng ta tạo mã rõ ràng hơn. Tôi cũng nghĩ rằng làm những việc như tạo ra một phương pháp thực hiện một loạt các công cụ để bạn có thể đưa nó vào bản đồ nói chung là một ý tưởng tốt.

Tôi không thấy lợi ích trong Phong cách 2. Bạn vẫn cần nhận ra rằng bạn cần kiểm tra null và bây giờ nó còn lớn hơn, do đó ít đọc hơn.

Phong cách tốt hơn sẽ là, nếu workerServive.getEmployee () sẽ trả về Tùy chọn và sau đó mã sẽ trở thành:

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

Bằng cách này, bạn không thể gọiemployeeServive.getEmployee (). GetId () và bạn nhận thấy rằng bạn nên xử lý valoue tùy chọn bằng cách nào đó. Và nếu trong toàn bộ các phương thức cơ sở mã của bạn không bao giờ trả về null (hoặc gần như không bao giờ được biết đến với các ngoại lệ trong nhóm của bạn đối với quy tắc này), thì nó sẽ tăng tính an toàn chống lại NPE.

Tôi nghĩ lợi ích lớn nhất là nếu chữ ký phương thức của bạn trả về một Employeebạn không kiểm tra null. Bạn biết bằng chữ ký đó rằng nó được đảm bảo để trả lại một nhân viên. Bạn không cần phải xử lý một trường hợp thất bại. Với một tùy chọn bạn biết bạn làm.

Trong mã tôi đã thấy có các kiểm tra null sẽ không bao giờ thất bại vì mọi người không muốn theo dõi mã để xác định xem có thể có null hay không, vì vậy họ ném séc null ở mọi nơi một cách phòng thủ. Điều này làm cho mã chậm hơn một chút, nhưng quan trọng hơn là nó làm cho mã nhiễu hơn nhiều.

Tuy nhiên, để làm việc này, bạn cần áp dụng mô hình này một cách nhất quán.

Câu trả lời của tôi là: Chỉ cần không. Ít nhất hãy suy nghĩ kỹ về việc nó có thực sự là một sự cải tiến hay không.

Một biểu thức (lấy từ một câu trả lời khác) như

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

dường như là cách thức chức năng phù hợp để xử lý các phương thức trả về ban đầu vô giá trị. Nó trông đẹp, nó không bao giờ ném và nó không bao giờ khiến bạn phải suy nghĩ về việc xử lý trường hợp "vắng mặt".

Nó trông tốt hơn so với cách cũ

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

Điều này làm cho rõ ràng rằng có thể có elsecác mệnh đề.

Các phong cách chức năng

• trông hoàn toàn khác biệt (và không thể đọc được đối với những người không sử dụng nó)
• là một nỗi đau để gỡ lỗi
• không thể dễ dàng gia hạn để xử lý trường hợp "vắng mặt" ( orElsekhông phải lúc nào cũng đủ)
• đánh lạc hướng để bỏ qua trường hợp "vắng mặt"

Trong mọi trường hợp, nó nên được sử dụng như thuốc chữa bách bệnh. Nếu nó được áp dụng phổ biến, thì ngữ nghĩa của .toán tử sẽ được thay thế bằng ngữ nghĩa của ?.toán tử , NPE bị lãng quên và tất cả các vấn đề bị bỏ qua.

Trong khi là một người hâm mộ Java lớn, tôi phải nói rằng phong cách chức năng chỉ là một thay thế tuyên bố của người đàn ông Java nghèo

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

nổi tiếng từ các ngôn ngữ khác. Chúng tôi có đồng ý rằng tuyên bố này

• không (thực sự) có chức năng?
• Rất giống với mã kiểu cũ, chỉ đơn giản hơn nhiều?
• dễ đọc hơn nhiều so với phong cách chức năng?
• có thân thiện với trình gỡ lỗi không?

Tùy chọn là một khái niệm (một loại bậc cao hơn) đến từ lập trình chức năng. Sử dụng nó sẽ giúp kiểm tra null lồng nhau và cứu bạn khỏi kim tự tháp diệt vong.