מדריך לרדיס עם רדיסון

1. סקירה כללית

Redisson הוא לקוח Redis עבור Java. במאמר זה נחקור כמה מתכונותיו ונדגים כיצד הוא יכול להקל על בניית יישומים עסקיים מבוזרים.

Redisson מהווה רשת נתונים בזיכרון המציע אובייקטים ושירותי Java מבוזרים המגובים על ידי Redis. מודל הנתונים המופץ בזיכרון שלו מאפשר שיתוף של אובייקטים ושירותים מתחום בין יישומים ושרתים.

במאמר זה נראה חם להתקין את Redisson, להבין כיצד היא פועלת ולחקור כמה מהאובייקטים והשירותים של Redisson.

2. תלות Maven

בוא נתחיל בייבוא רדיסון לפרויקט שלנו על ידי הוספת הסעיף למטה ל pom.xml:

 org.redisson redisson 3.13.1 

הגרסה האחרונה של תלות זו נמצאת כאן.

3. תצורה

לפני שנתחיל, עלינו לוודא שיש לנו את הגרסה העדכנית ביותר של הגדרת Redis ופועלת. אם אין לך Redis ואתה משתמש בלינוקס או מקינטוש, תוכל לעקוב אחר המידע כאן כדי להגדיר אותו. אם אתה משתמש ב- Windows, אתה יכול להגדיר את Redis באמצעות יציאה לא רשמית זו.

עלינו להגדיר את Redisson כדי להתחבר ל- Redis. Redisson תומכת בחיבורים לתצורות Redis הבאות:

  • צומת יחיד
  • מאסטר עם צמתים עבדים
  • צמתים זקיף
  • צמתים מקובצים
  • צמתים משוכפלים

Redisson תומכת באשכול ElastiCache ב- Amazon Web Services (AWS) ובמטמון Redis Azure עבור צמתים מקובצים ומשוכפלים.

בואו נתחבר למופע יחיד של Redis. מופע זה פועל באופן מקומי ביציאת ברירת המחדל, 6379:

לקוח RedissonClient = Redisson.create ();

אתה יכול להעביר תצורות שונות ל- רדיסון של אובייקט לִיצוֹר שיטה. זה יכול להיות תצורות כדי להתחבר ליציאה אחרת, או אולי להתחבר לאשכול רדיס. זֶה התצורה יכולה להיות בקוד Java או לטעון מקובץ תצורה חיצוני.

3.1. תצורת Java

בואו להגדיר את Redisson בקוד Java:

Config config = Config new (); config.useSingleServer () .setAddress ("redis: //127.0.0.1: 6379"); לקוח RedissonClient = Redisson.create (config);

אָנוּ ציין תצורות Redisson במופע של a תצורה לְהִתְנַגֵד ואז העבירו אותו ל לִיצוֹר שיטה. למעלה ציינו בפני Redisson שאנחנו רוצים להתחבר למופע יחיד של Redis. לשם כך השתמשנו ב- תצורה של אובייקט useSingleServer שיטה. זה מחזיר התייחסות ל- a SingleServerConfig לְהִתְנַגֵד.

ה SingleServerConfig לאובייקט יש הגדרות בהן Redisson משתמש כדי להתחבר למופע יחיד של Redis. הנה, אנו משתמשים בה setAddress שיטה להגדרת התצורה כתובת הגדרה. זה מגדיר את כתובת הצומת שאליו אנו מתחברים. כמה הגדרות אחרות כוללות נסה שוב נסיונות, connectionTimeout ו שם הלקוח. הגדרות אלה מוגדרות בשיטות הקביעה המתאימות להן.

אנו יכולים להגדיר את Redisson עבור תצורות Redis שונות באופן דומה באמצעות ה- תצורה השיטות הבאות של האובייקט:

  • useSingleServer - למופע של צומת יחיד. קבל כאן הגדרות צומת יחיד
  • useMasterSlaveServers - לאדון עם צמתים עבדים. קבל כאן את הגדרות הצומת הראשי-עבד
  • useSentinelServers - עבור צמתים זקיף. קבל כאן את הגדרות הצומת הזקיף
  • useClusterServers - עבור צמתים מקובצים. קבל כאן הגדרות צומת מקובצות
  • useReplicatedServers - עבור צמתים משוכפלים. קבל הגדרות צומת משוכפלות כאן

3.2. תצורת קבצים

Redisson יכול לטעון תצורות מ- JSON חיצוני או YAML קבצים:

Config config = Config.fromJSON (קובץ חדש ("singleNodeConfig.json")); לקוח RedissonClient = Redisson.create (config);

ה תצורה של אובייקט מאת ג'סון השיטה יכולה לטעון תצורות ממחרוזת, קובץ, זרם קלט או URL.

להלן תצורת הדוגמה ב- singleNodeConfig.json קוֹבֶץ:

{"singleServerConfig": {"idleConnectionTimeout": 10000, "connectTimeout": 10000, "timeout": 3000, "retryAttempts": 3, "retryInterval": 1500, "password": null, "subscriptionsPerConnection": 5, "clientName ": null," address ":" redis: //127.0.0.1: 6379 "," subscriptionConnectionMinimumIdleSize ": 1," subscriptionConnectionPoolSize ": 50," connectionMinimumIdleSize ": 10," connectionPoolSize ": 64," database ": 0, "dnsMonitoringInterval": 5000}, "threads": 0, "nettyThreads": 0, "codec": null}

הנה קובץ תצורה מתאים של YAML:

singleServerConfig: idleConnectionTimeout: 10000 connectTimeout: 10000 timeout: 3000 ניסיון שוב: 3 ניסיון מחדשInterval: 1500 סיסמא: מינויים nullPerConnection: 5 לקוח שם: כתובת null: "redis: //127.0.0.1: 6379" מנוי חיבור מינימום Idle גודל: 1 מנוי חיבור גודל: גודל חיבור: גודל חיבור: גודל מסד נתונים 64: 0 dns ניטור מרווח: 5000 אשכולות: 0 לאשכולות: 0 קודקים:! {} 

אנו יכולים להגדיר תצורות Redis אחרות מקובץ באופן דומה באמצעות הגדרות המיוחדות לתצורה זו. לעיונך, הנה פורמטים של קבצי JSON ו- YAML:

  • צומת יחיד - פורמט
  • מאסטר עם צמתים עבדים - פורמט
  • צמתים זקיף - פורמט
  • צמתים מקובצים - פורמט
  • צמתים משוכפלים - פורמט

כדי לשמור תצורת Java בתבנית JSON או YAML, אנו יכולים להשתמש ב- toJSON אוֹ toYAML שיטות של תצורה לְהִתְנַגֵד:

Config config = Config new (); // ... אנו מגדירים מספר הגדרות כאן ב- Java String jsonFormat = config.toJSON (); מחרוזת yamlFormat = config.toYAML ();

עכשיו כשאנחנו יודעים להגדיר את תצורת Redisson, בואו נסתכל כיצד Redisson מבצעת פעולות.

4. מבצע

Redisson תומך בממשקים סינכרוניים, אסינכרוניים ותגובתיים. פעולות על אלה ממשקים הם חוטים בטוחים.

כל הגופים (אובייקטים, אוספים, מנעולים ושירותים) שנוצרו על ידי RedissonClient יש שיטות סינכרוניות ואסינכרוניות. שיטות סינכרוניות נושאות גרסאות אסינכרוניות. בדרך כלל שיטות אלה נושאות את אותו שם השיטה של ​​הגרסאות הסינכרוניות שלהן המצורפות "Async". בואו נסתכל על שיטה סינכרונית של ה- RAtomicLong לְהִתְנַגֵד:

לקוח RedissonClient = Redisson.create (); RAtomicLong myLong = client.getAtomicLong ('myLong'); 

הגרסה האסינכרונית של הסינכרוני CompareAndSet השיטה תהיה:

RFuture isSet = myLong.compareAndSetAsync (6, 27);

הגרסה האסינכרונית של השיטה מחזירה RFuture לְהִתְנַגֵד. אנו יכולים להגדיר מאזינים לאובייקט זה להחזיר את התוצאה כשהיא תהיה זמינה:

isSet.handle ((תוצאה, חריג) -> {// לטפל בתוצאה או בחריג כאן.});

כדי ליצור אובייקטים תגובתיים, נצטרך להשתמש ב- RedissonReactiveClient:

לקוח RedissonReactiveClient = Redisson.createReactive (); RAtomicLongReactive myLong = client.getAtomicLong ("myLong"); מפרסם isSetPublisher = myLong.compareAndSet (5, 28);

שיטה זו מחזירה אובייקטים תגובתי המבוססים על תקן הזרמים התגובתי עבור Java 9.

בואו נחקור כמה מהאובייקטים שהופצו על ידי רדיסון.

5. אובייקטים

מופע פרטני של א אובייקט Redisson מסודר בסידור ומאוחסן בכל אחד מצמתי Redis הזמינים המגבים Redisson. אובייקטים אלה יכולים להיות מופצים באשכול על פני מספר צמתים וניתן לגשת אליהם באמצעות יישום יחיד או מספר יישומים / שרתים.

אובייקטים מבוזרים אלה עוקבים אחר המפרט של חבילת java.util.concurrent.atomic. הם תומכים בניתוחים ללא נעילה, בטיחות חוטים ואטומים על עצמים המאוחסנים ברדיס. אחידות הנתונים בין יישומים / שרתים מובטחת מכיוון שערכים לא מתעדכנים בזמן שאפליקציה אחרת קוראת את האובייקט.

אובייקטים של רדיסון קשורים למפתחות רדיס. אנו יכולים לנהל את המפתחות הללו באמצעות מפתחות מִמְשָׁק. ואז אנו ניגשים לאובייקטים של Redisson באמצעות המקשים האלה.

ישנן מספר אפשרויות בהן נשתמש כדי להשיג את מקשי Redis.

אנחנו יכולים פשוט להשיג את כל המקשים:

מפתחות RKeys = client.getKeys ();

לחלופין, אנו יכולים לחלץ רק את השמות:

ניתן לשנות את כל המפתחות = keys.getKeys ();

ולבסוף, אנו מסוגלים להשיג את המפתחות בהתאם לתבנית:

KeysByPattern Iterable = keys.getKeysByPattern ('מפתח *')

ממשק RKeys מאפשר גם מחיקת מקשים, מחיקת מקשים לפי תבנית ופעולות שימושיות אחרות מבוססות-מפתח בהן נוכל להשתמש כדי לנהל את המפתחות והאובייקטים שלנו.

אובייקטים מבוזרים המסופקים על ידי Redisson כוללים:

  • ObjectHolder
  • BinaryStreamHolder
  • GeospatialHolder
  • BitSet
  • AtomicLong
  • AtomicDouble
  • נוֹשֵׂא
  • BloomFilter
  • HyperLogLog

בואו נסתכל על שלושה מחפצים אלה: ObjectHolder, AtomicLong, ו נוֹשֵׂא.

5.1. בעל חפץ

מיוצג על ידי RBucket בכיתה, האובייקט הזה יכול להכיל כל סוג של אובייקט. הגודל המרבי של אובייקט זה הוא 512MB:

דלי RBucket = client.getBucket ("ספר חשבונות"); bucket.set (ספר חדש ()); ספר ספר חשבונות = bucket.get ();

ה RBucket האובייקט יכול לבצע פעולות אטומיות כגון CompareAndSet ו-getAndSet על חפצים שהוא מחזיק.

5.2. AtomicLong

מיוצג על ידי RAtomicLong בכיתה, האובייקט הזה דומה מאוד ל java.util.concurrent.atomic.AtomicLong מחלקה ומייצגת א ארוך ערך שניתן לעדכן באופן אטומי:

RAtomicLong atomicLong = client.getAtomicLong ("myAtomicLong"); atomicLong.set (5); atomicLong.incrementAndGet ();

5.3. נוֹשֵׂא

ה נוֹשֵׂא האובייקט תומך במנגנון "לפרסם ולהירשם" של Redis. להאזנה להודעות שפורסמו:

RTopic subscribeTopic = client.getTopic ("baeldung"); subscribeTopic.addListener (CustomMessage.class, (channel, customMessage) -> future.complete (customMessage.getMessage ()));

מעל ה נוֹשֵׂא רשום להאזנה להודעות מערוץ "baeldung". לאחר מכן אנו מוסיפים מאזין לנושא כדי לטפל בהודעות נכנסות מאותו ערוץ. אנו יכולים להוסיף מספר מאזינים לערוץ.

בואו נפרסם הודעות לערוץ "baeldung":

RTopic publishTopic = client.getTopic ("baeldung"); long clientsReceivedMessage = publishTopic.publish (CustomMessage חדש ("זו הודעה"));

זה יכול להתפרסם מיישום או שרת אחר. ה הודעה מותאמת אישית האובייקט יתקבל על ידי המאזין ויעובד כהגדרתו ב- onMessage שיטה.

אנו יכולים ללמוד עוד על אובייקטים אחרים של Redisson כאן.

6. אוספים

אנו מטפלים באוספי רדיסון באותו אופן בו אנו מטפלים בחפצים.

האוספים המופצים המסופקים על ידי Redisson כוללים:

  • מַפָּה
  • מולטימפה
  • מַעֲרֶכֶת
  • SortedSet
  • ScoredSortedSet
  • לקסSortedSet
  • רשימה
  • תוֹר
  • דק
  • BlockingQueue
  • BoundedBlockingQueue
  • BlockingDeque
  • BlockingFairQueue
  • עיכוב תור
  • PriorityQueue
  • PriorityDeque

בואו נסתכל על שלוש מהאוספים האלה: מפה, סט, ו רשימה.

6.1. מַפָּה

מפות מבוססות Redisson מיישמות את java.util.concurrent.ConcurrentMap ו java.util.Map ממשקים. לרדיסון יש ארבעה יישומי מפות. אלו הם RMap, RMapCache, RLocalCachedMap ו RClusteredMap.

בואו ליצור מפה עם Redisson:

RMap map = client.getMap ("ספר חשבונות"); ספר חדש newLedger = map.put ("123", ספר חדש ()); מפה

RMapCache תומך בפינוי כניסת מפות. RLocalCachedMap מאפשר שמירה מקומית של רשומות מפה. RClusteredMap מאפשר לפצל נתונים ממפה אחת על פני צמתים ראשוניים של אשכול Redis.

אנו יכולים ללמוד עוד על מפות רדיסון כאן.

6.2. מַעֲרֶכֶת

מבוסס על רדיסון מַעֲרֶכֶת מיישם את java.util.Set מִמְשָׁק.

לרדיסון יש שלוש מַעֲרֶכֶת יישומים, RSet, RSetCache, ו RClusteredSet עם פונקציונליות דומה לזו של עמיתיהם במפה.

בואו ניצור מַעֲרֶכֶת עם רדיסון:

RSet ledgerSet = client.getSet ("ledgerSet"); ledgerSet.add (ספר חדש ());

אנו יכולים ללמוד עוד על ערכות Redisson כאן.

6.3. רשימה

מבוסס רדיסון רשימות ליישם את java.util.List מִמְשָׁק.

בואו ניצור רשימה עם רדיסון:

RList ledgerList = client.getList ("ledgerList"); ledgerList.add (ספר חדש ());

אנו יכולים ללמוד עוד על אוספי Redisson אחרים כאן.

7. מנעולים ומסנכרנים

של רדיסון מנעולים מבוזרים מאפשרים סנכרון חוטים על פני יישומים / שרתים. רשימת המנעולים והסנכרונים של Redisson כוללת:

  • לנעול
  • FairLock
  • MultiLock
  • ReadWriteLock
  • סֵמָפוֹר
  • PermitExpizableSemaphore
  • CountDownLatch

בואו נסתכל על לנעול ו MultiLock.

7.1. לנעול

של רדיסון לנעול מכשירים java.util.concurrent.locks.Lock מִמְשָׁק.

בואו נשתמש במנעול המיוצג על ידי RLock מעמד:

נעילת RLock = client.getLock ("נעילה"); lock.lock (); // לבצע כמה פעולות ארוכות ... lock.unlock ();

7.2. MultiLock

של רדיסון RedissonMultiLock קבוצות מרובות RLock חפצים ומתייחסת אליהם כמנעול יחיד:

RLock lock1 = clientInstance1.getLock ("lock1"); RLock lock2 = clientInstance2.getLock ("lock2"); RLock lock3 = clientInstance3.getLock ("lock3"); נעילת RedissonMultiLock = RedissonMultiLock חדש (lock1, lock2, lock3); lock.lock (); // לבצע פעולת ריצה ארוכה ... lock.unlock ();

אנו יכולים ללמוד עוד על מנעולים אחרים כאן.

8. שירותים

Redisson חושפת 4 סוגים של שירותים מבוזרים. אלו הם: שירות מרחוק, שירות אובייקטים חיים, שירות המוציא לפועל ו שירות ביצועים מתוזמן. בואו נסתכל על השירות מרחוק ושירות אובייקטים חיים.

8.1. שירות מרחוק

שירות זה מספק הפעלת שיטת Java מרחוק בהנחיית Redis. שירות מרחוק של Redisson מורכב מיישום בצד השרת (מופע עובד) ומימוש בצד הלקוח. היישום בצד השרת מבצע שיטה מרוחקת שמופעלת על ידי הלקוח. שיחות משירות מרוחק יכולות להיות סינכרוניות או אסינכרוניות.

צד השרת רושם ממשק להפעלה מרחוק:

RRemoteService remoteService = client.getRemoteService (); LedgerServiceImpl ledgerServiceImpl = LedgerServiceImpl חדש (); remoteService.register (LedgerServiceInterface.class, ledgerServiceImpl);

צד הלקוח קורא לשיטה של ​​הממשק המרוחק הרשום:

RRemoteService remoteService = client.getRemoteService (); LedgerServiceInterface ledgerService = remoteService.get (LedgerServiceInterface.class); ערכי רשימה = ledgerService.getEntries (10);

אנו יכולים ללמוד עוד על שירותים מרוחקים כאן.

8.2. שירות אובייקטים חיים

אובייקטים חיים של Redisson מרחיבים את הרעיון של אובייקטים סטנדרטיים של Java, אליהם ניתן היה לגשת רק מ- JVM יחיד ל- אובייקטי Java משופרים שניתן לשתף בין JVM שונים במכונות שונות. זה נעשה על ידי מיפוי שדות של אובייקט לחשיש רדיס. מיפוי זה נעשה באמצעות מחלקת פרוקסי שנבנתה בזמן ריצה. מקבלי שדה וקובעי שדה ממופים לפקודות Redis hget / hset.

אובייקטים חיים של רדיסון תומכים בגישה לשדה האטומי כתוצאה מהטבע החד-הברגי של רדיס.

יצירת אובייקט חי היא פשוטה:

@REntity מחלקה ציבורית LedgerLiveObject {@RId שם מחרוזת פרטי; // גטרים וקובעים ...}

אנו מציינים את הכיתה שלנו עם @ REntity ושדה ייחודי או מזהה עם @לְשַׁחְרֵר. לאחר שעשינו זאת, נוכל להשתמש באובייקט החי שלנו ביישום שלנו:

שירות RLiveObjectService = client.getLiveObjectService (); LedgerLiveObject Ledger = LedgerLiveObject חדש (); ledger.setName ("ledger1"); ספר חשבונות = service.persist (ספר חשבונות);

אנו יוצרים את האובייקט החי שלנו כמו אובייקטים סטנדרטיים של Java באמצעות ה- חָדָשׁ מילת מפתח. לאחר מכן אנו משתמשים במופע של RLiveObjectService כדי לשמור את האובייקט ל- Redis באמצעות שלו להתמיד שיטה.

אם האובייקט נמשך בעבר ל- Redis, אנו יכולים לאחזר את האובייקט:

LedgerLiveObject returnLedger = service.get (LedgerLiveObject.class, "ledger1");

אנו משתמשים ב- RLiveObjectService כדי לקבל את האובייקט החי שלנו באמצעות השדה עם הערות @לְשַׁחְרֵר.

כאן אנו יכולים למצוא מידע נוסף על אובייקטים חיים של רדיסון, ושירותי רדיסון אחרים מתוארים כאן.

9. צנרת

רדיסון תומכת בצנרת. ניתן לתאם פעולות מרובות כפעולה אטומית אחת. זה מקל על ידי RBatch מעמד. פקודות מרובות מצטברות כנגד RBatch מופע אובייקט לפני שהם מבוצעים:

אצווה RBatch = client.createBatch (); batch.getMap ("ledgerMap"). fastPutAsync ("1", "2"); batch.getMap ("ledgerMap"). putAsync ("2", "5"); BatchResult batchResult = batch.execute ();

10. תסריטאות

Redisson תומך ב- scripting של LUA. אנחנו יכולים לבצע סקריפטים של LUA נגד Redis:

client.getBucket ("foo"). set ("bar"); תוצאת מחרוזת = client.getScript (). Eval (Mode.READ_ONLY, "return redis.call ('get', 'foo')", RScript.ReturnType.VALUE);

11. לקוח ברמה נמוכה

יתכן ונרצה לבצע פעולות רדיס שעדיין אינן נתמכות על ידי רדיסון. Redisson מספקת לקוח ברמה נמוכה המאפשר ביצוע פקודות Redis מקוריות:

RedisClientConfig redisClientConfig = חדש RedisClientConfig (); redisClientConfig.setAddress ("localhost", 6379); לקוח RedisClient = RedisClient.create (redisClientConfig); RedisConnection conn = client.connect (); conn.sync (StringCodec.INSTANCE, RedisCommands.SET, "test", 0); conn.closeAsync (); client.shutdown ();

הלקוח ברמה נמוכה תומך גם בפעולות אסינכרוניות.

12. מסקנה

מאמר זה הציג את Redisson ואת חלק מהתכונות שהופכות אותו לאידיאלי לפיתוח יישומים מבוזרים. בחנו את האובייקטים המופצים שלה, אוספים, מנעולים ושירותים. בדקנו גם כמה מהתכונות האחרות שלו, כגון צינורות, סקריפטים ולקוח ברמה נמוכה.

רדיסון מספקת גם שילוב עם מסגרות אחרות כגון ה- JCache API, Spring Cache, Cache Hibernate ו- Spring Sessions. אנו יכולים ללמוד עוד על שילובו עם מסגרות אחרות כאן.

אתה יכול למצוא דוגמאות קוד בפרויקט GitHub.


$config[zx-auto] not found$config[zx-overlay] not found