streamalism.org

1. הקדמה

אטומיקוס הוא ספריית עסקאות ליישומי Java. במדריך זה נבין מדוע ואיך להשתמש ב- Atomikos.

בתהליך נעבור גם על יסודות העסקאות ומדוע אנו זקוקים להן.

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

2. הבנת היסודות

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

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

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

2.1. עסקה מקומית לעומת מבוזרת

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

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

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

2.2. XA Specification ו- Java Transaction API

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

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

API ל- Java Transaction API (JTA) הוא ממשק API של Java Enterprise Edition שפותח בתהליך Java Community. זה מאפשר ליישומי Java ולשרתי יישומים לבצע עסקאות מבוזרות על פני משאבי XA.

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

3. מבוא לאטומיקוס

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

3.1. מה זה Atomikos

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

בדרך כלל, שרת היישומים מספק יישום ברירת מחדל של מנהל העסקאות. לדוגמה, במקרה של Enterprise Java Beans (EJB), מכולות EJB מנהלות התנהגות עסקאות ללא התערבות מפורשת של מפתחי יישומים. עם זאת, במקרים רבים זה לא יכול להיות אידיאלי, ואולי נצטרך שליטה ישירה על העסקה ללא תלות בשרת היישומים.

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

3.2. אדריכלות אטומיקוס

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

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

3.3. הצעות מוצר Atomikos

Atomikos הוא מנהל עסקאות מבוזר שמציע יותר תכונות ממה שמציע JTA / XA. יש לו מוצר קוד פתוח והיצע מסחרי מקיף הרבה יותר:

• עסקאות יסודות: Atomikos ' מוצר קוד פתוח המספק מנהל עסקאות JTA / XA ליישומי Java עבודה עם מאגרי מידע ותורי הודעות. זה שימושי בעיקר למטרות בדיקה והערכה.
• עסקאות אקסטרים: הצעה מסחרית של Atomikos, המציעה עסקאות מבוזרות על פני יישומים מורכבים, כולל שירותי REST מלבד מאגרי מידע ותורי הודעות. זה שימושי לבניית יישומים המבצעים עיבוד טרנזקציות קיצוניות (XTP).

במדריך זה נשתמש בספריית TransactionsEssentials כדי לבנות ולהדגים את היכולות של Atomikos.

4. הקמת Atomikos

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

4.1. תלות

ראשית, עלינו להגדיר את התלות. כאן, כל שעלינו לעשות הוא להכריז על התלות במאבן שלנו pom.xml קוֹבֶץ:

 עסקאות com.atomikos-jdbc 5.0.6 com.atomikos עסקאות-jms 5.0.6 

אנו משתמשים בתלות Atomikos עבור JDBC ו- JMS במקרה זה, אך תלות דומה קיימות ב- Maven Central עבור משאבים אחרים של תלונות XA.

4.2. תצורות

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

com.atomikos.icatch.file = נתיב_ל_קובץ שלך

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

4.3. מאגרי מידע

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

במאגר המלאי שלנו תהיה טבלה פשוטה לאירוח מלאי מוצרים:

צור מלאי טבלה (מפתח ראשוני VARCHAR מפתח, איזון INT);

ומאגר ההזמנות שלנו יכלול טבלה פשוטה לאירוח הזמנות שביצעו:

צור הזמנות טבלה (הזמנה מפתח ראשוני VARCHAR, מפתח מוצר VARCHAR, כמות INT לא בדיקת NULL (כמות <= 5));

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

5. עבודה עם Atomikos

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

5.1. מיידי UserTransaction

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

ראשית, עלינו לייצר א UserTransaction מאתומיקוס:

UserTransactionImp utx = UserTransactionImp חדש ();

5.2. מיידי מקור מידע

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

הראשון, AtomikosDataSourceBean, מודע לבסיס XADataSource:

AtomikosDataSourceBean dataSource = AtomikosDataSourceBean חדש ();

בזמן AtomikosNonXADataSourceBean משתמש בכל מחלקת נהגים רגילה של JDBC:

AtomikosNonXADataSourceBean dataSource = חדש AtomikosNonXADataSourceBean ();

כמו שהשם מרמז, AtomikosNonXADataSource אינו תואם XA. מכאן שלא ניתן להבטיח שעסקאות שבוצעו עם מקור נתונים כזה יהיו אטומיות. אז מדוע אי פעם נשתמש בזה? ייתכן שיש לנו מסד נתונים כלשהו שאינו תומך במפרט XA. Atomikos אינה אוסרת עלינו להשתמש במקור נתונים כזה ועדיין מנסה לספק אטומיות אם יש מקור נתונים כזה בעסקה. טכניקה זו דומה ל- Gambit Resource Last, וריאציה של תהליך ההתחייבות הדו-פאזי.

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

5.3. ביצוע פעולות בסיס נתונים

לאחר ההגדרה, זה די קל לשימוש מקור מידע במסגרת עסקה ביישום שלנו:

מקום ריק ריק מקום (סדר מחרוזת, כמות int) זורק חריג {סדר מחרוזת = UUID.randomUUID (). toString (); החזרת בוליאני = שקר; נסה את {utx.begin (); חיבור מלאי חיבור = רשימת מלאי נתונים. חיבור orderConnection = orderDataSource.getConnection (); הצהרה s1 = inventoryConnection.createStatement (); מחרוזת q1 = "עדכון מלאי להגדיר יתרה = יתרה -" + סכום + "כאשר productId = '" + productId + "'"; s1.executeUpdate (q1); s1.close (); הצהרה s2 = orderConnection.createStatement (); מחרוזת q2 = "הכנס לערכי הזמנות ('" + orderId + "', '" + productId + "'," + amount + ")"; s2.executeUpdate (q2); s2.close (); inventConnection.close (); orderConnection.close (); } לתפוס (חריג e) {rollback = true; } סוף סוף {if (! rollback) utx.commit (); אחרת utx.rollback (); }}

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

5.4. בדיקת התנהגות עסקית

לבסוף, עלינו להיות מסוגלים לבדוק את היישום שלנו באמצעות בדיקות יחידה פשוטות כדי לאמת שהתנהגות העסקה היא כצפוי:

@Test בטל ציבורי testPlaceOrderSuccess () זורק חריג {int כמות = 1; initialBalance ארוך = getBalance (voorraadDataSource, productId); יישום יישום = יישום חדש (inventDataSource, orderDataSource); application.placeOrder (productId, סכום); finalBalance ארוך = getBalance (inventoryDataSource, productId); assertEquals (איזון ראשוני - סכום, איזון סופי); } @Test בטל ציבורי testPlaceOrderFailure () זורק חריג {int amount = 10; initialBalance ארוך = getBalance (inventoryDataSource, productId); יישום יישום = יישום חדש (inventDataSource, orderDataSource); application.placeOrder (productId, סכום); finalBalance ארוך = getBalance (inventoryDataSource, productId); assertEquals (initialBalance, finalBalance); }

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

5.5. שימוש מתקדם של Atomikos

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

כמובן, זה לא הכרחי להשתמש תמיד במתאמי Atomikos עבור JDBC / JMS. אנו יכולים לבחור להשתמש במנהל העסקאות של Atomikos תוך כדי עבודה ישירה עם XAResource. עם זאת, במקרה זה, עלינו לדאוג במפורש להתגייס ולמחיקת המנויים XAResource מקרים עם שירות העסקה.

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

6. שילוב Atomikos

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

6.1. אטומיקוס עם אביב ו מקור מידע

אביב הוא אחת המסגרות הפופולריות בג'אווה המספקת מכולה של היפוך בקרה (IoC). יש לציין שיש לו תמיכה נהדרת גם בעסקאות. הוא מציע ניהול עסקאות הצהרתי בטכניקות תכנות מונחה-רוחב (AOP).

Spring תומך בכמה ממשקי API של עסקאות, כולל JTA לעסקאות מבוזרות. אנחנו יכולים להשתמש Atomikos כמנהל עסקאות JTA שלנו באביב ללא מאמץ רב. והכי חשוב, היישום שלנו נשאר די אגנוסטי לאטומיקוס, הודות לאביב.

בואו נראה איך נוכל לפתור את הבעיה הקודמת שלנו, הפעם באמצעות מינוף האביב. נתחיל בשכתוב ה- יישום מעמד:

מחלקה ציבורית יישום {privateSource מלאי DataSource; פרטי DataSource orderDataSource; יישום ציבורי (DataSource inventoryDataSource, DataSource orderDataSource) {this.inventoryDataSource = inventoryDataSource; this.orderDataSource = orderDataSource; } @ Transactional (rollbackFor = Exception.class) מקום ריק ציבורי placeRrder (String productId, int כמות) זורק Exception {String orderId = UUID.randomUUID (). ToString (); חיבור מלאי חיבור = רשימת מלאי נתונים. חיבור orderConnection = orderDataSource.getConnection (); הצהרה s1 = inventoryConnection.createStatement (); מחרוזת q1 = "עדכון מלאי להגדיר יתרה = יתרה -" + סכום + "כאשר productId = '" + productId + "'"; s1.executeUpdate (q1); s1.close (); הצהרה s2 = orderConnection.createStatement (); מחרוזת q2 = "הכנס לערכי הזמנות ('" + orderId + "', '" + productId + "'," + amount + ")"; s2.executeUpdate (q2); s2.close (); inventConnection.close (); orderConnection.close (); }}

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

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

@Configuration @EnableTransactionManagement מחלקה ציבורית Config {@Bean (initMethod = "init", destroyMethod = "close") ציבורי AtomikosDataSourceBean inventoryDataSource () {AtomikosDataSourceBean dataSource = חדש AtomikosDataSourceBean (); // הגדר תצורה של מסד נתונים המחזיק נתונים להחזרת נתונים להזמנה; } @Bean (initMethod = "init", destroyMethod = "close") ציבורי AtomikosDataSourceBean orderDataSource () {AtomikosDataSourceBean dataSource = AtomikosDataSourceBean חדש (); // הגדר תצורת מסד נתונים המחזיק נתונים להחזרת נתונים להזמנה; } @Bean (initMethod = "init", destroyMethod = "close") UserTransactionManager ציבורי userTransactionManager () זורק SystemException {UserTransactionManager userTransactionManager = UserTransactionManager חדש (); userTransactionManager.setTransactionTimeout (300); userTransactionManager.setForceShutdown (נכון); להחזיר userTransactionManager; } @Bean הציבור JtaTransactionManager jtaTransactionManager () זורק SystemException {JtaTransactionManager jtaTransactionManager = JtaTransactionManager חדש (); jtaTransactionManager.setTransactionManager (userTransactionManager ()); jtaTransactionManager.setUserTransaction (userTransactionManager ()); להחזיר jtaTransactionManager; } @Bean יישום יישום ציבורי () {להחזיר יישום חדש (inventDataSource (), orderDataSource ()); }}

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

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

6.2. Atomikos With Spring, JPA, and Hibernate

בעוד אביב סייע לנו לצמצם את קוד הדוד במידה מסוימת, הוא עדיין די מילולי. כלים מסוימים יכולים להקל על העבודה עם מאגרי מידע יחסיים בג'אווה. Java Persistence API (JPA) הוא מפרט המתאר את ניהול הנתונים היחסיים ביישומי Java. זה מפשט את קוד הגישה לנתונים ומניפולציה במידה רבה.

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

בואו נראה איך Spring, JPA ו- Hibernate יכולים להפוך את היישום שלנו לתמציתי עוד יותר תוך מתן היתרונות של עסקאות מבוזרות באמצעות Atomikos. כמו קודם, נתחיל בשכתוב ה- יישום מעמד:

יישום בכיתה ציבורית {@Autowired Private InventoryRepository inventoryRepository; @Autowired פרטי OrderRepository orderRepository; @Transactional (rollbackFor = Exception.class) public void placeOrder (String productId, int כמות) זורק SQLException {String orderId = UUID.randomUUID (). ToString (); מלאי מלאי = inventoryRepository.findOne (productId); inventaris.setBalance (voorraad.getBalance () - סכום); inventoryRepository.save (מלאי); הזמנת הזמנה = הזמנה חדשה (); order.setOrderId (orderId); order.setProductId (productId); order.setAmount (חדש ארוך (סכום)); orderRepository.save (order); }}

כפי שאנו רואים, איננו מתמודדים עם אף ממשקי API של מסדי נתונים ברמה נמוכה. עם זאת, כדי שקסם זה יעבוד, עלינו להגדיר מחלקות ותצורות JPA של Spring Data. נתחיל בהגדרת ישויות הדומיין שלנו:

@Entity @Table (name = "INVENTORY") מלאי בכיתה ציבורית {@Id פרטי מחרוזת productId; פרטי יתרה ארוכה; // גטרס וסטרים}

@Entity @Table (name = "ORDERS") ציבורי בכיתה הזמנה {@Id פרטי סדר מחרוזת; מוצר מחרוזת פרטי; @Max (5) סכום פרטי פרטי; // גטרס וסטרים}

בשלב הבא עלינו לספק את המאגרים לגופים אלה:

ממשק ציבורי @ מאגר InventoryRepository מרחיב את JpaRepository {} @Repository ממשק ציבורי OrderRepository מרחיב את JpaRepository {}

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

לבסוף, עלינו לספק את התצורות הרלוונטיות עבור מקור נתונים עבור מסדי נתונים של מלאי והזמנה ולמנהל העסקאות:

@Configuration @EnableJpaRepositories (basePackages = "com.baeldung.atomikos.spring.jpa.inventory", entityManagerFactoryRef = "inventoryEntityManager", transactionManagerRef = "transactionManager") מחלקה ציבורית InventoryConfig {@Bean (initMethod = "init" ") AtomikosDataSourceBean מלאיDataSource () {AtomikosDataSourceBean dataSource = AtomikosDataSourceBean חדש (); // הגדר את מקורות הנתונים להחזרת נתונים מקור; } @Bean EntityManagerFactory הציבורית מלאיEntityManager () {HibernateJpaVendorAdapter vendorAdapter = חדש HibernateJpaVendorAdapter (); מפעל LocalContainerEntityManagerFactoryBean = LocalContainerEntityManagerFactoryBean (); factory.setJpaVendorAdapter (vendorAdapter); // הגדר את מפעל החזרת המפעל למנהל הישויות factory.getObject (); }}

@Configuration @EnableJpaRepositories (basePackages = "com.baeldung.atomikos.spring.jpa.order", entityManagerFactoryRef = "orderEntityManager", transactionManagerRef = "transactionManager") מחלקה ציבורית OrderConfig {@Bean (initMethod = "init", destroyMeth ") AtomikosDataSourceBean public orderDataSource () {AtomikosDataSourceBean dataSource = AtomikosDataSourceBean חדש (); // הגדר את מקור הנתונים להחזרת נתונים מקור; } @Bean EntityManagerFactory orderEntityManager () {HibernateJpaVendorAdapter vendorAdapter = חדש HibernateJpaVendorAdapter (); מפעל LocalContainerEntityManagerFactoryBean = LocalContainerEntityManagerFactoryBean (); factory.setJpaVendorAdapter (vendorAdapter); // הגדר את מפעל החזרת המפעל של מנהל הישות. }}

@Configuration @EnableTransactionManagement מחלקה ציבורית Config {@Bean (initMethod = "init", destroyMethod = "close") UserTransactionManager publicTransactionManager () זורק SystemException {UserTransactionManager userTransactionManager = UserTransactionManager חדש (); userTransactionManager.setTransactionTimeout (300); userTransactionManager.setForceShutdown (נכון); להחזיר userTransactionManager; } @Bean הציבור JtaTransactionManager transactionManager () זורק SystemException {JtaTransactionManager jtaTransactionManager = JtaTransactionManager חדש (); jtaTransactionManager.setTransactionManager (userTransactionManager ()); jtaTransactionManager.setUserTransaction (userTransactionManager ()); להחזיר jtaTransactionManager; } @Bean יישום יישום ציבורי () {להחזיר יישום חדש (); }}

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

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

7. Atomikos מעבר ל- JTA

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

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

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

Atomikos מציעה וריאציה של עסקה מבוססת פיצויים הנקראת Try-Confirm / Cancel (TCC). TCC מציעה סמנטים עסקיים טובים יותר לגופים תחת עסקה. עם זאת, הדבר אפשרי רק עם תמיכה מתקדמת בארכיטקטורה של המשתתפים, ו- TCC זמין רק במסגרת ההיצע המסחרי Atomikos, ExtremeTransactions.

8. אלטרנטיבות לאטומיקוס

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

8.1. נראיאנה

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

Narayana מספקת תמיכה במגוון רחב של פרוטוקולי עסקאות כמו JTA, JTS, Web-Services ו- REST, עד כמה שם. יתר על כן, Narayana יכול להיות מוטבע במגוון רחב של מכולות.

בהשוואה לאטומיקוס, Narayana מספק כמעט את כל התכונות של מנהל עסקאות מבוזרות. במקרים רבים Narayana גמישה יותר לשילוב ושימוש ביישומים. למשל, ל- Narayana יש כריכות שפה עבור C / C ++ ו- Java. עם זאת, זה כרוך במחיר של מורכבות נוספת, ואת Atomikos קל יחסית להגדיר ולהשתמש.

8.2. ביטרוניקס

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

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

9. מסקנה

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

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

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