แแ แกแขแแขแแแจแ แแแกแแฃแแ แแแ แแแแแ, แแฃ แ แแแแ แแ แ แแขแแ แแแแแแแแแ แแแ
แฃแ แแแแ แแฅแแแแแแแก แกแแกแขแแแ (แจแแแแแแแจแ SV) แแ แแก แแแแแฌแแแแแฃแแ, แจแแชแแแแแก แขแแแแ แแแขแฃแแ แจแแขแงแแแแแแแแแแก แกแแกแขแแแ แแแ แแแขแแ แแแฃแแ แแแฌแแแแแแ. SV แจแแฅแแแแแแ แ แแแแ แช แแแฆแแแ แแแขแแแ แแแแก แกแแ แแแกแ แแแฆแแแ แแแกแจแขแแแฃแ แแแแ, แฎแแแแแกแแฌแแแแแ แ แแแแ แช แแแแแแ แกแแ แแแกแแก แกแแฎแแ (แแแฌแแแแแฃแแ 1C-แแก แแแแ ) แแ แ แแแแ แช แแแกแแแ แแแ แฌแแ แแแแแแก แแ แแแฃแฅแขแ, แ แแแแแแช แจแแแซแแแแ แแแแแแแกแแแก แแฅแแแแก แกแแแฃแแแ แกแแ แแแ แแ.
SV แแงแแแแแก แแแแแฌแแแแแฃแ แกแแชแแแก
แแ แแแแแแแก แจแแกแแฎแแ แแแแชแฎแแแแแ
แแแแก แแแกแแแแแแ, แแฃ แ แแขแแ แจแแแฅแแแแแ แฃแ แแแแ แแฅแแแแแแแก แกแแกแขแแแ, แแ แแแขแงแแแ แชแแขแแก, แแฃ แ แแแแ แแฃแจแแแแก แแแแแแก แแแแแแแชแแแแแก แแแแแแแแ แแแ 1C-แจแ.
แแแกแแฌแงแแกแแกแแแแก, แชแแขแ แฉแแแแก แจแแกแแฎแแ แแแแแแแก, แแแแช แฏแแ แแแแแ แแ แแชแแก แ แแก แแแแแแแแ :) แฉแแแ แแแแแแแแแ 1C:Enterprise แขแแฅแแแแแแแฃแ แแแแขแคแแ แแแก. แแแแขแคแแ แแ แแแแชแแแก แแแแแแก แแแแแแแชแแแแแก แจแแแฃแจแแแแแแก แแแกแขแ แฃแแแแขแก, แแกแแแ แแแจแแแแแก แแ แแก, แ แแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แแแแแแก แแแแแแแชแแแแก แแฌแแ แแแแ แแ แแก-แแแแขแคแแ แแฃแ แแแ แแแแจแ.
แแแแแแข-แกแแ แแแ แแก แแแแแแแแ แแแแก แแแ แแแแแแ
1C:Enterprise-แแ แจแแฅแแแแแ แแแแแแก แแแแแแแชแแแแ แแฃแจแแแแก แกแแ แแแแแแ
แแแแแแแชแแแก แแแแจแ แแ แแชแแแฃแ แแแแกแ แแ แคแฃแแฅแชแแแแแก แกแแแแฃแ แแแจแ แชแแแกแแฎแแ แฃแแแ แแงแแก แแแแแแแแฃแแ, แแฃ แกแแ แจแแกแ แฃแแแแแ แแแแ - &AtClient / &AtServer แแแ แแฅแขแแแแแแก แแแแแงแแแแแแ (&AtClient / &AtServer แแแแก แแแแแแกแฃแ แแแ แกแแแจแ). 1C แแแแแแแแแ แแแ แแฎแแ แจแแแแกแฌแแ แแแแ แแแแ, แ แแ แแแ แแฅแขแแแแแ แ แแแแฃแ แแ แแ แแก
แแฅแแแ แจแแแแซแแแแ แแแ แแแแ แกแแ แแแ แแก แแแแ แแแแแแขแแก แแแแแแแ, แแแแ แแ แแ แจแแแแซแแแแ แแแแแแขแแก แแแแแก แแแแแซแแฎแแแ แกแแ แแแ แแก แแแแแแแ. แแก แแ แแก แคแฃแแแแแแแขแฃแ แ แจแแแฆแฃแแแ, แ แแแแแแช แฉแแแ แจแแแฅแแแแแ แแ แแแแแ แแแแแแแก แแแแ. แแแ แซแแ, แแแแก แแแแ, แ แแ แกแแ แแแ แแก แแแแ แฃแแแ แแงแแก แแแฌแแ แแแ แแกแ, แ แแ แแก แจแแกแ แฃแแแแก แแแแแ แแแแ, แกแแแแช แแ แฃแแแ แแงแแก แแแซแแฎแแแฃแแ - แแแแแแขแแแแ แแฃ แกแแ แแแ แแแแ. แฎแแแ แกแแ แแแ แแก แแแแแก แกแฎแแ แกแแ แแแ แแก แแแแแแแ แแแแแซแแฎแแแแก แจแแแแฎแแแแแจแ, แแแแแแขแ, แ แแแแ แช แแกแแแ, แแ แแ แกแแแแแก. แแ แแแแก แแแแ, แ แแ แกแแ แแแ แแก แแแแแก แจแแกแ แฃแแแแแก แแ แแก แแแแแแขแก, แ แแแแแแแช แแแก แแแฃแ แแแ, แจแแแซแแ แแแฎแฃแ แแก, แแแกแฃแแแงแ แแแแแแแชแแแแแ แแ แกแแ แแแ แก แแฆแแ แแงแแแแแ แแแแแ แแแกแแ แแแแ.
แแแแ, แ แแแแแแช แแแฃแจแแแแแก แฆแแแแแแ แแแฌแแแแฃแแแแแก: แแแแแแขแแกแแแ แกแแ แแแ แแก แแ แแชแแแฃแ แแก แแแแแซแแฎแแแ แแแฃแจแแแแแก, แกแแ แแแ แแแแ แแแแแแขแแก แแ แแชแแแฃแ แแก แแแแแซแแฎแแแ แแ แ
แแก แแแจแแแแก, แ แแ แแฃ แฉแแแ แแแกแฃแ แก แกแแ แแแ แแก แแฎแ แแแแ แแแแแแขแแก แแแแแแแชแแแจแ แแแแแแแแ, แแแแแแแแแ, แ แแ "แแ แซแแแแแแแแแ" แแแแแ แแจแแก แแแแแ แแชแแ แแแกแ แฃแแแ แแ แแแแแ แแจแแก แแแฎแแ แจแแกแแซแแแแแแแ, แแกแแแ แแแแแแ แแ แแแแฅแแก. แแฅแแแ แฃแแแ แแแแแแงแแแแ แฎแ แแแแแ, แแแแแแแแแ, แแแ แแแแฃแแแ แแแแแแแแฎแแ แกแแ แแแ แ แแแแแแขแแก แแแแแแแ. แแแแ แแ แแก แแแแแแแ แแขแแแ แแแแก แกแแกแขแแแแก แแ แแกแแญแแ แ แแแ แแแแ แแ แแแแแแแ แแ แแแแแแงแฃแ แแแ แซแแแแแ แแแแแแแขแฃแ แ.
แแ แแกแแแ แแ แแก แกแแญแแ แแแแ, แแแแแแแแแ, แ แแแแกแแช แกแแขแแแแคแแแ แแแ แ แแแแแก
แแแแแ แฌแแ แแแแแ
แจแแฅแแแแแ แจแแขแงแแแแแแแแแแก แแแฅแแแแแแ. แกแฌแ แแคแ, แกแแแแแแ, แแแ แแแขแแ แแแฃแแ แแแฌแแแแแแ, แจแแขแงแแแแแแแแแแก แแแฅแแแแแ แซแแแแแก แจแแกแแซแแแแแแแแ. แแแฅแแแแแแแแแ แแแแแแแแแแ แ, แแแแแฎแแ แชแแแแแ แแแกแแแฏแแ แ (แจแแขแงแแแแแแแแแ, แแแแแ แแแ แแแ), แ แแแแแแช แแฃแจแแแแก 1C แแแแแแแชแแแแจแ.
แจแแแแฃแจแแแแ แกแแกแขแแแ แแกแ, แ แแ แฐแแ แแแแแขแแแฃแ แแ แแแกแจแขแแแแ แแแแแ แแงแแก. แแแแ แแ แแแขแแแ แแแ แฃแแแ แแแแคแแ แแก แแแแแซแแแแก แ แแแแแแแแแก แแแแ แแแ.
ะ ะตะฐะปะธะทะฐัะธั
แฉแแแ แแแแแแฌแงแแแขแแ, แ แแ แแ แแแแแแแ แแแแแแแแแ SV แกแแ แแแ แแก แแแฌแแแ แแแ แแแแแ 1C:Enterprise แแแแขแคแแ แแแจแ, แแ แแแแ แแแแแแฎแแ แชแแแแแ แแแ แชแแแแแฃแ แแ แแแฃแฅแขแแ, แ แแแแแก API แจแแแซแแแแ แแแ แแแแ 1C แแแแแแแชแแแก แแแแแฌแงแแแขแแแแแแแแก แแแแแแแ. แแก แแแแแแแ แแ แแแแแ แแแแแแแก แแแแ, แ แแแแแแแแแ แแแแแแ แ แแงแ แแก, แ แแ แแ แแแแแแแ แแแแแแแแแแแแ แจแแขแงแแแแแแแแแแก แแแชแแแ แกแฎแแแแแกแฎแแ 1C แแแแแแแชแแแแก แจแแ แแก (แแแแแแแแแ, แแแญแ แแแแก แแแแแฏแแแแขแกแ แแ แแฃแฆแแแขแ แฃแ แแฆแ แแชแฎแแแก แจแแ แแก). แกแฎแแแแแกแฎแแ 1C แแแแแแแชแแแแ แจแแแซแแแแ แแแฃแจแแแ 1C:Enterprise แแแแขแคแแ แแแก แกแฎแแแแแกแฎแแ แแแ แกแแแแ, แแแแแแแกแแแก แกแฎแแแแแกแฎแแ แกแแ แแแ แแแแ แแ แ.แจ. แแกแแ แแแ แแแแแจแ, SV-แแก, แ แแแแ แช แชแแแแแฃแแ แแ แแแฃแฅแขแแก แแแแแ แแแ, แ แแแแแแช แแแแแแ แแแแก 1C แแแกแขแแแแชแแแแแก โแแแแ แแแโ แแ แแก แแแขแแแแแฃแ แ แแแแแฌแงแแแขแ.
แแกแ แ แแ, แแแแแแฌแงแแแขแแ SV แแแแแแแแแแแแแ, แ แแแแ แช แชแแแแ แแ แแแฃแฅแขแ. แฉแแแ แแแ แฉแแแ, แ แแ แแชแแ แ แแแแแแแแแแแ แแแแแแงแแแแ CB แกแแ แแแ แ, แ แแแแแแช แฉแแแ แแแแแแแกแขแแแแ แแ แฉแแแแก แฆแ แฃแแแแจแ (wss://1cdialog.com), แ แแแ แแแแแแแ แแแชแแแแ แแแแแแขแ แฎแแ แฏแแแ, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ แกแแ แแแ แแก แแแแแแฃแ แแแกแขแแแแชแแแกแแแ แแ แแแแคแแแฃแ แแชแแแกแแแ. แแกแฎแแแ แแแแแแขแแแก แจแแแซแแแแ แแแแแแจแแฌแแแแแ แแฆแแแฉแแแแแ แกแแแฃแแแ แ CB แกแแ แแแ แแก แแแงแแแแแ แแแ แแแแแฅแขแแแจแ. แฉแแแ แแแแแแแงแแแแ แแกแแแแกแ แแแแแแแ แฉแแแแก แฆแ แฃแแแแแแ SaaS แแ แแแฃแฅแขแจแ
แแแแแชแฎแแแแก
แแแขแแแ แแแแกแ แแ แจแแชแแแแแแแก แขแแแแ แแแขแแแแก แแแกแแแแฌแแแแแแแ, แฉแแแ แแแแแแแแแกแแแ แแ แ แแ แ Java แแแแแแแชแแแก, แแ แแแแ แ แแแแแแแแ, แแแ แฌแแ แแแขแแแ แแแแก แแแแแแกแแ แแ. แแฃ แแฅแแแ แแญแแ แแแแแ แจแแขแงแแแแแแแแก แแแแแขแแแ แแแแแซแแแแ แแแแแซแแ, แแแแแแงแแแแ แแแแแฅแแแงแแแแ/แแแแแฌแแ แ Hazelcast-แจแ.
แแแแแแขแกแ แแ แกแแ แแแ แก แจแแ แแก แแแแฃแแแแแชแแ แฎแแแแ แแแแกแแแแขแแก แกแแจแฃแแแแแแ. แแก แแแ แแแ แจแแแคแแ แแแ แ แแแแฃแ แแ แแจแ แกแแกแขแแแแแก.
แแแแแฌแแแแแฃแแ แฅแแจแ
แฉแแแ แแแแ แฉแแแ Redis, Hazelcast แแ Ehcache-แก แจแแ แแก. 2015 แฌแแแแ. แ แแแแกแแ แแฎแแแฎแแ แแแแแฃแจแแ แแฎแแแ แแแแกแขแแ แ (แแแแแแขแแ แแฎแแแ, แกแแจแแแแแ), แแ แแก Sentinel แฃแแแ แแแ แจแแแฆแฃแแแแ. Ehcache-แ แแ แแชแแก แ แแแแ แจแแแแ แแแแก แแแแกแขแแ แจแ (แแก แคแฃแแฅแชแแ แแแแแแแแแแแ แแแแแฉแแแ). แฉแแแ แแแแแแฌแงแแแขแแ แแแแแแแแชแแแ แแก Hazelcast 3.4-แแ.
Hazelcast แแแ แแแแแ แแแกแแขแฃแ แแ แงแฃแแแแแ. แแ แแ แแแแแซแแก แ แแแแแจแ แแก แแ แแ แแก แซแแแแแ แแแแแกแแแแแ แแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแฎแแแแ แฅแแจแแ - แแแ แแ แแชแแก แ แแแแ แแแแแแแแแก แแแแแชแแแแแ แแแกแแแ, แแฃ แแแแแ แแแ แแ แแแแแ แ แแแแแซแก, แแแ แแแ แแแแแชแแแแแก. แฉแแแ แแแงแแแแแ แ แแแแแแแแ Hazelcast-แก, แ แแแแแแ แจแแ แแกแแช แแแแแแแแ แแ แแขแแแฃแ แแแแแชแแแแแก. แฉแแแ แแ แแแแแแแแ แฅแแจแแก แกแแ แแแแ แแ แแกแแก - แฉแแแ แแ แแแแฌแฃแฎแแแก แแก.
แฉแแแแแแแก Hazelcast แแ แแก:
- แแแแฎแแแ แแแแแก แกแแกแแแแแก แจแแแแฎแแ. แงแแแแ แฏแแ แแ แกแแกแแแกแแแแก แแแแแชแแแแ แแแแแจแ แฌแแกแแแแก แแแแ แแ แ แกแญแแ แแแแ, แแแแขแแ แงแแแแ แกแแกแแแก แแแแแแกแแแ Hazelcast-แจแ.
- แฅแแจแ. แแฃ แแฅแแแ แแซแแแ แแแแฎแแแ แแแแแก แแ แแคแแแก, แจแแแแแฌแแแ แฅแแจแ. แแแฌแแ แ แแฎแแแ แแแกแแฏแ - แฉแแแแ แฅแแจแจแ.
- แแแแแแแชแแแก แแแกแขแแแชแแแแก แจแแ แแก แแแแฃแแแแแชแแแก แแแแแแ. แแแแแซแ แฅแแแแก แแแแแแแแก แแ แแแแแกแแแก แแแก Hazelcast แแแแแจแ. แแ แแแแแแ แแแแแฌแแ แแแ แกแฎแแ แแแแแแแชแแแก แแแแแซแแแ แแฆแแแแ แแ แแแฃแจแแแแแแ แฆแแแแกแซแแแแแก.
- แแแกแแขแฃแ แ แกแแแแขแแแ. แแแแแแแแแ, แฉแแแ แแฅแแแแ แแแกแแฃแกแแแก แฃแแแแแแฃแ แ แแแกแแฆแแแแก แแแแแงแแแแแแ (แแ แแฏแแ แแแ แแแกแแฃแกแแ 1C แแแแแชแแแแ แแแแแจแ):
conversationKeyChecker.check("ะะะะะะะะะะะะ");
doInClusterLock("ะะะะะะะะะะะะ", () -> {
conversationKeyChecker.check("ะะะะะะะะะะะะ");
createChannel("ะะะะะะะะะะะะ");
});
แฉแแแ แจแแแแแแฌแแแ, แ แแ แแ แฎแ แแ แแ แแก. แแแแฆแแ แกแแแแขแ, แแกแแ แจแแแแแแฌแแแ แแ แจแแแฅแแแแแ. แแฃ แกแแแแขแก แแ แจแแแแแฌแแแแ แกแแแแขแแก แแฆแแแแก แจแแแแแ, แแแจแแ แแ แแก แจแแแกแ, แ แแ แกแฎแแ แแแแแช แจแแแแฌแแแแก แแ แแแแแแขแจแ แแ แแฎแแ แจแแแชแแแแ แจแแฅแแแแก แแแแแ แแแกแแฃแกแแ - แแแแ แแ แแก แฃแแแ แแ แกแแแแแก. แแฅแแแ แแ แจแแแแซแแแแ แฉแแแแขแแ แกแแแฅแ แแแแแแแฃแแ แแ แ แแแฃแแแ แฃแแ java Lock-แแก แแแแแงแแแแแแ. แแแแแชแแแแ แแแแแก แกแแจแฃแแแแแแ - แแก แแแแแ แแ แกแแแฌแฃแฎแแ แแ แแแแแชแแแแ แแแแแกแแแแก; Hazelcast-แแก แกแแจแฃแแแแแแ - แแก แแ แแก แแก, แ แแช แแญแแ แแแแแ.
DBMS-แแก แแ แฉแแแ
แฉแแแ แแแแฅแแก PostgreSQL-แแแ แแฃแจแแแแแกแ แแ แแ DBMS-แแก แแแแแแแแแ แแแแแ แแแแแแจแ แแแแแแแก แแแแ แแ แฌแแ แแแขแแแฃแแ แแแแแชแแแแแแ.
แแก แแแแแแ แแ แแ แแก PostgreSQL แแแแกแขแแ แแแ - แแ แแก
แแฃ แแฅแแแ แแญแแ แแแแแ แ แแแแชแแฃแ แ แแแแแชแแแแ แแแแแก แแแกแจแขแแแแ แแแ, แแก แแแจแแแแก
แฉแแแแ แแแจแแแก แแแ แแแแ แแแ แกแแ แแแแแแแกแฌแแแแแแ แฉแแแแ แแแแแแแชแแแก แแแแแแฃแแ แชแฎแ แแแแก แแแแแฌแแแแแแก แจแแกแแซแแแแแแแแก แกแฎแแแแแกแฎแแ แกแแ แแแ แแแแ แกแฎแแแแแกแฎแแ แแ แแแแ แชแแแ. A แกแแ แแแ แแ แแแแ แ แจแแขแงแแแแแแแแ - แแแฎแแแ, แแแแแแแขแแแแ แแ แชแฎแ แแแแก แแแฌแแแ B แกแแ แแแ แแ. แแก แแแแแฌแงแแแขแแแแแ แฃแแ แแแแ แงแแแ แแแ แแแแแ แแแ แแแขแแแแแแชแแแก แจแแกแแฎแแ, แแแแขแแ แแแแแแฌแงแแแขแแ แจแแแแแแคแแ แแแแ แกแแแฃแแแ แ แแแแ แแ แแแแแแแแแแแ แแแแแแแแ.
แแฅแแแ แจแแแแซแแแแ แฌแแแแแแฎแแ แแ แแแแแแแแแแแแก แจแแกแแฎแแ, แแแแแแแแแ, แแแแกแแแขแแ
SV-แก แแฅแแก แแแแแชแฎแแแแก แแ แแแแแแแขแแก แชแแแแแแ. แแแแแแแชแแ แแ แแก แแแแแแก แแแแแแแชแแแก แกแแแชแแคแแแฃแ แ แแแกแขแแแแชแแ, แ แแแแ แแชแแ ERP แแ Accounting, แแแแแกแ แแแแฎแแแ แแแแแแแ แแ แแแแแแก แแแแแชแแแแแแ. แแแแแแแขแ แแ แแก แแ แแแแแแแชแแ แแ แคแแแแแฃแ แ แแแ แ, แ แแแแแก แกแแฎแแแแแแช แแแแแแแชแแ แ แแแแกแขแ แแ แแแฃแแแ SV แกแแ แแแ แแ. แแแแแแแขแก แจแแฃแซแแแ แแแแ แแแแกแขแ แแ แแก แ แแแแแแแแ แแแแแแแชแแ แแ แแ แแแแแแแชแแแแก แจแแฃแซแแแแ แจแแขแงแแแแแแแแแแก แแแชแแแ แแ แแแแแแแแแ. แแแแแแแขแ แแแฎแแ แแแแฏแแ แ แฉแแแแก แกแแกแขแแแแจแ. แ แแแแแแแแ แแแแแแแขแแก แจแแขแงแแแแแแแแแ แจแแแซแแแแ แแแแแแแกแแแก แแ แ แคแแแแแฃแ แแแแแชแแแแ แแแแแจแ; แแฃ แฉแแแ แแฎแแแแแ, แ แแ แแแแแแแขแแ แแแแฌแงแ แแแแ แขแ แแคแแแแก แแแแแ แแ แแแ, แแแแแแแขแแแ แแแก แชแแแแ แคแแแแแฃแ แแแแแชแแแแ แแแแแจแ (แแ แแฃแแแแช แชแแแแ แแแแแชแแแแ แแแแแก แกแแ แแแ แแ).
แฉแแแ แแแแฅแแก แซแแ แแแแแ แแแแแชแแแแ แแแแ, แกแแแแช แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแ แแแแฎแแแ แงแแแแ แแแแแแแขแแก แแแแแชแแแแ แแแแแก แแแแแแ แแแแแก แจแแกแแฎแแ.
แแแแกแแแแก, แ แแ แซแแ แแแแแ แแแแแชแแแแ แแแแ แแ แแงแแก แแแแแ, แฉแแแ แแแแแฎแแแ แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแก (แแ แกแฎแแ แฎแจแแ แแ แกแแญแแ แ แแแแแชแแแแแก) แฅแแจแจแ.
แแฃ แแแแแแแขแแก แแแแแชแแแแ แแแแ แจแแแแแแแแก แแแแฌแงแแแก, แแแก แจแแแแแ แแแแญแ แแ แแแแแงแแคแแแแ. แกแฎแแ แแ แแแฅแขแแแแ แแแงแแแแแ
แแแแแแแแ แแแแฎแแแ แแแแแก แจแแขแงแแแแแแแแแแก แแแแแ แแแ แชแฃแแแ, แฉแแแ แแแแแฎแแแ แแแแแชแแแแ แแแแแแก แ แแแแแแแแแ. แกแแแฅแ แแแฃแแ แแ แแกแแแฅแ แแแฃแแ แ แแแแแแแแแก แแแแแแแแชแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแฆแแแแ แแแแ แซแแ แแแแแ แแแแแชแแแแ แแแแแก แแแแแ แแแแก แจแแแแฎแแแแแจแ. แจแแขแงแแแแแแแแก แแแแแ แแแ แแแฎแแแแ แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ แแแ แแแแแแ แแแแแชแแแแ แแแแ แแ แแแกแ แกแแแฅแ แแแฃแแ แ แแแแแแ แแ แแแ แแฃแแแ แแแ แฎแแ แฎแแแแ.
แแฃ แกแแแฅแ แแแฃแแ แ แแแแแแ แแแแแแ แแแแ, แแกแแแฅแ แแแฃแแ แ แแแแแแ แฎแแแแ แกแแแฅแ แแแฃแแ.
แแฃ แซแแ แแแแแ แแแแแชแแแแ แแแแ แแแแแแ แแแแ, แกแแแฅแ แแแฃแแ แ แแแแแแ แฎแแแแ แซแแ แแแแแ แแแแแชแแแแ แแแแ, แฎแแแ แแกแแแฅแ แแแฃแแ แ แแแแแแ แฎแแแแ แกแแแฅแ แแแฃแแ แ แแแแแแ.
Elastics-แแก แซแแแแ แกแแซแแแแแแ
แแแแแแแแ, แกแฎแแ แกแแแแแฎแแแแแ แแ แแแ, SV แแกแแแ แแ แแก แแแกแแแฏแแ แ, แแก แแแแแฎแแแก แกแฌแ แแค, แแแกแแฎแแ แฎแแแแ แแ แแแฅแแแ แซแแแแแก, แแแ แคแแแแแแแก แแแแแแแแกแฌแแแแแแ, แแ แแแฃแกแขแ แจแแกแแขแงแแแกแแแแก แแแแแงแแแแแแ. แฉแแแ แแแแแแฌแงแแแขแแ แแ แแแแแแแแแแแ แแแ แแแแ แแ แแแแแแแงแแแแ แฃแคแแกแ แกแแซแแแแ แกแแกแขแแแ Elasticsearch, แ แแแแแแช แจแแฅแแแแแแ แแแแแแแแแแแก แกแแคแฃแซแแแแแ
github-แแ แแแแแแแ
แแ แจแแแแ แฉแฃแแแแแ แกแแขแงแแ โแขแแฅแกแขแแกโ แซแแ แแช. แแก แแแแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแซแแแแแ แกแแขแงแแแก แแแกแแฌแงแแกแจแ, แจแฃแแจแ แแ แแแแแก.
แฒแแแ แกแฃแ แแแ
แแแแแแแ แแ แกแฃแ แแแ แกแขแแขแแแก แแแกแแฌแงแแกแแแแ, แแแแ แแ แแแแแแ แขแแแแแแ:
- แแแขแแ แแแขแจแ แแแแแแแแแแแ แแแแแแกแแ แ; แฉแแแ แแแแฅแแก nginx, แแก แจแแแซแแแแ แแงแแก แแแแแกแแแแ แ.
- Java แแแแแแแชแแแก แแแกแขแแแชแแแแ แแ แแแแแแแแแ แฃแ แแแแ แแแแแ Hazelcast-แแก แกแแจแฃแแแแแแ.
- แฉแแแ แแแงแแแแแ แแแ แกแแแแขแแแ แแฃแจแแแแแกแแแแก
แแแแ . - Java แแแแแแแชแแ แแแฌแแ แแแแ Java 8-แจแ แแ แจแแแแแแ แแแแแขแแแแกแแแ
OSGi . แแแแแแแ แแแแชแแแก Java 10-แแ แแแแ แแชแแแก แแ แแแแฃแแแแแ แแแแแกแแแแก.
แแแแแแแแ แแแ แแ แขแแกแขแแ แแแ
SV-แแก แจแแแฃแจแแแแแแกแ แแ แขแแกแขแแ แแแแก แแ แแชแแกแจแ แฉแแแ แจแแแฎแแแแ แฉแแแแก แแแแ แแแแแงแแแแแฃแแ แแ แแแฃแฅแขแแแแก แแ แแแ แ แกแแแแขแแ แแกแ แแแฎแแกแแแแแแแแก.
แฉแแขแแแ แแแแก แขแแกแขแแ แแแ แแ แแแฎแกแแแ แแแแก แแแแแแแ
แแแแแแฃแแ SV แแแแแจแแแแแก แแแแแจแแแแ แแแแชแแแก แแแขแแแ แแแแก แขแแกแขแแ แแแแก. แฌแแ แแแขแแแฃแแแ, แ แแแแกแแช:
- แขแแกแขแแ แ แแแแแแแแ แแฆแ แแแฃแจแแแ แแ แกแแ แแแกแแก แจแแคแแ แฎแแแแแ แแ แงแแคแแแ
- แกแแแแแแซแ แแแแ แแชแแแแแ แ แแแแแ แแแแก แแ แ แแ แแฆแแแแขแแแแแ แแแแคแแ แขแฃแ แแฆแแแ แก
- แแฃแจแแแแแก แแแฃแแ แแกแแแ แฌแแแ แแแ แกแแแกแแแ แจแแแแ แแแแ แแ แแ แแก 10% -แแ แแแขแ
แฉแแแ แแแแกแแแ แกแแขแแกแขแ แแแแแชแแแแ แแแแแก แแแแแชแแแแแแ - แแแแกแแแแแก แแแฆแแแ แแแคแแ แแแชแแแก แงแแแแแแ แแฅแขแแฃแ แ แแแแแแแขแแก แจแแกแแฎแแ แฌแแ แแแแแแก แกแแ แแแ แแแแ, แแแแ แแแแแแ แแแก แแแแ แแแก 5-แแ (แจแแขแงแแแแแแแแแแก, แแแกแแฃแกแแแแแก, แแแแฎแแแ แแแแแแแก แ แแแแแแแแ) แแ แแแแแฌแแแแ แแ แแแแ.
แฉแแแ แแแขแแ แแแ แฃแ แแแแ แแฅแแแแแแแก แกแแกแขแแแแก แแแขแแแ แแแแก แขแแกแขแแ แแแแก แกแแ แแแแคแแแฃแ แแชแแแจแ:
- แกแขแ แแก แขแแกแขแ
- แแฎแแแแ แแแแจแแ แแแ
- แแแแแแแขแแก แ แแแแกแขแ แแชแแ
แกแขแ แแก แขแแกแขแแก แแ แแก แฉแแแ แแแแฃแจแแแ แ แแแแแแแแ แแกแแฃแแ แแแแ แแ แแกแแแ แแขแแแ แแแแ แกแแกแขแแแแก แจแแฃแฉแแ แแแแแ: แจแแขแงแแแแแแแแแแก แฌแแ แ, แแแกแแฃแกแแแแแก แจแแฅแแแ, แจแแขแงแแแแแแแแแแก แกแแแก แแแฆแแแ. แฉแแแ แแแแแแแแ แฉแแแฃแแแแ แแแ แแแแฎแแแ แแแแแแแก แแแฅแแแแแแแแแก แกแแแฃแแแชแแแก (แแแแฆแแ แฉแแแ แฌแแฃแแแแฎแแแ แจแแขแงแแแแแแแแแแก แกแแ, แแแแฌแแ แ แแแแแแก) แแ แแ แแแ แแแฃแแ แแแแแฌแงแแแขแแแแแแแ (แกแฎแแแแแกแฎแแ แแแแคแแแฃแ แแชแแแก แแแแแขแแก แแแแแชแแแ, แแแแแแจแแก แแแแฃแจแแแแแ).
แแแแแแแแแ, แแกแ แแแแแแงแฃแ แแแ แกแขแ แแก แขแแกแขแแก แแแฌแแแ:
- แแแแฎแแแ แแแแแ แจแแแแก แกแแกแขแแแแจแ
- แแแฎแแแก แแฅแแแแก แฌแแฃแแแแฎแแ แแแกแแฃแกแแแแก
- 50% แกแแแแ แแฃแแแ แฌแแแแแแฎแแแก แจแแขแงแแแแแแแแแก
- 50% แกแแแแ แแฃแแแ แขแแฅแกแขแก
- แจแแแแแแ แแแแฎแแแ แแแแแ:
- แแฅแแก แแฎแแแ แแแกแแฃแกแแแก แจแแฅแแแแก 20% แจแแแกแ
- แจแแแแฎแแแแแ แแ แฉแแแก แแแก แ แแแแแแแ แแแกแแฃแกแแแก
- แจแแแแแ แแแแแก
- แแแฎแแแก แจแแขแงแแแแแแแแแก, แแแแฎแแแ แแแแแก แแ แแคแแแแแก
- แฅแแแแก แฎแฃแ แจแแขแงแแแแแแแแก แจแแแแฎแแแแแแ แแแแฎแแแ แแแแแแแก แแแกแแแแ แแแ แแ แแแกแแฃแกแแแแแ
- แขแแแแแก แแแกแแฃแกแแแก
- แแแแ แแแแ 20-แฏแแ
- แแแแแแแก, แแ แฃแแแแแ แกแชแแแแ แแก แแแกแแฌแงแแกแจแ
- แฉแแแแแขแ แจแแแแก แกแแกแขแแแแจแ (แแแแแแแชแแแก แแแแแแแ แจแแขแงแแแแแแแแแแก แแแแแซแแ)
- แแฅแแก 50% แจแแแกแ แจแแฅแแแแก แแฎแแแ แแ แฎแ แแแแแชแแแแ แแแชแแแแกแแแแก (แกแแแชแแแแฃแ แ แแแแฎแแแแ)
- 50% แกแแแแ แแฃแแแ แแแฌแแ แก แจแแขแงแแแแแแแแก แ แแแแแแแ แแ แกแแแฃแ แแ แฎแแ
"แแฎแแแแ แแแแจแแ แแแแก" แกแชแแแแ แ แแแฉแแแ แแแแแแแ. แแ แแก แกแแขแฃแแชแแ: แแแแฎแแแ แแแแแแแ แแแแแแแจแแ แแก แกแแกแขแแแ, แแแแ แแ แฏแแ แแ แฉแแแ แแแแ. แแแแแแฃแแ แแแแฎแแแ แแแแแ แแแแแก 09:00 แกแแแแแ แ แแแแก แแแแแแฃแขแแ แก, แแแงแแ แแแก แแแแจแแ แก แกแแ แแแ แแแ แแ แแฃแแก. แแก แแแญแแแ แกแแฎแแคแแแแ, แแแแ แ แแแแแแแแ - แแ แแแแแ แแ แแแแแขแแแ, แ แแช แแแ แแฅแแ แแ แแก PING/PONG, แแแแ แแ แแกแแแ แแแแ แฉแฃแแแแแ แแแแจแแ แก แกแแ แแแ แแแ (แแแ แแ แจแแฃแซแแแแ แแแแก แจแแแแ แฉแฃแแแแ - แ แ แแแฎแแแแ, แแฃ แแฎแแแ แจแแขแงแแแแแแแแ). แขแแกแขแ แแกแแฎแแแก แกแแขแฃแแชแแแก, แ แแแแกแแช แแกแแแ แแแแฎแแแ แแแแแแแก แแแแ แ แแแแแแแแ แชแแแแแแก แกแแกแขแแแแจแ แจแแกแแแแก แแแฎแแแแ แกแแแแจแ. แแก แกแขแ แแก แขแแกแขแแก แแกแแแแกแแ, แแแแ แแ แแแกแ แคแแแฃแกแแ แแแ แกแฌแแ แแ แแ แแแ แแแ แจแแงแแแแแแแ - แแกแ, แ แแ แแ แแแฎแแแก แฌแแ แฃแแแขแแแแแแแแ (แแแแแแแแ แแ แแงแแแแแก แกแแกแขแแแแก แแ แแก แฃแแแ แแจแแแแ - แซแแแแแ แ แแแแ แฃแแ แแกแแก แแแคแแฅแ แแแ).
แแแแแแแขแแ แ แแแแกแขแ แแชแแแก แกแแ แแแขแ แแฌแงแแแ แแแ แแแแ แแแจแแแแแแแ. แฉแแแแขแแ แแ แกแขแ แแก แขแแกแขแ แแ แแแแ แฌแแฃแแแแ, แ แแ แแแแแฌแแ แแก แแ แแก แกแแกแขแแแ แแ แจแแแแแแแฃแแ. แแแแ แแ แแแแฎแแแ แแแแแแ แแแแแแแแ แแ แ แแแแกแขแ แแชแแ แฌแแ แฃแแแขแแแแแ แแแฎแแ แขแแแแแฃแขแแก แแแแ. แ แแแแกแขแ แแชแแแกแแก แแแแแแแงแแแแ
แฉแแแ แแแงแแแแแ แ แแแแ แช แแแขแแแ แแแแก แแแแแ แแขแแ แก
แกแฌแแ แแ แแฅแแแแ แแแแแแฌแงแแแขแแ แแแฌแงแแแ.
แกแแ แแแแฃแแ แขแแกแขแแ แแแแก แแแฌแงแแแแกแแแแแแ, แฉแแแ แแฆแแแแแฉแแแแ, แ แแ JMeter-แแ แแแฎแกแแแ แแแแก แแแแแแแ แแแแฌแงแ.
แแแแแแแขแ แชแแแแ แแแแ แแแแแแแ; 176 แแแ แกแแแแแแแ, แแแก แแฅแแก 132 แฉแแแแแแ github-แแ. แแแแแ แแแขแแ แก แแแแก แแแแแแแฃแแแแ แแ แแแฃแฆแแ 2015 แฌแแแแแ (แฉแแแ แแแแฆแแ 2015 แฌแแแก, แจแแแแแ แแญแแ แแ แแแฉแแแแแ), แ แแแแแแแแ แแแขแฐแฃแแแก แแ แแแแแแ แแแฎแกแแแ แแแแก แแแแแแแแกแแแ แแแแแแจแแ แแแแ, 7 แแแฃแฎแฃแ แแแ แแแแฆแแแแก แแแแฎแแแแ.
แแฃ แแแแแฌแงแแแขแ แฉแแแขแแ แแ แแแขแแแ แแแแก แขแแกแขแแ แแแ แแ แแแแฃแแแก แแแแแงแแแแแแ, แแแฎแแแ, แงแฃแ แแแฆแแแ แแแแฅแชแแแ แจแแแแแ แแแกแแฃแกแแแแก:
- แแ แแแแ แฎแ แแฎแแแแ แแแ แแแแจแ แแแแแแงแแแแก แ แแแฃแแแ แฃแแ LinkedList แแ แจแแแแแ แแงแ
NPE แแแจแแแแแก แแ แแก. แแแแก แแแแแแ แแแ แจแแกแแซแแแแแแแ ConcurrentLinkedDeque-แแ แแแแแกแแแแ แแ แกแแแฅแ แแแแแแแฃแแ แแแแแแแแ. แฉแแแแแแแก แแแ แแแแ แแแ แแแแขแ แแแแ แฉแแแ (https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/43 ). - แแแฎแกแแแ แแแแก แแแแแแแ; แแแแแจแแแกแแก, แแแแจแแ แแก แแแคแแ แแแชแแ แแ แแจแแแแ (
https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/44 ). - แกแขแ แแแแแแแก แ แแแแแจแ (แ แแแแกแแช แแแ-แกแแแแขแ แแ แแ แแก แแแฎแฃแ แฃแแ แแแแฃแจแแก แแแแแก, แแแแ แแ แแแแแแงแแแแแ แแแแแแแแแแแ แแแแแแจแ), แ แแแแแ แแแแก แจแแแแแแแแ แแ แแฃแจแแแแก (
https://github.com/maciejzaleski/JMeter-WebSocketSampler/issues/19 ).
แแก แแ แแก แแ แ-แแ แแ แแแแแแแ github-แแ. แ แแช แฉแแแ แแแแแแแแแ:
- แแแฆแแก
แฉแแแแแแ แแแแ แแ แแแแแแ (@elyrank) โ แแกแฌแแ แแแก 1 แแ 3 แแ แแแแแแแแก - แแแแแแ แแแฃแแ แแ แแแแแแ 2
- แแแแแฎแแแแฃแแแ แแแ แชแแ 9.2.14-แแแ 9.3.12-แแแ
- แจแแคแฃแแฃแแ SimpleDateFormat ThreadLocal-แจแ; SimpleDateFormat แแ แแ แแก แซแแคแแกแแแแก แฃแกแแคแ แแฎแ, แ แแแแช แแแแแแแ แแแ NPE แแแจแแแแแก แแ แแก
- แแแคแแฅแกแแ แแ แแแฎแกแแแ แแแแก แแแแแ แแ แแ แแแแแแแ (แแแแจแแ แ แแ แแกแฌแแ แแ แแแแฎแฃแ แ แแแแแจแแแกแแก)
แแ แแแแแช แแก แแแแแแแแแ!
แแแฎแกแแแ แแแแก แแแแฌแฃแ แแ แแแแฌแงแ แแ แ แแ แ แแฆแแจแ, แแ แแแแ แแ แจแ. แแ แ แแฆแแ แแงแ แแแ แฉแแแแแ, แแแแขแแ แแแแแแฌแงแแแขแแ แแแแแแแ แแแแแแแก แแแจแแแแ, แแแแ แแ แแแฎ แแแแแขแแ. แแก แกแแแแแ แแกแ แฃแแแ แงแแคแแแแงแ แแแแแแฃแ แแ แแ แแแแ แแก แแแแแแแแแแแจแ.
แแ แ แแฆแ แแแแแแ...
แแฎแแ Hazelcast-แก แแแฎแกแแแ แแแ แแแแแฌแฃแ แ. แแฃแ แแแแแแแ แแฉแแแแ, แ แแ แ แแแแแแแแ แแฆแแก แขแแกแขแแ แแแแก แจแแแแแ, แฐแแแแแแแกแขแแ แแแแฌแงแ แฉแแแแแ แแแฎแกแแแ แแแแก แแแแแแแแแแแ แแ แแแ แแแแฃแแ แแแ แแแแแก แจแแแแแ แแแแกแขแแ แ แแแแจแแแ แแ แแแแแซแแแ แกแแแแแแแ แแแแแแ แซแแแแแแ แกแแแแแแแก. แฉแแแ แแแแฃแแแแจแแ แแ JVisualVM hazelcast-แก แแ แแแแฎแแ โแแแแแแแแแ แฎแแ แฎแโ - แแก แ แแแฃแแแ แฃแแแ แฃแฌแแแแแแ GC-แก, แแแแ แแ แแแฎแกแแแ แแแแก แแแกแฃแคแแแแแแ แแแ แแแฎแแ แฎแแ.
แแฆแแแฉแแแ, แ แแ hazelcast 3.4-แจแ, แ แฃแแแก / แแฃแแขแแแแแแก แฌแแจแแแกแแก (map.destroy()), แแแฎแกแแแ แแแ แแแแแแแแ แแ แแ แแก แแแแแแแแกแฃแคแแแแฃแแ:
แจแแชแแแแ แแฎแแ แแแแแกแฌแแ แแแฃแแแ 3.5-แจแ, แแแแ แแ แแแจแแ แแ แแแแแแ แแงแ. แฉแแแ แจแแแฅแแแแแ แแฎแแแ multiMaps แแแแแแแฃแ แ แกแแฎแแแแแแ แแ แฌแแแจแแแแ แแกแแแ แฉแแแแ แแแแแแแก แแแฎแแแแแ. แแแแ แแกแ แแแแแแงแฃแ แแแแแ:
public void join(Authentication auth, String sub) {
MultiMap<UUID, Authentication> sessions = instance.getMultiMap(sub);
sessions.put(auth.getUserId(), auth);
}
public void leave(Authentication auth, String sub) {
MultiMap<UUID, Authentication> sessions = instance.getMultiMap(sub);
sessions.remove(auth.getUserId(), auth);
if (sessions.size() == 0) {
sessions.destroy();
}
}
แแแแแ:
service.join(auth1, "ะะะะซะ_ะกะะะะฉะะะะฏ_ะ_ะะะกะฃะะะะะะ_UUID1");
service.join(auth2, "ะะะะซะ_ะกะะะะฉะะะะฏ_ะ_ะะะกะฃะะะะะะ_UUID1");
multiMap แจแแแฅแแแ แแแแแแฃแแ แแแแแฌแแ แแกแแแแก แแ แฌแแแจแแแ, แ แแชแ แแ แแงแ แกแแญแแ แ. แแแแแแฌแงแแแขแแ, แ แแ แแแแแแฌแงแ Map , แแแกแแฆแแแ แแฅแแแแ แแแแแฌแแ แแก แกแแฎแแแ, แฎแแแ แแแแจแแแแแแแแแ แแฅแแแแ แกแแกแแแก แแแแแขแแคแแแแขแแ แแแ (แกแแแแแแแช แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ แจแแแแซแแแแ แแแแฆแแ แแแแฎแแแ แแแแแก แแแแแขแแคแแแแขแแ แแแ).
public void join(Authentication auth, String sub) {
addValueToMap(sub, auth.getSessionId());
}
public void leave(Authentication auth, String sub) {
removeValueFromMap(sub, auth.getSessionId());
}
แกแฅแแแแแ แแแฃแแฏแแแแกแแ.
แแแแแ แ แ แแแกแฌแแแแแ แแแขแแแ แแแแก แขแแกแขแแ แแแแก แจแแกแแฎแแ?
- JSR223 แฃแแแ แแแแฌแแ แแก แแ แแแจแ แแ แจแแแชแแแแแก แแแแแแแแชแแแก แฅแแจแ - แแก แแแแ แแ แฃแคแ แ แกแฌแ แแคแแ.
แแแแแแแ . - Jmeter-Plugins แแ แแคแแแแแ แฃแคแ แ แแแแแแแ แแแกแแแแแแ, แแแแ แ แกแขแแแแแ แขแฃแแ.
แแแแแแแ .
Hazelcast-แแแ แฉแแแแ แแแแแชแแแแแแแก แจแแกแแฎแแ
Hazelcast แฉแแแแแแแก แแฎแแแ แแ แแแฃแฅแขแ แแงแ, แฉแแแ แแแแแฌแงแแ แแแกแแแ แแฃแจแแแแ 3.4.1 แแแ แกแแแแแ, แแฎแแ แฉแแแแ แฌแแ แแแแแแก แกแแ แแแ แ แแฃแจแแแแก 3.9.2 แแแ แกแแแแ (แฌแแ แแก แแแแแแขแจแ Hazelcast-แแก แฃแแฎแแแกแ แแแ แกแแ แแ แแก 3.10).
ID แแแแแ แแชแแ
แฉแแแ แแแแแฌแงแแ แแแแแ แ แแชแฎแแแก แแแแแขแแคแแแแขแแ แแแแ. แฌแแ แแแแแแแแแแ, แ แแ แฉแแแ แแแญแแ แแแแ แแแแแ แแ แแ แแแแแ แแฎแแแ แแ แแแฃแแแกแแแแก. แแแแแชแแแแ แแแแแจแ แแแแแแแแแแ แแแ แแ แแ แแก แจแแกแแคแแ แแกแ, แชแฎแ แแแแแ แฉแแ แแฃแแแ แแแฅแฃแชแแแชแแแแจแ - แแแแแแแก, แ แแ DB1-แจแ แแ แแก แจแแขแงแแแแแแแแก ID=1 แแ DB1-แจแ แจแแขแงแแแแแแแแก ID=2, แแ ID-แก แแแ แช Elasticsearch-แจแ แฉแแแแ แแ แแแ แช Hazelcast-แจแ. , แแแแ แแ แงแแแแแแ แชแฃแแ แแก แแ แแก, แแฃ แแกแฃแ แ แแ แ แแแแแชแแแแ แแแแแแแ แแแแแชแแแแแแก แแ แแจแ แแแแ แแแแแแแ (แแแแแแแแแ, แแแแแฌแงแแแขแแ, แ แแ แแ แแ แแแแแชแแแแ แแแแ แกแแแแแ แแกแแ แแ แแแแแแแขแแแแกแแแแก). แแฅแแแ แจแแแแซแแแแ แแแแแแขแแ แ แแแแแแแแ AtomicLongs Hazelcast-แจแ แแ แแฅ แจแแแแแฎแแ แแ แแชแฎแแแแ, แจแแแแแ แแฎแแแ ID-แแก แแแแแแแแแก แจแแกแ แฃแแแแ แแ แแก incrementAndGet แแแฃแก Hazelcast-แแกแแแแก แแแแฎแแแแแก แแ แ. แแแแ แแ Hazelcast-แก แแฅแแก แ แแฆแแช แฃแคแ แ แแแขแแแแแฃแ แ - FlakeIdGenerator. แแแแแแฃแ แแแแแแขแแแ แแแแแแจแแ แแแแกแแก แแแ แแซแแแแแ ID แแแแแแแแแ, แแแแแแแแแ, แแแ แแแแ - 1-แแแ 10-แแแ, แแแแ แแก - 000-แแแ 10-แแแ แแ แ.แจ. แแฎแแ แแแแแแขแก แจแแฃแซแแแ แแแแแฃแแแแแแแแ แแแกแชแแก แแฎแแแ แแแแแขแแคแแแแขแแ แแแ, แกแแแแ แแแกแแ แแแชแแแฃแแ แแแแแแแแแ แแ แแแกแ แฃแแแแแ. แแก แกแฌแ แแคแแ แแฃแจแแแแก, แแแแ แแ แ แแแแกแแช แแฅแแแ แแแแแขแแแ แแแแ แแแแแแแชแแแก (แแ Hazelcast แแแแแแขแก), แแฌแงแแแ แแฎแแแ แแแแแแแแแแ แแแ - แแฅแแแแ แแแแแแแแแแ แ, แแแแแขแแแแแแแ แแ แ.แจ. แแแ แแ แแแแกแ, แแแแแแแแแ แแแก แแแแแแแแแ แแ แแกแแแ, แ แแขแแ แแ แแก ID-แแแ แแแแแ แ แแชแฎแแ, แแแแ แแ แแกแแแ แแกแ แแ แแแแแแแแแแแ แฃแแแ. แงแแแแแคแแ แ แแแฌแแแแ แแ UUID-แแ แแแแแแแแแ.
แกแฎแแแแ แจแแ แแก, แแแแแแแก, แแแกแแช Twitter แแแกแฌแแแก, แแ แแก แแกแแแ Snowcast แแแแแแแแแแ - แแก แแ แแก Snowflake-แแก แแแแฎแแ แชแแแแแแ Hazelcast-แแก แแแแแ. แแแกแ แแแฎแแ แจแแแแซแแแแ แแฅ:
แแแแ แแ แฉแแแ แแแกแแ แแฆแแ แแแแแแแ.
TransactionalMap.replace
แแแแแ แแ แแ แกแแฃแ แแ แแแ: TransactionalMap.replace แแ แแฃแจแแแแก. แแ แขแแกแขแ:
@Test
public void replaceInMap_putsAndGetsInsideTransaction() {
hazelcastInstance.executeTransaction(context -> {
HazelcastTransactionContextHolder.setContext(context);
try {
context.getMap("map").put("key", "oldValue");
context.getMap("map").replace("key", "oldValue", "newValue");
String value = (String) context.getMap("map").get("key");
assertEquals("newValue", value);
return null;
} finally {
HazelcastTransactionContextHolder.clearContext();
}
});
}
Expected : newValue
Actual : oldValue
แแแแแฌแแ แฉแแแ แฉแแแแชแแแแแแก แแแฌแแ แ getForUpdate-แแก แแแแแงแแแแแแ:
protected <K,V> boolean replaceInMap(String mapName, K key, V oldValue, V newValue) {
TransactionalTaskContext context = HazelcastTransactionContextHolder.getContext();
if (context != null) {
log.trace("[CACHE] Replacing value in a transactional map");
TransactionalMap<K, V> map = context.getMap(mapName);
V value = map.getForUpdate(key);
if (oldValue.equals(value)) {
map.put(key, newValue);
return true;
}
return false;
}
log.trace("[CACHE] Replacing value in a not transactional map");
IMap<K, V> map = hazelcastInstance.getMap(mapName);
return map.replace(key, oldValue, newValue);
}
แจแแแแแฌแแแ แแ แ แแฎแแแแ แฉแแแฃแแแแ แแแ แแแแแชแแแแ แกแขแ แฃแฅแขแฃแ แแแ, แแ แแแแ แแแแ แขแ แแแแแฅแชแแแก แแแ แกแแแแแช. แฎแแแแ แแกแ, แ แแ IMap แแฃแจแแแแก, แแแแ แแ TransactionalMap แแฆแแ แแ แกแแแแแก.
แฉแแแแ แแฎแแแ JAR แจแแคแแ แฎแแแแก แแแ แแจแ
แแแ แแแ แ แแแจแ, แแแแแแฌแงแแแขแแ แฉแแแแแฌแแ แ แฉแแแแ แแแแกแแแแก แแแแแฅแขแแแ Hazelcast-แจแ. แแแแแแแแแ, แฉแแแ แแแแฅแแก Application แแแแกแ, แแแแแแ แแแกแ แจแแแแฎแแ แแ แฌแแแแแฎแแ. แฒแแแแ แฉแแแ:
IMap<UUID, Application> map = hazelcastInstance.getMap("application");
map.set(id, application);
แฌแแแแแฎแแ:
IMap<UUID, Application> map = hazelcastInstance.getMap("application");
return map.get(id);
แงแแแแแคแแ แ แแฃแจแแแแก. แจแแแแแ แฉแแแ แแแแแแฌแงแแแขแแ แจแแแแแฅแแแ แแแแแฅแกแ Hazelcast-แจแ, แ แแแ แแแซแแแแแ:
map.addIndex("subscriberId", false);
แแ แแฎแแแ แแ แแแฃแแแก แแแฌแแ แแกแแก, แแแ แแแแฌแงแแก ClassNotFoundException-แแก แแแฆแแแ. Hazelcast-แแ แกแชแแแ แแแแแแขแแแแแ แแแแแฅแกแจแ, แแแแ แแ แแ แแคแแ แ แแชแแแ แฉแแแแ แแแแกแแก แจแแกแแฎแแ แแ แกแฃแ แแ แแ แแแแกแแ JAR แแแแฌแแแแแแแ แแแก. แฉแแแ แกแฌแแ แแ แแก แแแแแแแแแ, แงแแแแแคแแ แ แแฃแจแแแแแ, แแแแ แแ แแแแแฉแแแ แแฎแแแ แแ แแแแแแ: แ แแแแ แแแแแแแฎแแแ JAR แแแแกแขแแ แแก แกแ แฃแแแ แจแแฉแแ แแแแก แแแ แแจแ? Hazelcast แแ แแฆแแแก แแฎแแ JAR-แก แแแแแซแแก แแแแแซแแก แแแแแฎแแแแแก แแ แแก. แแ แแขแแแแ แแแแแแฌแงแแแขแแ, แ แแ แจแแแแแซแแ แชแฎแแแ แแแ แแแแแฅแกแแแแก แซแแแแแก แแแ แแจแ. แแแแแก แแ แแแแแก, แแฃ แแงแแแแแ Hazelcast-แก, แ แแแแ แช แแแกแแฆแแแแก แฆแแ แแแฃแแแแแก แแแฆแแแแแก, แแแจแแ แงแแแแแคแแ แ แแแฃแจแแแแแก? แฒแแแแแแแแ แแ . แแฅ แแกแแ IMap-แแกแ แแ TransactionalMap-แแก แฅแชแแแ แแแแกแฎแแแแแแฃแแแ. แกแแแแช IMap แแ แแแแขแแ แแกแแแก, TransactionalMap แฃแจแแแแก แจแแชแแแแแก.
IMap. แแฌแแ แ 5000 แแแแแฅแขแก, แแแแแฎแฃแแแแ. แงแแแแแคแแ แ แแแกแแแแแแแแแ.
@Test
void get5000() {
IMap<UUID, Application> map = hazelcastInstance.getMap("application");
UUID subscriberId = UUID.randomUUID();
for (int i = 0; i < 5000; i++) {
UUID id = UUID.randomUUID();
String title = RandomStringUtils.random(5);
Application application = new Application(id, title, subscriberId);
map.set(id, application);
Application retrieved = map.get(id);
assertEquals(id, retrieved.getId());
}
}
แแแแ แแ แแก แแ แแฃแจแแแแก แขแ แแแแแฅแชแแแจแ, แฉแแแ แแแฆแแแ ClassNotFoundException:
@Test
void get_transaction() {
IMap<UUID, Application> map = hazelcastInstance.getMap("application_t");
UUID subscriberId = UUID.randomUUID();
UUID id = UUID.randomUUID();
Application application = new Application(id, "qwer", subscriberId);
map.set(id, application);
Application retrievedOutside = map.get(id);
assertEquals(id, retrievedOutside.getId());
hazelcastInstance.executeTransaction(context -> {
HazelcastTransactionContextHolder.setContext(context);
try {
TransactionalMap<UUID, Application> transactionalMap = context.getMap("application_t");
Application retrievedInside = transactionalMap.get(id);
assertEquals(id, retrievedInside.getId());
return null;
} finally {
HazelcastTransactionContextHolder.clearContext();
}
});
}
3.8-แจแ แแแแแฉแแแ แแแแฎแแแ แแแแแก แแแแกแแก แแแแแแแแแแก แแแฅแแแแแแ. แจแแแแซแแแแ แแแแแจแแแ แแ แแ แซแแ แแแแแ แแแแแซแ แแ แแแแแแฎแแแ แแแกแแ JAR แคแแแแ.
แแฎแแ แฉแแแ แแแแแแแแ แจแแแชแแแแแ แฉแแแแ แแแแแแแ: แฉแแแ แแแแแแ แแแแแแแแ แแแก JSON-แจแ แแ แแแแแฎแแแ Hazelcast-แจแ. Hazelcast-แก แแ แกแญแแ แแแแ แฉแแแแ แแแแกแแแแก แกแขแ แฃแฅแขแฃแ แแก แชแแแแ แแ แฉแแแ แจแแแแแซแแแ แแแแแฎแแแแ แจแแคแแ แฎแแแแก แแแ แแจแ. แแแแแแแก แแแแแฅแขแแแแก แแแ แกแแแก แแแแแขแ แแแแแก แแแแแแแชแแ. แแแแแแแชแแแก แกแฎแแแแแกแฎแแ แแแ แกแแ แจแแแซแแแแ แแแจแแแแฃแแ แแงแแก แแ แแแ แแฃแแแ แแ แจแแกแแซแแแแแแแ แกแแขแฃแแชแแ, แ แแแแกแแช แแฎแแแ แแแแแแแชแแ แฌแแ แก แแแแแฅแขแแแก แแฎแแแ แแแแแแแ, แแแแ แแ แซแแแแแ แฏแแ แแ แแชแแก แแ แแแแแแแก แจแแกแแฎแแ. แแ แแแแแแ แแฃแแแ, แแฎแแแ แแแแแแแชแแ แแแแฎแฃแแแแก แซแแแแ แแแแแแแชแแแก แแแแ แแแฌแแ แแ แแแแแฅแขแแแก, แ แแแแแแกแแช แแ แแฅแแ แแฎแแแ แแแแแแ. แฉแแแ แแแแฃแจแแแแแ แแกแแ แกแแขแฃแแชแแแแก แแแแแแแชแแแก แคแแ แแแแแจแ, แแแแ แแ แกแแแแ แขแแแแกแแแแก แฉแแแ แแ แแชแแแแ แแ แแ แแจแแแ แแแแแแก, แฉแแแ แแฎแแแแ แแแคแแ แแแแแ แแแแกแแแก แแฎแแแ แแแแแแแก แแแแแขแแแแ.
แ แแแแ แแฃแแ แฃแแแแแงแแคแ แแแฆแแ แจแแกแ แฃแแแแแก
แแแฎแ แแแแแแฃแ แแแ Hazelcast-แจแ - แแแ แแ, แแ แ แแแแแชแแแแ แแแแแจแ - แชแฃแแ
แแแแแชแแแแ แฅแแจแจแ แแแแแกแแแ แงแแแแแแแแก แฃแแแแแกแแ, แแแแ แ แแแแแชแแแแ แแแแแจแ แแแแแกแแแ, แแแแ แแ แแ แช แแแแแฃแงแแแแแแแ แฉแแแแฌแแ แแแแก แจแแแแฎแแ แแกแฃแ แ. แฉแแแ แแขแแแแแ แแแแแฌแงแแแขแแแแแแก แแแแก แจแแกแแฎแแ, แแฃ แ แ แฃแแแ แแงแแก แฅแแจแแ แแแฃแแ แแแแแแแแ แแแแก แแแแ แแขแแแแแแ. แ แแแแกแแช แแฎแแแ แคแฃแแฅแชแแแแแแแแ แแแแแ แแแฃแแแ, แฉแแแ แฉแแ แแแแ PostgreSQL-แจแ แงแแแแ แแแแฎแแแแแก แแฆแ แแชแฎแแแก (log_min_duration_statement 0-แแแ) แแ แแแฌแแ แแแแแ แแแขแแแ แแแแก แขแแกแขแแ แแแแก 20 แฌแฃแแแก แแแแแแแแแแแจแ. แจแแแ แแแแแฃแแ แแฃแ แแแแแแแก แแแแแงแแแแแแ, แฃแขแแแแขแแแก, แ แแแแ แแชแแ pgFouine แแ pgBadger, แจแแฃแซแแแแ แจแแฅแแแแ แแแแแแขแแแฃแ แ แแแแแ แแจแแแ. แแแแแ แแจแแแจแ, แแแ แแแ แ แแแจแ, แแแซแแแ แแแ แแ แฎแจแแ แจแแแแแฎแแแแก. แแแแ แแแแฎแแแแแแแกแแแแก, แฉแแแ แแฅแแแแ แจแแกแ แฃแแแแแก แแแแแแก (EXPLAIN) แแ แแแคแแกแแแ แจแแกแแซแแแแแแแ แแฃ แแ แ แแกแแแ แแแแฎแแแแแก แแแฉแฅแแ แแแ. แแแแแ แจแแงแแแแแก แแแแแชแแแแแแก แฎแจแแ แ แแแแฎแแแแ แแแ แแแ แฏแแแแ แฅแแจแจแ. แฉแแแ แแชแแแแแแ แจแแแแแแ แฉแฃแแแ แแแแฎแแแแแแ โแแ แขแงแแแโ, แแแแ แแแแแแแแ แแแแ แจแแแแแฎแแแแ.
แแฅแกแแแฃแแขแแชแแ
SV, แ แแแแ แช แแแแแแ แกแแ แแแกแ แแฅแกแแแฃแแขแแชแแแจแ แจแแแแแ 2017 แฌแแแก แแแแแคแฎแฃแแแ, แฎแแแ แ แแแแ แช แชแแแแ แแ แแแฃแฅแขแ, SV แแแแแแแแ 2017 แฌแแแก แแแแแแแ แจแ (แแ แแ แแก แแแขแ แแแ แกแแแก แกแขแแขแฃแกแจแ).
แคแฃแแฅแชแแแแแ แแแแก แแ แ แฌแแแแ แแแขแ แฎแแแก แแแแแแแแแแแจแ CB แแแแแแ แกแแ แแแกแแก แแฃแจแแแแแจแ แกแแ แแแแฃแแ แแ แแแแแแแแ แแ แงแแคแแแ. แฉแแแ แแแแแแ แแแแแ แแแแแแ แกแแ แแแกแก
SV แกแแ แแแ แแก แแแแแฌแแแแแ แแแฌแแแแแฃแแแ แแจแแแแแฃแ แ แแแแแขแแแแก แกแแฎแแ: RPM, DEB, MSI. แแแฃแก Windows-แแกแแแแก แฉแแแ แแแแแแแแแ แแ แ แแแกแขแแแแ แก แแ แแ EXE-แแก แกแแฎแแ, แ แแแแแแช แแแแแแกแขแแแแ แแแก แกแแ แแแ แก, Hazelcast-แก แแ Elasticsearch-แก แแ แ แแแแฅแแแแแ. แฉแแแ แแแแแแแแ แแแแแ แแแกแขแแแแชแแแก แแ แแแ แกแแแก แแฃแฌแแแแแแแ, แ แแแแ แช โแแแแโ แแแ แกแแแก, แแแแ แแ แแฎแแ แชแฎแแแ แแแฎแแ, แ แแ แแก แแ แแก แงแแแแแแ แแแแฃแแแ แฃแแ แแแแแแแแแแก แแแ แแแแขแ.
แฌแงแแ แ: www.habr.com