ಪುಸ್ತಕ “ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್ಸ್ ಇನ್ ಆಕ್ಷನ್. ನೈಜ-ಸಮಯದ ಕೆಲಸಕ್ಕಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಸೂಕ್ಷ್ಮ ಸೇವೆಗಳು"

ಹಲೋ, ಖಬ್ರೋ ನಿವಾಸಿಗಳು! ಥ್ರೆಡ್ ಸಂಸ್ಕರಣೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಬಯಸುವ ಯಾವುದೇ ಡೆವಲಪರ್‌ಗೆ ಈ ಪುಸ್ತಕ ಸೂಕ್ತವಾಗಿದೆ. ವಿತರಿಸಿದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕಾಫ್ಕಾ ಮತ್ತು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಚೆನ್ನಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಕಾಫ್ಕಾ ಚೌಕಟ್ಟನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಒಳ್ಳೆಯದು, ಆದರೆ ಇದು ಅನಿವಾರ್ಯವಲ್ಲ: ನಿಮಗೆ ಬೇಕಾದ ಎಲ್ಲವನ್ನೂ ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ. ಅನುಭವಿ ಕಾಫ್ಕಾ ಡೆವಲಪರ್‌ಗಳು ಮತ್ತು ನವಶಿಷ್ಯರು ಈ ಪುಸ್ತಕದಲ್ಲಿ ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್ಸ್ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಆಸಕ್ತಿದಾಯಕ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಕಲಿಯುತ್ತಾರೆ. ಧಾರಾವಾಹಿಯಂತಹ ಪರಿಕಲ್ಪನೆಗಳೊಂದಿಗೆ ಈಗಾಗಲೇ ಪರಿಚಿತವಾಗಿರುವ ಮಧ್ಯಂತರ ಮತ್ತು ಮುಂದುವರಿದ ಜಾವಾ ಡೆವಲಪರ್‌ಗಳು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ತಮ್ಮ ಕೌಶಲ್ಯಗಳನ್ನು ಅನ್ವಯಿಸಲು ಕಲಿಯುತ್ತಾರೆ. ಪುಸ್ತಕದ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಜಾವಾ 8 ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಜಾವಾ 8 ಲ್ಯಾಂಬ್ಡಾ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನ ಗಮನಾರ್ಹ ಬಳಕೆಯನ್ನು ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಲ್ಯಾಂಬ್ಡಾ ಕಾರ್ಯಗಳೊಂದಿಗೆ (ಇನ್ನೊಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿಯೂ ಸಹ) ಕೆಲಸ ಮಾಡುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿದುಕೊಳ್ಳುವುದು ಸೂಕ್ತವಾಗಿ ಬರುತ್ತದೆ.

ಆಯ್ದ ಭಾಗ. 5.3 ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ ಮತ್ತು ಕಿಟಕಿಯ ಕಾರ್ಯಾಚರಣೆಗಳು

ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಅತ್ಯಂತ ಭರವಸೆಯ ಭಾಗಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಮುಂದುವರಿಯುತ್ತೇವೆ. ಇಲ್ಲಿಯವರೆಗೆ ನಾವು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಕೆಳಗಿನ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದೇವೆ:

• ಸಂಸ್ಕರಣಾ ಸ್ಥಳಶಾಸ್ತ್ರವನ್ನು ರಚಿಸುವುದು;
• ಸ್ಟ್ರೀಮಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ರಾಜ್ಯವನ್ನು ಬಳಸುವುದು;
• ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಸಂಪರ್ಕಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು;
• ಈವೆಂಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳು (KStream) ಮತ್ತು ಅಪ್‌ಡೇಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳು (KTable).

ಕೆಳಗಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ ನಾವು ಈ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಒಟ್ಟಿಗೆ ತರುತ್ತೇವೆ. ಸ್ಟ್ರೀಮಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಮತ್ತೊಂದು ಉತ್ತಮ ವೈಶಿಷ್ಟ್ಯವಾದ ವಿಂಡೊಯಿಂಗ್ ಬಗ್ಗೆ ಸಹ ನೀವು ಕಲಿಯುವಿರಿ. ನಮ್ಮ ಮೊದಲ ಉದಾಹರಣೆಯು ಸರಳವಾದ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯಾಗಿದೆ.

5.3.1. ಉದ್ಯಮ ವಲಯದಿಂದ ಷೇರು ಮಾರಾಟದ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ

ಸ್ಟ್ರೀಮಿಂಗ್ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ ಮತ್ತು ಗುಂಪು ಮಾಡುವುದು ಪ್ರಮುಖ ಸಾಧನಗಳಾಗಿವೆ. ವೈಯಕ್ತಿಕ ದಾಖಲೆಗಳನ್ನು ಸ್ವೀಕರಿಸಿದಂತೆ ಪರಿಶೀಲಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಕಾಗುವುದಿಲ್ಲ. ಡೇಟಾದಿಂದ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆಯಲು, ಅವುಗಳನ್ನು ಗುಂಪು ಮಾಡುವುದು ಮತ್ತು ಸಂಯೋಜಿಸುವುದು ಅವಶ್ಯಕ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಹಲವಾರು ಉದ್ಯಮಗಳಲ್ಲಿನ ಕಂಪನಿಗಳ ಸ್ಟಾಕ್‌ಗಳ ಮಾರಾಟದ ಪ್ರಮಾಣವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕಾದ ದಿನದ ವ್ಯಾಪಾರಿಯ ವೇಷಭೂಷಣವನ್ನು ನೀವು ಹಾಕುತ್ತೀರಿ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಪ್ರತಿ ಉದ್ಯಮದಲ್ಲಿ ದೊಡ್ಡ ಷೇರು ಮಾರಾಟವನ್ನು ಹೊಂದಿರುವ ಐದು ಕಂಪನಿಗಳಲ್ಲಿ ನೀವು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೀರಿ.

ಅಂತಹ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯು ಡೇಟಾವನ್ನು ಅಪೇಕ್ಷಿತ ರೂಪಕ್ಕೆ ಭಾಷಾಂತರಿಸಲು ಕೆಳಗಿನ ಹಲವಾರು ಹಂತಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ (ಸಾಮಾನ್ಯ ಪದಗಳಲ್ಲಿ ಮಾತನಾಡುವುದು).

1. ಕಚ್ಚಾ ಸ್ಟಾಕ್ ಟ್ರೇಡಿಂಗ್ ಮಾಹಿತಿಯನ್ನು ಪ್ರಕಟಿಸುವ ವಿಷಯ ಆಧಾರಿತ ಮೂಲವನ್ನು ರಚಿಸಿ. ನಾವು ಸ್ಟಾಕ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಪ್ರಕಾರದ ವಸ್ತುವನ್ನು ಶೇರ್ ವಾಲ್ಯೂಮ್ ಪ್ರಕಾರದ ವಸ್ತುವಿಗೆ ಮ್ಯಾಪ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಸ್ಟಾಕ್ ಟ್ರಾನ್ಸಕ್ಷನ್ ಆಬ್ಜೆಕ್ಟ್ ಮಾರಾಟದ ಮೆಟಾಡೇಟಾವನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ನಮಗೆ ಮಾರಾಟವಾಗುತ್ತಿರುವ ಷೇರುಗಳ ಸಂಖ್ಯೆಯ ಡೇಟಾ ಮಾತ್ರ ಅಗತ್ಯವಿದೆ.
2. ಸ್ಟಾಕ್ ಚಿಹ್ನೆಯ ಮೂಲಕ ಶೇರ್‌ವಾಲ್ಯೂಮ್ ಡೇಟಾವನ್ನು ಗುಂಪು ಮಾಡಿ. ಚಿಹ್ನೆಯ ಮೂಲಕ ಗುಂಪು ಮಾಡಿದ ನಂತರ, ನೀವು ಈ ಡೇಟಾವನ್ನು ಸ್ಟಾಕ್ ಮಾರಾಟದ ಸಂಪುಟಗಳ ಉಪಮೊತ್ತಗಳಾಗಿ ಕುಗ್ಗಿಸಬಹುದು. KStream.groupBy ವಿಧಾನವು KGroupedStream ಪ್ರಕಾರದ ನಿದರ್ಶನವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂಬುದು ಗಮನಿಸಬೇಕಾದ ಸಂಗತಿ. ಮತ್ತು KGroupedStream.reduce ವಿಧಾನವನ್ನು ಮತ್ತಷ್ಟು ಕರೆ ಮಾಡುವ ಮೂಲಕ ನೀವು KTable ನಿದರ್ಶನವನ್ನು ಪಡೆಯಬಹುದು.

KGroupedStream ಇಂಟರ್ಫೇಸ್ ಎಂದರೇನು

KStream.groupBy ಮತ್ತು KStream.groupByKey ವಿಧಾನಗಳು KGroupedStream ನ ನಿದರ್ಶನವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ. KGroupedStream ಎನ್ನುವುದು ಕೀಗಳ ಮೂಲಕ ಗುಂಪು ಮಾಡಿದ ನಂತರ ಈವೆಂಟ್‌ಗಳ ಸ್ಟ್ರೀಮ್‌ನ ಮಧ್ಯಂತರ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ. ಅದರೊಂದಿಗೆ ನೇರ ಕೆಲಸ ಮಾಡಲು ಇದು ಉದ್ದೇಶಿಸಿಲ್ಲ. ಬದಲಿಗೆ, KGroupedStream ಅನ್ನು ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಯಾವಾಗಲೂ KTableಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಳ ಫಲಿತಾಂಶವು KTable ಆಗಿರುವುದರಿಂದ ಮತ್ತು ಅವರು ರಾಜ್ಯದ ಅಂಗಡಿಯನ್ನು ಬಳಸುವುದರಿಂದ, ಪರಿಣಾಮವಾಗಿ ಎಲ್ಲಾ ನವೀಕರಣಗಳನ್ನು ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ಮತ್ತಷ್ಟು ಕಳುಹಿಸಲಾಗುವುದಿಲ್ಲ.

KTable.groupBy ವಿಧಾನವು ಒಂದೇ ರೀತಿಯ KGroupedTable ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ - ನವೀಕರಣಗಳ ಸ್ಟ್ರೀಮ್‌ನ ಮಧ್ಯಂತರ ಪ್ರಾತಿನಿಧ್ಯ, ಕೀಲಿಯಿಂದ ಮರುಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

ಸ್ವಲ್ಪ ವಿರಾಮ ತೆಗೆದುಕೊಂಡು ಅಂಜೂರವನ್ನು ನೋಡೋಣ. 5.9, ನಾವು ಏನನ್ನು ಸಾಧಿಸಿದ್ದೇವೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ಈ ಟೋಪೋಲಜಿ ಈಗಾಗಲೇ ನಿಮಗೆ ಬಹಳ ಪರಿಚಿತವಾಗಿರಬೇಕು.

ಈ ಟೋಪೋಲಜಿಯ ಕೋಡ್ ಅನ್ನು ಈಗ ನೋಡೋಣ (ಅದನ್ನು ಫೈಲ್ src/main/java/bbejeck/chapter_5/AggregationsAndReducingExample.java ನಲ್ಲಿ ಕಾಣಬಹುದು) (ಪಟ್ಟಿ 5.2).

ನೀಡಿರುವ ಕೋಡ್ ಅದರ ಸಂಕ್ಷಿಪ್ತತೆ ಮತ್ತು ಹಲವಾರು ಸಾಲುಗಳಲ್ಲಿ ನಿರ್ವಹಿಸಲಾದ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಕ್ರಿಯೆಗಳಿಂದ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಟ್ಟಿದೆ. ಬಿಲ್ಡರ್.ಸ್ಟ್ರೀಮ್ ವಿಧಾನದ ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ನೀವು ಹೊಸದನ್ನು ಗಮನಿಸಬಹುದು: ಎನಮ್ ಪ್ರಕಾರದ ಮೌಲ್ಯ AutoOffsetReset.EARLIEST (ಇತ್ತೀಚಿನವೂ ಇದೆ), Consumed.withOffsetResetPolicy ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಂದಿಸಲಾಗಿದೆ. ಈ ಎಣಿಕೆಯ ಪ್ರಕಾರವನ್ನು ಪ್ರತಿ KStream ಅಥವಾ KTable ಗಾಗಿ ಆಫ್‌ಸೆಟ್ ಮರುಹೊಂದಿಸುವ ತಂತ್ರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಬಳಸಬಹುದು ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್‌ನಿಂದ ಆಫ್‌ಸೆಟ್ ಮರುಹೊಂದಿಸುವ ಆಯ್ಕೆಗಿಂತ ಆದ್ಯತೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

GroupByKey ಮತ್ತು GroupBy

KStream ಇಂಟರ್ಫೇಸ್ ದಾಖಲೆಗಳನ್ನು ಗುಂಪು ಮಾಡಲು ಎರಡು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ: GroupByKey ಮತ್ತು GroupBy. ಇಬ್ಬರೂ KGroupedTable ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತಾರೆ, ಆದ್ದರಿಂದ ಅವುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು ಮತ್ತು ಯಾವುದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು ಎಂದು ನೀವು ಆಶ್ಚರ್ಯ ಪಡುತ್ತಿರಬಹುದು?

KStream ನಲ್ಲಿನ ಕೀಗಳು ಈಗಾಗಲೇ ಖಾಲಿಯಾಗಿಲ್ಲದಿದ್ದಾಗ GroupByKey ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಮತ್ತು ಮುಖ್ಯವಾಗಿ, "ಮರು-ವಿಭಜನೆಯ ಅಗತ್ಯವಿದೆ" ಧ್ವಜವನ್ನು ಎಂದಿಗೂ ಹೊಂದಿಸಲಾಗಿಲ್ಲ.

GroupBy ವಿಧಾನವು ನೀವು ಗ್ರೂಪಿಂಗ್ ಕೀಗಳನ್ನು ಬದಲಾಯಿಸಿದ್ದೀರಿ ಎಂದು ಊಹಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಮರುವಿಭಾಗದ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸರಿ ಎಂದು ಹೊಂದಿಸಲಾಗಿದೆ. ಗ್ರೂಪ್‌ಬೈ ವಿಧಾನದ ನಂತರ ಸೇರ್ಪಡೆಗಳು, ಒಟ್ಟುಗೂಡುವಿಕೆಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಸ್ವಯಂಚಾಲಿತ ಮರು-ವಿಭಜನೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಸಾರಾಂಶ: ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ, ನೀವು GroupBy ಬದಲಿಗೆ GroupByKey ಅನ್ನು ಬಳಸಬೇಕು.

ನಕ್ಷೆ ಮೌಲ್ಯಗಳು ಮತ್ತು ಗುಂಪಿನ ಮೂಲಕ ವಿಧಾನಗಳು ಏನು ಮಾಡುತ್ತವೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಮೊತ್ತ () ವಿಧಾನವನ್ನು ನೋಡೋಣ (src/main/java/bbejeck/model/ShareVolume.java ನಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ) (ಪಟ್ಟಿ 5.3).

ShareVolume.sum ವಿಧಾನವು ಸ್ಟಾಕ್ ಮಾರಾಟದ ಪರಿಮಾಣದ ಚಾಲನೆಯಲ್ಲಿರುವ ಒಟ್ಟು ಮೊತ್ತವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಲೆಕ್ಕಾಚಾರಗಳ ಸಂಪೂರ್ಣ ಸರಣಿಯ ಫಲಿತಾಂಶವು KTable ವಸ್ತುವಾಗಿದೆ . ಈಗ ನೀವು KTable ವಹಿಸುವ ಪಾತ್ರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ. ShareVolume ವಸ್ತುಗಳು ಬಂದಾಗ, ಅನುಗುಣವಾದ KTable ಆಬ್ಜೆಕ್ಟ್ ಇತ್ತೀಚಿನ ಪ್ರಸ್ತುತ ನವೀಕರಣವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಎಲ್ಲಾ ನವೀಕರಣಗಳು ಹಿಂದಿನ shareVolumeKTable ನಲ್ಲಿ ಪ್ರತಿಫಲಿಸುತ್ತದೆ, ಆದರೆ ಎಲ್ಲವನ್ನೂ ಮುಂದೆ ಕಳುಹಿಸಲಾಗುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ.

ನಂತರ ನಾವು ಈ KTable ಅನ್ನು ಒಟ್ಟುಗೂಡಿಸಲು (ವಹಿವಾಟು ಮಾಡಿದ ಷೇರುಗಳ ಸಂಖ್ಯೆಯಿಂದ) ಪ್ರತಿ ಉದ್ಯಮದಲ್ಲಿ ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಷೇರುಗಳನ್ನು ಹೊಂದಿರುವ ಐದು ಕಂಪನಿಗಳನ್ನು ತಲುಪಲು ಬಳಸುತ್ತೇವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಮ್ಮ ಕ್ರಮಗಳು ಮೊದಲ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಗೆ ಹೋಲುತ್ತವೆ.

1. ಉದ್ಯಮದ ಮೂಲಕ ಪ್ರತ್ಯೇಕ ಶೇರ್‌ವಾಲ್ಯೂಮ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಗುಂಪು ಮಾಡಲು ಮತ್ತೊಂದು ಗುಂಪಿನ ಮೂಲಕ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಿ.
2. ಶೇರ್‌ವಾಲ್ಯೂಮ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಸಾರಾಂಶವನ್ನು ಪ್ರಾರಂಭಿಸಿ. ಈ ಬಾರಿ ಒಟ್ಟುಗೂಡಿಸುವ ವಸ್ತುವು ಸ್ಥಿರ ಗಾತ್ರದ ಆದ್ಯತೆಯ ಸರತಿಯಾಗಿದೆ. ಈ ಸ್ಥಿರ-ಗಾತ್ರದ ಸರದಿಯಲ್ಲಿ, ಮಾರಾಟವಾದ ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಷೇರುಗಳನ್ನು ಹೊಂದಿರುವ ಐದು ಕಂಪನಿಗಳನ್ನು ಮಾತ್ರ ಉಳಿಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ.
3. ಹಿಂದಿನ ಪ್ಯಾರಾಗ್ರಾಫ್‌ನಿಂದ ಕ್ಯೂಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಕ್ಕೆ ಮ್ಯಾಪ್ ಮಾಡಿ ಮತ್ತು ಉದ್ಯಮದ ಮೂಲಕ ಸಂಖ್ಯೆಯ ಮೂಲಕ ಅಗ್ರ ಐದು ಹೆಚ್ಚು ವಹಿವಾಟು ಮಾಡಿದ ಸ್ಟಾಕ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸಿ.
4. ಫಲಿತಾಂಶಗಳನ್ನು ವಿಷಯಕ್ಕೆ ಸ್ಟ್ರಿಂಗ್ ರೂಪದಲ್ಲಿ ಬರೆಯಿರಿ.

ಅಂಜೂರದಲ್ಲಿ. ಚಿತ್ರ 5.10 ಡೇಟಾ ಫ್ಲೋ ಟೋಪೋಲಜಿ ಗ್ರಾಫ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ. ನೀವು ನೋಡುವಂತೆ, ಎರಡನೇ ಸುತ್ತಿನ ಪ್ರಕ್ರಿಯೆಯು ತುಂಬಾ ಸರಳವಾಗಿದೆ.

ಈಗ ನಾವು ಈ ಎರಡನೇ ಸುತ್ತಿನ ಪ್ರಕ್ರಿಯೆಯ ರಚನೆಯ ಬಗ್ಗೆ ಸ್ಪಷ್ಟವಾದ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ, ನಾವು ಅದರ ಮೂಲ ಕೋಡ್‌ಗೆ ತಿರುಗಬಹುದು (ನೀವು ಅದನ್ನು ಫೈಲ್ src/main/java/bbejeck/chapter_5/AggregationsAndReducingExample.java ನಲ್ಲಿ ಕಾಣಬಹುದು) (ಪಟ್ಟಿ 5.4) .

ಈ ಇನಿಶಿಯಲೈಜರ್ ಸ್ಥಿರ ಕ್ಯೂ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ. ಇದು java.util.TreeSet ಗಾಗಿ ಅಡಾಪ್ಟರ್ ಆಗಿರುವ ಕಸ್ಟಮ್ ವಸ್ತುವಾಗಿದ್ದು, ವ್ಯಾಪಾರ ಮಾಡಿದ ಷೇರುಗಳ ಅವರೋಹಣ ಕ್ರಮದಲ್ಲಿ ಉನ್ನತ N ಫಲಿತಾಂಶಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ.

ನೀವು ಈಗಾಗಲೇ groupBy ಮತ್ತು mapValues ​​ಕರೆಗಳನ್ನು ನೋಡಿದ್ದೀರಿ, ಆದ್ದರಿಂದ ನಾವು ಆ ಕರೆಗಳಿಗೆ ಹೋಗುವುದಿಲ್ಲ (KTable.toStream ವಿಧಾನವನ್ನು ನಾವು ಕರೆಯುತ್ತಿದ್ದೇವೆ ಏಕೆಂದರೆ KTable.print ವಿಧಾನವನ್ನು ಅಸಮ್ಮತಿಸಲಾಗಿದೆ). ಆದರೆ ನೀವು ಇನ್ನೂ ಒಟ್ಟು() ನ KTable ಆವೃತ್ತಿಯನ್ನು ನೋಡಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಚರ್ಚಿಸಲು ಸ್ವಲ್ಪ ಸಮಯವನ್ನು ಕಳೆಯುತ್ತೇವೆ.

ನೀವು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವಂತೆ, KTable ಅನ್ನು ವಿಭಿನ್ನವಾಗಿಸುತ್ತದೆ ಅದೇ ಕೀಗಳನ್ನು ಹೊಂದಿರುವ ದಾಖಲೆಗಳನ್ನು ನವೀಕರಣಗಳು ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. KTable ಹಳೆಯ ನಮೂದನ್ನು ಹೊಸದರೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ. ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯು ಇದೇ ರೀತಿಯಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ: ಅದೇ ಕೀಲಿಯೊಂದಿಗೆ ಇತ್ತೀಚಿನ ದಾಖಲೆಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಲಾಗುತ್ತದೆ. ರೆಕಾರ್ಡ್ ಬಂದಾಗ, ಅದನ್ನು ಆಡ್ಡರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು FixedSizePriorityQueue ವರ್ಗದ ನಿದರ್ಶನಕ್ಕೆ ಸೇರಿಸಲಾಗುತ್ತದೆ (ಒಟ್ಟಾರೆ ವಿಧಾನದ ಕರೆಯಲ್ಲಿ ಎರಡನೇ ಪ್ಯಾರಾಮೀಟರ್), ಆದರೆ ಇನ್ನೊಂದು ದಾಖಲೆಯು ಈಗಾಗಲೇ ಅದೇ ಕೀಲಿಯೊಂದಿಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ, ನಂತರ ಹಳೆಯ ದಾಖಲೆಯನ್ನು ವ್ಯವಕಲನವನ್ನು ಬಳಸಿ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ (ಮೂರನೇ ಪ್ಯಾರಾಮೀಟರ್ ಇನ್ ಒಟ್ಟು ವಿಧಾನದ ಕರೆ).

ಇದರ ಅರ್ಥವೇನೆಂದರೆ, ನಮ್ಮ ಸಂಗ್ರಾಹಕ, FixedSizePriorityQueue, ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಒಂದು ಕೀಲಿಯೊಂದಿಗೆ ಒಟ್ಟುಗೂಡಿಸುವುದಿಲ್ಲ, ಆದರೆ N ಹೆಚ್ಚು ವಹಿವಾಟು ನಡೆಸುವ ಸ್ಟಾಕ್‌ಗಳ ಪ್ರಮಾಣಗಳ ಚಲಿಸುವ ಮೊತ್ತವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಪ್ರತಿ ಒಳಬರುವ ನಮೂದು ಇದುವರೆಗೆ ಮಾರಾಟವಾದ ಷೇರುಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಪ್ರತಿ ಅಪ್‌ಡೇಟ್‌ನ ರೋಲಿಂಗ್ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ಅಗತ್ಯವಿಲ್ಲದೆಯೇ ಪ್ರಸ್ತುತ ಯಾವ ಕಂಪನಿಗಳ ಷೇರುಗಳು ಹೆಚ್ಚು ವಹಿವಾಟು ನಡೆಸುತ್ತಿವೆ ಎಂಬುದರ ಕುರಿತು KTable ನಿಮಗೆ ಮಾಹಿತಿಯನ್ನು ನೀಡುತ್ತದೆ.

ನಾವು ಎರಡು ಪ್ರಮುಖ ವಿಷಯಗಳನ್ನು ಮಾಡಲು ಕಲಿತಿದ್ದೇವೆ:

• ಸಾಮಾನ್ಯ ಕೀಲಿಯಿಂದ KTable ನಲ್ಲಿ ಗುಂಪು ಮೌಲ್ಯಗಳು;
• ಈ ಗುಂಪಿನ ಮೌಲ್ಯಗಳ ಮೇಲೆ ರೋಲಪ್ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯಂತಹ ಉಪಯುಕ್ತ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ.

ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ ಮೂಲಕ ಚಲಿಸುವ ಡೇಟಾದ ಅರ್ಥವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಅದು ಯಾವ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ಈ ಪುಸ್ತಕದಲ್ಲಿ ಈ ಹಿಂದೆ ಚರ್ಚಿಸಲಾದ ಕೆಲವು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ನಾವು ಒಟ್ಟಿಗೆ ತಂದಿದ್ದೇವೆ. ಅಧ್ಯಾಯ 4 ರಲ್ಲಿ, ಸ್ಟ್ರೀಮಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ದೋಷ-ಸಹಿಷ್ಣು, ಸ್ಥಳೀಯ ಸ್ಥಿತಿ ಎಷ್ಟು ಮುಖ್ಯ ಎಂಬುದನ್ನು ನಾವು ಚರ್ಚಿಸಿದ್ದೇವೆ. ಈ ಅಧ್ಯಾಯದಲ್ಲಿನ ಮೊದಲ ಉದಾಹರಣೆಯು ಸ್ಥಳೀಯ ರಾಜ್ಯವು ಏಕೆ ಮುಖ್ಯವಾಗಿದೆ ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ - ನೀವು ಈಗಾಗಲೇ ನೋಡಿದ ಮಾಹಿತಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಇದು ನೀಡುತ್ತದೆ. ಸ್ಥಳೀಯ ಪ್ರವೇಶವು ನೆಟ್‌ವರ್ಕ್ ವಿಳಂಬವನ್ನು ತಪ್ಪಿಸುತ್ತದೆ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೆಚ್ಚು ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ದೋಷ-ನಿರೋಧಕವಾಗಿಸುತ್ತದೆ.

ಯಾವುದೇ ರೋಲ್ಅಪ್ ಅಥವಾ ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸುವಾಗ, ನೀವು ರಾಜ್ಯದ ಅಂಗಡಿಯ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು. ರೋಲಪ್ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಳು KTable ನಿದರ್ಶನವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು KTable ಹಳೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಹೊಸದರೊಂದಿಗೆ ಬದಲಾಯಿಸಲು ರಾಜ್ಯದ ಸಂಗ್ರಹಣೆಯನ್ನು ಬಳಸುತ್ತದೆ. ನೀವು ನೋಡಿದಂತೆ, ಎಲ್ಲಾ ಅಪ್‌ಡೇಟ್‌ಗಳನ್ನು ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ಕಳುಹಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಸಾರಾಂಶ ಮಾಹಿತಿಯನ್ನು ಉತ್ಪಾದಿಸಲು ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿರುವುದರಿಂದ ಇದು ಮುಖ್ಯವಾಗಿದೆ. ನೀವು ಸ್ಥಳೀಯ ರಾಜ್ಯವನ್ನು ಅನ್ವಯಿಸದಿದ್ದರೆ, KTable ಎಲ್ಲಾ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ ಮತ್ತು ರೋಲ್ಅಪ್ ಫಲಿತಾಂಶಗಳನ್ನು ಫಾರ್ವರ್ಡ್ ಮಾಡುತ್ತದೆ.

ಮುಂದೆ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಅವಧಿಯೊಳಗೆ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ - ಕರೆಯಲ್ಪಡುವ ವಿಂಡೊಯಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳು.

5.3.2. ವಿಂಡೋ ಕಾರ್ಯಾಚರಣೆಗಳು

ಹಿಂದಿನ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಸ್ಲೈಡಿಂಗ್ ಕನ್ವಲ್ಯೂಷನ್ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯನ್ನು ಪರಿಚಯಿಸಿದ್ದೇವೆ. ಅಪ್ಲಿಕೇಶನ್ ಸ್ಟಾಕ್ ಮಾರಾಟದ ಪರಿಮಾಣದ ನಿರಂತರ ರೋಲ್-ಅಪ್ ಅನ್ನು ನಿರ್ವಹಿಸಿತು, ನಂತರ ವಿನಿಮಯದಲ್ಲಿ ಐದು ಹೆಚ್ಚು ವ್ಯಾಪಾರವಾಗುವ ಷೇರುಗಳ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ.

ಕೆಲವೊಮ್ಮೆ ಇಂತಹ ನಿರಂತರ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ ಮತ್ತು ಫಲಿತಾಂಶಗಳ ರೋಲ್-ಅಪ್ ಅಗತ್ಯ. ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ನೀವು ನಿರ್ದಿಷ್ಟ ಅವಧಿಯಲ್ಲಿ ಮಾತ್ರ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಕಳೆದ 10 ನಿಮಿಷಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಕಂಪನಿಯ ಷೇರುಗಳೊಂದಿಗೆ ಎಷ್ಟು ವಿನಿಮಯ ವಹಿವಾಟುಗಳನ್ನು ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ಲೆಕ್ಕ ಹಾಕಿ. ಅಥವಾ ಕಳೆದ 15 ನಿಮಿಷಗಳಲ್ಲಿ ಎಷ್ಟು ಬಳಕೆದಾರರು ಹೊಸ ಜಾಹೀರಾತು ಬ್ಯಾನರ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿದ್ದಾರೆ. ಅಪ್ಲಿಕೇಶನ್ ಅಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹಲವಾರು ಬಾರಿ ಮಾಡಬಹುದು, ಆದರೆ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟ ಅವಧಿಗೆ ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತದೆ (ಸಮಯ ವಿಂಡೋಗಳು).

ಖರೀದಿದಾರರಿಂದ ವಿನಿಮಯ ವಹಿವಾಟುಗಳನ್ನು ಎಣಿಸುವುದು

ಮುಂದಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಬಹು ವ್ಯಾಪಾರಿಗಳಾದ್ಯಂತ ಸ್ಟಾಕ್ ವಹಿವಾಟುಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತೇವೆ-ದೊಡ್ಡ ಸಂಸ್ಥೆಗಳು ಅಥವಾ ಸ್ಮಾರ್ಟ್ ವೈಯಕ್ತಿಕ ಹಣಕಾಸುದಾರರು.

ಈ ಟ್ರ್ಯಾಕಿಂಗ್‌ಗೆ ಎರಡು ಸಂಭವನೀಯ ಕಾರಣಗಳಿವೆ. ಅವುಗಳಲ್ಲಿ ಒಂದು ಮಾರುಕಟ್ಟೆಯ ನಾಯಕರು ಏನನ್ನು ಖರೀದಿಸುತ್ತಿದ್ದಾರೆ / ಮಾರಾಟ ಮಾಡುತ್ತಿದ್ದಾರೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು. ಈ ದೊಡ್ಡ ಆಟಗಾರರು ಮತ್ತು ಅತ್ಯಾಧುನಿಕ ಹೂಡಿಕೆದಾರರು ಅವಕಾಶವನ್ನು ನೋಡಿದರೆ, ಅವರ ತಂತ್ರವನ್ನು ಅನುಸರಿಸಲು ಇದು ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ. ಎರಡನೆಯ ಕಾರಣವೆಂದರೆ ಅಕ್ರಮ ಆಂತರಿಕ ವ್ಯಾಪಾರದ ಯಾವುದೇ ಸಂಭವನೀಯ ಚಿಹ್ನೆಗಳನ್ನು ಗುರುತಿಸುವ ಬಯಕೆ. ಇದನ್ನು ಮಾಡಲು, ಪ್ರಮುಖ ಪತ್ರಿಕಾ ಪ್ರಕಟಣೆಗಳೊಂದಿಗೆ ದೊಡ್ಡ ಮಾರಾಟದ ಸ್ಪೈಕ್‌ಗಳ ಪರಸ್ಪರ ಸಂಬಂಧವನ್ನು ನೀವು ವಿಶ್ಲೇಷಿಸಬೇಕಾಗುತ್ತದೆ.

ಅಂತಹ ಟ್ರ್ಯಾಕಿಂಗ್ ಕೆಳಗಿನ ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

• ಸ್ಟಾಕ್-ಟ್ರಾನ್ಸಾಕ್ಷನ್ಸ್ ವಿಷಯದಿಂದ ಓದಲು ಸ್ಟ್ರೀಮ್ ಅನ್ನು ರಚಿಸುವುದು;
• ಖರೀದಿದಾರರ ID ಮತ್ತು ಸ್ಟಾಕ್ ಚಿಹ್ನೆಯಿಂದ ಒಳಬರುವ ದಾಖಲೆಗಳನ್ನು ಗುಂಪು ಮಾಡುವುದು. ಗುಂಪಿನ ಮೂಲಕ ವಿಧಾನಕ್ಕೆ ಕರೆ ಮಾಡುವುದರಿಂದ KGroupedStream ವರ್ಗದ ನಿದರ್ಶನವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ;
• KGroupedStream.windowedBy ವಿಧಾನವು ಸಮಯ ವಿಂಡೋಗೆ ಸೀಮಿತವಾದ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ವಿಂಡೋಡ್ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ವಿಂಡೋ ಪ್ರಕಾರವನ್ನು ಅವಲಂಬಿಸಿ, TimeWindowedKStream ಅಥವಾ SessionWindowedKStream ಅನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ;
• ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಾಗಿ ವಹಿವಾಟು ಎಣಿಕೆ. ಈ ಎಣಿಕೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ದಾಖಲೆಯನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ವಿಂಡೋಡ್ ಡೇಟಾ ಹರಿವು ನಿರ್ಧರಿಸುತ್ತದೆ;
• ಒಂದು ವಿಷಯಕ್ಕೆ ಫಲಿತಾಂಶಗಳನ್ನು ಬರೆಯುವುದು ಅಥವಾ ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ಅವುಗಳನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಮಾಡುವುದು.

ಈ ಅಪ್ಲಿಕೇಶನ್‌ನ ಟೋಪೋಲಜಿ ಸರಳವಾಗಿದೆ, ಆದರೆ ಅದರ ಸ್ಪಷ್ಟ ಚಿತ್ರವು ಸಹಾಯಕವಾಗಿರುತ್ತದೆ. ಅಂಜೂರವನ್ನು ನೋಡೋಣ. 5.11.

ಮುಂದೆ, ನಾವು ವಿಂಡೋ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರ್ಯವನ್ನು ಮತ್ತು ಅನುಗುಣವಾದ ಕೋಡ್ ಅನ್ನು ನೋಡುತ್ತೇವೆ.

ವಿಂಡೋ ವಿಧಗಳು

ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳಲ್ಲಿ ಮೂರು ವಿಧದ ಕಿಟಕಿಗಳಿವೆ:

• ಸೆಷನಲ್;
• "ಟಂಬ್ಲಿಂಗ್" (ಟಂಬ್ಲಿಂಗ್);
• ಸ್ಲೈಡಿಂಗ್ / ಜಿಗಿತ.

ಯಾವುದನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ನಿಮ್ಮ ವ್ಯಾಪಾರದ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಟಂಬ್ಲಿಂಗ್ ಮತ್ತು ಜಂಪಿಂಗ್ ವಿಂಡೋಗಳು ಸಮಯ-ಸೀಮಿತವಾಗಿರುತ್ತದೆ, ಆದರೆ ಸೆಶನ್ ವಿಂಡೋಗಳು ಬಳಕೆದಾರರ ಚಟುವಟಿಕೆಯಿಂದ ಸೀಮಿತವಾಗಿರುತ್ತದೆ-ಸೆಶನ್(ಗಳ) ಅವಧಿಯು ಬಳಕೆದಾರ ಎಷ್ಟು ಸಕ್ರಿಯವಾಗಿದೆ ಎಂಬುದರ ಮೇಲೆ ಮಾತ್ರ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ. ನೆನಪಿಡುವ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ಎಲ್ಲಾ ವಿಂಡೋ ಪ್ರಕಾರಗಳು ನಮೂದುಗಳ ದಿನಾಂಕ / ಸಮಯದ ಅಂಚೆಚೀಟಿಗಳನ್ನು ಆಧರಿಸಿವೆ, ಸಿಸ್ಟಮ್ ಸಮಯದಲ್ಲ.

ಮುಂದೆ, ನಾವು ಪ್ರತಿಯೊಂದು ವಿಂಡೋ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ನಮ್ಮ ಟೋಪೋಲಜಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ. ಸಂಪೂರ್ಣ ಕೋಡ್ ಅನ್ನು ಮೊದಲ ಉದಾಹರಣೆಯಲ್ಲಿ ಮಾತ್ರ ನೀಡಲಾಗುವುದು; ಇತರ ರೀತಿಯ ವಿಂಡೋಗಳಿಗಾಗಿ ವಿಂಡೋ ಕಾರ್ಯಾಚರಣೆಯ ಪ್ರಕಾರವನ್ನು ಹೊರತುಪಡಿಸಿ ಏನೂ ಬದಲಾಗುವುದಿಲ್ಲ.

ಸೆಷನ್ ವಿಂಡೋಗಳು

ಸೆಷನ್ ವಿಂಡೋಗಳು ಎಲ್ಲಾ ರೀತಿಯ ವಿಂಡೋಗಳಿಗಿಂತ ಬಹಳ ಭಿನ್ನವಾಗಿವೆ. ಬಳಕೆದಾರರ ಚಟುವಟಿಕೆಯಿಂದ (ಅಥವಾ ನೀವು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಯಸುವ ಘಟಕದ ಚಟುವಟಿಕೆಯಿಂದ) ಸಮಯಕ್ಕೆ ಸೀಮಿತವಾಗಿಲ್ಲ. ಸೆಷನ್ ವಿಂಡೋಗಳನ್ನು ನಿಷ್ಕ್ರಿಯತೆಯ ಅವಧಿಗಳಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾಗಿದೆ.

ಚಿತ್ರ 5.12 ಅಧಿವೇಶನ ವಿಂಡೋಗಳ ಪರಿಕಲ್ಪನೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಚಿಕ್ಕ ಅಧಿವೇಶನವು ಅದರ ಎಡಭಾಗದಲ್ಲಿರುವ ಅಧಿವೇಶನದೊಂದಿಗೆ ವಿಲೀನಗೊಳ್ಳುತ್ತದೆ. ಮತ್ತು ಬಲಭಾಗದಲ್ಲಿರುವ ಅಧಿವೇಶನವು ಪ್ರತ್ಯೇಕವಾಗಿರುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ದೀರ್ಘಾವಧಿಯ ನಿಷ್ಕ್ರಿಯತೆಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ. ಸೆಷನ್ ವಿಂಡೋಗಳು ಬಳಕೆದಾರರ ಚಟುವಟಿಕೆಯನ್ನು ಆಧರಿಸಿವೆ, ಆದರೆ ನಮೂದು ಯಾವ ಸೆಷನ್‌ಗೆ ಸೇರಿದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ನಮೂದುಗಳಿಂದ ದಿನಾಂಕ/ಸಮಯದ ಅಂಚೆಚೀಟಿಗಳನ್ನು ಬಳಸಿ.

ಸ್ಟಾಕ್ ವಹಿವಾಟುಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಸೆಷನ್ ವಿಂಡೋಗಳನ್ನು ಬಳಸುವುದು

ವಿನಿಮಯ ವಹಿವಾಟುಗಳ ಕುರಿತು ಮಾಹಿತಿಯನ್ನು ಸೆರೆಹಿಡಿಯಲು ಸೆಷನ್ ವಿಂಡೋಗಳನ್ನು ಬಳಸೋಣ. ಅಧಿವೇಶನ ವಿಂಡೋಗಳ ಅನುಷ್ಠಾನವನ್ನು ಪಟ್ಟಿ 5.5 ರಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ (ಇದನ್ನು src/main/java/bbejeck/chapter_5/CountingWindowingAndKTableJoinExample.java ನಲ್ಲಿ ಕಾಣಬಹುದು).

ಈ ಟೋಪೋಲಜಿಯಲ್ಲಿನ ಹೆಚ್ಚಿನ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನೀವು ಈಗಾಗಲೇ ನೋಡಿದ್ದೀರಿ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಇಲ್ಲಿ ಮತ್ತೆ ನೋಡುವ ಅಗತ್ಯವಿಲ್ಲ. ಆದರೆ ಇಲ್ಲಿ ಹಲವಾರು ಹೊಸ ಅಂಶಗಳಿವೆ, ಅದನ್ನು ನಾವು ಈಗ ಚರ್ಚಿಸುತ್ತೇವೆ.

ಯಾವುದೇ ಗುಂಪಿನ ಮೂಲಕ ಕಾರ್ಯಾಚರಣೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲವು ರೀತಿಯ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ (ಒಟ್ಟುಗೂಡುವಿಕೆ, ರೋಲ್ಅಪ್ ಅಥವಾ ಎಣಿಕೆ). ನೀವು ಚಾಲನೆಯಲ್ಲಿರುವ ಒಟ್ಟು ಅಥವಾ ವಿಂಡೋ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯೊಂದಿಗೆ ಸಂಚಿತ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸಬಹುದು, ಇದು ನಿರ್ದಿಷ್ಟ ಸಮಯದ ವಿಂಡೋದೊಳಗೆ ದಾಖಲೆಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ಪಟ್ಟಿ 5.5 ರಲ್ಲಿನ ಕೋಡ್ ಸೆಷನ್ ವಿಂಡೋಗಳಲ್ಲಿ ವಹಿವಾಟುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಕೆ ಮಾಡುತ್ತದೆ. ಅಂಜೂರದಲ್ಲಿ. 5.13 ಈ ಕ್ರಿಯೆಗಳನ್ನು ಹಂತ ಹಂತವಾಗಿ ವಿಶ್ಲೇಷಿಸಲಾಗಿದೆ.

windowedBy(SessionWindows.with(twentySeconds) ವರೆಗೆ (ಹದಿನೈದು ನಿಮಿಷಗಳು)) ಕರೆ ಮಾಡುವ ಮೂಲಕ ನಾವು 20 ಸೆಕೆಂಡುಗಳ ನಿಷ್ಕ್ರಿಯತೆಯ ಮಧ್ಯಂತರ ಮತ್ತು 15 ನಿಮಿಷಗಳ ನಿರಂತರ ಮಧ್ಯಂತರದೊಂದಿಗೆ ಅಧಿವೇಶನ ವಿಂಡೋವನ್ನು ರಚಿಸುತ್ತೇವೆ. 20 ಸೆಕೆಂಡ್‌ಗಳ ಐಡಲ್ ಮಧ್ಯಂತರ ಎಂದರೆ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಸ್ತುತ ಸೆಷನ್‌ನ ಅಂತ್ಯ ಅಥವಾ ಪ್ರಾರಂಭದ 20 ಸೆಕೆಂಡುಗಳ ಒಳಗೆ ಪ್ರಸ್ತುತ (ಸಕ್ರಿಯ) ಸೆಷನ್‌ಗೆ ಬರುವ ಯಾವುದೇ ನಮೂದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಮುಂದೆ, ಅಧಿವೇಶನ ವಿಂಡೋದಲ್ಲಿ ಯಾವ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮಾಡಬೇಕೆಂದು ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ - ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಎಣಿಕೆ ಮಾಡಿ. ಒಳಬರುವ ನಮೂದು ನಿಷ್ಕ್ರಿಯತೆಯ ವಿಂಡೋದ ಹೊರಗೆ ಬಿದ್ದರೆ (ದಿನಾಂಕ/ಸಮಯದ ಸ್ಟ್ಯಾಂಪ್‌ನ ಎರಡೂ ಬದಿ), ಅಪ್ಲಿಕೇಶನ್ ಹೊಸ ಸೆಶನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಧಾರಣ ಮಧ್ಯಂತರ ಎಂದರೆ ಸೆಶನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಸಮಯದವರೆಗೆ ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಸೆಷನ್‌ನ ನಿಷ್ಕ್ರಿಯತೆಯ ಅವಧಿಯನ್ನು ಮೀರಿದ ತಡವಾದ ಡೇಟಾವನ್ನು ಅನುಮತಿಸುತ್ತದೆ ಆದರೆ ಇನ್ನೂ ಲಗತ್ತಿಸಬಹುದು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ವಿಲೀನದಿಂದ ಉಂಟಾಗುವ ಹೊಸ ಅಧಿವೇಶನದ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯವು ಆರಂಭಿಕ ಮತ್ತು ಇತ್ತೀಚಿನ ದಿನಾಂಕ/ಸಮಯ ಸ್ಟ್ಯಾಂಪ್‌ಗೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ.

ಸೆಷನ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನೋಡಲು ಎಣಿಕೆ ವಿಧಾನದಿಂದ ಕೆಲವು ನಮೂದುಗಳನ್ನು ನೋಡೋಣ (ಕೋಷ್ಟಕ 5.1).

ದಾಖಲೆಗಳು ಬಂದಾಗ, ನಾವು ಅದೇ ಕೀಲಿಯೊಂದಿಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸೆಷನ್‌ಗಳನ್ನು ಹುಡುಕುತ್ತೇವೆ, ಪ್ರಸ್ತುತ ದಿನಾಂಕ/ಸಮಯದ ಸ್ಟ್ಯಾಂಪ್‌ಗಿಂತ ಕಡಿಮೆ ಸಮಯ - ನಿಷ್ಕ್ರಿಯತೆಯ ಮಧ್ಯಂತರ, ಮತ್ತು ಪ್ರಸ್ತುತ ದಿನಾಂಕ/ಸಮಯದ ಸ್ಟ್ಯಾಂಪ್ + ನಿಷ್ಕ್ರಿಯತೆಯ ಮಧ್ಯಂತರಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಪ್ರಾರಂಭದ ಸಮಯ. ಇದನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು, ಕೋಷ್ಟಕದಿಂದ ನಾಲ್ಕು ನಮೂದುಗಳು. 5.1 ಅನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಒಂದೇ ಅಧಿವೇಶನದಲ್ಲಿ ವಿಲೀನಗೊಳಿಸಲಾಗಿದೆ.

1. ರೆಕಾರ್ಡ್ 1 ಮೊದಲು ಬರುತ್ತದೆ, ಆದ್ದರಿಂದ ಪ್ರಾರಂಭದ ಸಮಯವು ಅಂತಿಮ ಸಮಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ ಮತ್ತು 00:00:00 ಆಗಿದೆ.

2. ಮುಂದೆ, ನಮೂದು 2 ಬರುತ್ತದೆ, ಮತ್ತು ನಾವು 23:59:55 ಕ್ಕಿಂತ ಮುಂಚೆಯೇ ಕೊನೆಗೊಳ್ಳುವ ಮತ್ತು 00:00:35 ಕ್ಕಿಂತ ನಂತರ ಪ್ರಾರಂಭವಾಗುವ ಸೆಷನ್‌ಗಳಿಗಾಗಿ ನೋಡುತ್ತೇವೆ. ನಾವು ರೆಕಾರ್ಡ್ 1 ಅನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಸೆಷನ್ 1 ಮತ್ತು 2 ಅನ್ನು ಸಂಯೋಜಿಸುತ್ತೇವೆ. ನಾವು ಸೆಷನ್ 1 (ಹಿಂದಿನ) ಮತ್ತು ಸೆಷನ್ 2 ರ ಅಂತಿಮ ಸಮಯವನ್ನು (ನಂತರ) ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಇದರಿಂದ ನಮ್ಮ ಹೊಸ ಸೆಷನ್ 00:00:00 ಕ್ಕೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು 00 ಕ್ಕೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ: 00:15.

3. ರೆಕಾರ್ಡ್ 3 ಆಗಮಿಸುತ್ತದೆ, ನಾವು 00:00:30 ಮತ್ತು 00:01:10 ನಡುವಿನ ಅವಧಿಗಳಿಗಾಗಿ ಹುಡುಕುತ್ತೇವೆ ಮತ್ತು ಯಾವುದನ್ನೂ ಕಂಡುಹಿಡಿಯುವುದಿಲ್ಲ. ಕೀ 123-345-654,FFBE ಗಾಗಿ ಎರಡನೇ ಸೆಶನ್ ಅನ್ನು ಸೇರಿಸಿ, 00:00:50 ಕ್ಕೆ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.

4. ರೆಕಾರ್ಡ್ 4 ಆಗಮಿಸುತ್ತದೆ ಮತ್ತು ನಾವು 23:59:45 ಮತ್ತು 00:00:25 ನಡುವಿನ ಅವಧಿಗಳಿಗಾಗಿ ಹುಡುಕುತ್ತಿದ್ದೇವೆ. ಈ ಬಾರಿ 1 ಮತ್ತು 2 ಎರಡೂ ಸೆಷನ್‌ಗಳು ಕಂಡುಬರುತ್ತವೆ. ಎಲ್ಲಾ ಮೂರು ಸೆಷನ್‌ಗಳನ್ನು ಒಂದಾಗಿ ಸಂಯೋಜಿಸಲಾಗಿದೆ, ಪ್ರಾರಂಭ ಸಮಯ 00:00:00 ಮತ್ತು ಅಂತಿಮ ಸಮಯ 00:00:15.

ಈ ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಿರುವ ವಿಷಯದಿಂದ, ಈ ಕೆಳಗಿನ ಪ್ರಮುಖ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ:

• ಅವಧಿಗಳು ಸ್ಥಿರ ಗಾತ್ರದ ಕಿಟಕಿಗಳಲ್ಲ. ಅವಧಿಯ ಅವಧಿಯನ್ನು ನಿರ್ದಿಷ್ಟ ಅವಧಿಯ ಚಟುವಟಿಕೆಯಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ;
• ಡೇಟಾದಲ್ಲಿನ ದಿನಾಂಕ/ಸಮಯದ ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಈವೆಂಟ್ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸೆಷನ್‌ನಲ್ಲಿ ಅಥವಾ ನಿಷ್ಕ್ರಿಯ ಅವಧಿಯಲ್ಲಿ ಬರುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.

ಮುಂದೆ ನಾವು ಮುಂದಿನ ರೀತಿಯ ವಿಂಡೋವನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ - "ಟಂಬ್ಲಿಂಗ್" ವಿಂಡೋಗಳು.

"ಟಂಬ್ಲಿಂಗ್" ಕಿಟಕಿಗಳು

ಉರುಳುವ ಕಿಟಕಿಗಳು ನಿರ್ದಿಷ್ಟ ಸಮಯದೊಳಗೆ ಬೀಳುವ ಘಟನೆಗಳನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತವೆ. ಪ್ರತಿ 20 ಸೆಕೆಂಡ್‌ಗಳಿಗೆ ನಿರ್ದಿಷ್ಟ ಕಂಪನಿಯ ಎಲ್ಲಾ ಸ್ಟಾಕ್ ವಹಿವಾಟುಗಳನ್ನು ನೀವು ಸೆರೆಹಿಡಿಯಬೇಕು ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ, ಆದ್ದರಿಂದ ನೀವು ಆ ಅವಧಿಯಲ್ಲಿ ಎಲ್ಲಾ ಈವೆಂಟ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೀರಿ. 20-ಸೆಕೆಂಡ್ ಮಧ್ಯಂತರದ ಕೊನೆಯಲ್ಲಿ, ವಿಂಡೋವು ಉರುಳುತ್ತದೆ ಮತ್ತು ಹೊಸ 20-ಸೆಕೆಂಡ್ ವೀಕ್ಷಣಾ ಮಧ್ಯಂತರಕ್ಕೆ ಚಲಿಸುತ್ತದೆ. ಚಿತ್ರ 5.14 ಈ ಪರಿಸ್ಥಿತಿಯನ್ನು ವಿವರಿಸುತ್ತದೆ.

ನೀವು ನೋಡುವಂತೆ, ಕಳೆದ 20 ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಸ್ವೀಕರಿಸಿದ ಎಲ್ಲಾ ಈವೆಂಟ್‌ಗಳನ್ನು ವಿಂಡೋದಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ. ಈ ಅವಧಿಯ ಕೊನೆಯಲ್ಲಿ, ಹೊಸ ವಿಂಡೋವನ್ನು ರಚಿಸಲಾಗಿದೆ.

ಪಟ್ಟಿ 5.6 ಪ್ರತಿ 20 ಸೆಕೆಂಡ್‌ಗಳಿಗೆ ಸ್ಟಾಕ್ ವಹಿವಾಟುಗಳನ್ನು ಸೆರೆಹಿಡಿಯಲು ಟಂಬ್ಲಿಂಗ್ ವಿಂಡೋಗಳ ಬಳಕೆಯನ್ನು ಪ್ರದರ್ಶಿಸುವ ಕೋಡ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ (src/main/java/bbejeck/chapter_5/CountingWindowingAndKtableJoinExample.java ನಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ).

TimeWindows.of ವಿಧಾನ ಕರೆಗೆ ಈ ಸಣ್ಣ ಬದಲಾವಣೆಯೊಂದಿಗೆ, ನೀವು ಟಂಬ್ಲಿಂಗ್ ವಿಂಡೋವನ್ನು ಬಳಸಬಹುದು. ಈ ಉದಾಹರಣೆಯು ತನಕ () ವಿಧಾನವನ್ನು ಕರೆಯುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ 24 ಗಂಟೆಗಳ ಡೀಫಾಲ್ಟ್ ಧಾರಣ ಮಧ್ಯಂತರವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ, ವಿಂಡೋ ಆಯ್ಕೆಗಳ ಕೊನೆಯದಕ್ಕೆ ತೆರಳಲು ಸಮಯವಾಗಿದೆ - "ಹೋಪಿಂಗ್" ವಿಂಡೋಗಳು.

ಸ್ಲೈಡಿಂಗ್ ("ಜಂಪಿಂಗ್") ಕಿಟಕಿಗಳು

ಸ್ಲೈಡಿಂಗ್ / ಜಿಗಿಯುವ ಕಿಟಕಿಗಳು ಉರುಳುವ ಕಿಟಕಿಗಳನ್ನು ಹೋಲುತ್ತವೆ, ಆದರೆ ಸ್ವಲ್ಪ ವ್ಯತ್ಯಾಸದೊಂದಿಗೆ. ಇತ್ತೀಚಿನ ಈವೆಂಟ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಹೊಸ ವಿಂಡೋವನ್ನು ರಚಿಸುವ ಮೊದಲು ಸ್ಲೈಡಿಂಗ್ ವಿಂಡೋಗಳು ಸಮಯದ ಮಧ್ಯಂತರದ ಅಂತ್ಯದವರೆಗೆ ಕಾಯುವುದಿಲ್ಲ. ವಿಂಡೋ ಅವಧಿಗಿಂತ ಕಡಿಮೆ ಕಾಯುವ ಮಧ್ಯಂತರದ ನಂತರ ಅವರು ಹೊಸ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತಾರೆ.

ಟಂಬ್ಲಿಂಗ್ ಮತ್ತು ಜಂಪಿಂಗ್ ಕಿಟಕಿಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ವಿವರಿಸಲು, ಸ್ಟಾಕ್ ಎಕ್ಸ್ಚೇಂಜ್ ವಹಿವಾಟುಗಳನ್ನು ಎಣಿಸುವ ಉದಾಹರಣೆಗೆ ಹಿಂತಿರುಗಿ ನೋಡೋಣ. ವಹಿವಾಟುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವುದು ನಮ್ಮ ಗುರಿಯಾಗಿದೆ, ಆದರೆ ಕೌಂಟರ್ ಅನ್ನು ನವೀಕರಿಸುವ ಮೊದಲು ನಾವು ಸಂಪೂರ್ಣ ಸಮಯವನ್ನು ಕಾಯಲು ಬಯಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ನಾವು ಕೌಂಟರ್ ಅನ್ನು ಕಡಿಮೆ ಅಂತರದಲ್ಲಿ ನವೀಕರಿಸುತ್ತೇವೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ಇನ್ನೂ ಪ್ರತಿ 20 ಸೆಕೆಂಡಿಗೆ ವಹಿವಾಟುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುತ್ತೇವೆ, ಆದರೆ ಅಂಜೂರದಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಪ್ರತಿ 5 ಸೆಕೆಂಡುಗಳಿಗೆ ಕೌಂಟರ್ ಅನ್ನು ನವೀಕರಿಸುತ್ತೇವೆ. 5.15. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಅತಿಕ್ರಮಿಸುವ ಡೇಟಾದೊಂದಿಗೆ ಮೂರು ಫಲಿತಾಂಶ ವಿಂಡೋಗಳೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತೇವೆ.

ಪಟ್ಟಿ 5.7 ಸ್ಲೈಡಿಂಗ್ ವಿಂಡೋಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಕೋಡ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ (src/main/java/bbejeck/chapter_5/CountingWindowingAndKtableJoinExample.java ನಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ).

AdvanceBy() ವಿಧಾನಕ್ಕೆ ಕರೆಯನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಉರುಳುವ ವಿಂಡೋವನ್ನು ಜಿಗಿಯುವ ವಿಂಡೋಗೆ ಪರಿವರ್ತಿಸಬಹುದು. ತೋರಿಸಿರುವ ಉದಾಹರಣೆಯಲ್ಲಿ, ಉಳಿತಾಯ ಮಧ್ಯಂತರವು 15 ನಿಮಿಷಗಳು.

ಸಮಯ ವಿಂಡೋಗಳಿಗೆ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಹೇಗೆ ಮಿತಿಗೊಳಿಸುವುದು ಎಂಬುದನ್ನು ನೀವು ಈ ವಿಭಾಗದಲ್ಲಿ ನೋಡಿದ್ದೀರಿ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಈ ವಿಭಾಗದಿಂದ ಕೆಳಗಿನ ಮೂರು ವಿಷಯಗಳನ್ನು ನೀವು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಬೇಕೆಂದು ನಾನು ಬಯಸುತ್ತೇನೆ:

• ಅಧಿವೇಶನ ವಿಂಡೋಗಳ ಗಾತ್ರವು ಸಮಯದ ಅವಧಿಯಿಂದ ಸೀಮಿತವಾಗಿಲ್ಲ, ಆದರೆ ಬಳಕೆದಾರರ ಚಟುವಟಿಕೆಯಿಂದ;
• "ಟಂಬ್ಲಿಂಗ್" ವಿಂಡೋಗಳು ಒಂದು ನಿರ್ದಿಷ್ಟ ಅವಧಿಯಲ್ಲಿ ಘಟನೆಗಳ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ;
• ಜಂಪಿಂಗ್ ವಿಂಡೋಗಳ ಅವಧಿಯನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ, ಆದರೆ ಅವುಗಳನ್ನು ಆಗಾಗ್ಗೆ ನವೀಕರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ವಿಂಡೋಗಳಲ್ಲಿ ಅತಿಕ್ರಮಿಸುವ ನಮೂದುಗಳನ್ನು ಹೊಂದಿರಬಹುದು.

ಮುಂದೆ, ಸಂಪರ್ಕಕ್ಕಾಗಿ KTable ಅನ್ನು ಮತ್ತೆ KStream ಗೆ ಪರಿವರ್ತಿಸುವುದು ಹೇಗೆ ಎಂದು ನಾವು ಕಲಿಯುತ್ತೇವೆ.

5.3.3. KStream ಮತ್ತು KTable ವಸ್ತುಗಳನ್ನು ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ

ಅಧ್ಯಾಯ 4 ರಲ್ಲಿ, ನಾವು ಎರಡು KStream ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಸಂಪರ್ಕಿಸುವ ಕುರಿತು ಚರ್ಚಿಸಿದ್ದೇವೆ. ಈಗ ನಾವು KTable ಮತ್ತು KStream ಅನ್ನು ಹೇಗೆ ಸಂಪರ್ಕಿಸಬೇಕು ಎಂಬುದನ್ನು ಕಲಿಯಬೇಕಾಗಿದೆ. ಕೆಳಗಿನ ಸರಳ ಕಾರಣಕ್ಕಾಗಿ ಇದು ಅಗತ್ಯವಾಗಬಹುದು. KStream ರೆಕಾರ್ಡ್‌ಗಳ ಸ್ಟ್ರೀಮ್ ಆಗಿದೆ, ಮತ್ತು KTable ರೆಕಾರ್ಡ್ ನವೀಕರಣಗಳ ಸ್ಟ್ರೀಮ್ ಆಗಿದೆ, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನೀವು KTable ನಿಂದ ನವೀಕರಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು ರೆಕಾರ್ಡ್ ಸ್ಟ್ರೀಮ್‌ಗೆ ಹೆಚ್ಚುವರಿ ಸಂದರ್ಭವನ್ನು ಸೇರಿಸಲು ಬಯಸಬಹುದು.

ಸ್ಟಾಕ್ ಎಕ್ಸ್ಚೇಂಜ್ ವಹಿವಾಟುಗಳ ಸಂಖ್ಯೆಯ ಡೇಟಾವನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ ಮತ್ತು ಸಂಬಂಧಿತ ಉದ್ಯಮಗಳಿಗೆ ಸ್ಟಾಕ್ ಎಕ್ಸ್ಚೇಂಜ್ ಸುದ್ದಿಗಳೊಂದಿಗೆ ಅವುಗಳನ್ನು ಸಂಯೋಜಿಸೋಣ. ನೀವು ಈಗಾಗಲೇ ಹೊಂದಿರುವ ಕೋಡ್‌ನಲ್ಲಿ ಇದನ್ನು ಸಾಧಿಸಲು ನೀವು ಏನು ಮಾಡಬೇಕು ಎಂಬುದು ಇಲ್ಲಿದೆ.

1. ಸ್ಟಾಕ್ ವಹಿವಾಟುಗಳ ಸಂಖ್ಯೆಯ ಡೇಟಾದೊಂದಿಗೆ KTable ವಸ್ತುವನ್ನು KStream ಆಗಿ ಪರಿವರ್ತಿಸಿ, ನಂತರ ಈ ಸ್ಟಾಕ್ ಚಿಹ್ನೆಗೆ ಅನುಗುಣವಾದ ಉದ್ಯಮ ವಲಯವನ್ನು ಸೂಚಿಸುವ ಕೀಲಿಯೊಂದಿಗೆ ಕೀಲಿಯನ್ನು ಬದಲಿಸಿ.
2. ಸ್ಟಾಕ್ ಎಕ್ಸ್ಚೇಂಜ್ ಸುದ್ದಿಗಳೊಂದಿಗೆ ವಿಷಯದಿಂದ ಡೇಟಾವನ್ನು ಓದುವ KTable ವಸ್ತುವನ್ನು ರಚಿಸಿ. ಈ ಹೊಸ KTable ಅನ್ನು ಉದ್ಯಮ ವಲಯದಿಂದ ವರ್ಗೀಕರಿಸಲಾಗುತ್ತದೆ.
3. ಉದ್ಯಮ ವಲಯದ ಮೂಲಕ ಸ್ಟಾಕ್ ಎಕ್ಸ್ಚೇಂಜ್ ವಹಿವಾಟುಗಳ ಸಂಖ್ಯೆಯ ಮಾಹಿತಿಯೊಂದಿಗೆ ಸುದ್ದಿ ನವೀಕರಣಗಳನ್ನು ಸಂಪರ್ಕಿಸಿ.

ಈಗ ಈ ಕ್ರಿಯಾ ಯೋಜನೆಯನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಎಂದು ನೋಡೋಣ.

KTable ಅನ್ನು KStream ಗೆ ಪರಿವರ್ತಿಸಿ

KTable ಅನ್ನು KStream ಗೆ ಪರಿವರ್ತಿಸಲು ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡಬೇಕಾಗಿದೆ.

1. KTable.toStream() ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿ.
2. KStream.map ವಿಧಾನವನ್ನು ಕರೆಯುವ ಮೂಲಕ, ಉದ್ಯಮದ ಹೆಸರಿನೊಂದಿಗೆ ಕೀಲಿಯನ್ನು ಬದಲಾಯಿಸಿ, ತದನಂತರ Windowed ನಿದರ್ಶನದಿಂದ ವಹಿವಾಟಿನ ಸಾರಾಂಶ ವಸ್ತುವನ್ನು ಹಿಂಪಡೆಯಿರಿ.

ನಾವು ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಜೋಡಿಸುತ್ತೇವೆ (ಕೋಡ್ ಅನ್ನು ಫೈಲ್ src/main/java/bbejeck/chapter_5/CountingWindowingAndKtableJoinExample.java ನಲ್ಲಿ ಕಾಣಬಹುದು) (ಪಟ್ಟಿ 5.8).

ನಾವು KStream.map ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮಾಡುತ್ತಿರುವುದರಿಂದ, ಹಿಂತಿರುಗಿದ KStream ನಿದರ್ಶನವನ್ನು ಸಂಪರ್ಕದಲ್ಲಿ ಬಳಸಿದಾಗ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರು-ವಿಭಜಿಸಲಾಗುತ್ತದೆ.

ನಾವು ಪರಿವರ್ತನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ್ದೇವೆ, ಮುಂದೆ ನಾವು ಸ್ಟಾಕ್ ಸುದ್ದಿಗಳನ್ನು ಓದಲು KTable ವಸ್ತುವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ.

ಸ್ಟಾಕ್ ಸುದ್ದಿಗಾಗಿ KTable ರಚನೆ

ಅದೃಷ್ಟವಶಾತ್, KTable ವಸ್ತುವನ್ನು ರಚಿಸುವುದು ಕೇವಲ ಒಂದು ಸಾಲಿನ ಕೋಡ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ (ಕೋಡ್ ಅನ್ನು src/main/java/bbejeck/chapter_5/CountingWindowingAndKtableJoinExample.java ನಲ್ಲಿ ಕಾಣಬಹುದು) (ಪಟ್ಟಿ 5.9).

ಸ್ಟ್ರಿಂಗ್ ಸೆರ್ಡೆಸ್ ಅನ್ನು ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ಬಳಸುವುದರಿಂದ ಯಾವುದೇ ಸೆರ್ಡೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ಗಮನಿಸಬೇಕಾದ ಅಂಶವಾಗಿದೆ. ಅಲ್ಲದೆ, ಆರಂಭಿಕ ಎಣಿಕೆಯನ್ನು ಬಳಸುವ ಮೂಲಕ, ಟೇಬಲ್ ಅನ್ನು ಪ್ರಾರಂಭದಲ್ಲಿಯೇ ದಾಖಲೆಗಳಿಂದ ತುಂಬಿಸಲಾಗುತ್ತದೆ.

ಈಗ ನಾವು ಅಂತಿಮ ಹಂತಕ್ಕೆ ಹೋಗಬಹುದು - ಸಂಪರ್ಕ.

ವಹಿವಾಟು ಎಣಿಕೆ ಡೇಟಾದೊಂದಿಗೆ ಸುದ್ದಿ ನವೀಕರಣಗಳನ್ನು ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ

ಸಂಪರ್ಕವನ್ನು ರಚಿಸುವುದು ಕಷ್ಟವೇನಲ್ಲ. ಸಂಬಂಧಿತ ಉದ್ಯಮಕ್ಕೆ ಯಾವುದೇ ಸ್ಟಾಕ್ ಸುದ್ದಿ ಇಲ್ಲದಿದ್ದಲ್ಲಿ ನಾವು ಎಡ ಸೇರುವಿಕೆಯನ್ನು ಬಳಸುತ್ತೇವೆ (ಅಗತ್ಯ ಕೋಡ್ ಅನ್ನು ಫೈಲ್ src/main/java/bbejeck/chapter_5/CountingWindowingAndKtableJoinExample.java ಫೈಲ್‌ನಲ್ಲಿ ಕಾಣಬಹುದು) (ಪಟ್ಟಿ 5.10).

ಈ leftJoin ಆಪರೇಟರ್ ತುಂಬಾ ಸರಳವಾಗಿದೆ. ಅಧ್ಯಾಯ 4 ರಲ್ಲಿನ ಸೇರ್ಪಡೆಗಳಂತೆ, JoinWindow ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ ಏಕೆಂದರೆ KStream-KTable ಸೇರುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುವಾಗ, ಪ್ರತಿ ಕೀಲಿಗಾಗಿ KTable ನಲ್ಲಿ ಕೇವಲ ಒಂದು ನಮೂದು ಇರುತ್ತದೆ. ಅಂತಹ ಸಂಪರ್ಕವು ಸಮಯಕ್ಕೆ ಸೀಮಿತವಾಗಿಲ್ಲ: ದಾಖಲೆಯು KTable ಅಥವಾ ಗೈರುಹಾಜರಿಯಲ್ಲಿದೆ. ಮುಖ್ಯ ತೀರ್ಮಾನ: KTable ವಸ್ತುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಕಡಿಮೆ ಪುನರಾವರ್ತಿತವಾಗಿ ನವೀಕರಿಸಿದ ಉಲ್ಲೇಖ ಡೇಟಾದೊಂದಿಗೆ KStream ಅನ್ನು ಉತ್ಕೃಷ್ಟಗೊಳಿಸಬಹುದು.

ಈಗ ನಾವು KStream ನಿಂದ ಈವೆಂಟ್‌ಗಳನ್ನು ಶ್ರೀಮಂತಗೊಳಿಸಲು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ನೋಡುತ್ತೇವೆ.

5.3.4. GlobalKTable ವಸ್ತುಗಳು

ನೀವು ನೋಡುವಂತೆ, ಈವೆಂಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಉತ್ಕೃಷ್ಟಗೊಳಿಸುವ ಅಥವಾ ಅವುಗಳಿಗೆ ಸಂದರ್ಭವನ್ನು ಸೇರಿಸುವ ಅವಶ್ಯಕತೆಯಿದೆ. ಅಧ್ಯಾಯ 4 ರಲ್ಲಿ ನೀವು ಎರಡು KStream ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ನಡುವಿನ ಸಂಪರ್ಕವನ್ನು ನೋಡಿದ್ದೀರಿ ಮತ್ತು ಹಿಂದಿನ ವಿಭಾಗದಲ್ಲಿ ನೀವು KStream ಮತ್ತು KTable ನಡುವಿನ ಸಂಪರ್ಕವನ್ನು ನೋಡಿದ್ದೀರಿ. ಈ ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಹೊಸ ಪ್ರಕಾರ ಅಥವಾ ಮೌಲ್ಯಕ್ಕೆ ಕೀಲಿಗಳನ್ನು ಮ್ಯಾಪ್ ಮಾಡುವಾಗ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಮರು-ವಿಭಜಿಸುವುದು ಅವಶ್ಯಕ. ಕೆಲವೊಮ್ಮೆ ಮರುವಿಭಾಗವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ, ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳು ಅದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಡುತ್ತದೆ. ಮರು-ವಿಭಜನೆಯು ಅವಶ್ಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ಕೀಗಳು ಬದಲಾಗಿವೆ ಮತ್ತು ದಾಖಲೆಗಳು ಹೊಸ ವಿಭಾಗಗಳಲ್ಲಿ ಕೊನೆಗೊಳ್ಳಬೇಕು, ಇಲ್ಲದಿದ್ದರೆ ಸಂಪರ್ಕವು ಅಸಾಧ್ಯವಾಗುತ್ತದೆ (ಇದನ್ನು ಅಧ್ಯಾಯ 4 ರಲ್ಲಿ, ಉಪವಿಭಾಗ 4.2.4 ರಲ್ಲಿ "ಮರು-ವಿಭಜನೆ ಡೇಟಾ" ವಿಭಾಗದಲ್ಲಿ ಚರ್ಚಿಸಲಾಗಿದೆ).

ಮರು-ವಿಭಜನೆಯು ವೆಚ್ಚವನ್ನು ಹೊಂದಿದೆ

ಮರು-ವಿಭಜನೆಗೆ ವೆಚ್ಚಗಳು ಬೇಕಾಗುತ್ತವೆ - ಮಧ್ಯಂತರ ವಿಷಯಗಳನ್ನು ರಚಿಸಲು ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲ ವೆಚ್ಚಗಳು, ಮತ್ತೊಂದು ವಿಷಯದಲ್ಲಿ ನಕಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದು; ಈ ವಿಷಯದಿಂದ ಬರೆಯುವ ಮತ್ತು ಓದುವ ಕಾರಣದಿಂದಾಗಿ ಹೆಚ್ಚಿದ ಸುಪ್ತತೆ ಎಂದರ್ಥ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನೀವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಅಂಶಗಳು ಅಥವಾ ಆಯಾಮಗಳಲ್ಲಿ ಸೇರಬೇಕಾದರೆ, ನೀವು ಸೇರ್ಪಡೆಗಳನ್ನು ಸರಪಳಿಯಲ್ಲಿ ಸೇರಿಸಬೇಕು, ಹೊಸ ಕೀಲಿಗಳೊಂದಿಗೆ ದಾಖಲೆಗಳನ್ನು ಮ್ಯಾಪ್ ಮಾಡಬೇಕು ಮತ್ತು ಮರು-ವಿಭಜನಾ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮತ್ತೆ ಚಲಾಯಿಸಬೇಕು.

ಚಿಕ್ಕ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ

ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಸಂಪರ್ಕಿಸಬೇಕಾದ ಉಲ್ಲೇಖ ಡೇಟಾದ ಪ್ರಮಾಣವು ತುಲನಾತ್ಮಕವಾಗಿ ಚಿಕ್ಕದಾಗಿದೆ, ಆದ್ದರಿಂದ ಅದರ ಸಂಪೂರ್ಣ ಪ್ರತಿಗಳು ಪ್ರತಿ ನೋಡ್‌ನಲ್ಲಿ ಸುಲಭವಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ. ಈ ರೀತಿಯ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ, ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್ಸ್ GlobalKTable ವರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

GlobalKTable ನಿದರ್ಶನಗಳು ಅನನ್ಯವಾಗಿವೆ ಏಕೆಂದರೆ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರತಿಯೊಂದು ನೋಡ್‌ಗಳಿಗೆ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ. ಮತ್ತು ಎಲ್ಲಾ ಡೇಟಾವು ಪ್ರತಿ ನೋಡ್‌ನಲ್ಲಿ ಇರುವುದರಿಂದ, ಈವೆಂಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಉಲ್ಲೇಖ ಡೇಟಾ ಕೀಲಿಯಿಂದ ವಿಭಜಿಸುವ ಅಗತ್ಯವಿಲ್ಲ ಆದ್ದರಿಂದ ಅದು ಎಲ್ಲಾ ವಿಭಾಗಗಳಿಗೆ ಲಭ್ಯವಿರುತ್ತದೆ. GlobalKTable ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಕೀಲಿ ರಹಿತ ಸೇರ್ಪಡೆಗಳನ್ನು ಸಹ ಮಾಡಬಹುದು. ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಹಿಂದಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ಹಿಂತಿರುಗಿ ನೋಡೋಣ.

KStream ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು GlobalKTable ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ

ಉಪವಿಭಾಗ 5.3.2 ರಲ್ಲಿ, ನಾವು ಖರೀದಿದಾರರಿಂದ ವಿನಿಮಯ ವಹಿವಾಟುಗಳ ವಿಂಡೋ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸಿದ್ದೇವೆ. ಈ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ಫಲಿತಾಂಶಗಳು ಈ ರೀತಿ ಕಾಣುತ್ತವೆ:

{customerId='074-09-3705', stockTicker='GUTM'}, 17
{customerId='037-34-5184', stockTicker='CORK'}, 16

ಈ ಫಲಿತಾಂಶಗಳು ಉದ್ದೇಶವನ್ನು ಪೂರೈಸಿದ್ದರೂ, ಗ್ರಾಹಕರ ಹೆಸರು ಮತ್ತು ಪೂರ್ಣ ಕಂಪನಿಯ ಹೆಸರನ್ನು ಸಹ ಪ್ರದರ್ಶಿಸಿದ್ದರೆ ಅದು ಹೆಚ್ಚು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ. ಗ್ರಾಹಕರ ಹೆಸರು ಮತ್ತು ಕಂಪನಿಯ ಹೆಸರನ್ನು ಸೇರಿಸಲು, ನೀವು ಸಾಮಾನ್ಯ ಸೇರ್ಪಡೆಗಳನ್ನು ಮಾಡಬಹುದು, ಆದರೆ ನೀವು ಎರಡು ಪ್ರಮುಖ ಮ್ಯಾಪಿಂಗ್‌ಗಳನ್ನು ಮತ್ತು ಮರು-ವಿಭಜನೆಯನ್ನು ಮಾಡಬೇಕಾಗುತ್ತದೆ. GlobalKTable ನೊಂದಿಗೆ ನೀವು ಅಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳ ವೆಚ್ಚವನ್ನು ತಪ್ಪಿಸಬಹುದು.

ಇದನ್ನು ಮಾಡಲು, ನಾವು 5.11 ಪಟ್ಟಿಯಿಂದ ಕೌಂಟ್‌ಸ್ಟ್ರೀಮ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ (ಅನುಗುಣವಾದ ಕೋಡ್ ಅನ್ನು src/main/java/bbejeck/chapter_5/GlobalKTableExample.java ನಲ್ಲಿ ಕಾಣಬಹುದು) ಮತ್ತು ಅದನ್ನು ಎರಡು GlobalKTable ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ.

ನಾವು ಇದನ್ನು ಈಗಾಗಲೇ ಚರ್ಚಿಸಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ನಾನು ಅದನ್ನು ಪುನರಾವರ್ತಿಸುವುದಿಲ್ಲ. ಆದರೆ toStream().map ಫಂಕ್ಷನ್‌ನಲ್ಲಿನ ಕೋಡ್ ಅನ್ನು ಓದುವ ಸಲುವಾಗಿ ಇನ್‌ಲೈನ್ ಲ್ಯಾಂಬ್ಡಾ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ನ ಬದಲಿಗೆ ಫಂಕ್ಷನ್ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿ ಅಮೂರ್ತಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ನಾನು ಗಮನಿಸುತ್ತೇನೆ.

ಮುಂದಿನ ಹಂತವು GlobalKTable ನ ಎರಡು ನಿದರ್ಶನಗಳನ್ನು ಘೋಷಿಸುವುದು (ತೋರಿಸಲಾದ ಕೋಡ್ ಅನ್ನು src/main/java/bbejeck/chapter_5/GlobalKTableExample.java ಫೈಲ್‌ನಲ್ಲಿ ಕಾಣಬಹುದು) (ಪಟ್ಟಿ 5.12).

ಎಣಿಕೆಯ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವಿಷಯದ ಹೆಸರುಗಳನ್ನು ವಿವರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.

ಈಗ ನಾವು ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ಸಿದ್ಧಪಡಿಸಿದ್ದೇವೆ, ಸಂಪರ್ಕಕ್ಕಾಗಿ ಕೋಡ್ ಅನ್ನು ಬರೆಯುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ (ಇದನ್ನು ಫೈಲ್ src/main/java/bbejeck/chapter_5/GlobalKTableExample.java ನಲ್ಲಿ ಕಾಣಬಹುದು) (ಪಟ್ಟಿ 5.13).

ಈ ಕೋಡ್‌ನಲ್ಲಿ ಎರಡು ಸೇರ್ಪಡೆಗಳಿದ್ದರೂ, ಅವುಗಳ ಯಾವುದೇ ಫಲಿತಾಂಶಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಬಳಸದ ಕಾರಣ ಅವುಗಳನ್ನು ಚೈನ್ ಮಾಡಲಾಗಿದೆ. ಸಂಪೂರ್ಣ ಕಾರ್ಯಾಚರಣೆಯ ಕೊನೆಯಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ಮೇಲಿನ ಸೇರ್ಪಡೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನೀವು ಚಲಾಯಿಸಿದಾಗ, ನೀವು ಈ ರೀತಿಯ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ:

{customer='Barney, Smith' company="Exxon", transactions= 17}

ಸಾರವು ಬದಲಾಗಿಲ್ಲ, ಆದರೆ ಈ ಫಲಿತಾಂಶಗಳು ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗಿ ಕಾಣುತ್ತವೆ.

ನೀವು ಅಧ್ಯಾಯ 4 ಕ್ಕೆ ಎಣಿಸಿದರೆ, ನೀವು ಈಗಾಗಲೇ ಹಲವಾರು ರೀತಿಯ ಸಂಪರ್ಕಗಳನ್ನು ಕ್ರಿಯೆಯಲ್ಲಿ ನೋಡಿದ್ದೀರಿ. ಅವುಗಳನ್ನು ಕೋಷ್ಟಕದಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ. 5.2 ಈ ಕೋಷ್ಟಕವು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಆವೃತ್ತಿ 1.0.0 ರಂತೆ ಸಂಪರ್ಕ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ; ಭವಿಷ್ಯದ ಬಿಡುಗಡೆಗಳಲ್ಲಿ ಏನಾದರೂ ಬದಲಾಗಬಹುದು.

ವಿಷಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು, ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ರೀಕ್ಯಾಪ್ ಮಾಡೋಣ: ನೀವು ಸ್ಥಳೀಯ ಸ್ಥಿತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಈವೆಂಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು (KStream) ಮತ್ತು ಅಪ್‌ಡೇಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು (KTable) ಸಂಪರ್ಕಿಸಬಹುದು. ಪರ್ಯಾಯವಾಗಿ, ಉಲ್ಲೇಖ ಡೇಟಾದ ಗಾತ್ರವು ತುಂಬಾ ದೊಡ್ಡದಾಗಿರದಿದ್ದರೆ, ನೀವು GlobalKTable ವಸ್ತುವನ್ನು ಬಳಸಬಹುದು. GlobalKTables ಪ್ರತಿಯೊಂದು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ ನೋಡ್‌ಗೆ ಎಲ್ಲಾ ವಿಭಾಗಗಳನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ಕೀಲಿಯು ಯಾವ ವಿಭಾಗಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗಿದ್ದರೂ ಎಲ್ಲಾ ಡೇಟಾ ಲಭ್ಯವಿರುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಮುಂದೆ ನಾವು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ವೈಶಿಷ್ಟ್ಯವನ್ನು ನೋಡುತ್ತೇವೆ, ಇದಕ್ಕೆ ಧನ್ಯವಾದಗಳು ನಾವು ಕಾಫ್ಕಾ ವಿಷಯದಿಂದ ಡೇಟಾವನ್ನು ಸೇವಿಸದೆ ರಾಜ್ಯದ ಬದಲಾವಣೆಗಳನ್ನು ವೀಕ್ಷಿಸಬಹುದು.

5.3.5. ಪ್ರಶ್ನಿಸಬಹುದಾದ ಸ್ಥಿತಿ

ನಾವು ಈಗಾಗಲೇ ರಾಜ್ಯವನ್ನು ಒಳಗೊಂಡ ಹಲವಾರು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಿದ್ದೇವೆ ಮತ್ತು ಯಾವಾಗಲೂ ಫಲಿತಾಂಶಗಳನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತೇವೆ (ಅಭಿವೃದ್ಧಿ ಉದ್ದೇಶಗಳಿಗಾಗಿ) ಅಥವಾ ಅವುಗಳನ್ನು ಒಂದು ವಿಷಯಕ್ಕೆ ಬರೆಯುತ್ತೇವೆ (ಉತ್ಪಾದನಾ ಉದ್ದೇಶಗಳಿಗಾಗಿ). ವಿಷಯಕ್ಕೆ ಫಲಿತಾಂಶಗಳನ್ನು ಬರೆಯುವಾಗ, ಅವುಗಳನ್ನು ವೀಕ್ಷಿಸಲು ನೀವು ಕಾಫ್ಕಾ ಗ್ರಾಹಕರನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ.

ಈ ವಿಷಯಗಳಿಂದ ಡೇಟಾವನ್ನು ಓದುವುದನ್ನು ವಸ್ತುನಿಷ್ಠ ವೀಕ್ಷಣೆಗಳ ಪ್ರಕಾರವೆಂದು ಪರಿಗಣಿಸಬಹುದು. ನಮ್ಮ ಉದ್ದೇಶಗಳಿಗಾಗಿ, ನಾವು ವಿಕಿಪೀಡಿಯಾದಿಂದ ವಸ್ತುರೂಪದ ವೀಕ್ಷಣೆಯ ವ್ಯಾಖ್ಯಾನವನ್ನು ಬಳಸಬಹುದು: “... ಪ್ರಶ್ನೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಹೊಂದಿರುವ ಭೌತಿಕ ಡೇಟಾಬೇಸ್ ವಸ್ತು. ಉದಾಹರಣೆಗೆ, ಇದು ರಿಮೋಟ್ ಡೇಟಾದ ಸ್ಥಳೀಯ ನಕಲು ಆಗಿರಬಹುದು ಅಥವಾ ಟೇಬಲ್‌ನ ಸಾಲುಗಳು ಮತ್ತು/ಅಥವಾ ಕಾಲಮ್‌ಗಳ ಉಪವಿಭಾಗ ಅಥವಾ ಫಲಿತಾಂಶಗಳನ್ನು ಸೇರಬಹುದು ಅಥವಾ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ಮೂಲಕ ಪಡೆದ ಸಾರಾಂಶ ಕೋಷ್ಟಕವಾಗಿರಬಹುದು” (https://en.wikipedia.org/wiki /ಮೆಟೀರಿಯಲೈಸ್ಡ್_ವೀಕ್ಷಣೆ).

ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳು ರಾಜ್ಯದ ಸ್ಟೋರ್‌ಗಳಲ್ಲಿ ಸಂವಾದಾತ್ಮಕ ಪ್ರಶ್ನೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಸಹ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಈ ವಸ್ತುನಿಷ್ಠ ವೀಕ್ಷಣೆಗಳನ್ನು ನೇರವಾಗಿ ಓದಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ರಾಜ್ಯದ ಅಂಗಡಿಯ ಪ್ರಶ್ನೆಯು ಓದಲು-ಮಾತ್ರ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಿರುವಾಗ ಆಕಸ್ಮಿಕವಾಗಿ ಸ್ಥಿತಿಯನ್ನು ಅಸಮಂಜಸಗೊಳಿಸುವ ಬಗ್ಗೆ ನೀವು ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ರಾಜ್ಯ ಮಳಿಗೆಗಳನ್ನು ನೇರವಾಗಿ ಪ್ರಶ್ನಿಸುವ ಸಾಮರ್ಥ್ಯವು ಮುಖ್ಯವಾಗಿದೆ. ಇದರರ್ಥ ನೀವು ಮೊದಲು ಕಾಫ್ಕಾ ಗ್ರಾಹಕರಿಂದ ಡೇಟಾವನ್ನು ಪಡೆದುಕೊಳ್ಳದೆಯೇ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ಡೇಟಾವನ್ನು ಮತ್ತೆ ಬರೆಯುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂಬ ಕಾರಣದಿಂದಾಗಿ ಇದು ಅಪ್ಲಿಕೇಶನ್‌ನ ದಕ್ಷತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ:

• ಡೇಟಾದ ಪ್ರದೇಶಕ್ಕೆ ಧನ್ಯವಾದಗಳು, ಅವುಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು;
• ಡೇಟಾದ ನಕಲು ತೆಗೆದುಹಾಕಲಾಗಿದೆ, ಏಕೆಂದರೆ ಇದನ್ನು ಬಾಹ್ಯ ಸಂಗ್ರಹಣೆಗೆ ಬರೆಯಲಾಗಿಲ್ಲ.

ನೀವು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ನಾನು ಬಯಸುವ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದಲೇ ನೀವು ನೇರವಾಗಿ ರಾಜ್ಯವನ್ನು ಪ್ರಶ್ನಿಸಬಹುದು. ಇದು ನಿಮಗೆ ನೀಡುವ ಅವಕಾಶಗಳನ್ನು ಅತಿಯಾಗಿ ಹೇಳಲಾಗುವುದಿಲ್ಲ. ಕಾಫ್ಕಾದಿಂದ ಡೇಟಾವನ್ನು ಸೇವಿಸುವ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ದಾಖಲೆಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಬದಲು, ನೀವು ಅದೇ ಫಲಿತಾಂಶದೊಂದಿಗೆ ರಾಜ್ಯ ಮಳಿಗೆಗಳನ್ನು ಪ್ರಶ್ನಿಸಬಹುದು. ರಾಜ್ಯ ಮಳಿಗೆಗಳಿಗೆ ನೇರ ಪ್ರಶ್ನೆಗಳು ಕಡಿಮೆ ಕೋಡ್ (ಗ್ರಾಹಕ ಇಲ್ಲ) ಮತ್ತು ಕಡಿಮೆ ಸಾಫ್ಟ್‌ವೇರ್ (ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಡೇಟಾಬೇಸ್ ಟೇಬಲ್ ಅಗತ್ಯವಿಲ್ಲ) ಎಂದರ್ಥ.

ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ನಾವು ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ನೆಲವನ್ನು ಕವರ್ ಮಾಡಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ನಾವು ಇದೀಗ ರಾಜ್ಯದ ಅಂಗಡಿಗಳ ವಿರುದ್ಧ ಸಂವಾದಾತ್ಮಕ ಪ್ರಶ್ನೆಗಳ ನಮ್ಮ ಚರ್ಚೆಯನ್ನು ಬಿಡುತ್ತೇವೆ. ಆದರೆ ಚಿಂತಿಸಬೇಡಿ: ಅಧ್ಯಾಯ 9 ರಲ್ಲಿ, ನಾವು ಸಂವಾದಾತ್ಮಕ ಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ ಸರಳ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. ಸಂವಾದಾತ್ಮಕ ಪ್ರಶ್ನೆಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಹೇಗೆ ಸೇರಿಸಬಹುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸಲು ಇದು ಮತ್ತು ಹಿಂದಿನ ಅಧ್ಯಾಯಗಳ ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ಇದು ಬಳಸುತ್ತದೆ.

ಸಾರಾಂಶ

• KStream ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಈವೆಂಟ್‌ಗಳ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ, ಡೇಟಾಬೇಸ್‌ನ ಒಳಸೇರಿಸುವಿಕೆಗೆ ಹೋಲಿಸಬಹುದು. KTable ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಪ್‌ಡೇಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ, ಡೇಟಾಬೇಸ್‌ಗೆ ನವೀಕರಣಗಳಂತೆ. KTable ವಸ್ತುವಿನ ಗಾತ್ರವು ಬೆಳೆಯುವುದಿಲ್ಲ, ಹಳೆಯ ದಾಖಲೆಗಳನ್ನು ಹೊಸದರಿಂದ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ.
• ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ KTable ವಸ್ತುಗಳು ಅಗತ್ಯವಿದೆ.
• ವಿಂಡೊಯಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಒಟ್ಟು ಡೇಟಾವನ್ನು ಸಮಯ ಬಕೆಟ್‌ಗಳಾಗಿ ವಿಭಜಿಸಬಹುದು.
• GlobalKTable ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಧನ್ಯವಾದಗಳು, ವಿಭಜನೆಯನ್ನು ಲೆಕ್ಕಿಸದೆ ನೀವು ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಎಲ್ಲಿಯಾದರೂ ಉಲ್ಲೇಖ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
• KStream, KTable ಮತ್ತು GlobalKTable ವಸ್ತುಗಳ ನಡುವಿನ ಸಂಪರ್ಕಗಳು ಸಾಧ್ಯ.

ಇಲ್ಲಿಯವರೆಗೆ, ನಾವು ಉನ್ನತ ಮಟ್ಟದ KStream DSL ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವತ್ತ ಗಮನಹರಿಸಿದ್ದೇವೆ. ಉನ್ನತ ಮಟ್ಟದ ವಿಧಾನವು ಅಚ್ಚುಕಟ್ಟಾಗಿ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆಯಾದರೂ, ಅದನ್ನು ಬಳಸುವುದು ವ್ಯಾಪಾರ-ವಹಿವಾಟುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. DSL KStream ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಎಂದರೆ ನಿಯಂತ್ರಣದ ಮಟ್ಟವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ ನಿಮ್ಮ ಕೋಡ್‌ನ ಸಂಕ್ಷಿಪ್ತತೆಯನ್ನು ಹೆಚ್ಚಿಸುವುದು. ಮುಂದಿನ ಅಧ್ಯಾಯದಲ್ಲಿ, ನಾವು ಕಡಿಮೆ ಮಟ್ಟದ ಹ್ಯಾಂಡ್ಲರ್ ನೋಡ್ API ಅನ್ನು ನೋಡುತ್ತೇವೆ ಮತ್ತು ಇತರ ಟ್ರೇಡ್-ಆಫ್‌ಗಳನ್ನು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ. ಕಾರ್ಯಕ್ರಮಗಳು ಮೊದಲಿಗಿಂತಲೂ ಉದ್ದವಾಗಿರುತ್ತದೆ, ಆದರೆ ನಮಗೆ ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಹ್ಯಾಂಡ್ಲರ್ ನೋಡ್ ಅನ್ನು ರಚಿಸಲು ನಮಗೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

→ ಪುಸ್ತಕದ ಕುರಿತು ಹೆಚ್ಚಿನ ವಿವರಗಳನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು ಪ್ರಕಾಶಕರ ವೆಬ್‌ಸೈಟ್

→ Habrozhiteli ಗಾಗಿ ಕೂಪನ್ ಬಳಸಿ 25% ರಿಯಾಯಿತಿ - ಕಾಫ್ಕಾ ಸ್ಟ್ರೀಮ್ಸ್

→ ಪುಸ್ತಕದ ಕಾಗದದ ಆವೃತ್ತಿಗೆ ಪಾವತಿಸಿದ ನಂತರ, ಇ-ಮೇಲ್ ಮೂಲಕ ಎಲೆಕ್ಟ್ರಾನಿಕ್ ಪುಸ್ತಕವನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ.

ಮೂಲ: www.habr.com