Wie SpringBoot Mybatis integriert, um Hinzufügung, Löschung, Änderung und Abfrage zu implementieren

Zuerst: Erstellen Sie eine MySQL-Datenbank

Zuerst sollten wir eine Datenbank erstellen, um unsere CRUD-Daten zu verwalten (Sie können sie mit visuellen Tools erstellen oder SQL-Befehle verwenden, um sie zu erstellen). Nach der Erstellung der Datenbank müssen wir eine Tabelle zum Speichern von Daten erstellen. Die Felder können von uns selbst festgelegt werden später erstellen.

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;

Zweitens: Erstellen Sie ein SpringBoot-Projekt und führen Sie die erforderlichen Abhängigkeitspakete ein.

Verwenden Sie IDEA, um ein SpringBoot-Projekt zu erstellen:

• 1 Wählen Sie Spring Initializr zum Erstellen und dann 1.8 für JDK, Java8 Version.

• 2. Wählen Sie Spring Web, JDBC API, Mybatis Framework, MySQL Driver und Lombok als Initialisierungskomponenten aus, die verwendet werden können.

• 3. Klicken Sie nach der Auswahl auf „Fertig stellen“, um zu erstellen.

• 4. Überprüfen Sie, ob Ihr Maven richtig konfiguriert ist. Andernfalls kann Ihre POM-Abhängigkeit nicht geladen werden Spiegeladresse und lokales Lager, dann wählt IDEA einfach Mavens XML-Datei und die lokale Lageradresse aus.

Die oben aufgeführten erforderlichen Abhängigkeitspakete können Sie direkt hinzufügen, ohne das Projekt neu zu erstellen.

Drittens: Erstellen Sie das Programmverzeichnis und Um die Kerndatei application.xml zu konfigurieren, müssen Sie zunächst vier Ordner erstellen, nämlich: Entity (Benutzerentität), Controller, Service, Dao, und dann müssen Sie ein neues Mapper-Verzeichnis unter dem Ressourcenverzeichnis erstellen wird zum Speichern einer SQL-Anweisung verwendet. An diesem Punkt müssen wir meines Erachtens das MVC-Modell verstehen. Da unser Zugriff eine Schicht nach der anderen aufruft und dann nach der Abfrage der Daten zurückkehrt, sollte unsere Ebene sein: Controller (die Kontrollschicht, die auch die Schicht ist, die empfängt). die vom Front-End übergebenen Parameter) -> Service (Geschäftsschicht, alle unsere Geschäfte, wie z. B. Urteile und einige Schleifenanweisungen, müssen in dieser Schicht geschrieben werden) -> , und ist hauptsächlich für Datenoperationen verantwortlich) -> Datenbank,

ist in der Abbildung unten dargestellt:

Ich habe keine guten Zeichenwerkzeuge, also habe ich sie einfach gezeichnet Wie auch immer, der Datenfluss ist so, Sie können ihn sich ansehen.

Erstellen Sie eine YML-Datei im Ressourcenordner und geben Sie den folgenden Inhalt ein:

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实体包的路径，可根据自己的配置

Nachdem wir die YML-Datei konfiguriert haben, gehen wir zu den Datenbanken auf der rechten Seite, um zu sehen, ob wir eine Verbindung zu unserer herstellen können lokale MySQL-Datenbank:

Geben Sie den Datentabellennamen (unsere Tabelle hier ist die Benutzertabelle), den Benutzernamen und das Kennwort sowie den Datenbanknamen ein.

Viertens: Schreiben Sie Entität, Dao, Service und Controller-Ebene und erstellen Sie die Mapper.xml-Datei.

Entity-Paket: Erstellen Sie eine UserEntity-Klasse. Der Inhalt lautet wie folgt:

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;
    }
}

Dao-Paket: Erstellen Sie eine UserDao-Schnittstelle. Der Inhalt lautet wie folgt:

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);
}

Servicepaket: Erstellen Sie eine UserService-Klasse. Der Inhalt lautet wie folgt:

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);
    }
}

Controller-Paket: Erstellen Sie eine UserController-Klasse. Der Inhalt lautet:

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;
    }
}

Nachdem wir den obigen Inhalt geschrieben haben, müssen wir den Mapper erstellen. xml-Datei im Mapper-Ordner, wie unten gezeigt:

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

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

Das obige ist der detaillierte Inhalt vonWie SpringBoot Mybatis integriert, um Hinzufügung, Löschung, Änderung und Abfrage zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!