Guide du mappage d'objets avec ModelMapper en Java

Feb 18 2023

Le mappage d'objets est un processus de transformation de données d'un objet à un autre. En Java, cela peut être une tâche fastidieuse qui nécessite beaucoup de code passe-partout pour mapper des données entre deux objets avec des structures différentes. Heureusement, il existe une bibliothèque puissante appelée ModelMapper qui simplifie le processus de mappage d'objets et offre une grande flexibilité dans la personnalisation du comportement de mappage.

Dans cet article, nous allons vous présenter ModelMapper et vous montrer comment l'utiliser pour mapper entre deux objets en Java.

Premiers pas avec ModelMapper

Pour commencer à utiliser ModelMapper dans votre projet Java, vous devez ajouter la bibliothèque ModelMapper à votre projet. Si vous utilisez Maven, ajoutez la dépendance suivante au pom.xmlfichier de votre projet :

<dependency>
  <groupId>org.modelmapper</groupId>
  <artifactId>modelmapper</artifactId>
  <version>2.4.2</version>
</dependency>

implementation 'org.modelmapper:modelmapper:2.4.2'

Mapper des objets avec ModelMapper

Supposons que vous ayez deux objets avec des structures différentes et que vous souhaitiez mapper des données entre eux. Voici un exemple :

public class User {
    private String name;
    private int age;

    // constructor, getters, and setters
}

public class UserDTO {
    private String fullName;
    private int userAge;

    // constructor, getters, and setters
}

public class Main {
    public static void main(String[] args) {
        User user = new User("John", 30);
        ModelMapper modelMapper = new ModelMapper();
        UserDTO userDTO = modelMapper.map(user, UserDTO.class);
        System.out.println(userDTO.getFullName()); // Output: John
        System.out.println(userDTO.getUserAge()); // Output: 30
    }
}

Lorsque nous exécutons la mainméthode, la sortie sera Johnet 30, ce qui indique que le mappage a réussi.

Personnalisation du mappage d'objets

ModelMapper offre une grande flexibilité dans la personnalisation du mappage d'objets. Vous pouvez spécifier des mappages de champs personnalisés, créer des convertisseurs de type et configurer différentes stratégies de mappage.

Mappages de champs personnalisés

Parfois, vous devrez peut-être mapper des champs avec des noms différents entre deux objets. Vous pouvez y parvenir en spécifiant des mappages de champs personnalisés. Voici un exemple :

modelMapper.typeMap(User.class, UserDTO.class)
  .addMappings(mapper -> {
      mapper.map(src -> src.getName(), UserDTO::setFullName);
      mapper.map(src -> src.getAge(), UserDTO::setUserAge);
  });

Convertisseurs de types

ModelMapper fournit un certain nombre de convertisseurs de type intégrés qui peuvent convertir automatiquement les données entre différents types. Cependant, vous devrez parfois créer vos propres convertisseurs de type pour les types de données personnalisés. Voici un exemple :

public class DateToStringConverter extends AbstractConverter<Date, String> {
    @Override
    protected String convert(Date source) {
        return source.toString();
    }
}

Nous pouvons enregistrer le convertisseur de type personnalisé auprès de l' ModelMapperinstance en appelant la addConverter()méthode :

modelMapper.addConverter(new DateToStringConverter());

Stratégies de cartographie

ModelMapper fournit plusieurs stratégies de mappage qui peuvent être utilisées pour personnaliser le comportement de mappage. Certaines des stratégies disponibles incluent Strict, Looseet Standard.

Par exemple, la Loosestratégie permet le mappage entre des champs avec des noms et des types différents, tandis que la Strictstratégie applique des règles de mappage strictes et déclenche une exception lorsqu'un mappage ne peut pas être effectué.

Vous pouvez définir la stratégie de mappage en appelant la setMatchingStrategy()méthode sur l' ModelMapperinstance :

modelMapper.getConfiguration()
  .setMatchingStrategy(MatchingStrategies.LOOSE);

Conclusion

Dans cet article, nous vous avons montré comment utiliser ModelMapper pour mapper entre deux objets en Java. ModelMapper est une bibliothèque puissante qui simplifie le processus de mappage d'objets et offre une grande flexibilité dans la personnalisation du comportement de mappage.

En utilisant ModelMapper, vous pouvez éviter d'écrire beaucoup de code passe-partout pour le mappage d'objets et vous concentrer sur les fonctionnalités de base de votre application.