streamalism.org

1. הקדמה

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

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

2. התקנה והתקנה

כהתחלה, עיין בדף ההתחלה לקבלת הוראות ההתקנה וההתקנה הראשוניות.

התלות של Maven ליישום שאנחנו הולכים לבנות:

 org.apache.ignite ignite-core $ {ignite.version} org.apache.ignite ignite-indexing $ {ignite.version} 

הצתה-ליבה היא התלות החובה היחידה בפרויקט. כמו שאנחנו רוצים גם לתקשר עם SQL, הצתה-אינדקס נמצא גם כאן. $ {ignite.version} היא הגרסה האחרונה של Apache Ignite.

כצעד האחרון, אנו מתחילים את הצומת Ignite:

הצומת הצתה התחיל בסדר (id = 53c77dea) תמונת מצב טופולוגית [ver = 1, שרתים = 1, לקוחות = 0, מעבדים = 4, offheap = 1.2GB, heap = 1.0GB] אזורי נתונים מוגדרים: ^ - ברירת מחדל [initSize = 256.0 MiB, maxSize = 1.2 GiB, persistenceEnabled = false]

פלט המסוף שלמעלה מראה שאנחנו מוכנים לצאת לדרך.

3. אדריכלות זיכרון

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

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

ארכיטקטורת זיכרון עמידה מתחלקת לבלוקים בגודל קבוע הנקרא עמודים. דפים מאוחסנים מחוץ לערמת ג'אווה ומאורגנים ב- RAM. יש לו מזהה ייחודי: FullPageId.

דפים מקיימים אינטראקציה עם הזיכרון באמצעות ה- PageMemory הַפשָׁטָה.

זה עוזר לקרוא, לכתוב דף, וגם להקצות מזהה דף. בתוך הזיכרון, Ignite משייך עמודים מאגרי זיכרון.

4. דפי זיכרון

לדף יכולות להיות המצבים הבאים:

• לא פורק - שום מאגר עמודים נטען בזיכרון
• נקה - מאגר העמודים נטען ומסונכרן עם הנתונים בדיסק
• Durty - מאגר הדפים מכיל נתונים שונים מאלה שבדיסק
• מלוכלך במחסום - יש שינוי נוסף שמתחיל לפני שהראשון ממשיך לדיסק. כאן מתחיל מחסום ו PageMemory שומר על שני מאגרי זיכרון לכל דף.

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

הקיבולת המרבית של האזור היא מגזר זיכרון. זהו זיכרון פיזי או מערך בתים רציף.

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

אינדקסים של SQL ומטמון מאוחסנים במבנים המכונים B + Trees. מקשי המטמון מסודרים לפי ערכי המפתח שלהם.

5. מחזור חיים

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

בואו נעבור על סוגי האירועים במחזור החיים:

• BEFORE_NODE_START - לפני ההפעלה של הצומת Ignite
• AFTER_NODE_START - יורה ממש לאחר תחילת הצומת Ignite
• BEFORE_NODE_STOP - לפני שתתחיל את עצירת הצומת
• AFTER_NODE_STOP - לאחר שהצומת Ignite נעצר

להפעלת צומת ברירת מחדל של הצתה:

Ignite ignite = Ignition.start ();

או מקובץ תצורה:

Ignite ignite = Ignition.start ("config / example-cache.xml");

במקרה שנזדקק לשליטה רבה יותר בתהליך האתחול, יש דרך אחרת בעזרת LifecycleBean מִמְשָׁק:

מחלקה ציבורית CustomLifecycleBean מיישמת את LifecycleBean {@Override public void onLifecycleEvent (LifecycleEventType lifecycleEventType) זורק את IgniteException {if (lifecycleEventType == LifecycleEventType.AFTER_NODE_START) {// ...}}}

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

לשם כך אנו מעבירים את מופע התצורה עם ה- CustomLifecycleBean לשיטת ההתחלה:

תצורת IgniteConfiguration = חדש IgniteConfiguration (); configuration.setLifecycleBeans (CustomLifecycleBean חדש ()); Ignite ignite = Ignition.start (תצורה);

6. רשת נתונים בזיכרון

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

זה יכול לספק שיפור ביצועים משמעותי בתוכנות צד שלישי, כמו NoSql, מסדי נתונים של RDMS כשכבה נוספת למטמון.

6.1. תמיכה במטמון

ממשק ה- API לגישה לנתונים מבוסס על מפרט JCache JSR 107.

כדוגמה, בואו ליצור מטמון באמצעות תצורת תבנית:

מטמון IgniteCache = ignite.getOrCreateCache ("baeldingCache");

בואו נראה מה קורה כאן לפרטים נוספים. ראשית, Ignite מוצא את אזור הזיכרון בו נשמר המטמון.

לאחר מכן, דף אינדקס העץ B + ימוקם על בסיס קוד ה- hash של המפתח. אם האינדקס קיים, ימצא דף נתונים של המפתח המתאים.

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

הבא, בואו נוסיף כמה עוֹבֵד חפצים:

cache.put (1, עובד חדש (1, "ג'ון", נכון)); cache.put (2, עובד חדש (2, "אנה", שקר)); cache.put (3, עובד חדש (3, "ג'ורג '", נכון));

שוב, הזיכרון העמיד יחפש את אזור הזיכרון אליו שייך המטמון. בהתבסס על מפתח המטמון, דף האינדקס ממוקם במבנה עץ + B.

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

לאחר מכן, דף נתונים מוקצה לדף האינדקס.

כדי לקרוא את העובד מהמטמון, אנו פשוט משתמשים בערך המפתח:

עובד שכיר = cache.get (1);

6.2. תמיכה בסטרימינג

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

אנו יכולים לשנות את הדוגמה שלנו ולהזרים את הנתונים מהקובץ. ראשית, אנו מגדירים סטרימר נתונים:

IgniteDataStreamer streamer = הצית. DataStreamer (cache.getName ());

בשלב הבא נוכל לרשום שנאי זרם כדי לסמן את העובדים שהתקבלו כמועסקים:

streamer.receiver (StreamTransformer.from ((e, arg) -> {עובד שכיר = e.getValue (); עובד.סט.עובד (נכון); e.setValue (עובד); עובד חוזר;}));

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

נתיב נתיב = Paths.get (IgniteStream.class.getResource ("עובדים.טקסט") .toURI ()); Gson gson = Gson חדש (); Files.lines (path) .forEach (l -> streamer.addData (employee.getId (), gson.fromJson (l, Employee.class)));

בשימוש של streamer.addData () הכניס את החפצים לעובד לזרם.

7. תמיכה ב- SQL

הפלטפורמה מספקת מסד נתונים SQL ממוקד זיכרון וסובל מתקלות.

אנחנו יכולים להתחבר עם ממשק API טהור של SQL או עם JDBC. תחביר SQL כאן הוא ANSI-99, כך שכל פונקציות הצבירה הסטנדרטיות בשאילתות, פעולות שפה DML, DDL נתמכות.

7.1. JDBC

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

למטרה הזאת, אנו רושמים מנהל התקן של JDBC ופותחים חיבור כשלב הבא:

Class.forName ("org.apache.ignite.IgniteJdbcThinDriver"); חיבור conn = DriverManager.getConnection ("jdbc: ignite: thin: //127.0.0.1/");

בעזרת פקודת DDL הרגילה, אנו מאכלסים את ה- עוֹבֵד שולחן:

sql.executeUpdate ("צור טבלה עובד (" + "מזהה מפתח ראשי ארוך, שם VARCHAR, הוא עובד זעיר (1))" + "עם \" תבנית = משוכפל \ "");

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

לאחר מכן, בואו נסביר נתונים באמצעות הצהרת INSERT DML:

PreparedStatement sql = conn.prepareStatement ("הכנס לעובד (מזהה, שם, הוא עובד) ערכים (?,?,?)"); sql.setLong (1, 1); sql.setString (2, "ג'יימס"); sql.setBoolean (3, נכון); sql.executeUpdate (); // להוסיף את השאר 

לאחר מכן אנו בוחרים את הרשומות:

ResultSet rs = sql.executeQuery ("בחר E.name, e.isEm Employed" + "FROM Employee e" + "WHERE e.isEm Employed = TRUE")

7.2. שאילת האובייקטים

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

מטמון IgniteCache = ignite.cache ("baeldungCache"); SqlFieldsQuery sql = SqlFieldsQuery חדש ("בחר שם מהעובד איפה isEm Employed = 'נכון'"); QueryCursor סמן = cache.query (sql); עבור (שורה שורה: סמן) {// לעשות משהו עם השורה}

8. סיכום

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

כתוצאה, למדנו כיצד להשתמש בשפת SQL ו- Java API לצורך אחסון, אחזור, הזרמת הנתונים בתוך רשת ההתמדה או הזיכרון.

כרגיל, הקוד השלם למאמר זה זמין באתר GitHub.