जावा में फंक्शनल स्टाइल एरर हैंडलिंग

अपवादों का उपयोग करके त्रुटियों को संभालने के लिए शास्त्रीय दृष्टिकोण के अलावा, एक कार्यात्मक दृष्टिकोण को भी प्रतिष्ठित किया जा सकता है।

एक अपवाद को तुरंत फेंकने के बजाय, आप इसे स्थानीय कर सकते हैं और फिर उस पर कुछ क्रियाएं कर सकते हैं।

उदाहरण के लिए, स्काला में, इसके लिए एक विशिष्ट कोशिश वर्ग का उपयोग किया जाता है।

def inputStreamForURL(url: String): Try[Try[Try[InputStream]]] = parseURL(url).map { u => Try(u.openConnection()).map(conn => Try(conn.getInputStream)) } 

जावा दुनिया में, वावर पुस्तकालय का उपयोग करके, आप एक कार्यात्मक शैली में त्रुटियों को भी संभाल सकते हैं।

 Try.of(() -> u.openConnection()).getOrElse(other); 

जावा 8 में, वैकल्पिक प्रकार को शून्य प्रकारों के साथ अधिक सही ढंग से काम करने के लिए जोड़ा गया था। यह आपको एक ऑब्जेक्ट लपेटने की अनुमति देता है, जो अशक्त हो सकता है, और एक कार्यात्मक शैली में इसके साथ आगे काम करना सुरक्षित है।

विभिन्न प्रकार के अपवादों के साथ काम करने के लिए, आप वैकल्पिक के समान एक वर्ग लागू कर सकते हैं, जो थ्रेड-सुरक्षित और गैर-परस्पर भी है।

 public final class Expected<T, E extends Throwable> { private final T value; private final E error; private Expected() { this.value = null; this.error = null; } private Expected(T value) { this.value = Objects.requireNonNull(value); this.error = null; } private Expected(E error) { this.error = Objects.requireNonNull(error); this.value = null; } public static <T, E extends Throwable> Expected<T, E> of(T value) { return new Expected<>(value); } public static <T, E extends Throwable> Expected<T, E> of(E error) { return new Expected<>(error); } public static <T, E extends Throwable> Expected<T, E> of(Supplier<T> supplier) { try { return new Expected<>(supplier.get()); } catch (Throwable e) { return new Expected<>((E) e); } } public boolean isValue() { return value != null; } public boolean isError() { return error != null; } public T value() { return value; } public E error() { return error; } } 

इसके अलावा, यह जांचने के लिए कि कोई अपवाद फेंका गया था या नहीं, आप एक साधारण आगंतुक लिख सकते हैं।

 Expected<Integer, SQLException> data = Expected.of(new SQLException()); matches(data, Expected::error, e -> out.println("get error: " + e), Expected::value, v -> out.println("get value: " + v) ); Expected<Integer, ArithmeticException> expression = Expected.of(() -> 4 / 0); matches(expression, Expected::error, e -> out.println("get error: " + e), Expected::value, v -> out.println("get value: " + v) ); 

 public static <T, E extends Throwable> void matches(Expected<T, E> value, Function<Expected<T, E>, E> firstFunction, Consumer<E> firstBranch, Function<Expected<T, E>, T> secondFunction, Consumer<T> secondBranch) { if (value.isError()) { E arg = firstFunction.apply(value); firstBranch.accept(arg); } else { T arg = secondFunction.apply(value); secondBranch.accept(arg); } } 

C ++ 23 में, मानक पुस्तकालय में एक समान वर्ग जोड़ने की योजना है।

ऐसी कक्षा मानक जावा पुस्तकालय में एक अच्छी वैकल्पिक कंपनी का गठन कर सकती है। लेकिन अफसोस, इस समय, एक कार्यात्मक शैली में अपवादों के साथ काम करने के लिए, आप Vavr लाइब्रेरी का उपयोग कर सकते हैं या उम्मीद की समानता में अपनी कक्षाएं लिख सकते हैं।

कक्षा का पूर्ण स्रोत कोड github: लिंक पर देखा जा सकता है।