Zusammenfassung verschiedener Möglichkeiten, Dinge im Frühjahr + MyBatis + MySQL zu verwenden

Autor：Eve Cole Aktualisierungszeit：2025-07-31 01:00:03

Vorwort

In diesem Artikel wird hauptsächlich aufgezeichnet, wie Spring die Dinge unterstützt und wie die Dinge der Datenbank einfach implementiert werden können, wenn Spring MyBatis kombiniert. Ich werde unten nicht viel darüber sagen. Schauen wir uns die detaillierte Einführung zusammen an.

I. Voraussetzung

Fall1: Dinge unterstützen die Situation in zwei Tischen

Bereiten Sie zuerst zwei Tabellen vor, eine Benutzertabelle und eine Story -Tabelle, die Struktur lautet wie folgt

 Tabelle `user`` (` id` int (11) unsigned nicht null auto_increment, `name` varchar (20) nicht null Standard '' Kommentar 'Benutzername',` pwd` varchar (26) nicht null default '' comment 'password' `updated` varchar(13) NOT NULL DEFAULT '0', PRIMARY KEY (`id`), KEY `name` (`name`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;CREATE TABLE `story` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `userId` int(20) unsigned NOT NULL DEFAULT '0' COMMENT 'author' userID', `name` varchar(20) NOT NULL DEFAULT '' COMMENT 'Author', `title` varchar(26) NOT NULL DEFAULT '' COMMENT 'password', `story` text COMMENT 'Story content', `isDeleted` tinyint(1) NOT NULL DEFAULT '0', `created` varchar(13) NOT NULL DEFAULT '0', `updated` varchar(13) NOT NULL DEFAULT '0', PRIMARY KEY (`id`), KEY `userId` (` userId`)) Engine = innoDB Standard charSet = utf8mb4;

Unsere Situation ist, dass, wenn der Benutzer den Namen modifiziert, die Namen beider Tabellen zusammen geändert werden müssen und Inkonsistenzen nicht zulässig sind.

Case2: Unterstützung für Einzeltabellen

Geld übertragen, ein Benutzer reduziert Geld, ein anderer Benutzer erhöht das Geld

 CREATE TABLE `money` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(20) NOT NULL DEFAULT '' COMMENT 'Username', `money` int(26) NOT NULL DEFAULT '0' COMMENT 'money', `isDeleted` tinyint(1) NOT NULL DEFAULT '0', `created` varchar(13) NOT NULL DEFAULT '0', `updated` varchar (13) nicht null Standard '0', Primärschlüssel (`id`), Schlüssel` name` (`name`)) Engine = innoDB Standard charSet = utf8mb4;

Im Vergleich zum obigen Fall ist dies einfacher. Die folgenden Beispiele werden hauptsächlich basierend darauf erklärt. Was Case1 betrifft, muss es erweitert werden.

Implementieren Sie zunächst den entsprechenden DAO und die Entität

 @Datapublic Class MoneyEntity implementiert serialisierbare {private statische endgültige lange Serialversionuid = -7074788842783160025L; private int id; privater Zeichenfolge Name; privates Geld; Privat intiert; privat int erstellt; private int aktualisiert;} öffentliche Schnittstelle MoneyDao {MoneyEntity queryMoney (@param ("id") int userId); // Geld hinzufügen, wenn negativ es negativ ist, bedeutet dies, Geld int IncrementMoney (@param ("id") int userId, @param ("addmoney") int addmoney) zu reduzieren;};}

Die entsprechende Mapper -Datei ist

 <? namespace = "com.git.hui.demo.mybatis.mapper.moneydao"> <sql id = "MoneyEntity"> id, `name`,` ond $ resultType = "com.git.hui.demo.mybatis.entity.moneyEntity"> select <include refid = "meynEntity"/> aus Geld, wobei id = {id} </select> <Update id = "Incrementmoney"> update ond adday = addmoney} addmoney} {mapper> </mapper> </mapper> </mapper> </mappellation

Die entsprechende Konfiguration der MyBatis -Verbindungsdatenquelle

 <Bean> <Eigenschaft name = "Standorte"> <wert> classPath*: jdbc.properties </value> </property> </bean> <bean id = "dataSource" init-method = "init" destroy-method = "close"> <Property name = "triverClassname" $ {{{{{{{{{{$ $}} "/> < name = "userername" value = "$ {userername}"/> <Eigenschaft name = "password" value = "$ {password}"/> <Eigenschaft name = "filters" value = "stat"/> <Eigenschaft name = "MaxActive" value = "20"/> <Property name = "initialSize" value = "1"/> <'. value = "1"/> <Eigenschaft name = "TimeBetweenevictionRunsmillis" value = "60000"/> <Eigenschaft name = "mineVictableIdletImemillis" value = "300000"/> <Eigenschaft name = "validationQuery" value = "select 'x' name = "testonborrow" value = "false"/> <Eigenschaft name = "testonReturn" value = "false"/> <Eigenschaft name = "PoolpreparedStatements" value = "true"/> <Eigenschaft name = "maxpoolpoolpreparedStatementPerctionSize" value ". ref = "dataSource"/> <!-Geben Sie die Mapper-Datei an-> <Eigenschaft name = "mapperlocations" value = "classPath*: mapper/*. xml"/> </bean> <!-angeben scan dao-> <bean> <Property name = "basepackage" value = "com.git.Hui.demo.demo.Mybatis"/> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban> </ban>

Ii. Beispieldemonstration

Durch die Online -Abfrage gibt es vier Möglichkeiten, Frühlingssachen zu verwalten. Hier sind Demonstrationen nacheinander, wie man jede Methode abspielt und dann sehen, wie man im eigentlichen Projekt auswählt

1. Hartcodierte Methode

Programmiermanagement, das das Ding Management mehrerer DB -Operationen durch TransactionTemplate realisiert

A. Durchführung

Dann kann unser Übertragungsfall wie folgt implementiert werden

 @RepositoryPublic Class codedemo1 {@autowired private meyndao meyndao; @Autowired Private TransactionTemplate TransactionTemplate; / ** * Übertragung * * @param inuserid * @param outuserId * @param paymoney * @param Status 0 zeigt eine normale Übertragung an, 1 gibt an, dass eine Ausnahme intern ausgelöst wird. Status) {transactionTemplate.execute (neue transactioncallbackwithoutresult () {Protected void doIntransactionWithoutresult (TransactionStatus transactionStatus) {MoneyEntity Entity = meynDao.queryMoney (OutUSerid); if (enttity.getmone Moneydao.incrementMoney (OutuserId, -Paymoney); } // Folgendes sind alle zugehörigen Testfälle private void TestCase (endgültige InuserID, endgültige int outuserID, endgültiger int Status) {if (status == 1) {werfen neuer illegalArgumentException ("Übertragungsausnahme !!!"); } else if (status == 2) {addMoney (inuserId); try {thread.sleep (3000); } catch (interruptedException e) {e.printstacktrace (); }} else if (status == 3) {addMoney (outuserId); try {thread.sleep (3000); } catch (interruptedException e) {e.printstacktrace (); }}} public void addMoney (endgültige int userID) {System.out.printf ("intern AddMoney:" + System.currentTimemillis ()); neuer Thread (new Runnable () {public void run () {MoneyDao.incrementMoney (userId, 200); System.out.println ("sub modify sculde! Jetzt:" + System.currentTimemillis ());}}). Start (); }}

Betrachten Sie hauptsächlich die obige Transformationsmethode. Die Einkapselung von Dingen wird durch transactionTemplate intern realisiert. Es gibt drei DB -Operationen intern, eine Abfrage und zwei Updates. Die spezifische Analyse wird später erklärt.

Der obige Code ist relativ einfach. Das einzige, worauf Sie achten müssen, ist, wie die TransactionTemplate -Bean definiert ist. Wenn Sie die und die vorherigen XML -Datei nicht einfügen, fügen Sie einfach den Schlüsselcode ein. Einer ist der Transaktionsmanager, der basierend auf DataSource erstellt wurde, und das andere ist die auf Transaktionsmanager erstellte TransActionTemplate.

 <!-programmierende Dinge-> <bean id = "transactionManager"> <Eigenschaft name = "dataSource" ref = "dataSource"/> </bean> <bean id = "transactionTemplate"> <Eigenschaft name = "transactionManager" ref = "/> </> </> </bean>

B. Testfälle

Normale Demonstrationssituation, die Demonstration hat keine Ausnahmen, und die Gleichzeitverwaltung wird nicht berücksichtigt

 @Runwith (SpringJunit4ClassRunner.class) @ContextConfiguration ({"ClassPath*: Spring/service.xml", "classPath*: testdataSource1.xml"}) public class codedemo1Test {@autowed private Codedemo1Mo1Edemo1; @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 ()); }}

Die Ausgabe ist wie folgt, es gibt kein Problem mit dem Geld beider Konten

Während des Übertragungsprozesses tritt eine Anomalie auf, insbesondere wenn der Übertragung das Geld abgezogen hat und der Empfänger das Geld nicht erhalten hat, dh die Situation, in der der Status in dem Fall 1 beträgt.

 // Die interne Ausnahme wirft @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 ()); try {codedemo1.transfor (1, 2, 10, 1); } catch (Ausnahme 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 ());}

In dieser Hinsicht hoffen wir, das Geld aus dem Übertragung zurückzugeben und es wie folgt auszugeben. Wir haben festgestellt, dass sich keines Geld geändert hat.

Wenn der Status 2 ist, bedeutet dies, dass zwischen dem Geld des Übertragers abgezogen wurde und das Geld des Zahlungsempfängers nicht eingegangen ist. Jemand hat 200 an den Zahlungsempfänger übertragen. Zu diesem Zeitpunkt sollte nach dem Verriegelungsmechanismus von MySQL die Übertragung der anderen Person sofort empfangen werden (da das Konto des Zahlungsempfängers nicht gesperrt ist), und es sollte kein Problem mit dem Betrag geben.

Das Ausgabeergebnis ist wie folgt:

Wenn der Status 3 ist, bedeutet dies, dass das Geld des Übertragers abgezogen wurde und das Geld des Zahlungsempfängers nicht eingegangen ist und jemand 200 an den Übertragung überwiesen wurde. Zu diesem Zeitpunkt kann er nur darauf warten, dass die Übertragung der Übertragung vor dem Erfolg von +200 nach dem Erfolg des Transfers und der Schreibschloss hinzugefügt wird. Natürlich muss der endgültige Betrag auch der gleiche sein.

Das Ausgangsergebnis ist wie folgt

C. Zusammenfassung

Bisher wurden in einem Beispiel programmierende Dinge demonstriert. Aus dem obigen Prozess gibt es den Menschen das gleiche Gefühl wie das Schreiben von Dingen im Zusammenhang mit SQL.

2. Basierend auf der Transaktionsproxyfaktorik -Methode

Die nächsten drei sind deklaratives Management, das weniger verwendet wird

A. Durchführung

Zusätzlich zum Abtöten von TransactionTemplate und Entfernen der internen SQL -Logik im Vergleich zum vorherigen stellte ich fest, dass es im Grunde keinen Unterschied gibt.

 public class factoryBeandemo2 {@autowired Private MoneyDao MoneyDao; / ** * Übertragung * * @param inuserid * @param outuserId * @param paymoney * @param Status 0 zeigt eine normale Übertragung an, 1 gibt an, dass eine Ausnahme intern ausgelegt wurde. Status) {MoneyEntity Entity = meynDao.QueryMoney (outuserId); if (entity.getMoney ()> paymoney) {// Sie können Geld überweisen // Geld erster Gelddao.incrementMoney (outuserId, -paymoney); TestCase (Inuserid, OutuserId, Status); // Geld zu Moneydao.incrementMoney (inuserid, paymoney) hinzufügen; System.out.println ("Übertragung ist abgeschlossen! Jetzt:" + System.currentTimemillis ()); }} private void testCase (endgültige InuserID, endgültige int outuserID, endgültiger int Status) {if (status == 1) {werfen Sie neue IllegalArgumentException ("Übertragung ausnahme !!!"); } else if (status == 2) {addMoney (inuserId); try {thread.sleep (3000); } catch (interruptedException e) {e.printstacktrace (); }} else if (status == 3) {addMoney (outuserId); try {thread.sleep (3000); } catch (interruptedException e) {e.printstacktrace (); }}} public void addMoney (endgültige int userID) {System.out.println ("Internal add Geld:" + System.currentTimemillis ()); neuer Thread (new Runnable () {public void run () {MoneyDao.incrementMoney (userId, 200); System.out.println ("sub modify sculde! Jetzt:" + System.currentTimemillis ());}}). Start (); }}

Der entscheidende Punkt ist, dass wir eine TransaktionsproxybeanFactory konfigurieren müssen. Wir wissen, dass Beanfactory ein Mittel für uns ist, um selbst eine Bohne zu schaffen. Die damit verbundene XML -Konfiguration lautet wie folgt

 <!-programmierende Dinge-> <bean id = "transactionManager"> <Eigenschaft name = "dataSource" ref = "dataSource"/> </bean> <bean id = "factoryBeandemo2"/> <!-Konfigurieren Sie den Proxy für das Geschäftsschicht-> <bean id = "FactoryBeanDemDemDemDemDemDemDemDemDemoproxy"> <!-Das Ziel. ref = "factoryBeandemo2" /> <!-Inject the Transaction Manager-> <Eigenschaft name = "Transaktionsmanager" Ref = "TransactionManager" /> <!-Inject die Eigenschaften der Transaktion-> <Eigenschaftsname = "TransactionAttributes"> <Props> <! Welche Ausnahmen Roll-Back-Transaktionen* +Ausnahme: Welche Ausnahmen rollen keine Transaktionen zurück-> <!-Dieser Schlüssel entspricht den Methoden in der Zielklasse-> <Prop Key = "transfor"> propagation_required </prop> <!-<Prop Key = "Transfer"> Propagation_Required, Readong. -> <!-<prop Key = "Transfer"> Propagation_Required,+java.lang.arithmeTexception </prop>-> </props> </property> </bean>

Durch die obige Konfiguration können wir grob verstehen, dass TransactionProxyFactoryBean eine Proxy -Klasse von FactoryBeandemo2 erstellt. Diese Proxy -Klasse umfasst die Logik, die sich mit guten Dingen im Inneren bezieht, was als einfache allgemeine Abstraktion der vorherigen Programmierung angesehen werden kann.

B. Prüfen

Der Testcode ist im Grunde der gleiche wie zuvor. Der einzige Unterschied besteht darin, dass wir die von den Beanfactory generierte Bohne verwenden sollten, anstatt direkt mit FactoryBeandemo2 zu verwenden

Normaler Demo -Fall:

 @RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration({"classpath*:spring/service.xml", "classpath*:test-datasource2.xml"})public class FactoryBeanDemo1Test { @Resource(name = "factoryBeanDemoProxy") private FactoryBeanDemo2 factoryBeanDemo2; @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 ()); }}

Ausgabe

Wenn der Status 1 ist und die interne Ausnahme nicht der Fall ist, hoffen wir, dass es kein Problem mit dem Geld geben wird.

 @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 ()); Versuchen Sie {factoryBeandemo2.Transfor (1, 2, 10, 1); } catch (Ausnahme 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 ());}

Die Ausgabe ist

Wenn der Status 2 ist, sollte das Analyseergebnis das gleiche wie oben sein, und der Ausgang ist wie folgt

Wenn der Status 3 ist, die Ausgabe

C. Zusammenfassung

Die Idee von TransactionProxyFactoryBean besteht darin, den Proxy -Modus zu verwenden, um das Ding -Management zu implementieren, eine Proxy -Klasse zu generieren, Zielmethoden abzunehmen und eine Reihe von SQL -Operationen in Dinge zu integrieren. Im Vergleich zu Hardcode ist es nicht invasiv und unterstützt flexible Konfigurationsmethoden.

Die Nachteile sind ebenfalls offensichtlich, jeweils muss konfiguriert werden, was ziemlich kompliziert ist

3.. So verwenden Sie XML

Der Frühling hat zwei Hauptmerkmale: IOC und AOP. Können wir für solche Dinge AOP verwenden, um es zu tun?

Für Methoden, die eingeschaltet werden müssen, abfangen, die Dinge vor der Ausführung starten, Dinge nach der Ausführung einreichen und zurückrollen, wenn eine Ausnahme eintritt.

Aus dieser Perspektive fühlt es sich sehr vielversprechend an und die folgenden zwei Haltungen werden auf diese Weise gespielt, sodass die Abhängigkeit von Aspekt erforderlich ist.

 <Depopenty> <gruppe> org.aspespectj </Groupid> <artifactId> Aspektjweaver </artifactId> <version> 1.8.7 </Version> </abhängig>

A. Durchführung

Die Java -Klasse entspricht genau dem zweiten Typ, und nur die XML ändert sich

 <!-Zuerst fügen Sie den Namespace hinzu-> xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: aop = "http://www.springframework.org/schema/aop" xsi: schemalocation = "... http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"<! id = "txadvice" Transaktionsmanager = "TransactionManager"> <tx: Attribute> <!-Ausbreitung: Transaktionsausbreitungsverhalten Isolierung: Transaktionisolationsstufe Leseschicht: Nur schreibgeschützte Rollback-für: Welche Ausnahmen sind aufgetreten, no-rollback-für: Welche Ausnahmen sind aufgetragen, keine Rollback-Tempor. </tx: Attribute> </tx: Ratschläge> <!-Konfigurationsabschnitt-> <AOP: config> <!-Konfiguration Point-Cut-> <AOP: Pointcut Expression = "Execution (* com.git.hui.demo.mybatis.Repository.Transaction.xmldemo3. <AOP: Advisor Ratschläge-ref = "txadvice" pointcut-ref = "pointcut1"/> </aoP: config>

Beachten Sie die obige Konfiguration und denken Sie über die zweite Methode nach. Die Idee ist fast gleich, aber diese Methode ist offensichtlich allgemeiner. Durch den Abschnitt und den Schnittpunkt kann eine große Anzahl von Konfigurationen reduziert werden.

B. Prüfen

 @Runwith (SpringJunit4ClassRunner.class) @ContextConfiguration ({"classPath*: Spring/service.xml", "classPath*: test-dataSource3.xml"}) public class xmlbeantest {@autowired private xmldemo3 xmldemo; @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 ()); }}

Dieser Test unterscheidet sich nicht von der allgemeinen Schreibmethode und ist einfacher als die Injektionsmethode der zweiten FactoryBean

Normaler Ausgang

Status = 1 Wenn eine Ausnahme auftritt, ist der Ausgang

Status = 2 Das Szenario der Sparen während des Übertragungsprozesses stimmt mit den vorherigen Erwartungen überein.

Die Ausgabe von Status = 3 stimmt mit den vorherigen Erwartungen überein

4. Annotationsmethode

Damit werden die XML beseitigt und für Anmerkungen verwendet, um die Konfiguration in der vorherigen XML durch die @Transactional -Annotation zu ersetzen.

A. Durchführung

 @RepositoryPublic Class Annodemo4 {@autowired Private MoneyDao MoneyDao; /** * Transfer * * @param inuserId * @param outuserId * @param paymoney * @param Status 0 zeigt eine normale Übertragung an, 1 zeigt an, dass eine Ausnahme intern ausgelegt wird. readOnly: read-only* rollbackFor :What exceptions have occurred noRollbackFor :What exceptions have occurred not to rollback* rollbackForClassName Rollback according to the exception class name*/ @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, readOnly = false) public void transform(final int inUserId, final int outUserId, final int payMoney, final int status) {MoneyEntity Entity = MoneyDao.QueryMoney (outuserId); if (entity.getMoney ()> paymoney) {// Sie können Geld überweisen // Geld erster Gelddao.incrementMoney (outuserId, -paymoney); TestCase (Inuserid, OutuserId, Status); // Geld zu Moneydao.incrementMoney (inuserid, paymoney) hinzufügen; System.out.println ("Übertragung ist abgeschlossen! Jetzt:" + System.currentTimemillis ()); }} private void testCase (endgültige InuserID, endgültige int outuserID, endgültiger int Status) {if (status == 1) {werfen Sie neue IllegalArgumentException ("Übertragung ausnahme !!!"); } else if (status == 2) {addMoney (inuserId); try {thread.sleep (3000); } catch (interruptedException e) {e.printstacktrace (); }} else if (status == 3) {addMoney (outuserId); try {thread.sleep (3000); } catch (interruptedException e) {e.printstacktrace (); }}} private void addmoney (endgültige int userID) {System.out.println ("Innenmeldes Geld:" + System.currentTimemillis ()); neuer Thread (new Runnable () {public void run () {MoneyDao.incrementMoney (userId, 200); System.out.println ("sub modify sculde! Jetzt:" + System.currentTimemillis ());}}). Start (); }}

Daher ist es notwendig, es in XML zu konfigurieren, um die Annotation von Dingen zu ermöglichen

 <!-programmierende Dinge-> <bean id = "transactionManager"> <Eigenschaft name = "dataSource" ref = "dataSource"/> </bean> <tx: Annotationsgetriebene Transaktionsmanager = "TransactionManager"/>

Das macht es klarer. In den tatsächlichen Projekten sind XML- und Annotationsmethoden auch die am häufigsten verwendeten Szenarien.

B. Testfall

Es ist genau das gleiche wie der dritte Testfall, und das Ausgabeergebnis ist das gleiche und wird direkt weggelassen

III. Zusammenfassung

Die obigen Gespräche über vier Möglichkeiten, Dinge im Frühling zu verwenden. Unter ihnen kann die hartcodierte Methode das beste Verständnis sein, was der direkten Übersetzung der Methode zur Verwendung von Dingen in SQL in den entsprechenden Java-Code entspricht. und die FactoryBean -Methode entspricht der Behandlung von besonderen Umständen und der Behandlung jedes Dings mit einer Proxy -Klasse, um die Funktion der Dinge zu verbessern. Die beiden letztgenannten Prinzipien werden fast mithilfe der Ding -Benachrichtigung (AOP) implementiert, um Tangentenpunkte und verwandte Informationen zu definieren.

Programmierung:

TransactionTemplate injizieren
transactionTemplate#execute

Proxy Beanfactory:

Verwenden Sie TransactionProxyFactoryBean, um Proxy für Dinge im Zusammenhang mit Dingen zu generieren
Der Benutzer erhält die Proxy -Klasse über FactoryBean als die verwendete Bean

XML -Konfiguration:

Verwenden Sie die TX -Tag + AOP -Methode, um zu erreichen
<TX: Ratschläge> Tag Definiert Ding -Benachrichtigungen, und es kann mehr Konfigurationsinformationen in darin bestehen
<AOP: Konfigurieren Sie die Punkt und die Facetten

Annotationsmethode:

Fügen Sie einfach @Transactional Annotation zur Methode oder Klasse hinzu, die die Dinge öffnet
Öffnen Sie die Dinge Annotation < tx:annotation-driven transaction-manager="transactionManager"/>

Iv. Andere

1. Referenz

dokumentieren

Vier Arten des Frühlings -Transaktionsmanagements

Quellcode

Projektquellcode: Studie-Demo (lokaler Download)
Hauptansichtspaketpfad: Dinge Demo (lokaler Download)
Testbezogener Code: Test Demo (lokaler Download)

Zusammenfassen

Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Referenzwert für das Studium oder die Arbeit eines jeden hat. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen. Vielen Dank für Ihre Unterstützung bei Wulin.com.