Comment SpringBoot intègre Mybatis pour implémenter l'ajout, la suppression, la modification et la requête

Premier : créer une base de données MySQL

Nous devons d'abord créer une base de données pour exploiter nos données CRUD (vous pouvez utiliser des outils visuels pour la créer, ou vous pouvez utiliser des commandes SQL pour la créer). Après la création Après avoir créé la base de données, nous devons créer une table pour stocker les données. Le nom de la table est celui de l'utilisateur. Les champs peuvent être définis par nous-mêmes, à condition qu'ils correspondent aux entités que nous avons. créer plus tard.

CREATE TABLE `user` (
  `userId` bigint NOT NULL AUTO_INCREMENT,
  `userName` varchar(255) COLLATE utf8mb4_bin NOT NULL,
  `userAddress` varchar(255) COLLATE utf8mb4_bin NOT NULL,
  PRIMARY KEY (`userId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

Deuxième : créez un projet SpringBoot et introduisez les packages de dépendances requis

Créez un projet SpringBoot à l'aide d'IDEA :

• 1 Sélectionnez Spring Initializr pour créer, puis sélectionnez JDK 1.8, version Java8.

• 2. Sélectionnez Spring Web, l'API JDBC, Mybatis Framework, MySQL Driver et Lombok comme composants d'initialisation pouvant être utilisés.

• 3. Après la sélection, cliquez sur Terminer pour créer.

• 4. Après avoir créé SpringBoot, vérifiez si votre Maven n'est pas configuré, vérifiez comment configurer Maven. Sinon, votre dépendance pom ne peut pas être chargée. Comment passer à Alibaba Source. l'adresse de l'image et l'entrepôt local, puis IDEA sélectionne simplement le fichier XML de Maven et l'adresse de l'entrepôt local.

Voici les packages de dépendances requis Si vous oubliez de les présenter, vous pouvez les ajouter directement sans recréer le projet

Troisièmement : Créez le répertoire du programme. et Pour configurer le fichier application.xml principal, vous devez d'abord créer quatre dossiers, à savoir : Entité (entité utilisateur), Contrôleur, Service, Dao, puis vous devez créer un nouveau répertoire Mapper sous le répertoire de ressources Ce répertoire Mapper. est utilisé pour stocker l'instruction SQL. À ce stade, je pense que je dois comprendre le modèle MVC. Puisque notre accès est appelé une couche à la fois, puis revient après avoir interrogé les données, notre niveau devrait être : Contrôleur (la couche de contrôle, qui est également la couche qui reçoit les paramètres transmis par le front-end) -> Service (couche métier, toutes nos activités, telles que les jugements et certaines instructions de boucle, doivent être écrites dans cette couche) -> base de données, et est principalement responsable des opérations de données. C'est le fonctionnement CRUD) -> Base de données,

est illustré dans la figure ci-dessous :

Je n'ai pas de bons outils de dessin, alors j'ai juste dessiné. avec désinvolture. Quoi qu'il en soit, le flux de données est comme ça, vous pouvez y jeter un œil.

Créez un fichier yml dans le dossier ressources et saisissez le contenu suivant :

server:
  port: 8080    //本机的端口号
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/自己数据库的名称?useUnicode=true & characterEncoding=utf-8 &
      useSSL=true & serverTimezone=Asia/Shanghai
    username: root      //数据库的用户名
    password: xxxxxx    //数据库的密码

mybatis:
  mapper-locations: classpath:/Mapper/*.xml
  type-aliases-package: com.example.test.Entity    //这个是扫描到Entity实体包的路径，可根据自己的配置

Après avoir configuré le fichier yml, nous allons dans les bases de données à droite pour voir si nous pouvons nous connecter à notre base de données MySQL locale :

Remplissez le nom de la table de données (notre table ici est la table utilisateur), le nom d'utilisateur et le mot de passe, ainsi que le nom de la base de données

Quatrième : écrivez l'entité, le Dao, le service et Couche contrôleur, et créez le fichier mapper.xml

Package Entity : créez une classe UserEntity, le contenu est le suivant :

public class UserEntity {
    private Integer userId;
    private String userName;
    private String userAddress;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }
}

Package Dao : créez une interface UserDao, le contenu est le suivant :

import com.example.test.Entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface UserDao {
     List<UserEntity> queryLimit(Integer currentPage, Integer pageSize);

     Integer addUser(UserEntity user);

     Integer updateUser(UserEntity user);

     Integer deleteUser(UserEntity user);
}

Package de service : créez une classe UserService, le contenu est le suivant :

import com.example.test.Dao.UserDao;
import com.example.test.Entity.UserEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("UserService")
public class UserService {
    @Autowired
    private UserDao userDao;

    public List<UserEntity> queryLimit(Integer currentPage,Integer pageSzie){
        return userDao.queryLimit(currentPage,pageSzie);
    }

    public Integer addUser(UserEntity user){
        return userDao.addUser(user);
    }

    public Integer updateUser(UserEntity user){
        return userDao.updateUser(user);
    }

    public Integer deleteUser(UserEntity user){
        return userDao.deleteUser(user);
    }
}

Package Controller : Créez une classe UserController, le contenu est :

import com.example.test.Entity.UserEntity;
import com.example.test.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserService userService;

    String message = "";
    @RequestMapping("/queryLimit")
    public List<UserEntity> queryLimit(@RequestParam("currentPage") Integer currentPage,@RequestParam("pageSize") Integer pageSize){
        return userService.queryLimit(currentPage,pageSize);
    }

    @PostMapping("/addUser")
    public String addUer(@RequestBody UserEntity user){
        //用Mybatis执行insert语句的时候，插入成功会返回1，不成功则会抛出异常，捕获一下异常就好
        try {
            userService.addUser(user);
            message = "增加用户成功";
        }catch (Exception exception){
            message = "增加用户异常";
        }
        return message;
    }

    @PutMapping("/updateUser")
    public String updateUser(@RequestBody UserEntity user){
        //Mybatis的更新操作成功返回1，用户不存在返回0，失败则抛异常
        try {
            message = userService.updateUser(user) == 1?"更新用户成功":"用户不存在，更新失败";
        }catch (Exception exception){
            message = "更新异常";
        }
        return message;
    }

    @DeleteMapping("/deleteUser")
    public String deleteUser(@RequestBody UserEntity user){
        //Mybatis的删除操作和更新返回值一样，成功返回1，用户不存在返回0，失败则抛异常
        try {
            message = userService.deleteUser(user) == 1?"删除用户成功":"用户不存在，删除失败";
        }catch (Exception exception){
            message = "删除异常";
        }
        return message;
    }
}

Après avoir écrit le contenu ci-dessus, nous devons créer le mappeur. xml dans le dossier Mapper, comme indiqué ci-dessous :

mapper.xml文件内容如下：需要注意的地方是namespace：这个路径是你的UserDao接口的路径，因为你传过来的数据需要和xml进行一个绑定，这样你编写的SQL语句才能接收到你前端传过来的数据（大体意思可以这么理解），而id则是和你UserDao中的接口方法相对应，比如我的UserDao接口中的查找方法命名是queryLimit，那么我在xml文件中的查询语句的id就应该和queryLimit想对应，即：id=“queryLimit”。
resultType是返回数据的类型
parameterType则是传入的数据类型

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.test.Dao.UserDao">
    <select id="queryLimit" resultType="UserEntity">
        select * from user limit #{currentPage},#{pageSize};
    </select>

    <insert id="addUser" parameterType="UserEntity">
        insert into user(userName,userAddress) values(#{userName},#{userAddress});
    </insert>

    <update id="updateUser" parameterType="UserEntity">
        update user set userName=#{userName},userAddress=#{userAddress} where userId=#{userId};
    </update>

    <delete id="deleteUser" parameterType="UserEntity">
        delete from user where userId=#{userId};
    </delete>
</mapper>

最后我们需要在启动类加一点东西（MapperScan扫描的是我们Dao包的地址，填写自己的就好）

第五：测试结果（这里我用的postman来进行接口测试）

查询用户数据->地址为：http://localhost:8080/user/queryLimit?currentPage=0&pageSize=5

添加用户数据-> 地址为：http://localhost:8080/user/addUser

数据库也能看到数据：

更新用户数据-> 地址为：http://localhost:8080/user/updateUser

更新之后数据库数据为：

删除用户数据-> 地址为：http://localhost:8080/user/deleteUser

查看数据库数据已经删除：

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!