ਕਿਤਾਬ "ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਇਨ ਐਕਸ਼ਨ। ਰੀਅਲ-ਟਾਈਮ ਕੰਮ ਲਈ ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼"

ਹੈਲੋ, ਖਾਬਰੋ ਨਿਵਾਸੀਓ! ਇਹ ਕਿਤਾਬ ਕਿਸੇ ਵੀ ਡਿਵੈਲਪਰ ਲਈ ਢੁਕਵੀਂ ਹੈ ਜੋ ਥ੍ਰੈਡ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਸਮਝਣਾ ਚਾਹੁੰਦਾ ਹੈ। ਵਿਤਰਿਤ ਪ੍ਰੋਗਰਾਮਿੰਗ ਨੂੰ ਸਮਝਣਾ ਤੁਹਾਨੂੰ ਕਾਫਕਾ ਅਤੇ ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਨੂੰ ਬਿਹਤਰ ਤਰੀਕੇ ਨਾਲ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ। ਕਾਫਕਾ ਫਰੇਮਵਰਕ ਨੂੰ ਜਾਣਨਾ ਚੰਗਾ ਹੋਵੇਗਾ, ਪਰ ਇਹ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ: ਮੈਂ ਤੁਹਾਨੂੰ ਉਹ ਸਭ ਕੁਝ ਦੱਸਾਂਗਾ ਜਿਸਦੀ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ। ਤਜਰਬੇਕਾਰ ਕਾਫਕਾ ਡਿਵੈਲਪਰ ਅਤੇ ਨਵੇਂ ਲੋਕ ਇਸ ਕਿਤਾਬ ਵਿੱਚ ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿਲਚਸਪ ਸਟ੍ਰੀਮ ਪ੍ਰੋਸੈਸਿੰਗ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਸਿੱਖਣਗੇ। ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਵਰਗੀਆਂ ਧਾਰਨਾਵਾਂ ਤੋਂ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਜਾਣੂ ਇੰਟਰਮੀਡੀਏਟ ਅਤੇ ਐਡਵਾਂਸਡ ਜਾਵਾ ਡਿਵੈਲਪਰ ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਆਪਣੇ ਹੁਨਰ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਸਿੱਖਣਗੇ। ਕਿਤਾਬ ਦਾ ਸਰੋਤ ਕੋਡ Java 8 ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ ਅਤੇ Java 8 lambda ਸਮੀਕਰਨ ਸੰਟੈਕਸ ਦੀ ਮਹੱਤਵਪੂਰਨ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਜਾਣਨਾ ਕਿ ਲੇਮਡਾ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ (ਭਾਵੇਂ ਕਿਸੇ ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ ਵੀ) ਕੰਮ ਆਵੇਗਾ।

ਅੰਸ਼. 5.3 ਏਗਰੀਗੇਸ਼ਨ ਅਤੇ ਵਿੰਡੋਿੰਗ ਓਪਰੇਸ਼ਨ

ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਦੇ ਸਭ ਤੋਂ ਵਧੀਆ ਭਾਗਾਂ ਦੀ ਪੜਚੋਲ ਕਰਨ ਲਈ ਅੱਗੇ ਵਧਾਂਗੇ। ਹੁਣ ਤੱਕ ਅਸੀਂ ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਪਹਿਲੂਆਂ ਨੂੰ ਕਵਰ ਕੀਤਾ ਹੈ:

• ਇੱਕ ਪ੍ਰੋਸੈਸਿੰਗ ਟੋਪੋਲੋਜੀ ਬਣਾਉਣਾ;
• ਸਟ੍ਰੀਮਿੰਗ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਰਾਜ ਦੀ ਵਰਤੋਂ ਕਰਨਾ;
• ਡਾਟਾ ਸਟ੍ਰੀਮ ਕਨੈਕਸ਼ਨਾਂ ਦਾ ਪ੍ਰਦਰਸ਼ਨ;
• ਇਵੈਂਟ ਸਟ੍ਰੀਮ (KStream) ਅਤੇ ਅੱਪਡੇਟ ਸਟ੍ਰੀਮ (KTable) ਵਿਚਕਾਰ ਅੰਤਰ।

ਹੇਠ ਲਿਖੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਅਸੀਂ ਇਹਨਾਂ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਇਕੱਠੇ ਲਿਆਵਾਂਗੇ। ਤੁਸੀਂ ਵਿੰਡੋਿੰਗ ਬਾਰੇ ਵੀ ਸਿੱਖੋਗੇ, ਸਟ੍ਰੀਮਿੰਗ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਇੱਕ ਹੋਰ ਵਧੀਆ ਵਿਸ਼ੇਸ਼ਤਾ। ਸਾਡੀ ਪਹਿਲੀ ਉਦਾਹਰਣ ਇੱਕ ਸਧਾਰਨ ਇਕੱਤਰਤਾ ਹੋਵੇਗੀ।

5.3.1 ਉਦਯੋਗ ਖੇਤਰ ਦੁਆਰਾ ਸਟਾਕ ਦੀ ਵਿਕਰੀ ਦਾ ਏਕੀਕਰਨ

ਸਟ੍ਰੀਮਿੰਗ ਡੇਟਾ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਏਗਰੀਗੇਸ਼ਨ ਅਤੇ ਗਰੁੱਪਿੰਗ ਮਹੱਤਵਪੂਰਨ ਸਾਧਨ ਹਨ। ਵਿਅਕਤੀਗਤ ਰਿਕਾਰਡਾਂ ਦੀ ਜਾਂਚ ਜਿਵੇਂ ਕਿ ਉਹ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ, ਅਕਸਰ ਨਾਕਾਫ਼ੀ ਹੁੰਦੀ ਹੈ। ਡੇਟਾ ਤੋਂ ਵਾਧੂ ਜਾਣਕਾਰੀ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ ਲਈ, ਉਹਨਾਂ ਨੂੰ ਸਮੂਹ ਅਤੇ ਜੋੜਨਾ ਜ਼ਰੂਰੀ ਹੈ.

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਦਿਨ ਵਪਾਰੀ ਦੀ ਪੁਸ਼ਾਕ ਪਾਓਗੇ ਜਿਸਨੂੰ ਕਈ ਉਦਯੋਗਾਂ ਵਿੱਚ ਕੰਪਨੀਆਂ ਦੇ ਸਟਾਕਾਂ ਦੀ ਵਿਕਰੀ ਦੀ ਮਾਤਰਾ ਨੂੰ ਟਰੈਕ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਤੁਸੀਂ ਹਰੇਕ ਉਦਯੋਗ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਸ਼ੇਅਰ ਵਿਕਰੀ ਵਾਲੀਆਂ ਪੰਜ ਕੰਪਨੀਆਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ।

ਅਜਿਹੇ ਏਕੀਕਰਣ ਲਈ ਡੇਟਾ ਨੂੰ ਲੋੜੀਂਦੇ ਰੂਪ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਕਈ ਕਦਮਾਂ ਦੀ ਲੋੜ ਹੋਵੇਗੀ (ਆਮ ਸ਼ਬਦਾਂ ਵਿੱਚ ਬੋਲਣਾ)।

1. ਇੱਕ ਵਿਸ਼ਾ-ਆਧਾਰਿਤ ਸਰੋਤ ਬਣਾਓ ਜੋ ਕੱਚੇ ਸਟਾਕ ਵਪਾਰ ਦੀ ਜਾਣਕਾਰੀ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਸਾਨੂੰ ShareVolume ਕਿਸਮ ਦੀ ਵਸਤੂ ਨਾਲ ਸਟਾਕ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਕਿਸਮ ਦੀ ਵਸਤੂ ਦਾ ਨਕਸ਼ਾ ਬਣਾਉਣਾ ਹੋਵੇਗਾ। ਬਿੰਦੂ ਇਹ ਹੈ ਕਿ ਸਟਾਕ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਆਬਜੈਕਟ ਵਿੱਚ ਵਿਕਰੀ ਮੈਟਾਡੇਟਾ ਸ਼ਾਮਲ ਹੈ, ਪਰ ਸਾਨੂੰ ਸਿਰਫ ਵੇਚੇ ਜਾ ਰਹੇ ਸ਼ੇਅਰਾਂ ਦੀ ਸੰਖਿਆ ਬਾਰੇ ਡੇਟਾ ਦੀ ਲੋੜ ਹੈ।
2. ਸ਼ੇਅਰ ਵੌਲਯੂਮ ਡੇਟਾ ਨੂੰ ਸਟਾਕ ਪ੍ਰਤੀਕ ਦੁਆਰਾ ਸਮੂਹ ਕਰੋ। ਇੱਕ ਵਾਰ ਪ੍ਰਤੀਕ ਦੁਆਰਾ ਸਮੂਹ ਕੀਤੇ ਜਾਣ 'ਤੇ, ਤੁਸੀਂ ਇਸ ਡੇਟਾ ਨੂੰ ਸਟਾਕ ਵਿਕਰੀ ਵਾਲੀਅਮ ਦੇ ਉਪ-ਜੋੜ ਤੱਕ ਸਮੇਟ ਸਕਦੇ ਹੋ। ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ KStream.groupBy ਢੰਗ KGroupedStream ਕਿਸਮ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਦਿੰਦਾ ਹੈ। ਅਤੇ ਤੁਸੀਂ KGroupedStream.reduce ਵਿਧੀ ਨੂੰ ਅੱਗੇ ਕਾਲ ਕਰਕੇ KTable ਉਦਾਹਰਨ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।

ਕੇ-ਗਰੁੱਪਡਸਟ੍ਰੀਮ ਇੰਟਰਫੇਸ ਕੀ ਹੈ

KStream.groupBy ਅਤੇ KStream.groupByKey ਢੰਗ KGroupedStream ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਵਾਪਸ ਕਰਦੇ ਹਨ। ਕੇ. ਇਹ ਇਸਦੇ ਨਾਲ ਸਿੱਧੇ ਕੰਮ ਲਈ ਬਿਲਕੁਲ ਨਹੀਂ ਹੈ. ਇਸਦੀ ਬਜਾਏ, KGroupedStream ਨੂੰ ਐਗਰੀਗੇਸ਼ਨ ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਸਦਾ ਨਤੀਜਾ ਹਮੇਸ਼ਾ ਕੇ-ਟੇਬਲ ਹੁੰਦਾ ਹੈ। ਅਤੇ ਕਿਉਂਕਿ ਐਗਰੀਗੇਸ਼ਨ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਨਤੀਜਾ ਇੱਕ 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। ਦੋਵੇਂ ਇੱਕ ਕੇ-ਗਰੁੱਪਡ ਟੇਬਲ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਇਸਲਈ ਤੁਸੀਂ ਸ਼ਾਇਦ ਸੋਚ ਰਹੇ ਹੋਵੋਗੇ ਕਿ ਇਹਨਾਂ ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ ਅਤੇ ਕਿਸਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਨੀ ਹੈ?

GroupByKey ਢੰਗ ਉਦੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ KStream ਵਿੱਚ ਕੁੰਜੀਆਂ ਪਹਿਲਾਂ ਹੀ ਖਾਲੀ ਨਹੀਂ ਹੁੰਦੀਆਂ ਹਨ। ਅਤੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ, "ਮੁੜ-ਵਿਭਾਜਨ ਦੀ ਲੋੜ ਹੈ" ਫਲੈਗ ਕਦੇ ਵੀ ਸੈੱਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ।

GroupBy ਢੰਗ ਇਹ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਗਰੁੱਪਿੰਗ ਕੁੰਜੀਆਂ ਬਦਲ ਦਿੱਤੀਆਂ ਹਨ, ਇਸਲਈ ਮੁੜ-ਵਿਭਾਜਨ ਫਲੈਗ ਸਹੀ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ। GroupBy ਵਿਧੀ ਤੋਂ ਬਾਅਦ ਜੁਆਇਨ, ਏਗਰੀਗੇਸ਼ਨ ਆਦਿ ਕਰਨ ਨਾਲ ਆਟੋਮੈਟਿਕ ਰੀ-ਵਿਭਾਜਨ ਹੋ ਜਾਵੇਗਾ।
ਸੰਖੇਪ: ਜਦੋਂ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਤੁਹਾਨੂੰ GroupBy ਦੀ ਬਜਾਏ GroupByKey ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ mapValues ​​ਅਤੇ groupBy ਢੰਗ ਕੀ ਕਰਦੇ ਹਨ, ਇਸ ਲਈ ਆਓ sum() ਵਿਧੀ (src/main/java/bbejeck/model/ShareVolume.java ਵਿੱਚ ਪਾਇਆ ਗਿਆ) (ਸੂਚੀ 5.3) 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ।

ShareVolume.sum ਵਿਧੀ ਸਟਾਕ ਵਿਕਰੀ ਵਾਲੀਅਮ ਦੇ ਚੱਲ ਰਹੇ ਕੁੱਲ ਨੂੰ ਵਾਪਸ ਕਰਦੀ ਹੈ, ਅਤੇ ਗਣਨਾ ਦੀ ਪੂਰੀ ਲੜੀ ਦਾ ਨਤੀਜਾ ਇੱਕ KTable ਵਸਤੂ ਹੈ। . ਹੁਣ ਤੁਸੀਂ KTable ਦੀ ਭੂਮਿਕਾ ਨੂੰ ਸਮਝਦੇ ਹੋ। ਜਦੋਂ ShareVolume ਆਬਜੈਕਟ ਆਉਂਦੇ ਹਨ, ਤਾਂ ਸੰਬੰਧਿਤ KTable ਆਬਜੈਕਟ ਨਵੀਨਤਮ ਮੌਜੂਦਾ ਅੱਪਡੇਟ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਇਹ ਯਾਦ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਸਾਰੇ ਅੱਪਡੇਟ ਪਿਛਲੇ ਸ਼ੇਅਰਵੋਲਯੂਮਕੇਟੇਬਲ ਵਿੱਚ ਪ੍ਰਤੀਬਿੰਬਿਤ ਹੁੰਦੇ ਹਨ, ਪਰ ਸਾਰੇ ਅੱਗੇ ਨਹੀਂ ਭੇਜੇ ਜਾਂਦੇ ਹਨ।

ਫਿਰ ਅਸੀਂ ਇਸ ਕੇਟੇਬਲ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਉਦਯੋਗ ਵਿੱਚ ਵਪਾਰ ਕੀਤੇ ਸ਼ੇਅਰਾਂ ਦੀ ਸਭ ਤੋਂ ਵੱਧ ਮਾਤਰਾ ਵਾਲੀਆਂ ਪੰਜ ਕੰਪਨੀਆਂ ਤੱਕ ਪਹੁੰਚਣ ਲਈ (ਵਪਾਰ ਕੀਤੇ ਸ਼ੇਅਰਾਂ ਦੀ ਸੰਖਿਆ ਦੁਆਰਾ) ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ ਕਰਦੇ ਹਾਂ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਸਾਡੀਆਂ ਕਾਰਵਾਈਆਂ ਪਹਿਲੀ ਇਕੱਤਰਤਾ ਦੇ ਸਮਾਨ ਹੋਣਗੀਆਂ।

1. ਉਦਯੋਗ ਦੁਆਰਾ ਵਿਅਕਤੀਗਤ ਸ਼ੇਅਰ ਵਾਲੀਅਮ ਵਸਤੂਆਂ ਨੂੰ ਸਮੂਹ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਸਮੂਹ ਦੁਆਰਾ ਕਾਰਵਾਈ ਕਰੋ।
2. ShareVolume ਵਸਤੂਆਂ ਦਾ ਸਾਰ ਦੇਣਾ ਸ਼ੁਰੂ ਕਰੋ। ਇਸ ਵਾਰ ਐਗਰੀਗੇਸ਼ਨ ਆਬਜੈਕਟ ਇੱਕ ਸਥਿਰ-ਆਕਾਰ ਦੀ ਤਰਜੀਹ ਕਤਾਰ ਹੈ। ਇਸ ਨਿਸ਼ਚਿਤ-ਆਕਾਰ ਦੀ ਕਤਾਰ ਵਿੱਚ, ਸਿਰਫ ਪੰਜ ਕੰਪਨੀਆਂ ਹੀ ਬਰਕਰਾਰ ਹਨ ਜਿਨ੍ਹਾਂ ਦੇ ਸ਼ੇਅਰਾਂ ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਮਾਤਰਾ ਵੇਚੀ ਗਈ ਹੈ।
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, ਇੱਕ ਕੁੰਜੀ ਨਾਲ ਸਾਰੇ ਮੁੱਲਾਂ ਨੂੰ ਇਕੱਠਾ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਪਰ N ਸਭ ਤੋਂ ਵੱਧ ਵਪਾਰ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਸਟਾਕਾਂ ਦੀਆਂ ਮਾਤਰਾਵਾਂ ਦੀ ਇੱਕ ਚਲਦੀ ਰਕਮ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਹਰੇਕ ਆਉਣ ਵਾਲੀ ਐਂਟਰੀ ਵਿੱਚ ਹੁਣ ਤੱਕ ਵੇਚੇ ਗਏ ਸ਼ੇਅਰਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਸ਼ਾਮਲ ਹੈ। KTable ਤੁਹਾਨੂੰ ਇਸ ਬਾਰੇ ਜਾਣਕਾਰੀ ਦੇਵੇਗਾ ਕਿ ਕਿਹੜੀਆਂ ਕੰਪਨੀਆਂ ਦੇ ਸ਼ੇਅਰ ਇਸ ਸਮੇਂ ਸਭ ਤੋਂ ਵੱਧ ਵਪਾਰ ਕਰ ਰਹੇ ਹਨ, ਹਰੇਕ ਅਪਡੇਟ ਦੇ ਰੋਲਿੰਗ ਏਗਰੀਗੇਸ਼ਨ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ।

ਅਸੀਂ ਦੋ ਮਹੱਤਵਪੂਰਨ ਗੱਲਾਂ ਕਰਨੀਆਂ ਸਿੱਖੀਆਂ:

• ਇੱਕ ਆਮ ਕੁੰਜੀ ਦੁਆਰਾ KTable ਵਿੱਚ ਗਰੁੱਪ ਮੁੱਲ;
• ਇਹਨਾਂ ਸਮੂਹਿਕ ਮੁੱਲਾਂ 'ਤੇ ਰੋਲਅਪ ਅਤੇ ਐਗਰੀਗੇਸ਼ਨ ਵਰਗੇ ਉਪਯੋਗੀ ਓਪਰੇਸ਼ਨ ਕਰਦੇ ਹਨ।

ਇਹ ਜਾਣਨਾ ਕਿ ਇਹਨਾਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਕਿਵੇਂ ਕਰਨਾ ਹੈ, ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਐਪਲੀਕੇਸ਼ਨ ਦੁਆਰਾ ਜਾਣ ਵਾਲੇ ਡੇਟਾ ਦੇ ਅਰਥ ਨੂੰ ਸਮਝਣ ਅਤੇ ਇਹ ਸਮਝਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਇਹ ਕਿਹੜੀ ਜਾਣਕਾਰੀ ਰੱਖਦਾ ਹੈ।

ਅਸੀਂ ਇਸ ਕਿਤਾਬ ਵਿੱਚ ਪਹਿਲਾਂ ਵਿਚਾਰੀਆਂ ਗਈਆਂ ਕੁਝ ਮੁੱਖ ਧਾਰਨਾਵਾਂ ਨੂੰ ਵੀ ਇਕੱਠਾ ਕੀਤਾ ਹੈ। ਅਧਿਆਇ 4 ਵਿੱਚ, ਅਸੀਂ ਚਰਚਾ ਕੀਤੀ ਹੈ ਕਿ ਸਟ੍ਰੀਮਿੰਗ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਨੁਕਸ-ਸਹਿਣਸ਼ੀਲ, ਸਥਾਨਕ ਰਾਜ ਕਿੰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇਸ ਅਧਿਆਇ ਵਿੱਚ ਪਹਿਲੀ ਉਦਾਹਰਨ ਨੇ ਦਿਖਾਇਆ ਕਿ ਸਥਾਨਕ ਰਾਜ ਇੰਨਾ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ—ਇਹ ਤੁਹਾਨੂੰ ਉਸ ਜਾਣਕਾਰੀ ਨੂੰ ਟਰੈਕ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਦਿੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਦੇਖ ਚੁੱਕੇ ਹੋ। ਸਥਾਨਕ ਪਹੁੰਚ ਨੈੱਟਵਰਕ ਦੇਰੀ ਤੋਂ ਬਚਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਵਧੇਰੇ ਪ੍ਰਦਰਸ਼ਨਕਾਰੀ ਅਤੇ ਤਰੁੱਟੀ-ਰੋਧਕ ਬਣਾਉਂਦੀ ਹੈ।

ਕਿਸੇ ਵੀ ਰੋਲਅੱਪ ਜਾਂ ਐਗਰੀਗੇਸ਼ਨ ਓਪਰੇਸ਼ਨ ਨੂੰ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਸਟੇਟ ਸਟੋਰ ਦਾ ਨਾਮ ਜ਼ਰੂਰ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਰੋਲਅੱਪ ਅਤੇ ਐਗਰੀਗੇਸ਼ਨ ਓਪਰੇਸ਼ਨ ਇੱਕ KTable ਉਦਾਹਰਨ ਦਿੰਦਾ ਹੈ, ਅਤੇ KTable ਪੁਰਾਣੇ ਨਤੀਜਿਆਂ ਨੂੰ ਨਵੇਂ ਨਾਲ ਬਦਲਣ ਲਈ ਸਟੇਟ ਸਟੋਰੇਜ਼ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖਿਆ ਹੈ, ਸਾਰੇ ਅੱਪਡੇਟ ਪਾਈਪਲਾਈਨ ਹੇਠਾਂ ਨਹੀਂ ਭੇਜੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਏਗਰੀਗੇਸ਼ਨ ਓਪਰੇਸ਼ਨ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਪੈਦਾ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ਲੋਕਲ ਸਟੇਟ ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕਰਦੇ ਹੋ, ਤਾਂ KTable ਸਾਰੇ ਏਕੀਕਰਣ ਅਤੇ ਰੋਲਅੱਪ ਨਤੀਜਿਆਂ ਨੂੰ ਅੱਗੇ ਭੇਜ ਦੇਵੇਗਾ।

ਅੱਗੇ, ਅਸੀਂ ਇੱਕ ਖਾਸ ਸਮੇਂ ਦੇ ਅੰਦਰ ਏਗਰੀਗੇਸ਼ਨ ਵਰਗੇ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਵੇਖਾਂਗੇ - ਅਖੌਤੀ ਵਿੰਡੋਿੰਗ ਓਪਰੇਸ਼ਨ।

5.3.2 ਵਿੰਡੋ ਓਪਰੇਸ਼ਨ

ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਸਲਾਈਡਿੰਗ ਕਨਵੋਲਿਊਸ਼ਨ ਅਤੇ ਏਗਰੀਗੇਸ਼ਨ ਨੂੰ ਪੇਸ਼ ਕੀਤਾ ਹੈ। ਐਪਲੀਕੇਸ਼ਨ ਨੇ ਐਕਸਚੇਂਜ 'ਤੇ ਪੰਜ ਸਭ ਤੋਂ ਵੱਧ ਵਪਾਰ ਕੀਤੇ ਸਟਾਕਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਤੋਂ ਬਾਅਦ ਸਟਾਕ ਦੀ ਵਿਕਰੀ ਦਾ ਲਗਾਤਾਰ ਰੋਲ-ਅੱਪ ਕੀਤਾ।

ਕਦੇ-ਕਦਾਈਂ ਅਜਿਹੇ ਲਗਾਤਾਰ ਇਕੱਠੇ ਹੋਣਾ ਅਤੇ ਨਤੀਜਿਆਂ ਦਾ ਰੋਲ-ਅੱਪ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ। ਅਤੇ ਕਈ ਵਾਰ ਤੁਹਾਨੂੰ ਸਿਰਫ ਇੱਕ ਦਿੱਤੇ ਸਮੇਂ ਦੇ ਦੌਰਾਨ ਓਪਰੇਸ਼ਨ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਗਣਨਾ ਕਰੋ ਕਿ ਪਿਛਲੇ 10 ਮਿੰਟਾਂ ਵਿੱਚ ਕਿਸੇ ਖਾਸ ਕੰਪਨੀ ਦੇ ਸ਼ੇਅਰਾਂ ਨਾਲ ਕਿੰਨੇ ਐਕਸਚੇਂਜ ਲੈਣ-ਦੇਣ ਕੀਤੇ ਗਏ ਸਨ। ਜਾਂ ਪਿਛਲੇ 15 ਮਿੰਟਾਂ ਵਿੱਚ ਕਿੰਨੇ ਉਪਭੋਗਤਾਵਾਂ ਨੇ ਇੱਕ ਨਵੇਂ ਵਿਗਿਆਪਨ ਬੈਨਰ 'ਤੇ ਕਲਿੱਕ ਕੀਤਾ। ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਕਈ ਵਾਰ ਅਜਿਹੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰ ਸਕਦੀ ਹੈ, ਪਰ ਉਹਨਾਂ ਨਤੀਜਿਆਂ ਦੇ ਨਾਲ ਜੋ ਸਿਰਫ਼ ਨਿਸ਼ਚਿਤ ਸਮੇਂ (ਸਮਾਂ ਵਿੰਡੋਜ਼) 'ਤੇ ਲਾਗੂ ਹੁੰਦੇ ਹਨ।

ਖਰੀਦਦਾਰ ਦੁਆਰਾ ਐਕਸਚੇਂਜ ਲੈਣ-ਦੇਣ ਦੀ ਗਿਣਤੀ

ਅਗਲੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਤੋਂ ਵੱਧ ਵਪਾਰੀਆਂ ਵਿੱਚ ਸਟਾਕ ਲੈਣ-ਦੇਣ ਨੂੰ ਟਰੈਕ ਕਰਾਂਗੇ—ਜਾਂ ਤਾਂ ਵੱਡੀਆਂ ਸੰਸਥਾਵਾਂ ਜਾਂ ਸਮਾਰਟ ਵਿਅਕਤੀਗਤ ਫਾਈਨਾਂਸਰ।

ਇਸ ਟਰੈਕਿੰਗ ਦੇ ਦੋ ਸੰਭਵ ਕਾਰਨ ਹਨ। ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਇਹ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਮਾਰਕੀਟ ਲੀਡਰ ਕੀ ਖਰੀਦ/ਵੇਚ ਰਹੇ ਹਨ। ਜੇ ਇਹ ਵੱਡੇ ਖਿਡਾਰੀ ਅਤੇ ਸੂਝਵਾਨ ਨਿਵੇਸ਼ਕ ਮੌਕਾ ਦੇਖਦੇ ਹਨ, ਤਾਂ ਇਹ ਉਹਨਾਂ ਦੀ ਰਣਨੀਤੀ ਦੀ ਪਾਲਣਾ ਕਰਨਾ ਸਮਝਦਾਰ ਹੈ. ਦੂਜਾ ਕਾਰਨ ਗੈਰ-ਕਾਨੂੰਨੀ ਅੰਦਰੂਨੀ ਵਪਾਰ ਦੇ ਕਿਸੇ ਵੀ ਸੰਭਾਵੀ ਸੰਕੇਤ ਨੂੰ ਲੱਭਣ ਦੀ ਇੱਛਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰੈਸ ਰਿਲੀਜ਼ਾਂ ਦੇ ਨਾਲ ਵੱਡੇ ਵਿਕਰੀ ਸਪਾਈਕਸ ਦੇ ਸਬੰਧਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ.

ਅਜਿਹੇ ਟਰੈਕਿੰਗ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਕਦਮ ਹੁੰਦੇ ਹਨ:

• ਸਟਾਕ-ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿਸ਼ੇ ਤੋਂ ਪੜ੍ਹਨ ਲਈ ਇੱਕ ਸਟ੍ਰੀਮ ਬਣਾਉਣਾ;
• ਖਰੀਦਦਾਰ ਆਈਡੀ ਅਤੇ ਸਟਾਕ ਪ੍ਰਤੀਕ ਦੁਆਰਾ ਆਉਣ ਵਾਲੇ ਰਿਕਾਰਡਾਂ ਦਾ ਸਮੂਹ ਕਰਨਾ। ਗਰੁੱਪਬਾਈ ਢੰਗ ਨੂੰ ਕਾਲ ਕਰਨ ਨਾਲ ਕੇ-ਗਰੁੱਪਡਸਟ੍ਰੀਮ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਮਿਲਦੀ ਹੈ;
• 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(20Minutes)) ਨੂੰ ਕਾਲ ਕਰਕੇ ਅਸੀਂ 15 ਸਕਿੰਟਾਂ ਦੇ ਅਕਿਰਿਆਸ਼ੀਲਤਾ ਅੰਤਰਾਲ ਅਤੇ 20 ਮਿੰਟਾਂ ਦੇ ਨਿਰੰਤਰ ਅੰਤਰਾਲ ਦੇ ਨਾਲ ਇੱਕ ਸੈਸ਼ਨ ਵਿੰਡੋ ਬਣਾਉਂਦੇ ਹਾਂ। 20 ਸਕਿੰਟਾਂ ਦੇ ਇੱਕ ਨਿਸ਼ਕਿਰਿਆ ਅੰਤਰਾਲ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਕੋਈ ਵੀ ਐਂਟਰੀ ਸ਼ਾਮਲ ਹੋਵੇਗੀ ਜੋ ਮੌਜੂਦਾ ਸੈਸ਼ਨ ਦੇ ਅੰਤ ਜਾਂ ਚਾਲੂ ਹੋਣ ਦੇ XNUMX ਸਕਿੰਟਾਂ ਦੇ ਅੰਦਰ ਮੌਜੂਦਾ (ਸਰਗਰਮ) ਸੈਸ਼ਨ ਵਿੱਚ ਆਉਂਦੀ ਹੈ।

ਅੱਗੇ, ਅਸੀਂ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹਾਂ ਕਿ ਸੈਸ਼ਨ ਵਿੰਡੋ ਵਿੱਚ ਕਿਹੜਾ ਐਗਰੀਗੇਸ਼ਨ ਓਪਰੇਸ਼ਨ ਕਰਨ ਦੀ ਲੋੜ ਹੈ - ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਗਿਣਤੀ ਕਰੋ। ਜੇਕਰ ਕੋਈ ਇਨਕਮਿੰਗ ਐਂਟਰੀ ਅਕਿਰਿਆਸ਼ੀਲਤਾ ਵਿੰਡੋ ਤੋਂ ਬਾਹਰ ਆਉਂਦੀ ਹੈ (ਤਾਰੀਖ/ਸਮਾਂ ਸਟੈਂਪ ਦੇ ਕਿਸੇ ਵੀ ਪਾਸੇ), ਐਪਲੀਕੇਸ਼ਨ ਇੱਕ ਨਵਾਂ ਸੈਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ। ਧਾਰਨ ਅੰਤਰਾਲ ਦਾ ਮਤਲਬ ਹੈ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੇਂ ਲਈ ਇੱਕ ਸੈਸ਼ਨ ਨੂੰ ਕਾਇਮ ਰੱਖਣਾ ਅਤੇ ਦੇਰ ਨਾਲ ਡੇਟਾ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਜੋ ਸੈਸ਼ਨ ਦੀ ਅਕਿਰਿਆਸ਼ੀਲਤਾ ਮਿਆਦ ਤੋਂ ਅੱਗੇ ਵਧਦਾ ਹੈ ਪਰ ਫਿਰ ਵੀ ਨੱਥੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਭੇਦ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਨਵੇਂ ਸੈਸ਼ਨ ਦੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਸਮਾਪਤੀ ਸਭ ਤੋਂ ਪੁਰਾਣੀ ਅਤੇ ਨਵੀਨਤਮ ਮਿਤੀ/ਸਮਾਂ ਸਟੈਂਪ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ।

ਆਉ ਇਹ ਦੇਖਣ ਲਈ ਗਿਣਤੀ ਵਿਧੀ ਦੀਆਂ ਕੁਝ ਐਂਟਰੀਆਂ ਨੂੰ ਵੇਖੀਏ ਕਿ ਸੈਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ (ਸਾਰਣੀ 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 ਵਿਧੀ ਕਾਲ ਵਿੱਚ ਇਸ ਛੋਟੀ ਜਿਹੀ ਤਬਦੀਲੀ ਨਾਲ, ਤੁਸੀਂ ਇੱਕ ਟੰਬਲਿੰਗ ਵਿੰਡੋ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਉਦਾਹਰਨ till() ਵਿਧੀ ਨੂੰ ਕਾਲ ਨਹੀਂ ਕਰਦੀ ਹੈ, ਇਸਲਈ 24 ਘੰਟਿਆਂ ਦਾ ਡਿਫੌਲਟ ਧਾਰਨ ਅੰਤਰਾਲ ਵਰਤਿਆ ਜਾਵੇਗਾ।

ਅੰਤ ਵਿੱਚ, ਵਿੰਡੋਜ਼ ਦੇ ਆਖਰੀ ਵਿਕਲਪਾਂ - "ਹੌਪਿੰਗ" ਵਿੰਡੋਜ਼ 'ਤੇ ਜਾਣ ਦਾ ਸਮਾਂ ਆ ਗਿਆ ਹੈ।

ਸਲਾਈਡਿੰਗ ("ਜੰਪਿੰਗ") ਵਿੰਡੋਜ਼

ਸਲਾਈਡਿੰਗ/ਹੌਪਿੰਗ ਵਿੰਡੋਜ਼ ਟੰਬਲਿੰਗ ਵਿੰਡੋਜ਼ ਦੇ ਸਮਾਨ ਹਨ, ਪਰ ਥੋੜੇ ਜਿਹੇ ਫਰਕ ਨਾਲ। ਸਲਾਈਡਿੰਗ ਵਿੰਡੋਜ਼ ਹਾਲ ਹੀ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਇੱਕ ਨਵੀਂ ਵਿੰਡੋ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਸਮਾਂ ਅੰਤਰਾਲ ਦੇ ਅੰਤ ਤੱਕ ਇੰਤਜ਼ਾਰ ਨਹੀਂ ਕਰਦੀਆਂ ਹਨ। ਉਹ ਵਿੰਡੋ ਦੀ ਮਿਆਦ ਤੋਂ ਘੱਟ ਉਡੀਕ ਅੰਤਰਾਲ ਤੋਂ ਬਾਅਦ ਨਵੀਂ ਗਣਨਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।

ਟੰਬਲਿੰਗ ਅਤੇ ਜੰਪਿੰਗ ਵਿੰਡੋਜ਼ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਦਰਸਾਉਣ ਲਈ, ਆਓ ਸਟਾਕ ਐਕਸਚੇਂਜ ਲੈਣ-ਦੇਣ ਦੀ ਗਿਣਤੀ ਕਰਨ ਦੀ ਉਦਾਹਰਨ 'ਤੇ ਵਾਪਸ ਆਓ। ਸਾਡਾ ਟੀਚਾ ਅਜੇ ਵੀ ਲੈਣ-ਦੇਣ ਦੀ ਗਿਣਤੀ ਨੂੰ ਗਿਣਨਾ ਹੈ, ਪਰ ਅਸੀਂ ਕਾਊਂਟਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰੇ ਸਮੇਂ ਦੀ ਉਡੀਕ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦੇ। ਇਸ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਛੋਟੇ ਅੰਤਰਾਲਾਂ 'ਤੇ ਕਾਊਂਟਰ ਨੂੰ ਅਪਡੇਟ ਕਰਾਂਗੇ। ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਅਜੇ ਵੀ ਹਰ 20 ਸਕਿੰਟਾਂ ਵਿੱਚ ਲੈਣ-ਦੇਣ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਕਰਾਂਗੇ, ਪਰ ਹਰ 5 ਸਕਿੰਟਾਂ ਵਿੱਚ ਕਾਊਂਟਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਾਂਗੇ, ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ। 5.15 ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਓਵਰਲੈਪਿੰਗ ਡੇਟਾ ਦੇ ਨਾਲ ਤਿੰਨ ਨਤੀਜੇ ਵਿੰਡੋਜ਼ ਦੇ ਨਾਲ ਖਤਮ ਹੁੰਦੇ ਹਾਂ।

ਸੂਚੀ 5.7 ਸਲਾਈਡਿੰਗ ਵਿੰਡੋਜ਼ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਕੋਡ ਦਿਖਾਉਂਦਾ ਹੈ (src/main/java/bbejeck/chapter_5/CountingWindowingAndKtableJoinExample.java ਵਿੱਚ ਪਾਇਆ ਜਾਂਦਾ ਹੈ)।

ਇੱਕ ਟੰਬਲਿੰਗ ਵਿੰਡੋ ਨੂੰ ਐਡਵਾਂਸਬਾਈ() ਵਿਧੀ ਵਿੱਚ ਇੱਕ ਕਾਲ ਜੋੜ ਕੇ ਇੱਕ ਹੌਪਿੰਗ ਵਿੰਡੋ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਦਿਖਾਈ ਗਈ ਉਦਾਹਰਨ ਵਿੱਚ, ਬਚਤ ਦਾ ਅੰਤਰਾਲ 15 ਮਿੰਟ ਹੈ।

ਤੁਸੀਂ ਇਸ ਭਾਗ ਵਿੱਚ ਦੇਖਿਆ ਹੈ ਕਿ ਕਿਵੇਂ ਏਗਰੀਗੇਸ਼ਨ ਨਤੀਜਿਆਂ ਨੂੰ ਸਮਾਂ ਵਿੰਡੋਜ਼ ਤੱਕ ਸੀਮਿਤ ਕਰਨਾ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇਸ ਭਾਗ ਤੋਂ ਹੇਠ ਲਿਖੀਆਂ ਤਿੰਨ ਗੱਲਾਂ ਨੂੰ ਯਾਦ ਰੱਖੋ:

• ਸੈਸ਼ਨ ਵਿੰਡੋਜ਼ ਦਾ ਆਕਾਰ ਸਮਾਂ ਮਿਆਦ ਦੁਆਰਾ ਨਹੀਂ, ਪਰ ਉਪਭੋਗਤਾ ਦੀ ਗਤੀਵਿਧੀ ਦੁਆਰਾ ਸੀਮਿਤ ਹੈ;
• "ਟੰਬਲਿੰਗ" ਵਿੰਡੋਜ਼ ਇੱਕ ਦਿੱਤੇ ਸਮੇਂ ਦੇ ਅੰਦਰ ਘਟਨਾਵਾਂ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ;
• ਜੰਪਿੰਗ ਵਿੰਡੋਜ਼ ਦੀ ਮਿਆਦ ਨਿਸ਼ਚਿਤ ਕੀਤੀ ਗਈ ਹੈ, ਪਰ ਉਹਨਾਂ ਨੂੰ ਅਕਸਰ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹਨਾਂ ਵਿੱਚ ਸਾਰੀਆਂ ਵਿੰਡੋਜ਼ ਵਿੱਚ ਓਵਰਲੈਪਿੰਗ ਐਂਟਰੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ।

ਅੱਗੇ, ਅਸੀਂ ਸਿੱਖਾਂਗੇ ਕਿ ਕੁਨੈਕਸ਼ਨ ਲਈ ਕੇਟੇਬਲ ਨੂੰ ਵਾਪਸ ਕੇ-ਸਟ੍ਰੀਮ ਵਿੱਚ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ।

5.3.3. KStream ਅਤੇ KTable ਵਸਤੂਆਂ ਨੂੰ ਜੋੜਿਆ ਜਾ ਰਿਹਾ ਹੈ

ਅਧਿਆਇ 4 ਵਿੱਚ, ਅਸੀਂ ਦੋ KStream ਆਬਜੈਕਟ ਨੂੰ ਜੋੜਨ ਬਾਰੇ ਚਰਚਾ ਕੀਤੀ ਹੈ। ਹੁਣ ਸਾਨੂੰ KTable ਅਤੇ KStream ਨੂੰ ਜੋੜਨਾ ਸਿੱਖਣਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੇ ਸਧਾਰਨ ਕਾਰਨ ਕਰਕੇ ਇਸਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ। KStream ਰਿਕਾਰਡਾਂ ਦੀ ਇੱਕ ਸਟ੍ਰੀਮ ਹੈ, ਅਤੇ KTable ਰਿਕਾਰਡ ਅੱਪਡੇਟ ਦੀ ਇੱਕ ਸਟ੍ਰੀਮ ਹੈ, ਪਰ ਕਈ ਵਾਰ ਤੁਸੀਂ KTable ਤੋਂ ਅੱਪਡੇਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰਿਕਾਰਡ ਸਟ੍ਰੀਮ ਵਿੱਚ ਵਾਧੂ ਸੰਦਰਭ ਜੋੜਨਾ ਚਾਹ ਸਕਦੇ ਹੋ।

ਆਉ ਸਟਾਕ ਐਕਸਚੇਂਜ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਦੀ ਸੰਖਿਆ 'ਤੇ ਡੇਟਾ ਲੈਂਦੇ ਹਾਂ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਬੰਧਤ ਉਦਯੋਗਾਂ ਲਈ ਸਟਾਕ ਐਕਸਚੇਂਜ ਦੀਆਂ ਖਬਰਾਂ ਨਾਲ ਜੋੜਦੇ ਹਾਂ। ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਕੋਡ ਨੂੰ ਦਿੱਤੇ ਹੋਏ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਕੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

1. ਸਟਾਕ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਡੇਟਾ ਦੇ ਨਾਲ ਇੱਕ KTable ਆਬਜੈਕਟ ਨੂੰ KStream ਵਿੱਚ ਬਦਲੋ, ਇਸ ਤੋਂ ਬਾਅਦ ਕੁੰਜੀ ਨੂੰ ਇਸ ਸਟਾਕ ਚਿੰਨ੍ਹ ਨਾਲ ਸੰਬੰਧਿਤ ਉਦਯੋਗ ਖੇਤਰ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੀ ਕੁੰਜੀ ਨਾਲ ਬਦਲੋ।
2. ਇੱਕ 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 ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਨਾਲ ਹੀ, EARLIEST ਗਣਨਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਸਾਰਣੀ ਬਹੁਤ ਸ਼ੁਰੂ ਵਿੱਚ ਰਿਕਾਰਡਾਂ ਨਾਲ ਭਰੀ ਜਾਂਦੀ ਹੈ।

ਹੁਣ ਅਸੀਂ ਅੰਤਮ ਪੜਾਅ - ਕੁਨੈਕਸ਼ਨ 'ਤੇ ਜਾ ਸਕਦੇ ਹਾਂ।

ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਗਿਣਤੀ ਡੇਟਾ ਨਾਲ ਖ਼ਬਰਾਂ ਦੇ ਅਪਡੇਟਾਂ ਨੂੰ ਜੋੜਨਾ

ਇੱਕ ਕੁਨੈਕਸ਼ਨ ਬਣਾਉਣਾ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ. ਸੰਬੰਧਿਤ ਉਦਯੋਗ ਲਈ ਕੋਈ ਸਟਾਕ ਖਬਰ ਨਾ ਹੋਣ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਅਸੀਂ ਇੱਕ ਖੱਬਾ ਜੁਆਇਨ ਵਰਤਾਂਗੇ (ਲੋੜੀਂਦਾ ਕੋਡ ਫਾਈਲ src/main/java/bbejeck/chapter_5/CountingWindowingAndKtableJoinExample.java) (ਲਿਸਟਿੰਗ 5.10) ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

ਇਹ LeftJoin ਆਪਰੇਟਰ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ। ਅਧਿਆਇ 4 ਵਿੱਚ ਜੋੜਾਂ ਦੇ ਉਲਟ, JoinWindow ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ ਕਿਉਂਕਿ ਜਦੋਂ ਇੱਕ KStream-KTable ਜੋੜਨ ਲਈ, KTable ਵਿੱਚ ਹਰੇਕ ਕੁੰਜੀ ਲਈ ਸਿਰਫ਼ ਇੱਕ ਐਂਟਰੀ ਹੁੰਦੀ ਹੈ। ਅਜਿਹਾ ਕੁਨੈਕਸ਼ਨ ਸਮੇਂ ਵਿੱਚ ਸੀਮਿਤ ਨਹੀਂ ਹੈ: ਰਿਕਾਰਡ ਜਾਂ ਤਾਂ ਕੇਟੇਬਲ ਵਿੱਚ ਹੈ ਜਾਂ ਗੈਰਹਾਜ਼ਰ ਹੈ। ਮੁੱਖ ਸਿੱਟਾ: KTable ਵਸਤੂਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਸੀਂ KStream ਨੂੰ ਘੱਟ ਵਾਰ-ਵਾਰ ਅੱਪਡੇਟ ਕੀਤੇ ਸੰਦਰਭ ਡੇਟਾ ਨਾਲ ਭਰਪੂਰ ਕਰ ਸਕਦੇ ਹੋ।

ਹੁਣ ਅਸੀਂ KStream ਤੋਂ ਇਵੈਂਟਸ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਦਾ ਇੱਕ ਹੋਰ ਕੁਸ਼ਲ ਤਰੀਕਾ ਦੇਖਾਂਗੇ।

5.3.4 ਗਲੋਬਲ ਕੇਟੇਬਲ ਆਬਜੈਕਟ

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਇਵੈਂਟ ਸਟ੍ਰੀਮ ਨੂੰ ਅਮੀਰ ਬਣਾਉਣ ਜਾਂ ਉਹਨਾਂ ਵਿੱਚ ਸੰਦਰਭ ਜੋੜਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਅਧਿਆਇ 4 ਵਿੱਚ ਤੁਸੀਂ ਦੋ KStream ਆਬਜੈਕਟ ਦੇ ਵਿੱਚ ਕੁਨੈਕਸ਼ਨ ਵੇਖੇ ਹਨ, ਅਤੇ ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ ਤੁਸੀਂ ਇੱਕ KStream ਅਤੇ KTable ਵਿਚਕਾਰ ਕੁਨੈਕਸ਼ਨ ਦੇਖਿਆ ਹੈ। ਇਹਨਾਂ ਸਾਰੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ, ਇੱਕ ਨਵੀਂ ਕਿਸਮ ਜਾਂ ਮੁੱਲ ਨਾਲ ਕੁੰਜੀਆਂ ਦੀ ਮੈਪਿੰਗ ਕਰਦੇ ਸਮੇਂ ਡਾਟਾ ਸਟ੍ਰੀਮ ਨੂੰ ਮੁੜ-ਵਿਭਾਜਨ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ। ਕਦੇ-ਕਦੇ ਪੁਨਰ-ਵਿਭਾਜਨ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਕਈ ਵਾਰ ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਆਪਣੇ ਆਪ ਹੀ ਕਰਦਾ ਹੈ। ਮੁੜ-ਵਿਭਾਜਨ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਕੁੰਜੀਆਂ ਬਦਲ ਗਈਆਂ ਹਨ ਅਤੇ ਰਿਕਾਰਡ ਨਵੇਂ ਭਾਗਾਂ ਵਿੱਚ ਖਤਮ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ, ਨਹੀਂ ਤਾਂ ਕੁਨੈਕਸ਼ਨ ਅਸੰਭਵ ਹੋ ਜਾਵੇਗਾ (ਇਸਦੀ ਚਰਚਾ ਅਧਿਆਇ 4 ਵਿੱਚ, ਉਪਭਾਗ 4.2.4 ਦੇ ਭਾਗ “ਡਾਟਾ ​​ਮੁੜ-ਵਿਭਾਜਨ” ਵਿੱਚ ਕੀਤੀ ਗਈ ਸੀ)।

ਮੁੜ-ਵਿਭਾਜਨ ਦੀ ਇੱਕ ਲਾਗਤ ਹੈ

ਮੁੜ-ਵਿਭਾਜਨ ਲਈ ਲਾਗਤਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ - ਵਿਚਕਾਰਲੇ ਵਿਸ਼ਿਆਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਵਾਧੂ ਸਰੋਤ ਖਰਚੇ, ਕਿਸੇ ਹੋਰ ਵਿਸ਼ੇ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨਾ; ਇਸਦਾ ਅਰਥ ਇਹ ਵੀ ਹੈ ਕਿ ਇਸ ਵਿਸ਼ੇ ਤੋਂ ਲਿਖਣ ਅਤੇ ਪੜ੍ਹਨ ਕਾਰਨ ਵਧੀ ਹੋਈ ਲੇਟੈਂਸੀ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜੇਕਰ ਤੁਹਾਨੂੰ ਇੱਕ ਤੋਂ ਵੱਧ ਪਹਿਲੂਆਂ ਜਾਂ ਮਾਪਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਜੋੜਾਂ ਨੂੰ ਚੇਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਨਵੀਆਂ ਕੁੰਜੀਆਂ ਨਾਲ ਰਿਕਾਰਡਾਂ ਨੂੰ ਮੈਪ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਮੁੜ-ਵਿਭਾਜਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ।

ਛੋਟੇ ਡੇਟਾਸੇਟਾਂ ਨਾਲ ਕਨੈਕਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਕਨੈਕਟ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਸੰਦਰਭ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਮੁਕਾਬਲਤਨ ਛੋਟੀ ਹੁੰਦੀ ਹੈ, ਇਸਲਈ ਇਸ ਦੀਆਂ ਪੂਰੀਆਂ ਕਾਪੀਆਂ ਹਰੇਕ ਨੋਡ 'ਤੇ ਆਸਾਨੀ ਨਾਲ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਫਿੱਟ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਤਰ੍ਹਾਂ ਦੀਆਂ ਸਥਿਤੀਆਂ ਲਈ, ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਗਲੋਬਲ ਕੇਟੇਬਲ ਕਲਾਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਗਲੋਬਲਕੇਟੇਬਲ ਉਦਾਹਰਨਾਂ ਵਿਲੱਖਣ ਹਨ ਕਿਉਂਕਿ ਐਪਲੀਕੇਸ਼ਨ ਹਰੇਕ ਨੋਡ ਲਈ ਸਾਰੇ ਡੇਟਾ ਦੀ ਨਕਲ ਕਰਦੀ ਹੈ। ਅਤੇ ਕਿਉਂਕਿ ਸਾਰਾ ਡਾਟਾ ਹਰੇਕ ਨੋਡ 'ਤੇ ਮੌਜੂਦ ਹੈ, ਇਸ ਲਈ ਇਵੈਂਟ ਸਟ੍ਰੀਮ ਨੂੰ ਹਵਾਲਾ ਡੇਟਾ ਕੁੰਜੀ ਦੁਆਰਾ ਵੰਡਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ ਤਾਂ ਜੋ ਇਹ ਸਾਰੇ ਭਾਗਾਂ ਲਈ ਉਪਲਬਧ ਹੋਵੇ। ਤੁਸੀਂ ਗਲੋਬਲਕੇਟੇਬਲ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀ-ਰਹਿਤ ਜੋੜ ਵੀ ਬਣਾ ਸਕਦੇ ਹੋ। ਆਓ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਪਿਛਲੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚੋਂ ਇੱਕ 'ਤੇ ਵਾਪਸ ਚਲੀਏ।

ਕੇਸਟਰੀਮ ਆਬਜੈਕਟ ਨੂੰ ਗਲੋਬਲ ਕੇਟੇਬਲ ਆਬਜੈਕਟ ਨਾਲ ਜੋੜਨਾ

ਉਪ ਧਾਰਾ 5.3.2 ਵਿੱਚ, ਅਸੀਂ ਖਰੀਦਦਾਰਾਂ ਦੁਆਰਾ ਐਕਸਚੇਂਜ ਲੈਣ-ਦੇਣ ਦੀ ਵਿੰਡੋ ਏਗਰੀਗੇਸ਼ਨ ਕੀਤੀ ਹੈ। ਇਸ ਇਕੱਤਰੀਕਰਨ ਦੇ ਨਤੀਜੇ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਦਿਖਾਈ ਦਿੱਤੇ:

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

ਜਦੋਂ ਕਿ ਇਹਨਾਂ ਨਤੀਜਿਆਂ ਨੇ ਉਦੇਸ਼ ਦੀ ਪੂਰਤੀ ਕੀਤੀ, ਇਹ ਵਧੇਰੇ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਜੇਕਰ ਗਾਹਕ ਦਾ ਨਾਮ ਅਤੇ ਕੰਪਨੀ ਦਾ ਪੂਰਾ ਨਾਮ ਵੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ। ਗਾਹਕ ਦਾ ਨਾਮ ਅਤੇ ਕੰਪਨੀ ਦਾ ਨਾਮ ਜੋੜਨ ਲਈ, ਤੁਸੀਂ ਆਮ ਜੋੜ ਸਕਦੇ ਹੋ, ਪਰ ਤੁਹਾਨੂੰ ਦੋ ਮੁੱਖ ਮੈਪਿੰਗ ਅਤੇ ਮੁੜ-ਵਿਭਾਜਨ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਗਲੋਬਲਕੇਟੇਬਲ ਨਾਲ ਤੁਸੀਂ ਅਜਿਹੇ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਲਾਗਤ ਤੋਂ ਬਚ ਸਕਦੇ ਹੋ।

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਲਿਸਟਿੰਗ 5.11 ਤੋਂ ਕਾਊਂਟਸਟ੍ਰੀਮ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ (ਸੰਬੰਧਿਤ ਕੋਡ src/main/java/bbejeck/chapter_5/GlobalKTableExample.java ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ) ਅਤੇ ਇਸਨੂੰ ਦੋ GlobalKTable ਆਬਜੈਕਟ ਨਾਲ ਜੋੜਾਂਗੇ।

ਅਸੀਂ ਇਸ ਬਾਰੇ ਪਹਿਲਾਂ ਹੀ ਚਰਚਾ ਕਰ ਚੁੱਕੇ ਹਾਂ, ਇਸਲਈ ਮੈਂ ਇਸਨੂੰ ਦੁਹਰਾਵਾਂਗਾ ਨਹੀਂ। ਪਰ ਮੈਂ ਨੋਟ ਕਰਦਾ ਹਾਂ ਕਿ toStream().map ਫੰਕਸ਼ਨ ਵਿੱਚ ਕੋਡ ਨੂੰ ਪੜ੍ਹਨਯੋਗਤਾ ਲਈ ਇੱਕ ਇਨਲਾਈਨ ਲੈਂਬਡਾ ਸਮੀਕਰਨ ਦੀ ਬਜਾਏ ਇੱਕ ਫੰਕਸ਼ਨ ਆਬਜੈਕਟ ਵਿੱਚ ਐਬਸਟਰੈਕਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਅਗਲਾ ਕਦਮ ਗਲੋਬਲਕੇਟੇਬਲ ਦੀਆਂ ਦੋ ਉਦਾਹਰਨਾਂ ਘੋਸ਼ਿਤ ਕਰਨਾ ਹੈ (ਦਿਖਾਇਆ ਕੋਡ 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 ਆਬਜੈਕਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
• ਵਿੰਡੋਿੰਗ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਸਮੁੱਚੀ ਡਾਟੇ ਨੂੰ ਸਮੇਂ ਦੀਆਂ ਬਾਲਟੀਆਂ ਵਿੱਚ ਵੰਡ ਸਕਦੇ ਹੋ।
• ਗਲੋਬਲਕੇਟੇਬਲ ਆਬਜੈਕਟਸ ਲਈ ਧੰਨਵਾਦ, ਤੁਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਕਿਤੇ ਵੀ ਸੰਦਰਭ ਡੇਟਾ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ, ਵਿਭਾਗੀਕਰਨ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ।
• KStream, KTable ਅਤੇ GlobalKTable ਆਬਜੈਕਟ ਵਿਚਕਾਰ ਕੁਨੈਕਸ਼ਨ ਸੰਭਵ ਹਨ।

ਹੁਣ ਤੱਕ, ਅਸੀਂ ਉੱਚ-ਪੱਧਰੀ KStream DSL ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕੀਤਾ ਹੈ। ਹਾਲਾਂਕਿ ਉੱਚ-ਪੱਧਰੀ ਪਹੁੰਚ ਤੁਹਾਨੂੰ ਸਾਫ਼-ਸੁਥਰੇ ਅਤੇ ਸੰਖੇਪ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ, ਇਸਦੀ ਵਰਤੋਂ ਕਰਨਾ ਇੱਕ ਵਪਾਰ-ਬੰਦ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। DSL KStream ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਮਤਲਬ ਹੈ ਕੰਟਰੋਲ ਦੀ ਡਿਗਰੀ ਘਟਾ ਕੇ ਤੁਹਾਡੇ ਕੋਡ ਦੀ ਸੰਖੇਪਤਾ ਨੂੰ ਵਧਾਉਣਾ। ਅਗਲੇ ਅਧਿਆਇ ਵਿੱਚ, ਅਸੀਂ ਹੇਠਲੇ-ਪੱਧਰ ਦੇ ਹੈਂਡਲਰ ਨੋਡ API ਨੂੰ ਵੇਖਾਂਗੇ ਅਤੇ ਹੋਰ ਟ੍ਰੇਡ-ਆਫ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ। ਪ੍ਰੋਗਰਾਮ ਪਹਿਲਾਂ ਨਾਲੋਂ ਲੰਬੇ ਹੋਣਗੇ, ਪਰ ਅਸੀਂ ਲਗਭਗ ਕੋਈ ਵੀ ਹੈਂਡਲਰ ਨੋਡ ਬਣਾਉਣ ਦੇ ਯੋਗ ਹੋਵਾਂਗੇ ਜਿਸਦੀ ਸਾਨੂੰ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ।

→ ਕਿਤਾਬ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਇੱਥੇ ਲੱਭੇ ਜਾ ਸਕਦੇ ਹਨ ਪ੍ਰਕਾਸ਼ਕ ਦੀ ਵੈੱਬਸਾਈਟ

→ Habrozhiteli ਲਈ ਕੂਪਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 25% ਦੀ ਛੂਟ - ਕਾਫਕਾ ਸਟ੍ਰੀਮਜ਼

→ ਕਿਤਾਬ ਦੇ ਕਾਗਜ਼ੀ ਸੰਸਕਰਣ ਲਈ ਭੁਗਤਾਨ ਕਰਨ 'ਤੇ, ਇੱਕ ਇਲੈਕਟ੍ਰਾਨਿਕ ਕਿਤਾਬ ਈ-ਮੇਲ ਦੁਆਰਾ ਭੇਜੀ ਜਾਵੇਗੀ।

ਸਰੋਤ: www.habr.com