Verwendung von MyBatis zur Implementierung von Datenzugriff und -persistenz in Spring Boot

Spring Boot ist ein Framework für die schnelle Entwicklung, das Entwicklern dabei helfen kann, schnell WEB-Anwendungen zu erstellen. MyBatis ist ein hervorragendes ORM-Framework, das den Datenzugriff und die Persistenz zwischen Java und Datenbanken vereinfachen kann. In diesem Artikel wird erläutert, wie Sie mit MyBatis Datenzugriff und -persistenz in Spring Boot implementieren.

1. Spring Boot integriert MyBatis.

1. Abhängigkeiten hinzufügen.

Konfigurieren Sie die Datenquelle

Fügen Sie die Datenbankverbindungseigenschaft in application.properties hinzu:

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.1</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.42</version>
</dependency>

2. Hier verwenden wir die MySQL-Datenbank und verbinden uns mit dem Root-Konto mit dem Passwort 123456.

Konfigurieren Sie MyBatis

Spring Boot scannt standardmäßig automatisch den Mapper-Pfad in application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driverClassName=com.mysql.jdbc.Driver

3. Diese Konfiguration zeigt an, dass sich die Mapper-Datei im Mapper-Ordner unter dem Projekt befindet Klassenpfad.

Nach Abschluss der obigen Konfiguration hat Spring Boot die Integration von MyBatis abgeschlossen.

2. Entitätsklassen und Mapper schreiben

Entitätsklassen schreiben

Eine Benutzerklasse definieren, um eine Benutzertabelle in der Datenbank darzustellen:

mybatis.mapper-locations=classpath:mapper/*.xml

1. Mapper schreiben

Eine UserMapper-Schnittstelle zum Definieren einer Benutzertabelle hinzufügen, Lösch-, Änderungs- und Abfragevorgänge:

public class User {
    private Long id;
    private String name;
    private Integer age;
    // 省略getter和setter方法
}

2. Hier definieren wir die Methode zum Hinzufügen, Löschen, Ändern und Abfragen aller Benutzer.

3. Schreiben Sie Mapper.xml

Als nächstes müssen wir die Datei UserMapper.xml schreiben, um die in UserMapper definierten Operationen zu implementieren:

public interface UserMapper {
    void saveUser(User user);
    void updateUser(User user);
    void deleteUser(Long id);
    User findUserById(Long id);
    List<User> findAllUsers();
}

In dieser Datei implementieren wir alle in UserMapper definierten Methoden, wobei parameterType den Parameter darstellt Typ, resultType repräsentiert den Rückgabewerttyp.

4. Schreiben Sie die Service-Klasse und den Controller.

Schreiben Sie die Service-Klasse.

Definieren Sie eine UserService-Klasse, um die Operation der User-Tabelle zu kapseln:

<?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.demo.mapper.UserMapper">
    <insert id="saveUser" parameterType="com.example.demo.entity.User">
        insert into user(name, age) values (#{name}, #{age})
    </insert>

    <update id="updateUser" parameterType="com.example.demo.entity.User">
        update user set name = #{name}, age = #{age} where id = #{id}
    </update>

    <delete id="deleteUser" parameterType="java.lang.Long">
        delete from user where id = #{id}
    </delete>

    <select id="findUserById" parameterType="java.lang.Long"
            resultType="com.example.demo.entity.User">
        select * from user where id = #{id}
    </select>

    <select id="findAllUsers" resultType="com.example.demo.entity.User">
        select * from user
    </select>
</mapper>

1. In dieser Klasse verwenden wir die Annotation @Autowired, um den UserMapper einzufügen Das heißt, Sie können die in UserMapper definierten Methoden verwenden.

Schreiben Sie einen Controller

Definieren Sie eine UserController-Klasse, um die Hinzufügungs-, Lösch-, Änderungs- und Abfragevorgänge von Benutzern zu implementieren:

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public void saveUser(User user) {
        userMapper.saveUser(user);
    }

    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    public void deleteUser(Long id) {
        userMapper.deleteUser(id);
    }

    public User findUserById(Long id) {
        return userMapper.findUserById(id);
    }

    public List<User> findAllUsers() {
        return userMapper.findAllUsers();
    }
}

2. In dieser Klasse verwenden wir die Annotation @RestController, um anzugeben, dass die aktuelle Klasse ein Controller ist und verwenden Sie die Annotation @RequestMapping, um den Zugriffspfad anzugeben. Gleichzeitig wird UserService mithilfe der Annotation @Autowired injiziert, sodass die in UserService definierten Methoden verwendet werden können.

5. Testen

Jetzt haben wir die Konstruktion und Codierung des gesamten Projekts abgeschlossen. Als nächstes können wir Tools wie Postman verwenden, um die im Controller definierte API zu testen.

Verwenden Sie die POST-Anfrage, um Benutzerinformationen zu speichern. Der Anforderungstext lautet:

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

    @PostMapping("/")
    public String saveUser(@RequestBody User user) {
        userService.saveUser(user);
        return "success";
    }

    @PutMapping("/")
    public String updateUser(@RequestBody User user) {
        userService.updateUser(user);
        return "success";
    }

    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return "success";
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findUserById(id);
    }

    @GetMapping("/")
    public List<User> findAllUsers() {
        return userService.findAllUsers();
    }
}

.

Verwenden Sie die PUT-Anfrage, um Benutzerinformationen zu aktualisieren. Der Anforderungstext lautet:

{
    "name": "张三",
    "age": 18
}

GET-Anfrage zum Abrufen von Benutzerinformationen. Die URL lautet:

{
    "id": 1,
    "name": "李四",
    "age": 20
}

Booten und verwenden Sie ein einfaches Beispiel, um den gesamten Prozess zu veranschaulichen. MyBatis kann die Datenbankoperationen von Java-Programmen effizienter und präziser gestalten. Wenn Sie Datenbankoperationen in Spring Boot implementieren müssen, können Sie die Verwendung von MyBatis in Betracht ziehen.

Das obige ist der detaillierte Inhalt vonVerwendung von MyBatis zur Implementierung von Datenzugriff und -persistenz in Spring Boot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!