Der MapStruct in Quarkus

Bevor wir in die Tiefe eintauchen, lassen Sie uns schnell rekapitulieren, worum es bei MapStruct geht. Es ist ein Code-Generator, der zur Kompilierzeit typsichere Bean-Mapper erstellt. Kein Laufzeit-Overhead, keine Reflexionsmagie - nur reiner, effizienter Java-Code. Hier ein Beispiel, wie ein einfacher Mapper aussieht:

@Mapper
public interface UserMapper {
    UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);
    
    UserDTO mapToDTO(User user);
}

Einfach, oder? Aber wir fangen gerade erst an!

Die Top 10 MapStruct-Tricks, die Sie nie wussten, dass Sie sie brauchen

1. Mapping mit Kontext: Die geheime Zutat

Mussten Sie schon einmal zusätzliche Informationen an Ihren Mapper übergeben? Hier kommt die @Context-Annotation ins Spiel:

@Mapper
public interface UserMapper {
    @Mapping(target = "role", source = "user")
    UserDTO mapToDTO(User user, @Context SecurityContext securityContext);
    
    default String mapRole(User user, @Context SecurityContext securityContext) {
        return securityContext.isAdmin() ? "ADMIN" : user.getRole();
    }
}

Jetzt können Sie zur Laufzeit Kontext in Ihre Mapping-Logik einfügen. Praktisch, oder?

2. Benutzerdefinierte Methoden-Mappings: Wenn Standard nicht ausreicht

Manchmal müssen Sie selbst Hand anlegen und benutzerdefinierte Mapping-Logik schreiben:

@Mapper
public interface DateMapper {
    @Mapping(target = "formattedDate", source = "date", qualifiedByName = "formatDate")
    DateDTO map(DateEntity date);
    
    @Named("formatDate")
    default String formatDate(LocalDate date) {
        return date != null ? date.format(DateTimeFormatter.ISO_LOCAL_DATE) : null;
    }
}

Tipp: Verwenden Sie @Named, um Ihre benutzerdefinierten Methoden organisiert und wiederverwendbar zu halten.

3. Collection Mapping: Weil eins nie genug ist

MapStruct behandelt Sammlungen wie ein Profi:

@Mapper
public interface ProductMapper {
    List mapToDTOList(List products);
    
    Set mapToProductNames(List products);
}

Es wendet das Element-Mapping automatisch auf jedes Element in der Sammlung an. Magie!

4. Verschachteltes Objekt-Mapping: Tief eintauchen

Mit komplexen Objektstrukturen zu tun? MapStruct hilft Ihnen dabei:

@Mapper
public interface OrderMapper {
    @Mapping(target = "customerName", source = "customer.name")
    @Mapping(target = "orderItems", source = "items")
    OrderDTO mapToDTO(Order order);
    
    @Mapping(target = "productName", source = "product.name")
    OrderItemDTO mapToItemDTO(OrderItem item);
}

Es behandelt nahtlos verschachtelte Objekte und erspart Ihnen den Albtraum manueller Mappings.

5. Bedingtes Mapping: Die Kunst der Entscheidungsfindung

Manchmal müssen Sie Mapping-Entscheidungen spontan treffen:

@Mapper
public interface UserMapper {
    @Mapping(target = "status", expression = "java(mapStatus(user))")
    UserDTO mapToDTO(User user);
    
    default String mapStatus(User user) {
        return user.getLastLoginDate() != null && 
               user.getLastLoginDate().isAfter(LocalDate.now().minusDays(30)) 
               ? "ACTIVE" : "INACTIVE";
    }
}

Verwenden Sie Ausdrücke, um komplexe Logik in Ihre Mappings einzufügen.

6. Felder ignorieren: Die Kunst des selektiven Mappings

Manchmal ist weniger mehr. Ignorieren Sie Felder, die Sie nicht benötigen:

@Mapper
public interface UserMapper {
    @Mapping(target = "password", ignore = true)
    @Mapping(target = "createdAt", ignore = true)
    UserDTO mapToDTO(User user);
}

Perfekt, wenn Sie mit sensiblen Daten oder Feldern zu tun haben, die nicht in Ihr DTO gehören.

7. Reverse Mapping: In beide Richtungen gehen

Müssen Sie hin und her mappen? MapStruct hat Sie abgedeckt:

@Mapper
public interface UserMapper {
    @Mapping(target = "id", ignore = true)
    User mapToEntity(UserDTO dto);
    
    UserDTO mapToDTO(User user);
}

Definieren Sie einfach beide Methoden, und MapStruct übernimmt das bidirektionale Mapping für Sie.

8. Standardwerte: Die Lücken füllen

Manchmal müssen Sie Standardwerte für fehlende Daten bereitstellen:

@Mapper
public interface ProductMapper {
    @Mapping(target = "inStock", constant = "true")
    @Mapping(target = "category", defaultValue = "UNCATEGORIZED")
    ProductDTO mapToDTO(Product product);
}

Verwenden Sie constant für fest codierte Werte und defaultValue für Rückfallwerte, wenn die Quelle null ist.

9. Vor- und Nach-Mapping: Der letzte Schliff

Müssen Sie einige Operationen vor oder nach dem Mapping durchführen? Begrüßen Sie @BeforeMapping und @AfterMapping:

@Mapper
public abstract class OrderMapper {
    @Mapping(target = "total", ignore = true)
    public abstract OrderDTO mapToDTO(Order order);
    
    @AfterMapping
    protected void calculateTotal(Order order, @MappingTarget OrderDTO orderDTO) {
        orderDTO.setTotal(order.getItems().stream()
                               .mapToDouble(item -> item.getPrice() * item.getQuantity())
                               .sum());
    }
}

Perfekt für komplexe Berechnungen oder letzte Anpassungen.

10. Benutzerdefinierte MapStruct-Annotationen: Die Kraft der Abstraktion

Erstellen Sie Ihre eigenen Annotationen, um gängige Mapping-Muster zu kapseln:

@Retention(RetentionPolicy.CLASS)
@Mapping(target = "id", ignore = true)
@Mapping(target = "createdAt", expression = "java(java.time.LocalDateTime.now())")
public @interface ToEntity { }

@Mapper
public interface UserMapper {
    @ToEntity
    User mapToEntity(UserDTO dto);
}

Dieser Ansatz hilft, Ihre Mapper sauber zu halten und fördert die Wiederverwendbarkeit in Ihrem Code.

Zusammenfassung: Die MapStruct-Magie entfesselt

Da haben Sie es - 10 MapStruct-Tricks, die Ihr Quarkus-Mapping auf die nächste Stufe heben. Von kontextbewussten Mappings bis hin zu benutzerdefinierten Annotationen ist MapStruct vollgepackt mit Funktionen, die selbst die komplexesten Objekttransformationen vereinfachen können.

Denken Sie daran, der Schlüssel zur Beherrschung von MapStruct ist das Experimentieren. Scheuen Sie sich nicht, in die Dokumentation einzutauchen und verschiedene Kombinationen dieser Techniken auszuprobieren. Ihr zukünftiges Ich (und Ihre Code-Reviewer) werden Ihnen für den sauberen, effizienten und wartbaren Mapping-Code danken, den Sie produzieren werden.

Also, das nächste Mal, wenn Sie sich dabei ertappen, dass Sie zu dieser manuellen Setter-Suppe greifen, treten Sie einen Schritt zurück und fragen Sie sich: "Was würde MapStruct tun?" Die Chancen stehen gut, dass es einen Trick auf Lager hat, der Ihr Leben erheblich erleichtert.

Viel Spaß beim Mapping, Quarkus-Ninjas! 🚀

"Die Kunst des Mappings besteht nicht darin, neue Objekte zu schaffen, sondern die Beziehungen zwischen bestehenden zu offenbaren." - Anonymer Entwickler (wahrscheinlich)

P.S. Vergessen Sie nicht, das MapStruct-Repository auf GitHub zu markieren, wenn Sie es nützlich finden. Open-Source-Projekte leben von der Unterstützung der Community!