Define custom MapStruct mapper without having to define mapping of all fields

Suppose I have two DTOs which I wish to map with MapStruct, DTO1 and DTO2 have largely identical fields differing only in naming and I wish to map them all from one to the other. With MapStruct I could just do:

@Mapping(target = "desiredName", source = "notDesiredName")
// etc
DTO1 toDto1(Dto2 dto2);

but suppose I have just one property within Dto2 which I would like to pass through a function first. I know I could do:

default DTO1 toDto1(Dto2 dto2) {
    ...
    dto1.setSomething(myFunction(dto.getSomething)
    ...
}

How can I avoid having to rote define every other property conversion?

By default Mapstruct will automatically transfer all the fields with the same name/type. In order to intervene in what is done automatically use the @AfterMapping annotation and code only the exceptions. (or use @BeforeMapping)

import org.mapstruct.AfterMapping;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;

import com.example.demo.dto.Dto1;
import com.example.demo.dto.Dto2;

@Mapper
public abstract class DtoMapper {

	@Mapping(target = "desiredName", source = "notDesiredName")

    @AfterMapping
    protected void interveneWithSomethingThatChanges (Dto1 dto1, @MappingTarget Dto2 dto2) {
    	dto2.somethingThatChanges = dto1.somethingThatChanges + ": changed";
    }

    public abstract Dto2 toDto2(Dto1 dto1);
}

The remaining code is as follows:

MapperMain.java

import org.mapstruct.factory.Mappers;

import com.example.demo.dto.Dto1;
import com.example.demo.dto.Dto2;
import com.example.demo.mapper.DtoMapper;

public class MapperMain {

public static void main(String[] args) {
    final DtoMapper mapper
      = Mappers.getMapper(DtoMapper.class);
    
    Dto1 dto1 = new Dto1("somethingThatChanges", "somethingThatStaysTheSame", "somethingElseThatStaysTheSame");
	Dto2 dto2 = mapper.toDto2(dto1);
	
	System.out.println(dto2);


}

}

Output:

Dto2 [somethingThatChanges=somethingThatChanges: changed, somethingThatStaysTheSame=somethingThatStaysTheSame, desiredName=somethingElseThatStaysTheSame]

Dto1.java

public class Dto1 {
public String somethingThatChanges;
public String somethingThatStaysTheSame;
public String notDesiredName;

public Dto1(String somethingThatChanges, String somethingThatStaysTheSame, String notDesiredName) {
	this.somethingThatChanges = somethingThatChanges;
	this.somethingThatStaysTheSame = somethingThatStaysTheSame;
	this.notDesiredName = notDesiredName;
}
}

Dto2.java

public class Dto2 {
@Override
public String toString() {
	return "Dto2 [somethingThatChanges=" + somethingThatChanges + ", somethingThatStaysTheSame="
			+ somethingThatStaysTheSame + ", desiredName=" + desiredName + "]";
}
public String somethingThatChanges;
public String somethingThatStaysTheSame;
public String desiredName;
}

If you have a custom function to map a specific property you can use qualifiers.

e.g.

@Mapper
public interface MyMapper {


    @Mapping(target = "something", qualifiedByName = "customSomething")
    DTO1 toDto1(Dto2 dto2);

    @Named("customSomething")
    default String mapSomething(String value) {
         // perform mapping
    }
}

Let's digest the example. In this example both DTO1 and DTO2 have a field named something. Therefore, we only need to define Mapping#target (Mapping#source is obsolete when target and source match).

Next is the fact that we want to perform some special way of mapping this field. We define this with Mapping#qualifiedByName. This tells MapStruct to look for a custom mapping method annotated with @Named("customSomething").

The mapSomething method is a custom method annotated with @Named("customSomething") this tells MapStruct that this is a special mapping method and it should only be used if the user has specifically requested it (using Mapping#qualifiedBy)