[JAVA] Verwendung von MapStruct

Ich werde zusammenfassen, wie MapStruct verwendet wird. Die zu verwendende Version ist "1.2.0.Final".

Erstellen einer Mapper-Klasse

Die Mapper-Klasse wird erstellt, indem der Schnittstellenklasse oder der abstrakten Klasse "@ Mapper" hinzugefügt wird.

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

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

Definition der Zuordnungsmethode

Definieren Sie nach dem Erstellen der Mapper-Klasse die Mapping-Methode. Verwenden Sie "@ Mapping", um den Feldnamen anzugeben, der dem Zielattribut zugeordnet werden soll, und den Feldnamen, der dem Quellattribut zugeordnet werden soll. Es kann weggelassen werden, wenn die Feldnamen identisch sind.

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

Instanz der Mapper-Klasse

Eine Instanz der Mapper-Klasse kann mit Mappers # getMapper erstellt werden.

Mappers.getMapper(FooMapper.class);

Angeben des Komponentenmodells

Sie können die Methode zum Erstellen einer Instanz ändern, indem Sie das componentModel-Attribut von "@ Mapper" angeben. Dieses Mal werden wir DI mit Spring Framework aktivieren.

//Geben Sie die Feder an
@Mapper(componentModel = "spring")
public interface FooMapper {
    // omit..
}

Wenn Sie sich die automatisch generierte Mapper-Klasse ansehen, sehen Sie, dass "@ Component" hinzugefügt wurde.

import org.springframework.stereotype.Component;

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

Weitere Methoden finden Sie in der offiziellen Dokumentation http://mapstruct.org/documentation/stable/reference/html/#retrieving-mapper

Passen Sie den Zuordnungsprozess an

MapStruct bietet verschiedene Möglichkeiten zum Anpassen des Zuordnungsprozesses.

Kartenkonstanten

Verwenden Sie das Konstantenattribut "@ Mapping".

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

Stellen Sie den Standardwert ein

Sie können einen Standardwert für das Attribut defaultValue von "@ Mapping" festlegen. Gilt, wenn der zuzuordnende Wert null ist.

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

Führen Sie beliebigen Java-Code aus

Jeder Java-Code kann für den Zuordnungsprozess im Ausdrucksattribut "@ Zuordnung" angegeben werden. Fügen Sie den Java-Code in "java ()" ein.

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

Wenn Sie das Importattribut "@ Mapper" verwenden, müssen Sie es nicht anhand des Paketnamens beschreiben.

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

Formatieren Sie die Nummer

Sie können ein numerisches Format im Attribut numberFormat von @ Mapping angeben.

@Mapper
public interface FooMapper {
    @Mapping(target="num", numberFormat = "000") //Mit Null füllen
    Bar fooToBar(Foo foo);
}

Formatieren Sie das Datum

Sie können das Datumsformat im dateFormat-Attribut von "@ Mapping" angeben.

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

Zuordnung zwischen verschiedenen Aufzählungen

Sie können verschiedene Aufzählungen zuordnen. Verwenden Sie "@ ValueMapping", um Aufzählungen zuzuordnen.

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

Wenn kein zuzuordnendes Ziel vorhanden ist, setzen Sie null, indem Sie im Attribut staget "MappingConstants.NULL" angeben.

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

Wenn Sie den Standardwert angeben möchten, geben Sie im Quellattribut "MappingConstants.ANY_REMAINING" an.

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

Verwenden Sie "@ Qualifier"

Es kann verwendet werden, wenn Sie ein spezielles Verhalten hinzufügen möchten. Fügen Sie beispielsweise einen Prozess hinzu, der in Großbuchstaben konvertiert werden soll.

Annotation erstellen

Erstellen Sie zwei Anmerkungen, die "@ Qualifier" kombinieren, eine für die Klassenebene und eine für die Methodenebene.

Für Klassenstufe

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

Für Methodenebene

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

Definition des Verhaltens

Erstellen Sie eine Klasse, die das Verhalten definiert. Zu diesem Zeitpunkt wird die oben erstellte Anmerkung hinzugefügt.

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

Erstellen eines Mappers

Geben Sie die Klasse an, die das Verhalten im Verwendungsattribut "@ Mapper" definiert. Geben Sie im QualifiedBy-Attribut von "@ Mapping" zwei Anmerkungsklassen an und fügen Sie das Verhalten der Zuordnung hinzu.

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

Verwenden Sie "@ Context"

Das Verhalten des Mappings kann von außen mit @ Context geändert werden.

Erstellen eines Mappers

Fügen Sie ein Argument hinzu, wobei dem Argument der Zuordnungsmethode "@ Context" hinzugefügt wird.

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

Benutzerdefinierte Methode hinzufügen

Definieren Sie eine benutzerdefinierte Methode mit einem Argument mit "@ Context". Im folgenden Beispiel wird ein Feld vom Typ LocalDate formatiert und dem angegebenen Local zugeordnet.

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

    default String format(LocalDate date, @Context Locale locale) {
        //Format nach Lokal usw.
    }
}

Verwenden Sie Decorator

Mit Decorator können Sie den Zuordnungsprozess überschreiben und eine spezielle Verarbeitung hinzufügen.

Erstellen Sie zunächst eine Mapper-Klasse.

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

Erstellen einer Decorator-Klasse

Die Decorator-Klasse wird als abstrakte Klasse erstellt und ist ein Untertyp von Mapper, der angepasst werden soll.

public abstract class FooMapperDecorator implements FooMapper {

    private final FooMapper delegate;

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

    //Überschreiben Sie die Methode, die Sie anpassen möchten
    @Override
    public Bar fooToBar(Foo foo) {
        Bar bar = delegate.fooToBar(foo);
        //Fügen Sie eine spezielle Verarbeitung hinzu
        return bar;
    }
}

Decorator auftragen

Wenden Sie die Decorator-Klasse auf die Mapper-Klasse an. Verwenden Sie @ DecoratedWith, um sich zu bewerben.

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

Fügen Sie vor und nach dem Mapping-Prozess Ihre eigene Verarbeitung hinzu

Mit @ BeforeMapping und @ AfterMapping können Sie Ihre eigene Verarbeitung vor und nach der Mapping-Verarbeitung ausführen.

@Mapper
public abstract class FooMapper {
    //Die Methode, die Sie vor dem Mapping ausführen möchten
    @BeforeMapping
    protected void before(Foo foo) {
        // omit..
    }

    //Die Methode, die Sie nach dem Mapping ausführen möchten
    @AfterMapping
    protected void after(@MappingTarget Bar bar) {
        // omit..
    }

    public abstract Bar fooToBar(Foo foo);
}

Generierter Mapper

public class FooMapperImpl extends FooMapper {

    @Override
    public Bar fooToBar(Foo foo) {
        //Vor dem Mapping ausführen
        before( foo );

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

        //Zuordnungsprozess

        //Nach dem Mapping ausführen
        after( bar );

        return bar;
    }
}

Wiederverwendung der Zuordnung

Nach der Definition kann das Mapping mithilfe von "@ InheritConfiguration" wiederverwendet werden.

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

    @InheritConfiguration
    Bar fuga(Foo foo);
}

Sie können es als umgekehrte Zuordnung wiederverwenden, indem Sie "@ InheritInverseConfiguration" verwenden.

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

    @InheritInverseConfiguration
    Foo barToFoo(Bar bar);
}

Konfigurationsklasse

Sie können eine Konfigurationsklasse mit @ MappingConfig erstellen. In der Einstellungsklasse können Sie das Komponentenmodell angeben und festlegen, ob eine Warnung oder ein Fehler ausgegeben werden soll, wenn ein Element nicht zugeordnet ist. Siehe Javadoc für Details. http://mapstruct.org/documentation/stable/api/org/mapstruct/MapperConfig.html

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

}

Setzen Sie die erstellte Klasse auf die Mapper-Klasse. Geben Sie die erstellte Einstellungsklasse im Konfigurationsattribut von "@ Mapper" an.

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