FilesExpand file tree

 master

/

CatchCompletableExceptions.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

81 lines (78 loc) · 2.43 KB

 master

/

CatchCompletableExceptions.java

Copy path

Top

File metadata and controls

• Code
• Blame

81 lines (78 loc) · 2.43 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

// concurrent/CatchCompletableExceptions.java

// (c)2017 MindView LLC: see Copyright.txt

// We make no guarantees that this code is fit for any purpose.

// Visit http://OnJava8.com for more book information.

import java.util.concurrent.*;

public class CatchCompletableExceptions {

static void handleException(int failcount) {

// Call the Function only if there's an

// exception, must produce same type as came in:

CompletableExceptions

.test("exceptionally", failcount)

.exceptionally((ex) -> { // Function

if(ex == null)

System.out.println("I don't get it yet");

return new Breakable(ex.getMessage(), 0);

})

.thenAccept(str ->

System.out.println("result: " + str));

// Create a new result (recover):

CompletableExceptions

.test("handle", failcount)

.handle((result, fail) -> { // BiFunction

if(fail != null)

return "Failure recovery object";

else

return result + " is good";

})

.thenAccept(str ->

System.out.println("result: " + str));

// Do something but pass the same result through:

CompletableExceptions

.test("whenComplete", failcount)

.whenComplete((result, fail) -> { // BiConsumer

if(fail != null)

System.out.println("It failed");

else

System.out.println(result + " OK");

})

.thenAccept(r ->

System.out.println("result: " + r));

}

public static void main(String[] args) {

System.out.println("**** Failure Mode ****");

handleException(2);

System.out.println("**** Success Mode ****");

handleException(0);

}

}

/* Output:

**** Failure Mode ****

Breakable_exceptionally [1]

Throwing Exception for exceptionally

result: Breakable_java.lang.RuntimeException:

Breakable_exceptionally failed [0]

Breakable_handle [1]

Throwing Exception for handle

result: Failure recovery object

Breakable_whenComplete [1]

Throwing Exception for whenComplete

It failed

**** Success Mode ****

Breakable_exceptionally [-1]

Breakable_exceptionally [-2]

Breakable_exceptionally [-3]

Breakable_exceptionally [-4]

result: Breakable_exceptionally [-4]

Breakable_handle [-1]

Breakable_handle [-2]

Breakable_handle [-3]

Breakable_handle [-4]

result: Breakable_handle [-4] is good

Breakable_whenComplete [-1]

Breakable_whenComplete [-2]

Breakable_whenComplete [-3]

Breakable_whenComplete [-4]

Breakable_whenComplete [-4] OK

result: Breakable_whenComplete [-4]

*/