streamalism.org

1. הקדמה

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

2. מהי עסקה?

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

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

3. משאבים עסקאות מקומיות

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

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

3.1. JDBC

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

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

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

חיבור חיבור = DriverManager.getConnection (CONNECTION_URL, USER, PASSWORD); נסה את {connection.setAutoCommit (false); PreparedStatement firstStatement = חיבור. PrepareStatement ("firstQuery"); firstStatement.executeUpdate (); PreparedStatement secondStatement = חיבור .prepareStatement ("secondQuery"); secondStatement.executeUpdate (); connection.commit (); } לתפוס (חריג e) {connection.rollback (); }

הנה השבתנו את מצב ההתחייבות האוטומטית של חיבור. לפיכך, אנו יכולים להגדיר ידנית את גבול העסקה ולבצע א לְבַצֵעַ אוֹ גלגל לאחור. JDBC מאפשר לנו גם להגדיר a נקודת שמירה זה מספק לנו שליטה רבה יותר על כמה להחזיר.

3.2. JPA

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

ב- JPA, אנו יכולים להגדיר שיעורים רגילים כ- יֵשׁוּת המספק להם זהות מתמשכת. ה EntityManager class מספק את הממשק הדרוש לעבודה עם מספר ישויות בהקשר להתמדה. ניתן לחשוב על הקשר ההתמדה כמטמון ברמה הראשונה בו מתנהלים ישויות:

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

בואו נראה איך נוכל ליצור EntityManager ולהגדיר גבול עסקה באופן ידני:

EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory ("דוגמא jpa"); EntityManager entityManager = entityManagerFactory.createEntityManager (); נסה את {entityManager.getTransaction (). התחל (); entityManager.persist (firstEntity); entityManager.persist (secondEntity); entityManager.getTransaction (). commit (); } לתפוס (Exceotion e) {entityManager.getTransaction (). rollback (); }

הנה, אנו יוצרים EntityManager מ EntityManagerFactory במסגרת הקשר של התמדה בהיקף עסקה. ואז אנו מגדירים את גבול העסקה באמצעות התחל, לְבַצֵעַ, ו גלגל לאחור שיטות.

3.3. JMS

שירות המסרים של Java (JMS) הוא מפרט ב- Java ש- מאפשר ליישומים לתקשר בצורה אסינכרונית באמצעות הודעות. ה- API מאפשר לנו ליצור, לשלוח, לקבל ולקרוא הודעות מתור או נושא. ישנם מספר שירותי העברת הודעות התואמים למפרט JMS כולל OpenMQ ו- ActiveMQ.

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

JMS מאפשר לנו ליצור מוֹשָׁב מ חיבור שאנחנו מקבלים מספק ספציפי ConnectionFactory. יש לנו אפשרות ליצור מוֹשָׁב שמבצעים או לא. בגין אי-עסקה מוֹשָׁבס, אנו יכולים להגדיר עוד יותר מצב אישור מתאים.

בואו נראה איך נוכל ליצור עסקאות מוֹשָׁב לשלוח מספר הודעות במסגרת עסקה:

ActiveMQConnectionFactory connectionFactory = ActiveMQConnectionFactory חדש (CONNECTION_URL); חיבור חיבור = = connectionFactory.createConnection (); connection.start (); נסה {Session session = connection.createSession (true, 0); יעד = יעד = session.createTopic ("TEST.FOO"); מפיק MessageProducer = session.createProducer (יעד); producer.send (firstMessage); producer.send (secondMessage); session.commit (); } לתפוס (חריג e) {session.rollback (); }

הנה, אנו יוצרים MessageProducer בשביל ה יַעַד מסוג הנושא. אנחנו מקבלים את יַעַד מ ה מוֹשָׁב יצרנו קודם. אנו משתמשים בהמשך מוֹשָׁב להגדרת גבולות העסקה בשיטות לְבַצֵעַ ו גלגל לאחור.

4. עסקאות גלובליות

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

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

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

4.1. JTA

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

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

בואו נבין כמה ממשקי המפתח המודגשים לעיל:

• TransactionManager: ממשק המאפשר לשרת יישומים לתחום ולשלוט בעסקאות
• UserTransaction: ממשק זה מאפשר לתוכנית יישומים לתחום ולשלוט בעסקאות באופן מפורש
• XAResource: מטרת ממשק זה היא לאפשר למנהל עסקאות לעבוד עם מנהלי משאבים למשאבים תואמי XA

4.2. JTS

שירות העסקאות של ג'אווה (JTS) הוא מפרט לבניית מנהל העסקאות הממפה למפרט OMG OTS. JTS משתמש בממשקי CORBA ORB / TS הסטנדרטיים ובפרוטוקול Inter-ORB Internet (IIOP) לצורך התפשטות הקשר בין מנהלי עסקאות JTS.

ברמה גבוהה הוא תומך ב- Java Transaction API (JTA). מנהל עסקאות JTS מספק שירותי עסקאות לצדדים המעורבים בעסקה מבוזרת:

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

5. ניהול עסקאות JTA

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

5.1. JTA בשרת היישומים

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

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

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

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

5.2. JTA עצמאי

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

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

AtomikosDataSourceBean atomikosDataSourceBean = חדש AtomikosDataSourceBean (); atomikosDataSourceBean.setXaDataSourceClassName ("com.mysql.cj.jdbc.MysqlXADataSource"); DataSource dataSource = atomikosDataSourceBean;

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

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

AtomikosConnectionFactoryBean atomikosConnectionFactoryBean = AtomikosConnectionFactoryBean חדש (); atomikosConnectionFactoryBean.setXaConnectionFactory (ActiveMQXAConnectionFactory חדש ()); ConnectionFactory connectionFactory = atomikosConnectionFactoryBean;

הנה, אנו יוצרים מופע של AtomikosConnectionFactoryBean ורישום XAConnectionFactory מספק JMS מאופשר ב- XA. לאחר מכן, אנו יכולים להמשיך להשתמש בזה כרגיל ConnectionFactory.

כעת, Atomikos מספק לנו את החלק האחרון של הפאזל לקרב הכל, דוגמה של UserTransaction:

UserTransaction userTransaction = UserTransactionImp חדש ();

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

נסה את {userTransaction.begin (); java.sql.Connection dbConnection = dataSource.getConnection (); PreparedStatement preparStatement = dbConnection.prepareStatement (SQL_INSERT); preparedStatement.executeUpdate (); javax.jms.Connection mbConnection = connectionFactory.createConnection (); מושב מושב = mbConnection.createSession (נכון, 0); יעד יעד = session.createTopic ("TEST.FOO"); מפיק MessageProducer = session.createProducer (יעד); producer.send (MESSAGE); userTransaction.commit (); } לתפוס (חריג e) {userTransaction.rollback (); }

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

6. תמיכה בעסקאות באביב

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

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

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

הממשק המרכזי כאן הוא PlatformTransactionManager שיש בו מספר יישומים שונים. הוא מספק הפשטות על פני JDBC (DataSource), JMS, JPA, JTA, ומשאבים רבים אחרים.

6.1. תצורות

בואו נראה כיצד נוכל להגדיר אביב להשתמש ב- Atomikos כמנהל עסקאות ולספק תמיכה בעסקאות עבור JPA ו- JMS. נתחיל בהגדרת א PlatformTransactionManager מהסוג JTA:

@Bean פלטפורמת PlatformTransactionManager הציבוריתTransactionManager () זורק Throwable {להחזיר JtaTransactionManager חדש (userTransaction (), transactionManager ()); }

הנה, אנו מספקים מקרים של UserTransaction ו TransactionManager ל JTATransactionManager. מקרים אלה מסופקים על ידי ספריית מנהלי עסקאות כמו Atomikos:

@Bean UserTransaction ציבורי userTransaction () {החזר UserTransactionImp חדש (); } @Bean (initMethod = "init", destroyMethod = "סגור") TransactionManager publicManager () {להחזיר UserTransactionManager חדש (); }

השיעורים UserTransactionImp ו UserTransactionManager מסופקים על ידי Atomikos כאן.

יתר על כן, עלינו להגדיר את JmsTemplete אשר מחלקת הליבה המאפשרת גישה JMS סינכרוני באביב:

@Bean JmsTemplate הציבור jmsTemplate () זורק Throwable {להחזיר JmsTemplate חדש (connectionFactory ()); }

פה, ConnectionFactory מסופק על ידי Atomikos שם הוא מאפשר עסקאות מבוזרות עבור חיבור המסופק על ידי זה:

@Bean (initMethod = "init", destroyMethod = "close") public ConnectionFactory connectionFactory () {ActiveMQXAConnectionFactory activeMQXAConnectionFactory = ActiveMQXAConnectionFactory חדש (); activeMQXAConnectionFactory.setBrokerURL ("tcp: // localhost: 61616"); AtomikosConnectionFactoryBean atomikosConnectionFactoryBean = AtomikosConnectionFactoryBean חדש (); atomikosConnectionFactoryBean.setUniqueResourceName ("xamq"); atomikosConnectionFactoryBean.setLocalTransactionMode (false); atomikosConnectionFactoryBean.setXaConnectionFactory (activeMQXAConnectionFactory); להחזיר atomikosConnectionFactoryBean; }

אז, כפי שאנו רואים, כאן אנו עוטפים ספק ספציפי של JMS XAConnectionFactory עם AtomikosConnectionFactoryBean.

לאחר מכן עלינו להגדיר AbstractEntityManagerFactoryBean שאחראי על יצירת JPA EntityManagerFactory שעועית באביב:

@Bean LocalContainerEntityManagerFactory ציבורי Bean entityManager () זורק SQLException {LocalContainerEntityManagerFactoryBean entityManager = חדש LocalContainerEntityManagerFactoryBean (); entityManager.setDataSource (dataSource ()); מאפייני מאפיינים = מאפיינים חדשים (); properties.setProperty ("javax.persistence.transactionType", "jta"); entityManager.setJpaProperties (נכסים); return entityManager; }

כמו קודם, מקור מידע שקבענו ב LocalContainerEntityManagerFactoryBean כאן מסופק על ידי Atomikos עם פעולות מופצות מופעלות:

@Bean (initMethod = "init", destroyMethod = "close") DataSource ציבורי dataSource () זורק SQLException {MysqlXADataSource mysqlXaDataSource = MysqlXADataSource חדש (); mysqlXaDataSource.setUrl ("jdbc: mysql: //127.0.0.1: 3306 / test"); AtomikosDataSourceBean xaDataSource = AtomikosDataSourceBean חדש (); xaDataSource.setXaDataSource (mysqlXaDataSource); xaDataSource.setUniqueResourceName ("xads"); להחזיר את xaDataSource; }

שוב אנו עוטפים את הספק הספציפי XADataSource ב AtomikosDataSourceBean.

6.2. ניהול עסקאות

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

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

• תמיכה הצהרתית

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

@PersistenceContext EntityManager entityManager; @ JmsTemplate JmsTemplate אוטומטית; @Transactional (propagation = Propagation.REQUIRED) תהליך הריק הציבורי (ENTITY, MESSAGE) {entityManager.persist (ENTITY); jmsTemplate.convertAndSend (DESTINATION, MESSAGE); }

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

• תמיכה פרוגרמטית

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

@Autowired פרטי PlatformTransactionManager transactionManager; תהליך בטל ציבורי (ENTITY, MESSAGE) {TransactionTemplate transactionTemplate = חדש TransactionTemplate (transactionManager); transactionTemplate.executeWithoutResult (status -> {entityManager.persist (ENTITY); jmsTemplate.convertAndSend (DESTINATION, MESSAGE);}); }

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

7. מחשבות אחר

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

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

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

8. מסקנה

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

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

לבסוף עברנו כמה מהשיטות הטובות ביותר בעבודה עם עסקאות בג'אווה.