This document discusses reactive programming approaches for database access. It begins with an overview of blocking I/O versus non-blocking I/O and how reactive programming addresses issues with blocking. It then covers options for reactive NoSQL and SQL database access using Spring frameworks, including Spring Data reactive modules. While reactive solutions exist for NoSQL databases, the document notes that reactive options for SQL databases are still experimental. It evaluates projects like R2DBC that aim to make JDBC non-blocking and reactive.

1. / by Oleh Dokuka & Igor Lozynskyi
The state of
Reactive in the
Database’s Access

2. / by Oleh Dokuka & Igor Lozynskyi
The state of
Reactive in the
Database’s Access

3. 3
For whom this talk:
/ Reactive programmers
/ Performance geeks
/ Hibernate lovers/haters (?)
/ Curious people
/ We assume, you know what Reactive is

4. 4

5. Реактивный Хардкор
/ Oleh Dokuka
55
Igor Lozynskyi

6. Реактивный Хардкор
/ Oleh Dokuka
66
Oleh Dokuka

8. 8
Agenda
/ Why Reactive?
/ Reactive for NoSQL
/ Reactive for SQL
/ We use Spring Framework a lot

9. Part 1:
Blocking I/O World
9

11. Demo
11

12. efficient handling of
network connections
What do we want?

13. Connection per Thread

14. Part 2:
NI/O World
14

16. Demo
16

17. Many Connections
per Thread

18. do not block Thread
Rule:

19. Part 3:
Microservices
World
19

20. 20

22. Spring
RestTemplate
WebFlux

23. Demo
23

24. 24
Non-Blocking Clients
/ NIO (JDK 1.4+)
/ Netty Client (JDK 6+)
/ Jetty Client (JDK 8+)
/ JDK Client (JDK 11+)

26. Spring
WebClient
WebFlux

27. Demo
27

28. Part 4:
Real World
28

30. Spring DataReactive

31. 31

32. Demo
32

33. 33

34. 34

35. 35
~X ms - XX s

36. 36
~X - XXXX Rows

37. QueryOptions queryOptions =
.fetchSize(2).fetchSize(2)

38. 38
Node
.fetchSize(2)8765432

39. Go inside
39

40. Good:
Support async /
non-blocking
40

41. Bad:
No Streaming
41

42. Ugly:
Fetch is inflexible
42

43. 43

44. Demo
44

45. 45

46. Go inside
46

47. Good:
Flexible Fetch
47

48. Bad:
No Streaming
48

49. Ugly:
Just Ugly
49

50. 50

51. Demo
51

52. 52

53. Go inside
53

54. Good:
Support Streaming
54

55. Bad:
No Backpressure
55

56. Ugly:
Design
56

57. 57
Honorable Mention

58. 58
What do we want?

59. 59

60. 60

61. Reactive
Spring Data
MongoDB
Cassandra
Couchbase
Redis

62. What about SQL?

63. 80% of projects
use SQL DBs*

64. Make JDBC Reactive?

65. Make JDBC Reactive?

66. Wrap into a Thread Pool?

67. Requirements
/ Non-Blocking
/ Designed for Streams of Data
/ Backpressure Support

68. Disclaimer
/ Experimental
/ Not for production yet

69. 69

70. Demo
70

71. ADBA Criticism
/ Not reactive
/ No DSL like with Reactor
/ No Backpressure
/ Not ideal for data streams

72. 72

78. R2DBC Drivers
/ PostgreSQL
/ MySQL/MariaDB
/ Microsoft SQL
/ H2

79. Demo
79

80. R2DBC Criticism
/ It is in Alpha
/ Not validated yet
/ No Hibernate/EclipseLink (JPA)
/ Transactions

81. Reactive
Spring Data
MongoDB
Cassandra
Couchbase
Redis
R2DBC

82. Demo
82

83. 83
Summary
/ Reactive enables efficiency
/ We have reactive persistence for NoSQL
/ We have No reactive persistence for SQL
/ ADBA vs R2DBC
/ Stay tuned! It is interesting times!

84. 84
Takeaways
/ Web on Reactive Stack (Spring Framework)
/ www.r2dbc.io

85. /oleh.dokuka
/OlegDokuka
/OlehDokuka
Q&A
Thank you!
/aigor
/siromaha
/ihor.lozinsky
2018
Nov 24
Presentation
Code