[JAVA] Comment utiliser MapStruct

Je vais résumer comment utiliser MapStruct. La version à utiliser est «1.2.0.Final».

Créer une classe Mapper

La classe Mapper est créée en ajoutant @ Mapper à la classe d'interface ou à la classe abstraite.

@Mapper
public interface FooMapper {
    // omit..
}

@Mapper
public abstract FooMapper {
    // omit..
}

Définition de la méthode de mappage

Après avoir créé la classe Mapper, définissez la méthode Mapping. Utilisez @ Mapping pour spécifier le nom du champ à mapper à l'attribut cible et le nom du champ à mapper à l'attribut source. Il peut être omis si les noms de champ sont identiques.

@Mapper
public interface FooMapper {
    @Mapping(target="name", source="firstName")
    Bar fooToBar(Foo foo);
}

Instance de la classe Mapper

Une instance de la classe Mapper peut être créée avec Mappers # getMapper.

Mappers.getMapper(FooMapper.class);

Spécification du modèle de composant

Vous pouvez changer la méthode de création d'une instance en spécifiant l'attribut componentModel de @ Mapper. Cette fois, nous activerons DI avec Spring Framework.

//Spécifiez le ressort
@Mapper(componentModel = "spring")
public interface FooMapper {
    // omit..
}

Si vous regardez la classe Mapper générée automatiquement, vous pouvez voir que @ Component est ajouté.

import org.springframework.stereotype.Component;

@Component
public class FooMapperImpl implements FooMapper {
    // omit..
}

Voir la documentation officielle pour d'autres méthodes http://mapstruct.org/documentation/stable/reference/html/#retrieving-mapper

Personnalisez le processus de cartographie

MapStruct propose plusieurs façons de personnaliser le processus de cartographie.

Constantes de carte

Utilisez l'attribut constant de @ Mapping.

@Mapper
public interface FooMapper {
    @Mapping(target="name", constant = "Hogehoge")
    Bar fooToBar(Foo foo);
}

Définissez la valeur par défaut

Vous pouvez définir une valeur par défaut pour l'attribut defaultValue de @ Mapping. S'applique lorsque la valeur à mapper est nulle.

@Mapper
public interface FooMapper {
    @Mapping(target="name", defaultValue = "Hogehoge")
    Bar fooToBar(Foo foo);
}

Exécuter du code Java arbitraire

Tout code Java peut être spécifié pour le processus de mappage dans l'attribut Expression de @ Mapping. Placez le code Java dans java ().

@Mapper
public interface FooMapper {
    @Mapping(target="now", expression = "java(java.time.LocalDate.now())")
    Bar fooToBar(Foo foo);
}

Si vous utilisez l'attribut importations de @ Mapper, vous n'avez pas à décrire à partir du nom du package.

@Mapper(imports = LocalDate.class)
public interface FooMapper {
    @Mapping(target="now", expression = "java(LocalDate.now())")
    Bar fooToBar(Foo foo);
}

Formater le nombre

Vous pouvez spécifier un format numérique dans l'attribut numberFormat de @ Mapping.

@Mapper
public interface FooMapper {
    @Mapping(target="num", numberFormat = "000") //Remplir avec zéro
    Bar fooToBar(Foo foo);
}

Formater la date

Vous pouvez spécifier le format de date dans l'attribut dateFormat de @ Mapping.

@Mapper
public interface FooMapper {
    @Mapping(target="date", dateFormat = "yyyy/MM/dd")
    Bar fooToBar(Foo foo);
}

Mappage entre différents énumérations

Vous pouvez mapper différents Enums. Utilisez @ ValueMapping pour mapper les énumérations.

@Mapper
public interface FooMapper {
    @ValueMapping(source = "SMALL", target = "SHORT")
　　　　　　　　@ValueMapping(source = "MEDIUM", target = "TALL")
　　　　　　　　@ValueMapping(source = "LARGE", target = "GRANDE")
    BarEnum fooToBar(FooEnum foo);
}

S'il n'y a pas de cible à mapper, définissez null en spécifiant MappingConstants.NULL dans l'attribut de scène.

@ValueMapping(source = "VENTI", target = MappingConstants.NULL)

Si vous souhaitez spécifier la valeur par défaut, spécifiez MappingConstants.ANY_REMAINING dans l'attribut source.

@ValueMapping(source = MappingConstants.ANY_REMAINING, target = "LARGE")

Utilisez @ Qualifier

Il peut être utilisé lorsque vous souhaitez ajouter un comportement spécial. À titre d'exemple, ajoutez un processus à convertir en majuscules.

Créer des annotations

Créez deux annotations qui combinent «@ Qualifier», une pour le niveau de la classe et une pour le niveau de la méthode.

Pour le niveau de la classe

@Qualifier
@Retention(CLASS)
@Target(TYPE)
public @interface Converter {
}

Pour le niveau de la méthode

@Qualifier
@Retention(CLASS)
@Target(METHOD)
public @interface ToUpper {
}

Définition du comportement

Créez une classe qui définit le comportement. À ce stade, l'annotation créée ci-dessus est ajoutée.

@Converter
public class StringConverter {
    @ToUpper
    public String upperCase(String string) {
        return (string == null) ? null : string.toUpperCase();
    }
}

Créer un mappeur

Spécifiez la classe qui définit le comportement dans l'attribut uses de @ Mapper. Spécifiez deux classes d'annotations dans l'attributqualBy de @ Mapping et ajoutez le comportement au mappage.

@Mapper(uses = StringConverter.class)
public interface FooMapper {
    @Mapping(target="name", qualifiedBy = { Converter.class, ToUpper.class })
    Bar fooToBar(Foo foo);
}

Utilisez @ Context

Le comportement du mappage peut être modifié de l'extérieur en utilisant @ Context.

Créer un mappeur

Ajoutez un argument avec «@ Context» ajouté à l'argument de la méthode de mappage.

@Mapper
public interface FooMapper {
    Bar fooToBar(Foo foo, @Context Locale locale);
}

Ajouter une méthode personnalisée

Définissez une méthode personnalisée avec un argument avec @ Context. Dans l'exemple ci-dessous, un champ de type LocalDate est formaté et mappé au Local spécifié.

@Mapper
public interface FooMapper {
    Bar fooToBar(Foo foo, @Context Locale locale);

    default String format(LocalDate date, @Context Locale locale) {
        //Format selon Local, etc.
    }
}

Utiliser le décorateur

En utilisant Decorator, vous pouvez remplacer le processus de mappage et ajouter un traitement spécial.

Commencez par créer une classe Mapper.

@Mapper
public interface FooMapper {
    Bar fooToBar(Foo foo);
}

Créer une classe Decorator

La classe Decorator est créée en tant que classe abstraite et est un sous-type de Mapper à personnaliser.

public abstract class FooMapperDecorator implements FooMapper {

    private final FooMapper delegate;

    public FooMapperDecorator(FooMapper delegate) {
        this.delegate = delegate;
    }

    //Remplacer la méthode que vous souhaitez personnaliser
    @Override
    public Bar fooToBar(Foo foo) {
        Bar bar = delegate.fooToBar(foo);
        //Ajouter un traitement spécial
        return bar;
    }
}

Appliquer le décorateur

Appliquez la classe Decorator à la classe Mapper. Utilisez @ DecoratedWith pour postuler.

@Mapper
@DecoratedWith(FooMapperDecorator.class)
public interface FooMapper {
    Bar fooToBar(Foo foo);
}

Ajoutez votre propre traitement avant et après le processus de cartographie

En utilisant @ BeforeMapping et @ AfterMapping, vous pouvez exécuter votre propre traitement avant et après le processus de mappage.

@Mapper
public abstract class FooMapper {
    //La méthode que vous souhaitez exécuter avant le mappage
    @BeforeMapping
    protected void before(Foo foo) {
        // omit..
    }

    //La méthode que vous souhaitez exécuter après le mappage
    @AfterMapping
    protected void after(@MappingTarget Bar bar) {
        // omit..
    }

    public abstract Bar fooToBar(Foo foo);
}

Mappeur généré

public class FooMapperImpl extends FooMapper {

    @Override
    public Bar fooToBar(Foo foo) {
        //Exécuter avant le mappage
        before( foo );

        if ( foo == null ) {
            return null;
        }

        //Processus de cartographie

        //Exécuter après le mappage
        after( bar );

        return bar;
    }
}

Réutilisation de la cartographie

Une fois défini, le mappage peut être réutilisé en utilisant @ InheritConfiguration.

@Mapper(config = FooConfig.class)
public interface FooMapper {
    @Mapping(...)
    Bar fooToBar(Foo foo);

    @InheritConfiguration
    Bar fuga(Foo foo);
}

Vous pouvez le réutiliser en tant que mappage inversé en utilisant @ InheritInverseConfiguration.

@Mapper(config = FooConfig.class)
public interface FooMapper {
    @Mapping(...)
    Bar fooToBar(Foo foo);

    @InheritInverseConfiguration
    Foo barToFoo(Bar bar);
}

Classe de configuration

Vous pouvez créer une classe de configuration avec @ MappingConfig. Dans la classe de paramètres, vous pouvez spécifier le modèle de composant et définir s'il faut créer un avertissement ou une erreur lorsqu'un élément n'est pas mappé. Voir Javadoc pour plus de détails. http://mapstruct.org/documentation/stable/api/org/mapstruct/MapperConfig.html

@MapperConfig(unmappedTargetPolicy = ReportingPolicy.IGNORE
     , mappingInheritanceStrategy = MappingInheritanceStrategy.AUTO_INHERIT_ALL_FROM_CONFIG)
public interface FooConfig {

}

Définissez la classe créée sur la classe Mapper. Spécifiez la classe de paramètres créée dans l'attribut de configuration de @ Mapper.

@Mapper(config = FooConfig.class)
public interface FooMapper {
    // omit..
}