Comment configurer mybatis et la gestion des transactions dans Springboot

1. Configuration de Spring Boot et mybatis

1 Tout d'abord, toutes les dépendances requises pour Spring Boot pour configurer mybatis sont les suivantes :

<!-- 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>

Ici, nous parlons principalement du package de pilotes de base de données ci-dessus. Oracle et MySQL introduisent différents. dépendances. Si vous oubliez de l'introduire, une exception de classe de pilote introuvable sera signalée.

2. Ensuite, ajoutez le contenu suivant dans le fichier de configuration application.properties : 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);
    }
}

Il existe en fait de nombreux contenus commençant par spring.datasource ci-dessus, en particulier dans application.properties et voyez sur quoi vous pouvez cliquer.   

springboot collectera les informations commençant par spring.datasource par défaut, configurera l'objet DataSource, puis configurera sqlSessionFactory et d'autres configurations de connexion à la base de données associées, donc de nombreuses autres personnes parleront des classes de configuration à écrire. je pense que ceux-ci ne sont pas nécessaires. (La configuration de Druid nécessite un @Bean)  🎜🎜Bien sûr, si elle est particulièrement détaillée et que la configuration correspondante ne peut pas être cliquée via spring.datasource dans le fichier application.properties, cela peut être Besoin de configurer des classes ou quelque chose comme ça. 🎜🎜mybatis.mapper-locations L'emplacement pointé commence à partir de src/main/resource, et le chemin de classe doit être ajouté devant. Il pointe vers l'emplacement où votre fichier mapper.xml est placé. 🎜🎜3. Mybatis a généré des classes d'entités, des mappeurs, etc. grâce à l'ingénierie inverse des tables de base de données. Tout d'abord, j'ai publié la structure de placement spécifique du projet comme suit : 🎜🎜🎜🎜L'explication de l'image ci-dessus est la suivante :🎜 🎜La classe de démarrage doit être placée dans le projet. Par rapport au haut des autres classes, comme mentionné dans l'article précédent, Spring Boot n'a pas la balise traditionnelle configurée dans les projets Spring. depuis la classe de démarrage vers le conteneur Tomcat intégré par défaut. 🎜🎜Dans l'image ci-dessus, le service est placé au-dessus de sa classe d'implémentation. S'il y a deux services A et B, et qu'il y a Aimpl et Bimpl dans la classe d'implémentation, si Aimpl appelle B, il peut signaler "" au démarrage du conteneur. Un champ nommé « B introuvable » semble être une erreur, indiquant que l'ordre d'analyse du conteneur est erroné. 🎜🎜La meilleure solution à cette situation est de placer le service à un endroit élevé comme je l'ai fait. Lorsque le conteneur démarre, il analyse d'abord le service, puis analyse l'impl. De cette façon, le service peut définitivement être trouvé lors de l'implémentation. analyse de classe, c'est-à-dire Cette erreur ne se produira plus. Une autre solution consiste à ajouter une annotation supplémentaire lors de l'introduction du service : @Lazy🎜rrreee🎜En bref, s'il existe une relation entre appeler et être appelé, vous devez vous rappeler que l'appelé doit d'abord être scanné dans le conteneur intégré de Spring Boot. , c'est-à-dire be La position du package de l'appelant doit être placée plus haut (la position doit être au moins égale). 🎜🎜4. Une annotation @Service doit être ajoutée à la classe d'implémentation du service. Ce n'est peut-être pas nécessaire, je ne l'ai pas encore essayé.  🎜🎜5.spring boot+mybatis En plus de ces exigences, vous devez également ajouter une annotation @MapperScan à la classe de démarrage, comme suit :🎜rrreee🎜Ce qui suit est la valeur de l'espace de noms dans mon mapper.xml🎜 rrreee🎜**C'est fait Mybatis est configuré. 🎜🎜2. Configuration de la transaction🎜🎜Il s'agit d'ajouter deux annotations sur la base de mybatis🎜🎜1 Les annotations requises sont @EnableTransactionManagement et @Transactional <.> Deux, ils proviennent du package suivant : 🎜<blockquote>🎜spring-tx.jar🎜</blockquote>🎜En fait, ce package a été automatiquement introduit lorsque mybatis a été configuré pour introduire des dépendances, qui est le suivant : 🎜 rrreee🎜Donc, tant que les dépendances ci-dessus sont introduites, la transaction n'a pas besoin d'être importée dans le package 🎜🎜2 Tout d'abord, recherchez votre classe d'implémentation de service et ajoutez l'annotation <code>@Transactional. . Si vous l'ajoutez sur une classe, toutes les méthodes de la classe seront gérées par des transactions. Si vous l'ajoutez sur une méthode, alors seule cette méthode est conforme à la transaction spécifique. Bien sûr, nous l’ajoutons généralement à la méthode. Parce que seuls l’ajout, la suppression et la modification nécessiteront des transactions. 🎜🎜Par exemple, la méthode suivante d'insertion de données ajoute une transaction : 🎜rrreee🎜Si vous ne savez pas ce qu'il y a à l'intérieur, vous pouvez consulter cet article, spring, configuration de la gestion des transactions mybatis et utilisation de l'annotation @Transactional 🎜🎜3 Après. configuration, la classe de démarrage Spring Boot doit activer les transactions, et l'annotation utilisée pour activer les transactions est @EnableTransactionManagement, comme suit : 🎜rrreee🎜 Ceci termine la configuration de la transaction. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!