مقدمة
تسجل هذه المقالة بشكل أساسي كيف يدعم Spring الأشياء ، وكيف يمكنها ببساطة تنفيذ وظائف الأشياء الخاصة بقاعدة البيانات عندما يجمع Spring بين MyBatis. لن أقول الكثير عن ذلك أدناه ، دعنا نلقي نظرة على المقدمة التفصيلية معًا.
الحالة 1: حالة دعم الأشياء في طاولتين
قم أولاً بإعداد جدولين ، جدول مستخدم واحد وجدول قصة واحد ، الهيكل كما يلي
قم بإنشاء جدول `user` (`id` int (11) غير موقّع غير null auto_increment ،` name` varchar (20) غير فارغ '' اسم المستخدم '، "pwd` varchar (26) ، لا يوجد" ، "،" `upported` varchar (13) not null الافتراضي '0' ، المفتاح الأساسي (` id`) ، المفتاح `name` (name`)) المحرك = innodb الافتراضي charset = utf8mb4 ؛ إنشاء جدول` story` (`id` int (11) غير مُغمي Varchar (20) ليس افتراضيًا "تعليق" ، "مؤلف" ، "العنوان" varchar (26) ليس افتراضيًا "تعليقًا" ، "كلمة مرور" ، "قصة قصة" ، "محتوى القصة" ، "isdeleted" tinyint (1) ليس null '0' `userid` (` userId`)) engine = innodb default charset = utf8mb4 ؛
وضعنا هو أنه عندما يقوم المستخدم بتعديل الاسم ، يجب تعديل أسماء كلا الجدولين معًا ، ولا يُسمح بالتناقضات.
Case2: دعم جدول واحد
تحويل الأموال ، يقلل مستخدم واحد من الأموال ، ويزيد مستخدم آخر من المال
قم بإنشاء جدول `money` (`id` int (11) غير موقّع لا auto_increment ،` name` varchar (20) "التعليق" الافتراضي "،" اسم المستخدم "،" Money` int (26) ليس افتراضيًا "0" ، " varchar (13) not null default '0' ، المفتاح الأساسي (`id`) ، مفتاح` name` (name`)) المحرك = innodb default charset = utf8mb4 ؛
بالمقارنة مع الحالة أعلاه ، هذا أبسط. يتم شرح الأمثلة التالية بشكل أساسي بناءً على هذا. أما بالنسبة لـ Case1 ، فقد تم تركها.
أولاً ، قم بتنفيذ DAO والكيان المقابل
Datapublic Class Moneyentity تنفذ {Private Static Final Long SerialVersionuid = -7074788842783160025L ؛ معرف int الخاص ؛ اسم السلسلة الخاصة ؛ أموال int الخاصة ؛ int int isdeleted ؛ تم إنشاؤها int الخاص ؛ Private int updated ؛} الواجهة العامة moneydao {moneyentity querymoney (param ("id") int userId) ؛ // أضف أموالًا ، عندما يكون سلبيًا ، فهذا يعني تقليل الأموال int styrementmoney (param ("id") int userid ، param ("addmoney) int addmoney) ؛}ملف Mapper المقابل
<؟ مساحة الاسم = "com.git.hui.demo.mybatis.mapper.moneydao"> <sql id = "moneyentity"> id ، `name` ،` money` ، `isdeleted` ،` created` ، `updated` </sql> <select id =" querymoney " resultType = "com.git.hui.demo.mybatis.entity.moneyentity"> SELECT <refid = "moneyentity"/> from money where id =#{id} </select> <update id = "studymoneالتكوين المقابل لمصدر بيانات اتصال MyBatis
<Bean> <property name = "sortes"> <value> classpath*: jdbc.properties </value> </property> </bean> <bean id = "dataSource" init-method = "init" drate-method = "close"> <property name = "driverClassName" value = "$ {driver}"/> name = "username" value = "$ {username}"/> <property name = "password" value = "$ {password}"/> <property name = "filters" value = "stat"/> <property name = "maxactive" value = "20"/> value = "1"/> <property name = "timetweenevictionRunsMillis" value = "60000"/> <property name = "minevictableDletImemillis" value = "300000"/> <property name = "properalquerer" value = "very" name = "testOnBorrow" value = "false"/> <property name = "testOnreturn" value = "false"/> <property name = "poolpreparedsteements" value = "true"/> <property name = "maxpoolpropedStatePerConnectionize" value = "50" ref = "datasource"/> <!-حدد ملف mapper-> <property name = "mapperlocations" value = "classpath*: mapper/*.من خلال الاستعلام عبر الإنترنت ، هناك أربع طرق لإدارة أشياء الربيع. فيما يلي مظاهرات واحدة تلو الأخرى ، وكيفية تشغيل كل طريقة ، ثم انظر كيفية الاختيار في المشروع الفعلي
إدارة شيء البرمجة ، والتي تدرك إدارة شيء عمليات DB متعددة من خلال TransactionTemplate
أ. تطبيق
بعد ذلك ، يمكن تنفيذ حالة النقل الخاصة بنا على النحو التالي
repositorypublic class COREEDEMO1 {autowired private moneydao moneydao ؛ @Autowired TransactionTemplate TransactionTemplate ؛ / ** * نقل * * * param inuserid * param outuserid * param paymoney * @param status 0 تشير إلى التحويل الطبيعي ، يشير 1 إلى أن الاستثناء يتم إلقاؤه داخليًا ، ويشير 2 الحالة) {TransactionTemplate.execute (New TransactionCallbackWithoutResult () {proid void doIntransactionWithoutResult (TransactionStatus TransactionStatus) Moneydao.incrementMoney (outuserid ، -spaymoney) ؛ }. } آخر إذا (الحالة == 2) {addMoney (inuserid) ؛ حاول {thread.sleep (3000) ؛ } catch (interruptedException e) {E.PrintStackTrace () ؛ }} آخر إذا (الحالة == 3) {addMoney (OutUserId) ؛ حاول {thread.sleep (3000) ؛ } catch (interruptedException e) {E.PrintStackTrace () ؛ }}} public void addMoney (Final int userId) {system.out.printf ("addMoney داخلي:" + system.currentTimeMillis ()) ؛ New Thread (new RunNable () {public void run () {moneydao.incrementMoney (userId ، 200) ؛ system.out.println ("sub modify success! الآن: }}انظر بشكل رئيسي إلى طريقة التحويل أعلاه. يتم تحقيق تغليف الأشياء من خلال TransactionTemplate داخليًا. هناك ثلاث عمليات ديسيبل داخليًا واستعلامًا واحدًا واثنين من التحديثات. سيتم شرح التحليل المحدد لاحقًا.
الكود أعلاه بسيط نسبيا. الشيء الوحيد الذي تحتاج إلى الانتباه إليه هو كيفية تعريف المعاملات. إذا لم تكن تلصق ملف XML والمواصفات السابقة ، فما عليك سوى الصق رمز المفتاح. أحدهما هو TransactionManager الذي تم إنشاؤه على أساس مصدر البيانات ، والآخر هو المعاملة التي تم إنشاؤها على أساس المعاملات.
<!-برمجة الأشياء-> <bean id = "TransactionManager"> <property name = "datasource" ref = "datasource"/> </bean> <bean id = "transactiontemplate"> <property name = "TransactionManager" ref = "TransactionManager"/> </ban>
ب. حالات الاختبار
وضع العرض التوضيحي الطبيعي ، والمظاهرة ليس لها استثناءات ، ولا يتم النظر في وضع التزامن
Runwith (springJunit4ClassRunner.Class) contextConfiguration ({"classpath*: spring/service.xml" ، "classpath*: datasource1.xml"}) الفئة العامة codedemo1test {autowired private codedemo1 ؛ Autowired Private Moneydao Moneydao ؛ test public void testTransfor () {system.out.println ("----------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛ codedemo1.transfor (1 ، 2 ، 10 ، 0) ؛ System.out.println ("-----------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛ }}الناتج على النحو التالي ، لا توجد مشكلة في أموال كلا الحسابين
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10000
المعرف: 2 المال = 50000
تم الانتهاء من النقل! الآن: 1526130394266
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
يحدث خلل أثناء عملية التحويل ، خاصةً عندما يقوم الناقل بخصم الأموال ولم يتلق المستلم المال ، أي أن الوضع الذي يكون فيه الوضع في القضية هو 1.
. System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛ حاول {codedemo1.transfor (1 ، 2 ، 10 ، 1) ؛ } catch (استثناء e) {E.PrintStackTrace () ؛ } system.out.println ("---------------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛}في هذا الصدد ، نأمل في إعادة الأموال من المحول ، وأن نخرجها على النحو التالي. وجدنا أن أيا من المال قد تغير.
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
java.lang.illegalargumentexception: استثناء نقل !!!
... // حذف معلومات الاستثناء
المعرف: 2 المال = 49990
عندما يكون الوضع 2 ، فهذا يعني أنه بين أموال المحول تم خصمها ولم يتم استلام أموال المستفيد ، قام شخص ما بتحويل 200 إلى المستفيد. في هذا الوقت ، وفقًا لآلية قفل MySQL ، يجب استلام نقل الشخص الآخر على الفور (لأن حساب المستفيد غير مقفل) ، ولا ينبغي أن تكون هناك مشكلة في المبلغ.
نتيجة الإخراج على النحو التالي:
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
## على اليمين ملاحظة: أثناء عملية التحويل ، تم إيداع الأموال على الفور ، وتم إضافة الأموال في الداخل: 1526130827480
Sub تعديل النجاح! الآن: 1526130827500
## تم الانتهاء من التحويل بعد توفير المال! الآن: 1526130830488
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10220
المعرف: 2 المال = 49980
عندما يكون الوضع 3 ، فهذا يعني أنه تم خصم أموال الناقل ولم يتم استلام أموال المستفيد ، وتم تحويل شخص ما إلى 200 إلى الناقل. في هذا الوقت ، لأنه يتم إضافة سجل المحول وقفل الكتابة ، لا يمكنه سوى انتظار النقل لتقديم النقل إلى النجاح قبل نجاح +200. بالطبع ، يجب أن يكون المبلغ النهائي هو نفسه أيضًا.
نتيجة الإخراج على النحو التالي
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10220
المعرف: 2 المال = 49980
## على اليمين ملاحظة: لقد قمت بتوفير المال داخليًا ، لكنه لم ينجح على الفور
## ليس حتى يتم الانتهاء من النقل بأنه ناجح على الفور. انتبه إلى إضافة أموال إلى طابع زمني: 1526131101046
تم الانتهاء من النقل! الآن: 1526131104051
Sub تعديل النجاح! الآن: 1526131104053
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10230
المعرف: 2 المال = 50170
ج. ملخص
حتى الآن ، تم توضيح أشياء برمجة في مثال. من العملية أعلاه ، يمنح الناس نفس الشعور مثل كتابة الأشياء المتعلقة بـ SQL.
ابدأ المعاملة ؛
- هذا هو المنطق داخل طريقة تنفيذ المعاملة
- أي مجموعة من SQL تتطلب إدارة الأشياءيقترف؛
الثلاثة التالية هي إدارة الأشياء التعريفية ، والتي يتم استخدامها أقل لأن كل شيء يجب إضافة فئة إدارة
أ. تطبيق
بالإضافة إلى قتل TransactionTemplate وإزالة منطق SQL الداخلي ، مقارنة مع المنطق السابق ، وجدت أنه لا يوجد فرق في الأساس.
الطبقة العامة FactoryBeanDemo2 {autowired private moneydao moneydao ؛ / ** * transfer * * param inuserid * param outuserid * param paymoney * @param status 0 تشير إلى التحويل الطبيعي ، يشير 1 إلى أن استثناء تم إلقاؤه داخليًا ، ويشير 2 الحالة) {moneyentity unitity = moneydao.querymoney (outuserId) ؛ if (entity.getMoney ()> paymoney) {// يمكنك تحويل الأموال // تقليل الأموال أولاً moneydao.incrementMoney (Outuserid ، -paymoney) ؛ testcase (inuserid ، outuserid ، الحالة) ؛ // إضافة أموال إلى moneydao.incrementMoney (inuserid ، paymoney) ؛ System.out.println ("تم الانتهاء من النقل! الآن:" + system.currentTimeMillis ()) ؛ }} private void testcase (int inuserid final ، int intuserid ، الحالة النهائية int) {if (status == 1) {رمي جديد alfictalargumentexception ("نقل الاستثناء !!!") ؛ } آخر إذا (الحالة == 2) {addMoney (inuserid) ؛ حاول {thread.sleep (3000) ؛ } catch (interruptedException e) {E.PrintStackTrace () ؛ }} آخر إذا (الحالة == 3) {addMoney (OutUserId) ؛ حاول {thread.sleep (3000) ؛ } catch (interruptedException e) {E.PrintStackTrace () ؛ }}} public void addMoney (Final int userId) {system.out.println ("add add add introl:" + system.currentTimeMillis ()) ؛ New Thread (new RunNable () {public void run () {moneydao.incrementMoney (userId ، 200) ؛ system.out.println ("sub modify success! الآن: }}النقطة الأساسية هي أننا نحتاج إلى تكوين TransactionProxyBeanFactory. نحن نعلم أن Beanfactory هو وسيلة لنا لإنشاء الفول بأنفسنا. تكوين XML ذي الصلة على النحو التالي
<!-برمجة الأشياء-> <bean id = "TransactionManager"> <property name = "datasource" ref = "datasource"/> </bean> <bean id = "factorybeandemo2"/> <!-conference conference target exply = config targetor enderial = "تكوين". ref = "factorybeandemo2" /> <!-حقن مدير المعاملات-> <اسم property = "TransactionManager" ref = "TransactionManager" /> <!-حقن خصائص المعاملة-> <property name = "TransactactionAtributes"> <spros> <! : ما هي الاستثناءات التي تراجعت عن المعاملات* +الاستثناء: ما هي الاستثناءات التي لا تتراجع عن المعاملات-> <!-هذا المفتاح يتوافق مع الأساليب في الفئة الهدف-> <prop key = "transfor" <prop key = "transfer"> spection_required ،+java.lang.arithMeticexception </prop> -> </props> </property> </ban>
من خلال التكوين أعلاه ، يمكننا أن نفهم تقريبًا أن TransactionProxyFactoryBean يخلق فئة وكيل من FactoryBeanDemo2. تغلف فئة الوكيل هذه المنطق المتعلق بالأشياء الجيدة في الداخل ، والتي يمكن اعتبارها عبارة عن تجريد عام بسيط للبرمجة السابقة.
ب. امتحان
رمز الاختبار هو نفسه كما كان من قبل. الاختلاف الوحيد هو أنه يجب علينا استخدام الفول الناتج عن الفاصوليا أعلاه ، بدلاً من استخدام FactoryBeanDemo2 مباشرة
الحالة التجريبية العادية:
runwith (springjunit4classrunner.class) contextConfiguration ({"classpath*: spring/service.xml" ، "classpath*: test-datasource2 Autowired Private Moneydao Moneydao ؛ Test public void testTransfor () {system.out.println ("--------------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛ FactoryBeandemo2.transfor (1 ، 2 ، 10 ، 0) ؛ System.out.println ("--------------------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛ }}الإخراج
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10000
المعرف: 2 المال = 50000
تم الانتهاء من النقل! الآن: 1526132058886
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
إذا كانت الحالة 1 ، والاستثناء الداخلي ليس هو الحال ، نأمل ألا تكون هناك مشكلة في المال.
testpublic void testTransForexception () {system.out.println ("-------------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛ حاول {factorybeandemo2.transfor (1 ، 2 ، 10 ، 1) ؛ } catch (استثناء e) {system.out.println (e.getMessage ()) ؛؛ } system.out.println ("--------------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛}الإخراج هو
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
نقل الشذوذ !!!
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
عندما تكون الحالة 2 ، يجب أن تكون نتيجة التحليل هي نفسها أعلاه ، والإخراج كما يلي
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49950
المال الداخلي: 1526133325376
Sub تعديل النجاح! الآن: 1526133325387
تم الانتهاء من النقل! الآن: 1526133328381
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10220
المعرف: 2 المال = 49940
عندما تكون الحالة 3 ، الإخراج
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10220
المعرف: 2 المال = 49940
الأموال الداخلية: 1526133373466
تم الانتهاء من النقل! الآن: 1526133376476
Sub تعديل النجاح! الآن: 1526133376480
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10230
المعرف: 2 المال = 50130
ج. ملخص
تتمثل فكرة TransactionProxyFactoryBean في استخدام وضع الوكيل لتنفيذ إدارة الأشياء ، وإنشاء فئة بالوكالة ، وطرق التقاطع المستهدف ، وتغليف مجموعة من عمليات SQL في الأشياء ؛ بالمقارنة مع التعليمات البرمجية الصلبة ، فهو غير غامض ، ويدعم طرق التكوين المرنة.
العيوب واضحة أيضًا ، يجب تكوين كل منها ، وهو أمر معقد للغاية
الربيع له خصائصان رئيسيتان: IOC و AOP. لأشياء من هذا القبيل ، هل يمكننا استخدام AOP للقيام بذلك؟
بالنسبة للأساليب التي يجب تشغيلها ، واعتراض ، وبدء الأمور قبل التنفيذ ، وإرسال الأشياء بعد التنفيذ ، وتراجع عند حدوث استثناء.
من هذا المنظور ، يبدو واعداً للغاية ، ويتم لعب المواقف التالية بهذه الطريقة ، لذلك هناك حاجة إلى اعتماد الجانب.
<Rependency> <roupeD> org.aspectj </groupId> <StifactId> sidejweaver </shintifactid> <الإصدار> 1.8.7 </الإصدار> </dependency>
أ. تطبيق
فئة Java هي بالضبط نفس النوع الثاني ، وتغير XML فقط
<!-أضف أولاً مساحة الاسم-> xmlns: tx = "http://www.springframework.org/schema/tx" http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"< id = "txadvice" المعاملة-manager = "TransactionManager"> <tx: سمات> <!-الانتشار: سلوك انتشار المعاملات العزلة: مستوى عزل المعاملة القراءة فقط: قراءة فقط التراجع-for: أي استثناءات قد حدثت لا توجد استثناءات. </tx: سمات> </tx: explive> <!-قسم التكوين-> <aop: config> <!-configuration point-cut-> <aop: pointcut expression = "execution (* com.git.hui.demo.mybatis.repository.transaction.xmldemo3.* (..))" <aOP: Advisor excloy-ref = "txAdvice" pointcut-ref = "pointcut1"/> </ aop: config>
لاحظ التكوين أعلاه وفكر في الطريقة الثانية. الفكرة هي نفسها تقريبًا ، لكن من الواضح أن هذه الطريقة أكثر عمومية. من خلال القسم ونقطة القطع ، يمكن تقليل عدد كبير من التكوينات.
ب. امتحان
Runwith (SpringJunit4ClassRunner.Class) contextConfiguration ({"classpath*: spring/service.xml" ، "classpath*: datasource3 Autowired Private Moneydao Moneydao ؛ Test public void testTransfor () {system.out.println ("---------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛ xmldemo.transfor (1 ، 2 ، 10 ، 0) ؛ System.out.println ("--------------------------") ؛ System.out.println ("id: 1 money =" + moneydao.querymoney (1) .getMoney ()) ؛ system.out.println ("id: 2 money =" + moneydao.querymoney (2) .getMoney ()) ؛ }}لا يختلف هذا الاختبار عن طريقة الكتابة العامة ، وهو أبسط من طريقة الحقن في المصنع الثاني
الإخراج الطبيعي
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10000
المعرف: 2 المال = 50000
تم الانتهاء من النقل! الآن: 1526135301273
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
الحالة = 1 عند حدوث استثناء ، يكون الإخراج
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
نقل الشذوذ !!!
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
الحالة = 2 سيناريو توفير المال أثناء عملية التحويل ، يتوافق الإخراج مع التوقعات السابقة.
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10010
المعرف: 2 المال = 49990
المال الداخلي: 1526135438403
Sub تعديل النجاح! الآن: 1526135438421
تم الانتهاء من النقل! الآن: 1526135441410
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10220
المعرف: 2 المال = 49980
يتوافق إخراج الحالة = 3 مع التوقعات السابقة
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10220
المعرف: 2 المال = 49980
المال الداخلي: 1526135464341
تم الانتهاء من النقل! الآن: 1526135467349
Sub تعديل النجاح! الآن: 1526135467352
------------------------------------------------------------------------------------------------------------------------------------
المعرف: 1 المال = 10230
المعرف: 2 المال = 50170
هذا هو التخلص من XML واستخدام التعليقات التوضيحية للقيام بذلك ، وهو استبدال التكوين في XML السابق مع التعليق التوضيحي transactional.
أ. تطبيق
repositorypublic class annodemo4 {Auutowired private moneydao moneydao ؛ /** * transfer * * param inuserid * param outuserid * param paymoney * @param status 0 تشير إلى التحويل الطبيعي ، يشير 1 إلى أن استثناء يتم إلقاؤه داخليًا ، يشير 2 إلى موضوع جديد ، تعديل أموال inuserid + 200 ، 3 readonly: Read-only* rollbackfor: ما هي الاستثناءات التي حدثت norollbackfor: ما هي الاستثناءات التي حدثت عدم التراجع* rollbackforclassname rollback وفقًا لاسم فئة الاستثناء*/ @transactional (الانتشار = الانتشار. الكيان = moneydao.querymoney (outuserid) ؛ if (entity.getMoney ()> paymoney) {// يمكنك تحويل الأموال // تقليل الأموال أولاً moneydao.incrementMoney (Outuserid ، -paymoney) ؛ testcase (inuserid ، outuserid ، الحالة) ؛ // إضافة أموال إلى moneydao.incrementMoney (inuserid ، paymoney) ؛ System.out.println ("تم الانتهاء من النقل! الآن:" + system.currentTimeMillis ()) ؛ }} private void testcase (int inuserid final ، int intuserid ، الحالة النهائية int) {if (status == 1) {رمي جديد alfictalargumentexception ("نقل الاستثناء !!!") ؛ } آخر إذا (الحالة == 2) {addMoney (inuserid) ؛ حاول {thread.sleep (3000) ؛ } catch (interruptedException e) {E.PrintStackTrace () ؛ }} آخر إذا (الحالة == 3) {addMoney (OutUserId) ؛ حاول {thread.sleep (3000) ؛ } catch (interruptedException e) {E.PrintStackTrace () ؛ }}} private void addMoney (Final int userId) {system.out.println ("inse add add:" + system.currentTimeMillis ()) ؛ New Thread (new RunNable () {public void run () {moneydao.incrementMoney (userId ، 200) ؛ system.out.println ("sub modify success! الآن: }}لذلك ، من الضروري تكوينه في XML لتمكين شرح الأشياء
<!-برمجة الأشياء-> <bean id = "TransactionManager"> <property name = "dataSource" ref = "datasource"/> </bean> <tx: معاملة المعاملة التي تعتمد على التعليقات التوضيحية = "TransactionManager"/>
هذا يجعل الأمر أكثر وضوحا. في المشاريع الفعلية ، تعتبر طرق XML وطرق التعليقات التوضيحية أيضًا السيناريوهات الأكثر استخدامًا.
ب. حالة الاختبار
إنها بالضبط نفس حالة الاختبار الثالث ، ونتيجة الإخراج هي نفسها ، ويتم حذفها مباشرة
يتحدث أعلاه عن أربع طرق لاستخدام الأشياء في الربيع. من بينها ، قد تكون الطريقة المرمزة هي أفضل فهم ، وهو ما يعادل ترجمة طريقة استخدام الأشياء في SQL مباشرة إلى رمز Java المقابل ؛ وتعادل طريقة Factorybean معاملة الظروف الخاصة ومعالجة كل شيء مع فئة وكيل لتعزيز وظيفة الأشياء ؛ يتم تنفيذ المبادئ الأخيرة تقريبًا باستخدام إخطار الشيء (AOP) لتحديد نقاط الظل والمعلومات ذات الصلة.
برمجة:
transactionTemplate#executeوكيل Beanfactory:
تكوين XML:
طريقة التعليقات التوضيحية:
tx:annotation-driven transaction-manager="transactionManager"/>وثيقة
أربع طرق لإدارة معاملات الربيع
رمز المصدر
ما سبق هو المحتوى الكامل لهذه المقالة. آمل أن يكون لمحتوى هذه المقالة قيمة مرجعية معينة لدراسة أو عمل الجميع. إذا كان لديك أي أسئلة ، فيمكنك ترك رسالة للتواصل. شكرا لك على دعمك إلى wulin.com.