Utiliser MyBatis pour implémenter l'accès aux données et la persistance dans Spring Boot

Spring Boot est un framework de développement rapide qui peut aider les développeurs à créer rapidement des applications WEB. MyBatis est un excellent framework ORM qui peut simplifier l'accès aux données et la persistance entre Java et les bases de données. Cet article explique comment utiliser MyBatis pour implémenter l'accès aux données et la persistance dans Spring Boot.

1. Spring Boot intègre MyBatis

1. Ajouter des dépendances

Ajouter des dépendances MyBatis et MySQL dans le fichier pom.xml :

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

Ici, nous utilisons mybatis-spring-boot-starter pour intégrer MyBatis.

2. Configurez la source de données

Ajoutez la propriété de connexion à la base de données dans 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

Ici, nous utilisons la base de données MySQL et nous nous connectons en utilisant le compte root avec le mot de passe 123456.

3. Configurer MyBatis

Spring Boot analysera automatiquement le chemin du mappeur par défaut. Il nous suffit de configurer le chemin du mappeur dans application.properties :

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

Cette configuration indique que le fichier du mappeur se trouve dans le dossier du mappeur sous le projet. chemin de classe.

Après avoir terminé la configuration ci-dessus, Spring Boot a terminé l'intégration de MyBatis.

2. Écriture de classes d'entités et Mapper

1. Écriture de classes d'entités

Définissez une classe User pour représenter une table utilisateur dans la base de données :

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

2. Écriture de Mapper

Définissez une interface UserMapper pour définir l'ajout de table utilisateur, Opérations de suppression, de modification et d'interrogation :

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

Ici, nous définissons la méthode d'ajout, de suppression, de modification et d'interrogation de tous les utilisateurs.

3. Écrivez Mapper.xml

Ensuite, nous devons écrire le fichier UserMapper.xml pour implémenter les opérations définies dans UserMapper :

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

Dans ce fichier, nous implémentons toutes les méthodes définies dans UserMapper, où paramètreType représente le paramètre. Type, resultType représente le type de valeur de retour.

4. Écrivez la classe Service et le contrôleur

1. Écrivez la classe Service

Définissez une classe UserService pour encapsuler le fonctionnement de la table User :

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

Dans cette classe, nous utilisons l'annotation @Autowired pour injecter le UserMapper. , Autrement dit, vous pouvez utiliser les méthodes définies dans UserMapper.

2. Écrire un contrôleur

Définir une classe UserController pour implémenter des opérations d'ajout, de suppression, de modification et de requête pour les utilisateurs :

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

Dans cette classe, nous utilisons l'annotation @RestController pour indiquer que la classe actuelle est un contrôleur, et utilisez l'annotation @RequestMapping pour spécifier le chemin d'accès. Dans le même temps, UserService est injecté à l'aide de l'annotation @Autowired, c'est-à-dire que les méthodes définies dans UserService peuvent être utilisées.

5. Tests

Maintenant, nous avons terminé la construction et le codage de l'ensemble du projet. Ensuite, nous pouvons utiliser des outils tels que Postman pour tester l'API définie dans le contrôleur.

Utilisez la requête POST pour enregistrer les informations utilisateur, le corps de la requête est :

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

Utilisez la requête PUT pour mettre à jour les informations utilisateur, le corps de la requête est :

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

Utilisez la requête DELETE pour supprimer les informations utilisateur, l'URL est :

http://localhost:8080/user/1

Utilisez Requête GET pour obtenir des informations utilisateur, l'URL est :

http://localhost:8080/user/1

Utilisez la requête GET pour obtenir toutes les informations utilisateur, l'URL est :

http://localhost:8080/user/

6. Résumé

Cet article présente comment utiliser MyBatis pour obtenir l'accès aux données et la persistance au printemps Démarrez et utilise un exemple simple pour illustrer l'ensemble du processus. MyBatis peut rendre les opérations de base de données des programmes Java plus efficaces et concises. Si vous devez implémenter des opérations de base de données dans Spring Boot, vous pouvez envisager d'utiliser MyBatis.

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!