Implémenter le mappage ORM basé sur Spring Boot et MyBatis Plus

Dans le processus de développement d'applications Web Java, la technologie de mappage ORM (Object-Relational Mapping) est utilisée pour mapper les données relationnelles de la base de données avec des objets Java, facilitant ainsi l'accès et l'exploitation des données par les développeurs. En tant que l'un des frameworks de développement Web Java les plus populaires à l'heure actuelle, Spring Boot a fourni un moyen d'intégrer MyBatis, et MyBatis Plus est un framework ORM étendu sur la base de MyBatis. Cet article explique comment utiliser Spring Boot et MyBatis Plus pour implémenter le mappage ORM.

1. Spring Boot intègre MyBatis Plus
Utiliser MyBatis Plus dans Spring Boot est très simple, il suffit d'ajouter la dépendance de MyBatis Plus à maven.

<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.4.2</version>
</dependency>

En même temps, configurez les paramètres liés à MyBatis Plus dans application.properties ou application.yml, comme indiqué ci-dessous :

#数据库配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
#MyBatis Plus配置
mybatis.configuration.cache-enabled=false
mybatis.mapper-locations=classpath:mapper/*.xml

Parmi eux, le nom de classe du pilote, l'URL, le nom d'utilisateur et le mot de passe sont des configurations liées à la base de données, et mapper-locations est le chemin où se trouve le fichier de configuration de mappage SQL de MyBatis Plus.

2. Définir les classes d'entités et les interfaces Mapper
Comme MyBatis, l'utilisation de MyBatis Plus nécessite également de définir des classes d'entités et des interfaces Mapper. Ce qui suit prend une simple table User comme exemple pour définir la classe d'entité correspondante et l'interface Mapper.

1. Définir des classes d'entités

@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private Integer id;
    private String name;
    private Integer age;
    private String email;
    private Integer gender;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;

}

L'utilisation des annotations @Getter, @Setter et @Builder peut simplifier le code, tandis que @NoArgsConstructor et @AllArgsConstructor sont utilisés pour générer des constructeurs sans paramètre et avec paramètres complets.

2. Définissez l'interface Mapper

public interface UserMapper extends BaseMapper<User> {
}

Le BaseMapper fourni par MyBatis Plus est utilisé ici, ce qui permet d'économiser de nombreuses opérations SQL fastidieuses.

3. Utilisez MyBatis Plus pour les opérations de base de données
Après avoir défini l'interface Mapper, vous pouvez utiliser MyBatis Plus pour les opérations de base de données.

1. Insérer des données

User user = User.builder()
        .name("test")
        .age(20)
        .email("test@test.com")
        .gender(1)
        .createTime(LocalDateTime.now())
        .updateTime(LocalDateTime.now())
        .build();
int count = userMapper.insert(user);

Lors de l'insertion de données, vous pouvez directement utiliser la méthode d'insertion fournie dans l'interface Mapper, et MyBatis Plus mappera automatiquement les attributs de la classe d'entité aux colonnes correspondantes dans la base de données.

2. Interroger des données

List<User> userList = userMapper.selectList(null);

Lors de l'interrogation de données, vous pouvez directement utiliser la méthode selectList fournie dans l'interface Mapper et transmettre null ou un objet QueryWrapper vide pour interroger toutes les données. De plus, vous pouvez également utiliser des expressions lambda et des opérations de chaîne fournies par MyBatis Plus pour effectuer des requêtes plus complexes, comme indiqué ci-dessous :

QueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery()
        .eq(User::getGender, 1)
        .ge(User::getAge, 20)
        .orderByDesc(User::getCreateTime);
List<User> userList = userMapper.selectList(wrapper);

Dans le code ci-dessus, un QueryWrapper est défini à l'aide de Wrappers.lambdaQuery() Object, et créez des conditions de requête et des règles de tri via les opérations de chaîne .eq, .ge et .orderByDesc.

3. Mettre à jour les données

User user = userMapper.selectById(id);
user.setAge(30);
int count = userMapper.updateById(user);

Lors de la mise à jour des données, vous pouvez d'abord interroger les données qui doivent être mises à jour via selectById, puis modifier les attributs qui doivent être mis à jour et utiliser updateById pour mettre à jour les données modifiées dans la base de données.

4. Delete data

int count = userMapper.deleteById(id);

Enfin, lors de la suppression de données, appelez simplement la méthode deleteById fournie dans l'interface Mapper.

4. Conclusion
Cet article explique comment utiliser Spring Boot et MyBatis Plus pour implémenter le mappage ORM, et les opérations de base de données peuvent être réalisées grâce à une configuration et un code simples. MyBatis Plus, en tant que framework d'extension de MyBatis, peut grandement simplifier la charge de travail du développeur tout en améliorant la lisibilité et la maintenabilité du code. En raison de contraintes d'espace, cet article présente uniquement l'utilisation de base de MyBatis Plus. Pour des fonctions plus avancées, veuillez vous référer à la documentation officielle.

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!