પુસ્તક “કાફકા સ્ટ્રીમ્સ ઇન એક્શન. રીઅલ-ટાઇમ કામ માટે એપ્લિકેશન્સ અને માઇક્રોસર્વિસિસ"

હેલો, ખાબરોના રહેવાસીઓ! આ પુસ્તક કોઈપણ વિકાસકર્તા માટે યોગ્ય છે જે થ્રેડ પ્રક્રિયાને સમજવા માંગે છે. વિતરિત પ્રોગ્રામિંગને સમજવાથી તમને કાફકા અને કાફકા સ્ટ્રીમ્સને વધુ સારી રીતે સમજવામાં મદદ મળશે. કાફકા ફ્રેમવર્કને જાણવું સરસ રહેશે, પરંતુ આ જરૂરી નથી: હું તમને જે જોઈએ તે બધું કહીશ. અનુભવી કાફકા વિકાસકર્તાઓ અને શિખાઉ લોકો આ પુસ્તકમાં કાફકા સ્ટ્રીમ્સ લાઇબ્રેરીનો ઉપયોગ કરીને રસપ્રદ સ્ટ્રીમ પ્રોસેસિંગ એપ્લિકેશન્સ કેવી રીતે બનાવવી તે શીખશે. મધ્યવર્તી અને અદ્યતન જાવા વિકાસકર્તાઓ પહેલેથી જ સીરીયલાઇઝેશન જેવી વિભાવનાઓથી પરિચિત છે તેઓ કાફકા સ્ટ્રીમ્સ એપ્લિકેશન બનાવવા માટે તેમની કુશળતા લાગુ કરવાનું શીખશે. પુસ્તકનો સ્રોત કોડ Java 8 માં લખાયેલ છે અને Java 8 lambda અભિવ્યક્તિ વાક્યરચનાનો નોંધપાત્ર ઉપયોગ કરે છે, તેથી લેમ્બડા ફંક્શન્સ (બીજી પ્રોગ્રામિંગ ભાષામાં પણ) સાથે કેવી રીતે કામ કરવું તે જાણવું ઉપયોગી થશે.

અવતરણ. 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).

આપેલ કોડ તેના સંક્ષિપ્તતા અને ઘણી લીટીઓમાં કરવામાં આવતી ક્રિયાઓના વિશાળ વોલ્યુમ દ્વારા અલગ પડે છે. તમે builder.stream પદ્ધતિના પ્રથમ પરિમાણમાં કંઈક નવું જોઈ શકો છો: Enum પ્રકારનું મૂલ્ય AutoOffsetReset.EARLIEST (ત્યાં એક લેટેસ્ટ પણ છે), Consumed.withOffsetResetPolicy પદ્ધતિનો ઉપયોગ કરીને સેટ કરો. આ ગણતરી પ્રકાર દરેક KStream અથવા KTable માટે ઓફસેટ રીસેટ વ્યૂહરચના સ્પષ્ટ કરવા માટે વાપરી શકાય છે અને રૂપરેખાંકનમાંથી ઓફસેટ રીસેટ વિકલ્પ પર અગ્રતા લે છે.

GroupByKey અને GroupBy

KStream ઈન્ટરફેસ પાસે રેકોર્ડને જૂથબદ્ધ કરવા માટે બે પદ્ધતિઓ છે: GroupByKey અને GroupBy. બંને KGroupedTable પરત કરે છે, જેથી તમે વિચારી રહ્યા હશો કે તેમની વચ્ચે શું તફાવત છે અને કયાનો ઉપયોગ ક્યારે કરવો?

GroupByKey પદ્ધતિનો ઉપયોગ થાય છે જ્યારે KStream માં કીઓ પહેલેથી જ ખાલી ન હોય. અને સૌથી અગત્યનું, "ફરી પાર્ટીશનની જરૂર છે" ધ્વજ ક્યારેય સેટ થયો ન હતો.

GroupBy પદ્ધતિ ધારે છે કે તમે ગ્રૂપિંગ કીઓ બદલી છે, તેથી પુનઃપાર્ટીશન ફ્લેગ સાચું પર સેટ છે. ગ્રૂપબાય પદ્ધતિ પછી જોડા, એકત્રીકરણ, વગેરે પરફોર્મ કરવાથી આપોઆપ પુનઃ-પાર્ટીશન થશે.
સારાંશ: જ્યારે પણ શક્ય હોય, તમારે GroupBy ને બદલે GroupByKey નો ઉપયોગ કરવો જોઈએ.

તે સ્પષ્ટ છે કે mapValues ​​અને groupBy પદ્ધતિઓ શું કરે છે, તો ચાલો sum() પદ્ધતિ (src/main/java/bbejeck/model/ShareVolume.java માં જોવા મળે છે) (લિસ્ટિંગ 5.3) પર એક નજર કરીએ.

ShareVolume.sum પદ્ધતિ સ્ટોક સેલ્સ વોલ્યુમની ચાલી રહેલી કુલ રકમ પરત કરે છે, અને ગણતરીની સમગ્ર સાંકળનું પરિણામ KTable ઑબ્જેક્ટ છે. . હવે તમે KTableની ભૂમિકા સમજો છો. જ્યારે ShareVolume ઑબ્જેક્ટ્સ આવે છે, ત્યારે અનુરૂપ KTable ઑબ્જેક્ટ નવીનતમ વર્તમાન અપડેટનો સંગ્રહ કરે છે. તે યાદ રાખવું અગત્યનું છે કે તમામ અપડેટ્સ અગાઉના શેરવોલ્યુમકેટેબલમાં પ્રતિબિંબિત થાય છે, પરંતુ બધા આગળ મોકલવામાં આવતા નથી.

આગળ, આ 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 પદ્ધતિ નાપસંદ કરવામાં આવી છે). પરંતુ તમે હજુ સુધી aggregate() નું KTable સંસ્કરણ જોયું નથી, તેથી અમે તેની ચર્ચા કરવા માટે થોડો સમય પસાર કરીશું.

જેમ તમને યાદ છે, KTable ને જે અલગ બનાવે છે તે એ છે કે સમાન કી સાથેના રેકોર્ડને અપડેટ ગણવામાં આવે છે. KTable જૂની એન્ટ્રીને નવી એન્ટ્રી સાથે બદલે છે. એકત્રીકરણ એ જ રીતે થાય છે: સમાન કી સાથે નવીનતમ રેકોર્ડ્સ એકત્ર કરવામાં આવે છે. જ્યારે કોઈ રેકોર્ડ આવે છે, ત્યારે તેને એડડર (એગ્રિગેટ મેથડ કોલમાં બીજું પેરામીટર) નો ઉપયોગ કરીને FixedSizePriorityQueue ક્લાસ ઈન્સ્ટન્સમાં ઉમેરવામાં આવે છે, પરંતુ જો તે જ કી સાથે બીજો રેકોર્ડ પહેલેથી અસ્તિત્વમાં હોય, તો બાદબાકીનો ઉપયોગ કરીને જૂનો રેકોર્ડ દૂર કરવામાં આવે છે (ત્રીજું પેરામીટર એકંદર પદ્ધતિ કૉલ).

આ બધાનો અર્થ એ છે કે અમારું એગ્રીગેટર, FixedSizePriorityQueue, તમામ મૂલ્યોને એક કી વડે એકત્ર કરતું નથી, પરંતુ N સૌથી વધુ ટ્રેડેડ પ્રકારના શેરોના જથ્થાનો મૂવિંગ સરવાળો સંગ્રહિત કરે છે. દરેક ઇનકમિંગ એન્ટ્રીમાં અત્યાર સુધી વેચાયેલા શેરની કુલ સંખ્યા હોય છે. KTable તમને દરેક અપડેટના રોલિંગ એગ્રિગેશનની આવશ્યકતા વિના, હાલમાં કઈ કંપનીઓના શેર સૌથી વધુ ટ્રેડ થાય છે તેની માહિતી આપશે.

અમે બે મહત્વપૂર્ણ વસ્તુઓ કરવાનું શીખ્યા:

• સામાન્ય કી દ્વારા KTable માં જૂથ મૂલ્યો;
• આ જૂથબદ્ધ મૂલ્યો પર રોલઅપ અને એકત્રીકરણ જેવી ઉપયોગી કામગીરી કરો.

કાફકા સ્ટ્રીમ્સ એપ્લીકેશન દ્વારા ખસેડવામાં આવતા ડેટાના અર્થને સમજવા અને તે કઈ માહિતી વહન કરે છે તે સમજવા માટે આ કામગીરી કેવી રીતે કરવી તે જાણવું મહત્વપૂર્ણ છે.

અમે આ પુસ્તકમાં અગાઉ ચર્ચા કરેલી કેટલીક મુખ્ય વિભાવનાઓને પણ સાથે લાવ્યા છીએ. પ્રકરણ 4 માં, અમે ચર્ચા કરી છે કે સ્ટ્રીમિંગ એપ્લિકેશન માટે કેવી રીતે દોષ-સહિષ્ણુ, સ્થાનિક રાજ્ય મહત્વપૂર્ણ છે. આ પ્રકરણમાં પ્રથમ ઉદાહરણ દર્શાવ્યું છે કે શા માટે સ્થાનિક રાજ્ય એટલું મહત્વનું છે - તે તમને તમે પહેલાથી કઈ માહિતી જોઈ છે તેનો ટ્રૅક રાખવાની ક્ષમતા આપે છે. સ્થાનિક ઍક્સેસ નેટવર્ક વિલંબને ટાળે છે, એપ્લિકેશનને વધુ કાર્યક્ષમ અને ભૂલ-પ્રતિરોધક બનાવે છે.

કોઈપણ રોલઅપ અથવા એકત્રીકરણ કામગીરી કરતી વખતે, તમારે રાજ્ય સ્ટોરનું નામ સ્પષ્ટ કરવું આવશ્યક છે. રોલઅપ અને એકત્રીકરણ કામગીરી KTable દાખલો આપે છે, અને KTable જૂના પરિણામોને નવા સાથે બદલવા માટે સ્ટેટ સ્ટોરેજનો ઉપયોગ કરે છે. તમે જોયું તેમ, તમામ અપડેટ્સ પાઈપલાઈન નીચે મોકલવામાં આવતા નથી, અને આ અગત્યનું છે કારણ કે એકત્રીકરણ કામગીરી સારાંશ માહિતી ઉત્પન્ન કરવા માટે રચાયેલ છે. જો તમે સ્થાનિક સ્થિતિ લાગુ ન કરો, તો KTable તમામ એકત્રીકરણ અને રોલઅપ પરિણામોને ફોરવર્ડ કરશે.

આગળ, અમે ચોક્કસ સમયગાળાની અંદર એકત્રીકરણ જેવી કામગીરીઓ પર ધ્યાન આપીશું - કહેવાતા વિન્ડોઇંગ ઓપરેશન્સ.

5.3.2. વિન્ડો કામગીરી

અગાઉના વિભાગમાં, અમે સ્લાઇડિંગ કન્વોલ્યુશન અને એકત્રીકરણ રજૂ કર્યું હતું. એપ્લિકેશને શેરના વેચાણના જથ્થાનું સતત રોલ-અપ કર્યું હતું, ત્યારબાદ એક્સચેન્જ પર સૌથી વધુ ટ્રેડેડ પાંચ શેરોનું એકત્રીકરણ થયું હતું.

ક્યારેક આવા સતત એકત્રીકરણ અને પરિણામોનું રોલ-અપ જરૂરી છે. અને કેટલીકવાર તમારે આપેલ સમયગાળા દરમિયાન જ ઓપરેશન કરવાની જરૂર પડે છે. ઉદાહરણ તરીકે, ગણતરી કરો કે છેલ્લી 10 મિનિટમાં ચોક્કસ કંપનીના શેર સાથે કેટલા વિનિમય વ્યવહારો થયા. અથવા છેલ્લા 15 મિનિટમાં નવા જાહેરાત બેનર પર કેટલા વપરાશકર્તાઓએ ક્લિક કર્યું. એપ્લિકેશન આવી કામગીરી ઘણી વખત કરી શકે છે, પરંતુ પરિણામો સાથે કે જે ફક્ત નિર્દિષ્ટ સમય (સમય વિન્ડો) પર લાગુ થાય છે.

ખરીદનાર દ્વારા વિનિમય વ્યવહારોની ગણતરી

આગલા ઉદાહરણમાં, અમે બહુવિધ વેપારીઓ-કાં તો મોટી સંસ્થાઓ અથવા સ્માર્ટ વ્યક્તિગત ફાઇનાન્સર્સ વચ્ચેના સ્ટોક વ્યવહારોને ટ્રૅક કરીશું.

આ ટ્રેકિંગ માટે બે સંભવિત કારણો છે. તેમાંથી એક એ જાણવાની જરૂર છે કે માર્કેટ લીડર્સ શું ખરીદી/વેચાણ કરી રહ્યા છે. જો આ મોટા ખેલાડીઓ અને અત્યાધુનિક રોકાણકારો તક જુએ છે, તો તેમની વ્યૂહરચનાનું પાલન કરવું અર્થપૂર્ણ છે. બીજું કારણ ગેરકાયદેસર આંતરિક વેપારના કોઈપણ સંભવિત સંકેતો શોધવાની ઇચ્છા છે. આ કરવા માટે, તમારે મહત્વપૂર્ણ પ્રેસ રીલીઝ સાથે મોટા વેચાણના સ્પાઇક્સના સહસંબંધનું વિશ્લેષણ કરવાની જરૂર પડશે.

આવા ટ્રેકિંગમાં નીચેના પગલાંઓ શામેલ છે:

• સ્ટોક-ટ્રાન્ઝેક્શન વિષયમાંથી વાંચન માટે સ્ટ્રીમ બનાવવી;
• ખરીદનાર ID અને સ્ટોક પ્રતીક દ્વારા ઇનકમિંગ રેકોર્ડ્સનું જૂથબદ્ધ કરવું. groupBy પદ્ધતિને કૉલ કરવાથી 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).until(fifteenMinutes)) કૉલ કરીને અમે 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 માં જોવા મળે છે).

એડવાન્સ બાય() પદ્ધતિમાં કૉલ ઉમેરીને ટમ્બલિંગ વિન્ડોને હૉપિંગ વિન્ડોમાં રૂપાંતરિત કરી શકાય છે. બતાવેલ ઉદાહરણમાં, બચત અંતરાલ 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 દાખલામાંથી TransactionSummary ઑબ્જેક્ટ પુનઃપ્રાપ્ત કરો.

અમે આ ઑપરેશન્સને નીચે પ્રમાણે એકસાથે સાંકળશું (કોડ 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) માં મળી શકે છે.

એ નોંધવું યોગ્ય છે કે કોઈ Serde ઑબ્જેક્ટ્સનો ઉલ્લેખ કરવાની જરૂર નથી, કારણ કે સ્ટ્રિંગ Serdes સેટિંગમાં વપરાય છે. ઉપરાંત, પ્રારંભિક ગણતરીનો ઉપયોગ કરીને, કોષ્ટક ખૂબ જ શરૂઆતમાં રેકોર્ડ્સથી ભરેલું છે.

હવે આપણે અંતિમ પગલું - જોડાણ પર આગળ વધી શકીએ છીએ.

ટ્રાન્ઝેક્શન કાઉન્ટ ડેટા સાથે સમાચાર અપડેટ્સને કનેક્ટ કરવું

કનેક્શન બનાવવું મુશ્કેલ નથી. જો સંબંધિત ઉદ્યોગ માટે કોઈ સ્ટોક સમાચાર ન હોય તો અમે ડાબા જોડાણનો ઉપયોગ કરીશું (જરૂરી કોડ ફાઇલ src/main/java/bbejeck/chapter_5/CountingWindowingAndKtableJoinExample.java) (લિસ્ટિંગ 5.10) માં મળી શકે છે.

આ લેફ્ટજોઇન ઓપરેટર એકદમ સરળ છે. પ્રકરણ 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 ઑબ્જેક્ટનો ઉપયોગ કરી શકો છો. ગ્લોબલકેટેબલ્સ દરેક કાફકા સ્ટ્રીમ્સ એપ્લિકેશન નોડ પર તમામ પાર્ટીશનોની નકલ કરે છે, ખાતરી કરે છે કે તમામ ડેટા ઉપલબ્ધ છે તેની અનુલક્ષીને કી કયા પાર્ટીશનને અનુરૂપ છે.

આગળ આપણે કાફકા સ્ટ્રીમ્સ ફીચર જોઈશું, જેના કારણે આપણે કાફકા વિષયના ડેટાનો ઉપયોગ કર્યા વિના રાજ્યના ફેરફારોનું અવલોકન કરી શકીએ છીએ.

5.3.5. પ્રશ્નાર્થ સ્થિતિ

અમે પહેલાથી જ રાજ્યને સંડોવતા ઘણા ઓપરેશનો કર્યા છે અને હંમેશા પરિણામોને કન્સોલ પર આઉટપુટ કરીએ છીએ (વિકાસ હેતુઓ માટે) અથવા તેમને વિષય પર (ઉત્પાદનના હેતુઓ માટે) લખીએ છીએ. કોઈ વિષય પર પરિણામો લખતી વખતે, તમારે તેમને જોવા માટે કાફકા ઉપભોક્તાનો ઉપયોગ કરવો પડશે.

આ વિષયોમાંથી ડેટા વાંચવું એ એક પ્રકારનું ભૌતિક દૃષ્ટિકોણ ગણી શકાય. અમારા હેતુઓ માટે, અમે વિકિપીડિયામાંથી મટીરિયલાઇઝ્ડ વ્યૂની વ્યાખ્યાનો ઉપયોગ કરી શકીએ છીએ: “...એક ભૌતિક ડેટાબેઝ ઑબ્જેક્ટ જેમાં ક્વેરીનાં પરિણામો હોય છે. ઉદાહરણ તરીકે, તે રિમોટ ડેટાની સ્થાનિક નકલ, અથવા કોષ્ટકની પંક્તિઓ અને/અથવા કૉલમનો સબસેટ અથવા જોડાવાના પરિણામો, અથવા એકત્રીકરણ દ્વારા મેળવેલ સારાંશ કોષ્ટક હોઈ શકે છે" (https://en.wikipedia.org/wiki /Materialized_view).

કાફકા સ્ટ્રીમ્સ તમને સ્ટેટ સ્ટોર્સ પર ઇન્ટરેક્ટિવ ક્વેરીઝ ચલાવવાની પણ મંજૂરી આપે છે, જેનાથી તમે આ મટીરિયલાઇઝ્ડ વ્યૂઝને સીધા વાંચી શકો છો. એ નોંધવું અગત્યનું છે કે સ્ટેટ સ્ટોરની ક્વેરી એ ફક્ત વાંચવા માટેની કામગીરી છે. આ સુનિશ્ચિત કરે છે કે જ્યારે તમારી એપ્લિકેશન ડેટા પર પ્રક્રિયા કરી રહી હોય ત્યારે તમારે આકસ્મિક રીતે રાજ્યને અસંગત બનાવવાની ચિંતા કરવાની જરૂર નથી.

રાજ્ય સ્ટોર્સની સીધી ક્વેરી કરવાની ક્ષમતા મહત્વપૂર્ણ છે. આનો અર્થ એ છે કે તમે પહેલા કાફકા ગ્રાહક પાસેથી ડેટા મેળવ્યા વિના ડેશબોર્ડ એપ્લિકેશન્સ બનાવી શકો છો. તે એપ્લિકેશનની કાર્યક્ષમતામાં પણ વધારો કરે છે, તે હકીકતને કારણે કે ફરીથી ડેટા લખવાની જરૂર નથી:

• ડેટાની સ્થાનિકતાને આભાર, તેઓ ઝડપથી એક્સેસ કરી શકાય છે;
• ડેટાનું ડુપ્લિકેશન દૂર કરવામાં આવે છે, કારણ કે તે બાહ્ય સ્ટોરેજ પર લખાયેલું નથી.

મુખ્ય વસ્તુ જે હું તમને યાદ રાખવા માંગુ છું તે એ છે કે તમે તમારી એપ્લિકેશનની અંદરથી જ સ્ટેટ ક્વેરી કરી શકો છો. આ તમને જે તકો આપે છે તે વધારે પડતું કહી શકાય નહીં. કાફકાના ડેટાનો ઉપયોગ કરવા અને એપ્લિકેશન માટે ડેટાબેઝમાં રેકોર્ડ્સ સ્ટોર કરવાને બદલે, તમે સમાન પરિણામ સાથે સ્ટેટ સ્ટોર્સને ક્વેરી કરી શકો છો. રાજ્ય સ્ટોર્સ પર સીધી ક્વેરીઝનો અર્થ ઓછો કોડ (કોઈ ગ્રાહક નથી) અને ઓછા સોફ્ટવેર (પરિણામોને સંગ્રહિત કરવા માટે ડેટાબેઝ ટેબલની જરૂર નથી).

અમે આ પ્રકરણમાં થોડી જમીન આવરી લીધી છે, તેથી અમે હમણાં માટે રાજ્યના સ્ટોર્સ સામે ઇન્ટરેક્ટિવ પ્રશ્નોની અમારી ચર્ચા છોડીશું. પરંતુ ચિંતા કરશો નહીં: પ્રકરણ 9 માં, અમે ઇન્ટરેક્ટિવ પ્રશ્નો સાથે એક સરળ ડેશબોર્ડ એપ્લિકેશન બનાવીશું. તે ઇન્ટરેક્ટિવ ક્વેરીઝ દર્શાવવા માટે આ અને અગાઉના પ્રકરણોમાંથી કેટલાક ઉદાહરણોનો ઉપયોગ કરશે અને તમે તેને કાફકા સ્ટ્રીમ્સ એપ્લિકેશન્સમાં કેવી રીતે ઉમેરી શકો છો.

સારાંશ

• KStream ઑબ્જેક્ટ્સ ડેટાબેઝમાં દાખલ કરવા સાથે તુલનાત્મક, ઘટનાઓના પ્રવાહોનું પ્રતિનિધિત્વ કરે છે. KTable ઑબ્જેક્ટ અપડેટ સ્ટ્રીમ્સનું પ્રતિનિધિત્વ કરે છે, જેમ કે ડેટાબેઝના અપડેટ્સ. KTable ઑબ્જેક્ટનું કદ વધતું નથી, જૂના રેકોર્ડ્સ નવા દ્વારા બદલવામાં આવે છે.
• એકત્રીકરણ કામગીરી માટે KTable ઑબ્જેક્ટ આવશ્યક છે.
• વિન્ડોઇંગ ઓપરેશન્સનો ઉપયોગ કરીને, તમે એકીકૃત ડેટાને ટાઇમ બકેટમાં વિભાજિત કરી શકો છો.
• GlobalKTable ઑબ્જેક્ટ્સ માટે આભાર, તમે પાર્ટીશનને ધ્યાનમાં લીધા વિના એપ્લિકેશનમાં ગમે ત્યાં સંદર્ભ ડેટાને ઍક્સેસ કરી શકો છો.
• KStream, KTable અને GlobalKTable ઑબ્જેક્ટ વચ્ચે જોડાણો શક્ય છે.

અત્યાર સુધી, અમે ઉચ્ચ-સ્તરની KStream DSL નો ઉપયોગ કરીને કાફ્કા સ્ટ્રીમ્સ એપ્લિકેશન બનાવવા પર ધ્યાન કેન્દ્રિત કર્યું છે. જો કે ઉચ્ચ-સ્તરનો અભિગમ તમને સુઘડ અને સંક્ષિપ્ત પ્રોગ્રામ્સ બનાવવાની મંજૂરી આપે છે, તેનો ઉપયોગ વેપાર-બંધનું પ્રતિનિધિત્વ કરે છે. DSL KStream સાથે કામ કરવાનો અર્થ છે નિયંત્રણની ડિગ્રી ઘટાડીને તમારા કોડની સંક્ષિપ્તતા વધારવી. આગળના પ્રકરણમાં, અમે નીચા-સ્તરના હેન્ડલર નોડ API ને જોઈશું અને અન્ય ટ્રેડ-ઓફનો પ્રયાસ કરીશું. પ્રોગ્રામ્સ પહેલા કરતા લાંબા હશે, પરંતુ અમે લગભગ કોઈપણ હેન્ડલર નોડ બનાવી શકીશું જેની અમને જરૂર પડી શકે છે.

→ પુસ્તક વિશે વધુ વિગતો અહીં મળી શકે છે પ્રકાશકની વેબસાઇટ

→ Habrozhiteli માટે કૂપનનો ઉપયોગ કરીને 25% ડિસ્કાઉન્ટ - કાફકા સ્ટ્રીમ્સ

→ પુસ્તકના પેપર વર્ઝન માટે ચૂકવણી કરવા પર, ઈલેક્ટ્રોનિક પુસ્તક ઈ-મેલ દ્વારા મોકલવામાં આવશે.

સોર્સ: www.habr.com