MapStruct @Mapping Anotasyonu - Alanların Üstüne Yazılır

Giriş

@Mapping Anotasyonu şu işler için kullanıır

- Eğer alanlar arasında isim uyumsuzluğu varsa, mapping'i kodla belirtmek gerekir

- Eğer "custom mapping method" kullanmak istiyorsak

dateFormat Alanı

Örnek

Şöyle yaparız

@Mapper
public interface CustomerMapper {
  @Mapping(source="orderDate", target="stringDate", dateFormat= "dd.MM.yyy")
  Customer orderToCustomer(Order order);
}

defaultValue Alanı

Örnek

Şöyle yaparız

@Mapper
public interface CustomerMapper {
  @Mapping(source="age", target="cust.age", defaultValue= "NA")
  @Mapping(source="categoryId", constant="101")
  CustomerDto customerToCustomerDto(Customer customer);
}

expression Alanı

Açıklaması şöyle

expression(“java(…)”) : java code should be used to map on specific attribute.

Açıklaması şöyle

In case your expression has reference to some other classes, then you need to specify all such classes in the imports method of @Mapper annotation like —

@Mapper(imports = UUID.class)

or

@Mapper(imports = {UUID.class, Date.class})

Örnek

Şöyle yaparız

@Mapper(imports= UUID.class)
public interface CustomerMapper {
  @Mapping(target="id", expression="java(UUID.randomUUID().toString() )")
  CustomerDto customerToCustomerDto(Customer customer);
}

ignore Alanı

Açıklaması şöyle

ignore=true : Ignore mapping on specific attribute.

Örnek

Şöyle yaparız

@Mapping(source="id", target="id", ignore = true)
public User toEntity(UserModel userModel);

qualifiedByName Alanı

Açıklaması şöyle

There can be cases where you have to perform some complicated steps to map two fields. In such cases we can use the qualifiedByName method of @Mapping annotation to specify the method which should be invoked to perform that mapping.

- If using Java 8 and later versions, they can be defined as default or static methods within the same interface.

- If using a Java version older than Java 8, you can define all the mappings in an Abstract class instead of the Interface.

The method that contains logic must be annotated with the annotation @Named and it must contain the same name as the string you provided to the qualifiedByName method.

Örnek

Şöyle yaparız

@Mapper
public interface CustomerMapper {
  @Mapping(source"="amountInDollars", target="amountInCents",
    qualifiedByName="dollarsToCents")
  CustomerDto customerToCustomerDto(Customer customer);

  @Named("dollarsToCents")
  default String dollarsToCents(Float dollars) {
    return String.valueOf(dollars * 100);
  }
} 

source + target Alanları

Açıklaması şöyle

source : A source attribute should be mapped from.

target : A target attribute should be mapped to.

Örnek - source + target

Şöyle yaparız

@Mapper
public interface CarMapper {
  CarMapper INSTANCE = Mappers.getMapper( CarMapper.class );

  @Mapping(source = "make", target = "yearOfMake")
  CarDTO carToCarDto(Car car);
}

Örnek

@Mapping anotasyonu birden fazla kez kullanılabilir. Ayrıca source nesnenin alanlarına da erişilebilir. Şöyle yaparız. Burada Doctor sınıfında Speciality tipinden ve ismi speciality olan bir sınıf var. Bu sınıfın da name isimli bir alanı var

@Mapping(source = "phone", target = "contact")
@Mapping(source = "speciality.name", target = "specialityName")
DoctorDto toDto(Doctor doctor);

source + target + qualifiedByName Alanları - Custom Mapping Method

Eğer source alandan target alana dönüşüm için kendi metodumuzu belirtmek istersek kullanırız

Örnek - Alan Değerine Göre

Şöyle yaparız.  Burada source olarak üye alan ismi kullanılıyor.

@Mapper(unmappedTargetPolicy = ReportingPolicy.ERROR)
public interface FooMapper {

  @Mapping(source = "field1", target = "field2", qualifiedByName = "myConverter")
  Bar toFoo (Foo foo);

  @Named("myConverter")
  default int myConverter(int value) { return value * 2;}
}

Örnek - Nesneye Göre

Şöyle yaparız. Burada source olarak üye alan ismi değil, metod parametresi olan foo yazılıyor.

@Mapper(unmappedTargetPolicy = ReportingPolicy.ERROR)
public interface FooMapper {

  @Mapping(source = "foo", target = "field2", qualifiedByName = "myConverter")
  Bar toFoo (Foo foo);

  @Named("myConverter")
  default int myConverter(Foo foo) { return value * 2;}
}