configuration du springbootMybatisPlus

Avant-propos :

Mybatis est encore relativement populaire dans le cadre de la couche de persistance, et les projets généraux sont basés sur ssm. Bien que mybatis puisse exploiter directement la base de données via des instructions SQL en XML, il est très flexible. Cependant, ses opérations sont toutes effectuées via des instructions SQL, donc un grand nombre de fichiers XML doivent être écrits, ce qui est très gênant. mybatis-plus résout très bien ce problème.

1. Introduction à mybatis-plus :

Mybatis-Plus (MP en abrégé) est un outil d'amélioration pour Mybatis. Basé sur Mybatis, seules les améliorations sont apportées sans modifications, et il est né pour simplifier le développement et améliorer l'efficacité. Ceci est la définition officielle. Pour plus d'introduction et de fonctionnalités de mybatis-plus, veuillez vous référer au site officiel de mybatis-plus . Alors, comment est-il amélioré ? En fait, il a déjà encapsulé certaines méthodes crud, nous n'avons plus besoin d'écrire du XML, il suffit d'appeler ces méthodes directement, comme JPA.

Deuxièmement, Spring intègre mybatis-plus :

Comme l'a dit le responsable, mybatis-plus ne fait qu'améliorer et ne change pas sur la base de mybatis, donc son intégration avec spring est également très simple. Remplacez simplement les dépendances mybatis par les dépendances mybatis-plus, puis remplacez sqlSessionFactory par mybatis-plus. Ensuite, examinez les opérations spécifiques :
1. pom.xml :
les dépendances principales sont les suivantes :

        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.14.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>4.3.14.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.14.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!-- mp 依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>2.3</version>
        </dependency>

Remarque : Ce sont des dépendances principales. Ce projet utilise également le pilote mysql, c3p0, les journaux (slf4j-api, slf4j-log4j2) et lombok. Pour intégrer mybatis-plus, supprimez mybatis et mybatis-spring pour éviter les conflits ; lombok est un outil, ajoutez cette dépendance, développez l'outil et installez le plug-in Lombok, et vous pourrez l'utiliser. L'utilisation la plus courante est de l'utiliser dans les classes d'entités L'annotation @Data, afin que la classe d'entité n'ait pas besoin d'écrire set, get, toString et d'autres méthodes. Pour une utilisation plus approfondie de Lombok, veuillez utiliser Baidu.

2、log4j.xml :

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd
HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

3、jdbc.properties :

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///数据库名?useUnicode=true&characterEncoding=utf8
jdbc.username=#
jdbc.password=#

4、mybatis-config.xml :

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
</configuration>

Remarque : Comme il est intégré à Spring, la plupart des mybatis-plus sont écrits dans le fichier de configuration Spring, vous pouvez définir ici un mybatis-config.xml vide.

5、spring-dao.xml :

<?xml version="1.0" encoding="UTF-8"?>    
<beans xmlns="http://www.springframework.org/schema/beans"    
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
    xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:aop="http://www.springframework.org/schema/aop"   
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:jee="http://www.springframework.org/schema/jee"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xsi:schemaLocation="    
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd  
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">    
        
    <!-- 配置整合mybatis-plus过程 -->
    <!-- 1、配置数据库相关参数properties的属性：${url} -->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- 2、配置数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- mybatis的sqlsessionFactorybean：org.mybatis.spring.SqlSessionFactoryBean-->
    <!-- 3、配置mybatis-plus的sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="typeAliasesPackage" value="com.zhu.mybatisplus.entity"/>
    </bean>
    <!-- 4、DAO接口所在包名，Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.zhu.mybatisplus.dao" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean> 
</beans>

6、entité :

@Data
@TableName(value = "tb_employee")//指定表名
public class Employee {
    //value与数据库主键列名一致，若实体类属性名与表主键列名一致可省略value
    @TableId(value = "id",type = IdType.AUTO)//指定自增策略
    private Integer id;
    //若没有开启驼峰命名，或者表中列名不符合驼峰规则，可通过该注解指定数据库表中的列名，exist标明数据表中有没有对应列
    @TableField(value = "last_name",exist = true)
    private String lastName;
    private String email;
    private Integer gender;
    private Integer age;
}

7、mappeur :

public interface EmplopyeeDao extends BaseMapper<Employee> {
}

Ceci termine l’intégration de mybatis-plus et spring. La première consiste à remplacer les dépendances mybatis et mybatis-spring par des dépendances mybatis-plus, puis à remplacer sqlsessionfactory par mybatis-plus, puis à ajouter des annotations telles que @TableName, etc. à la classe d'entité et enfin l'héritage du mappeur .@TableIdBaseMapper

8. Testez :

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring/spring-dao.xml"})
public class test {
    @Autowired
    private DataSource dataSource;
    @Test
    public void testDataSource() throws SQLException {
        System.out.println(dataSource.getConnection());
    }
}

Exécutez le junit, vous pouvez afficher la connexion obtenue, indiquant que l'intégration ne pose aucun problème :

Tous les codes de cet article ont été testés par moi-même, et cet article implique beaucoup de codes. Afin de ne pas affecter la longueur, aucune capture d'écran n'est prise là où cela n'est pas nécessaire. Toutes les opérations ultérieures s'appuient sur ce projet intégré.
 

3. Crud général de mp :

Exigences :
 Il existe une table tb_employee et il existe déjà une classe d'entité correspondante Employee. Que devons-nous faire pour réaliser l'opération CRUD de la table tb_employee ?
Basé sur Mybatis :
vous devez écrire l'interface EmployeeMapper et écrire manuellement l'instruction SQL correspondant à la méthode CRUD dans le fichier de mappage EmployeeMapper.xml.
Basé sur MP :
il suffit de créer l'interface EmployeeMapper et d'hériter de l'interface BaseMapper.
Nous avons déjà Employee, tb_employee et EmployeeDao hérite également de BaseMapper, puis utilise la méthode crud.

1. Opération d'insertion :

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring/spring-dao.xml"})
public class test {
    @Autowired
    private EmplopyeeDao emplopyeeDao;
    @Test
    public void testInsert(){
        Employee employee = new Employee();
        employee.setLastName("东方不败");
        employee.setEmail("[email protected]");
        employee.setGender(1);
        employee.setAge(20);
        emplopyeeDao.insert(employee);
        //mybatisplus会自动把当前插入对象在数据库中的id写回到该实体中
        System.out.println(employee.getId());
    }
}

Pour effectuer l'opération d'ajout, appelez simplement la méthode insert pour transmettre l'entité.

2. Opération de mise à jour :

@Test
public void testUpdate(){
        Employee employee = new Employee();
        employee.setId(1);
        employee.setLastName("更新测试");
        //emplopyeeDao.updateById(employee);//根据id进行更新，没有传值的属性就不会更新
        emplopyeeDao.updateAllColumnById(employee);//根据id进行更新，没传值的属性就更新为null
}

Remarque : Faites attention à la différence entre ces deux opérations de mise à jour, updateByIdles méthodes, les champs sans transmission de valeur ne seront pas mis à jour, par exemple, si seul lastName est transmis, alors les attributs tels que l'âge et le sexe conserveront leurs valeurs d'origine ; les méthodes, comme le nom l'indique, updateAllColumnByIdmettra à jour toutes les colonnes sans valeurs seront mises à jour à null.

3. sélectionnez l'opération :

(1) Requête selon l'identifiant :

Employee employee = emplopyeeDao.selectById(1);

(2) Interroger une donnée selon la condition :

Employee employeeCondition = new Employee();
employeeCondition.setId(1);
employeeCondition.setLastName("更新测试");
//若是数据库中符合传入的条件的记录有多条，那就不能用这个方法，会报错
Employee employee = emplopyeeDao.selectOne(employeeCondition);

Remarque : L'instruction SQL de cette méthode indique where id = 1 and last_name = 更新测试que si plusieurs enregistrements remplissent cette condition, une erreur sera signalée.

(3) Renvoie plusieurs éléments de données en fonction des conditions de requête :
lorsqu'il existe plusieurs enregistrements qui répondent aux conditions spécifiées, la méthode ci-dessus signalera une erreur, cette méthode doit donc être utilisée.

Map<String,Object> columnMap = new HashMap<>();
columnMap.put("last_name","东方不败");//写表中的列名
columnMap.put("gender","1");
List<Employee> employees = emplopyeeDao.selectByMap(columnMap);
System.out.println(employees.size());

Remarque : La condition de requête est encapsulée avec la collection de cartes, columnMap, et écrit le nom de la colonne dans la table de données, et non le nom de l'attribut de la classe d'entité. Par exemple, le nom de l'attribut est lastName, le champ de la table de données est last_name et last_name doit être écrit ici. La valeur de retour de la méthode selectByMap est reçue par la collection de listes.

(4) Requête par lots par identifiant :

List<Integer> idList = new ArrayList<>();
idList.add(1);
idList.add(2);
idList.add(3);
List<Employee> employees = emplopyeeDao.selectBatchIds(idList);
System.out.println(employees);

Remarque : Ajoutez tous les identifiants qui doivent être interrogés à la collection de listes, puis appelez la méthode selectBatchIds et transmettez-la à la collection de listes. Cette méthode renvoie tous les enregistrements correspondant à l'identifiant, et toutes les valeurs de retour sont également reçues par la liste. .

(5), requête de pagination :

List<Employee> employees = emplopyeeDao.selectPage(new Page<>(1,2),null);
System.out.println(employees);

Remarque : La méthode selectPage est une requête de pagination. Les informations de pagination sont transmises dans la page. Cette dernière est une condition de pagination nulle. Laissez-la d'abord être nulle, puis parlez de son utilisation après avoir parlé du constructeur de condition. Cette pagination n'est pas réellement une pagination physique, mais une pagination mémoire. En d’autres termes, il n’y a pas d’instruction de limite lors de l’interrogation. La véritable pagination ne peut être réalisée qu'après la configuration du plug-in de pagination.

4. Opération de suppression :

(1), supprimer selon l'identifiant :

emplopyeeDao.deleteById(1);

(2), supprimer selon les conditions :

Map<String,Object> columnMap = new HashMap<>();
columnMap.put("gender",0);
columnMap.put("age",18);
emplopyeeDao.deleteByMap(columnMap);

Remarque : Cette méthode est similaire à selectByMap. Encapsulez la condition dans columnMap, puis appelez la méthode deleteByMap et transmettez-la dans columnMap. La valeur renvoyée est de type Integer, indiquant le nombre de lignes affectées.

(3), supprimer par lots selon l'identifiant :

 List<Integer> idList = new ArrayList<>();
 idList.add(1);
 idList.add(2);
 emplopyeeDao.deleteBatchIds(idList);

Remarque : Cette méthode est similaire à selectBatchIds, placez l'identifiant de l'enregistrement à supprimer dans idList, puis appelez deleteBatchIds et transmettez-le dans idList.

4. Configuration de la politique globale :

Grâce au petit cas ci-dessus, nous pouvons constater que la classe d'entité doit ajouter l'annotation @TableName pour spécifier le nom de la table de base de données et spécifier la stratégie de croissance de l'identifiant via l'annotation @TableId. Cela n'a pas d'importance s'il y a peu de classes d'entités, mais ce sera gênant s'il y a trop de classes d'entités. Par conséquent, la configuration de la politique globale peut être effectuée dans le fichier spring-dao.xml.

<!-- 5、mybatisplus的全局策略配置 -->
<bean id="globalConfiguration" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">
        <!-- 2.3版本后，驼峰命名默认值就是true，所以可不配置 -->
        <!--<property name="dbColumnUnderline" value="true"/>-->
        <!-- 全局主键自增策略，0表示auto -->
        <property name="idType" value="0"/>
        <!-- 全局表前缀配置 -->
        <property name="tablePrefix" value="tb_"/>
</bean>

La configuration ici n'est pas encore utilisée et la configuration doit être injectée dans sqlSessionFactory pour prendre effet. comme suit:

<!-- 3、配置mybatisplus的sqlSessionFactory -->
<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="typeAliasesPackage" value="com.zhu.mybatisplus.entity"/>
        <!-- 注入全局配置 -->
        <property name="globalConfig" ref="globalConfiguration"/>
</bean>

De cette façon, les annotations @TableName et @TableId dans la classe d'entité peuvent être supprimées.
 

5. Constructeur conditionnel (EntityWrapper) :

Pour les opérations CRUD de base ci-dessus, il nous suffit d'hériter d'un BaseMapper pour implémenter la plupart des opérations CRUD à table unique. BaseMapper fournit jusqu'à 17 méthodes d'utilisation, qui peuvent réaliser des opérations uniques, par lots, de pagination et autres de manière extrêmement pratique, réduisant considérablement la charge de développement. Mais la puissance de mybatis-plus ne se limite pas à cela. Veuillez voir comment gérer les exigences suivantes : Exigences
 :
Nous devons interroger tous les utilisateurs de la table tb_employee qui ont entre 18 et 50 ans, dont le sexe est de sexe masculin et dont le nom est xx. À ce stade, nous devrions comment répondre aux exigences ci-dessus ?
Utilisation de MyBatis : vous devez écrire du SQL avec une requête conditionnelle dans le fichier de mappage SQL et utiliser le plug-in PageHelper pour terminer la pagination. Pour répondre à l'exigence simple ci-dessus, nous devons souvent effectuer beaucoup de travail répétitif et monotone.
Utilisation de MP : vous n'avez toujours pas besoin d'écrire des instructions SQL, MP fournit un puissant constructeur conditionnel ------ EntityWrapper.

Examinons ensuite directement quelques cas pour expérimenter l'utilisation d'EntityWrapper.

1. Requête de page pour les utilisateurs âgés de 18 à 50 ans, dont le sexe est 0 et leur nom est Tom :

List<Employee> employees = emplopyeeDao.selectPage(new Page<Employee>(1,3),
     new EntityWrapper<Employee>()
        .between("age",18,50)
        .eq("gender",0)
        .eq("last_name","tom")
);

Remarque : Dans ce cas, nous pouvons voir que la requête de pagination est la même qu'avant et qu'un nouvel objet de page peut être transmis dans les informations de pagination. En ce qui concerne la condition de pagination, créez simplement un nouvel objet EntityWrapper et appelez les méthodes associées de l'objet. Les trois paramètres de la méthode between sont column, value1 et value2. Cette méthode indique que la valeur de la colonne doit être comprise entre value1 et value2 ; eq est un raccourci pour égal. Les deux paramètres de cette méthode, column et value, indiquent le valeur et valeur de la colonne Être égal. Notez que la colonne est le champ correspondant à la table de données, et non le champ attributaire de la classe d'entité.

2. Interrogez les utilisateurs avec un sexe de 0 et un enseignant à leur nom, ou un dans leur boîte mail :

List<Employee> employees = emplopyeeDao.selectList(
                new EntityWrapper<Employee>()
               .eq("gender",0)
               .like("last_name","老师")
                //.or()//和or new 区别不大
               .orNew()
               .like("email","a")
);

Remarque : La requête de pagination n'est pas mentionnée. Vous pouvez donc utiliser selectList et utiliser la méthode like d'EntityWrapper pour effectuer une requête floue. La méthode like signifie que la valeur de la colonne contient la valeur value. Ici, la méthode like consiste à interroger les enregistrements contenant le mot « professeur » dans le nom de famille ; « Ou » est représenté par la méthode ou ou orNew. Il n'y a pas beaucoup de différence entre ces deux méthodes, et vous pouvez utiliser l'une ou l'autre. Vous pouvez ressentir la différence par vous-même grâce à l'instruction SQL sur la console.

3. Le sexe de la requête est 0, trié selon l'âge et la pagination simple :

List<Employee> employees = emplopyeeDao.selectList(
                new EntityWrapper<Employee>()
                .eq("gender",0)
                .orderBy("age")//直接orderby 是升序，asc
                .last("desc limit 1,3")//在sql语句后面追加last里面的内容(改为降序，同时分页)
);

Remarque : La pagination simple fait référence à la pagination sans objets de page. La méthode orderBy consiste à trier par ordre croissant en fonction de la colonne entrante. Si vous souhaitez trier par ordre décroissant, vous pouvez utiliser la méthode orderByDesc, ou vous pouvez utiliser la dernière méthode comme indiqué dans le cas ; la dernière méthode consiste à ajouter la valeur de la dernière méthode jusqu'à la fin de l'instruction SQL. Dans ce cas, la dernière instruction SQL devient select ······ order by desc limit 1, 3, ajoutée desc limit 1,3afin que le tri décroissant et la pagination puissent être effectués.

4. Requête de page pour les utilisateurs âgés de 18 à 50 ans, dont le sexe est 0 et dont le nom est tom : le
constructeur de condition a non seulement EntityWrapper, mais aussi Condition. Utilisez Condition pour gérer cette exigence :

 List<Employee> employees = emplopyeeDao.selectPage(
                new Page<Employee>(1,2),
                Condition.create()
                        .between("age",18,50)
                        .eq("gender","0")
 );

Remarque : La différence entre Condition et EntityWrapper est que lors de la création d'un constructeur conditionnel, EntityWrapper est nouveau, tandis que Condition est créé en appelant la méthode create.

5. Mise à jour selon les conditions :

@Test
public void testEntityWrapperUpdate(){
        Employee employee = new Employee();
        employee.setLastName("苍老师");
        employee.setEmail("[email protected]");
        employee.setGender(0);
        emplopyeeDao.update(employee,
                new EntityWrapper<Employee>()
                .eq("last_name","tom")
                .eq("age",25)
        );
}

Remarque : Cet exemple indique que les informations de tous les utilisateurs dont le nom de famille est tom et l'âge est de 25 ans sont mises à jour avec les informations définies dans l'employé.

6. Supprimer selon les conditions :

emplopyeeDao.delete(
        new EntityWrapper<Employee>()
        .eq("last_name","tom")
        .eq("age",16)
);

Remarque : Dans ce cas, tous les utilisateurs dont le nom de famille est Tom et dont l'âge est de 16 ans sont supprimés.

#@ton#

帮助到您请点赞关注收藏谢谢！！