So konfigurieren Sie Mybatis und die Transaktionsverwaltung in Springboot

1. Konfiguration von Spring Boot und Mybatis

1. Alle für Spring Boot erforderlichen Abhängigkeiten sind wie folgt:

<!-- Spring Boot 启动父依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.1.RELEASE</version>
</parent>
<!--以上内容放在dependencies标签外，如果你有已经有父标签，那将以上部分粘贴到父项目中-->
<!-- spring boot 项目启动必须引入的web依赖,以下内容放在dependency即可 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>1.5.1.RELEASE</version>
</dependency>       
 <!-- Spring Boot Mybatis 依赖 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.2.0</version>
</dependency>
 <!-- oracle的数据库驱动包 -->
<dependency>
    <groupId>com.oracle</groupId>
    <artifactId>ojdbc6</artifactId>
    <version>11.2.0.4.0-atlassian-hosted</version>
</dependency>

Hier sprechen wir hauptsächlich über die unterschiedlichen Datenbanktreiberpakete Abhängigkeiten nicht vergessen. Wenn Sie vergessen, es einzuführen, wird eine Ausnahme „Treiberklasse nicht gefunden“ gemeldet.

2. Fügen Sie dann den folgenden Inhalt zur Konfigurationsdatei application.properties hinzu: application.properties 配置文件里添加如下内容：

##数据库连接信息
spring.datasource.url=jdbc:oracle:thin:@//192.168.1.171:1521/orcl
spring.datasource.username=znxd
spring.datasource.password=znxd
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
##指向mapper的xml文件位置
mybatis.mapper-locations=classpath:mapper/*Mapper.xml
##指向实体类的位置
mybatis.type-aliases-package=cloud.user.models.*

上边以spring.datasource 开头的内容其实有很多，具体，在application.properties 文件里输入后看看能点出的内容就知道了。  

springboot默认会把spring.datasource开头的信息收纳，进行DataSource对象的配置，进而进行sqlSessionFactory的配置等相关数据库连接的配置，所以其他很多人会说写什么配置类，那些我感觉没有必要的。（配置druid需要配一个@Bean）  

当然如果是特别详细的，而在application.properties文件里又通过spring.datasource 点不出相关的配置，那可能需要配置类什么的。

mybatis.mapper-locations 所指向的位置是从src/main/resource开始的，前边需要加上classpath，它指向的是你的mapper.xml文件放置的位置。

3.我是mybatis通过数据库表逆向工程生成的实体类、mapper等，先把项目具体的放置结构贴出来如下：

对于上图的解释如下：

启动类必须放在项目中相对其他类的最高处，前边文章说过，spring boot没有传统的spring 项目配置的 标签，它扫描bean的方式就是从启动类依次向下扫描进默认的内置tomcat容器的。

上图service放置的位置比其实现类放置的位置高，如果有两个service A和B，实现类里有Aimpl和Bimpl，如果有Aimpl调用B的情况，有可能会在启动容器报“a field named ‘B’ not found”貌似这种错误，说明容器扫描顺序有误。

这种情况的最好的解决办法，就应该像我将service放在高处，容器启动先扫描进service，然后再扫描impl,这样在实现类扫描的时候就肯定能找到service，也就不会出现这种错误了。另一种解决办法是在引入service时多添加一个注解：@Lazy

@Autowired
@Lazy //这样就会延迟加载，上图不需要，这里只是解释这注解
LogsUserActiveMapper logsUserActiveMapper;

总之，如果出现调用与被调用关系，一定要记得，被调用者要首先被扫描进spring boot内置容器，也就是被调用者的包位置要放的较高一些（位置至少也待相平）。

4.service实现类上需要加一个@Service 注解。这个可能不需要，我一直没有试试。 

5.spring boot+mybatis除了这些要求，还需要在启动类处添加一个注解@MapperScan，如下：

package cloud.kafka;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement //如果mybatis中service实现类中加入事务注解，需要此处添加该注解
@MapperScan("cloud.kafka.mapper")  //扫描的是mapper.xml中namespace指向值的包位置
public class KafkaLogApplication {
    public static void main(String[] args){
        SpringApplication.run(KafkaLogApplication.class, args);
    }
}

如下是我的mapper.xml里namespace的值

<mapper namespace="cloud.kafka.mapper.LogsUserActiveMapper" >

**这样就完成mybatis的配置了。

二、事务的配置

就是在mybatis的基础上加上两个注解

1、需要的注解为@EnableTransactionManagement 和@Transactional 两个，它们来自于下边这个包：

spring-tx.jar

该包其实在前边配置mybatis引入依赖时，已自动引入，就是下边这个：

 <!-- Spring Boot Mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.2.0</version>
</dependency>

所以只要上边的依赖引入进来，那事务就不需要再引入包了，

2.首先，找到你的service实现类，加上@Transactional 注解，如果你加在类上，那该类所有的方法都会被事务管理，如果你加在方法上，那仅仅该方法符合具体的事务。当然我们一般都是加在方法上。因为只有增、删、改才会需要事务。

比如下边的一个插入数据的方法添加事务：

@Override
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
public Integer add(Cbf_jtcy t) {
    return cbf_jtcyMapper.insert(t);
}

如果不知道里边都是什么东西，可以查看这篇文章，spring,mybatis事务管理配置与@Transactional注解使用

3.配置完后，spring boot启动类必须要开启事务，而开启事务用的注解就是@EnableTransactionManagement

@SpringBootApplication
@EnableTransactionManagement 
@MapperScan("microservice.qssj.mapper")//必须加这个，不加报错，如果不加，也可以在每个mapper上添加@Mapper注释，并且这里还要多填一个注释，那个我忘了，我一直用这个注解
public class QssjServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(QssjServiceApplication.class, args);
    }
}

Es gibt tatsächlich viele Inhalte, die mit spring.datasource oben beginnen , in application.properties ein und sehen Sie, worauf Sie klicken können.   

springboot sammelt standardmäßig die Informationen, die mit spring.datasource beginnen, konfiguriert das DataSource-Objekt und konfiguriert dann die sqlSessionFactory und andere verwandte Datenbankverbindungskonfigurationen, sodass viele andere Leute darüber sprechen werden, welche Konfigurationsklassen ich schreiben soll das Gefühl haben, dass es nicht notwendig ist. (Für die Konfiguration von Druid ist ein @Bean erforderlich.)  🎜🎜Wenn es besonders detailliert ist und die entsprechende Konfiguration nicht über spring.datasource in der application.properties-Datei angeklickt werden kann, kann dies natürlich der Fall sein Es müssen Klassen oder ähnliches konfiguriert werden. 🎜🎜mybatis.mapper-locations Der Speicherort, auf den verwiesen wird, beginnt bei src/main/resource, und der Klassenpfad muss vorangestellt werden. Er zeigt auf den Speicherort, an dem Ihre Datei „mapper.xml“ abgelegt ist. 🎜🎜3. Mybatis hat Entitätsklassen, Mapper usw. durch Reverse Engineering von Datenbanktabellen generiert. Zuerst habe ich die spezifische Platzierungsstruktur des Projekts wie folgt gepostet: 🎜🎜🎜🎜Die Erklärung für das obige Bild lautet wie folgt:🎜 🎜Die Startup-Klasse muss im Projekt platziert werden. Wie im vorherigen Artikel erwähnt, verfügt Spring Boot nicht über das herkömmliche -Tag, das in Spring-Projekten konfiguriert ist von der Startup-Klasse in den standardmäßig integrierten Tomcat-Container herunter. 🎜🎜Im obigen Bild ist der Dienst höher als seine Implementierungsklasse platziert und es gibt Aimpl und Bimpl in der Implementierungsklasse. Wenn Aimpl B aufruft, wird beim Starten möglicherweise „“ gemeldet Ein Feld namens „B“ scheint ein Fehler zu sein, was darauf hinweist, dass die Container-Scanreihenfolge falsch ist. 🎜🎜Die beste Lösung für diese Situation besteht darin, den Dienst an einer hohen Stelle zu platzieren, wie ich es getan habe. Wenn der Container startet, scannt er zuerst den Dienst und dann das Impl. Auf diese Weise kann der Dienst bei der Implementierung definitiv gefunden werden Klassenscan, das heißt, dieser Fehler tritt nicht mehr auf. Eine andere Lösung besteht darin, bei der Einführung des Dienstes eine zusätzliche Anmerkung hinzuzufügen: @Lazy🎜rrreee🎜Kurz gesagt, wenn eine Beziehung zwischen Anruf und Angerufenwerden besteht, müssen Sie bedenken, dass der Angerufene zuerst in den in Spring Boot integrierten Container gescannt werden muss Das heißt, die Paketposition des Anrufers sollte höher platziert werden (die Position sollte mindestens gleich sein). 🎜🎜4. Der Service-Implementierungsklasse muss eine @Service-Annotation hinzugefügt werden. Das ist vielleicht nicht notwendig, ich habe es noch nicht ausprobiert.  🎜🎜5.spring boot+mybatis Zusätzlich zu diesen Anforderungen müssen Sie der Startup-Klasse auch eine Annotation @MapperScan hinzufügen, wie folgt:🎜rrreee🎜Das Folgende ist der Wert des Namespace in meiner Mapper.xml🎜 rrreee🎜**Dies ist erledigt. Mybatis ist konfiguriert. 🎜🎜2. Transaktionskonfiguration🎜🎜Es müssen zwei Anmerkungen auf Basis von mybatis hinzugefügt werden🎜🎜1 Die erforderlichen Anmerkungen sind @EnableTransactionManagement und @Transactional Zweitens stammen sie aus dem folgenden Paket: 🎜<blockquote>🎜spring-tx.jar🎜</blockquote>🎜Tatsächlich wurde dieses Paket automatisch eingeführt, als mybatis für die Einführung von Abhängigkeiten konfiguriert wurde, nämlich das folgende : 🎜 rrreee🎜Solange also die oben genannten Abhängigkeiten eingeführt werden, muss die Transaktion nicht in das Paket importiert werden 🎜🎜2 Suchen Sie zunächst Ihre Service-Implementierungsklasse und fügen Sie die Annotation <code>@Transactional hinzu . Wenn Sie es in einer Klasse hinzufügen, werden alle Methoden der Klasse von Transaktionen verwaltet. Wenn Sie es in einer Methode hinzufügen, entspricht nur diese Methode der spezifischen Transaktion. Natürlich fügen wir es normalerweise der Methode hinzu. Denn nur das Hinzufügen, Löschen und Ändern erfordert Transaktionen. 🎜🎜Mit der folgenden Methode zum Einfügen von Daten wird beispielsweise eine Transaktion hinzugefügt: 🎜rrreee🎜Wenn Sie nicht wissen, was sich darin befindet, können Sie diesen Artikel lesen, die Konfiguration der Mybatis-Transaktionsverwaltung und die @Transactional-Annotation verwenden 🎜🎜3 Konfiguration: Die Spring Boot-Startup-Klasse muss Transaktionen aktivieren, und die zum Aktivieren von Transaktionen verwendete Annotation lautet @EnableTransactionManagement wie folgt: 🎜rrreee🎜Damit ist die Konfiguration der Transaktion abgeschlossen. 🎜

Das obige ist der detaillierte Inhalt vonSo konfigurieren Sie Mybatis und die Transaktionsverwaltung in Springboot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!