MapStructのクイックガイド

@Mapper
public interface SimpleSourceDestinationMapper {
    SimpleDestination sourceToDestination(SimpleSource source);
    SimpleSource destinationToSource(SimpleDestination destination);
}

public class SimpleSourceDestinationMapperImpl
  implements SimpleSourceDestinationMapper {
    @Override
    public SimpleDestination sourceToDestination(SimpleSource source) {
        if ( source == null ) {
            return null;
        }
        SimpleDestination simpleDestination = new SimpleDestination();
        simpleDestination.setName( source.getName() );
        simpleDestination.setDescription( source.getDescription() );
        return simpleDestination;
    }
    @Override
    public SimpleSource destinationToSource(SimpleDestination destination){
        if ( destination == null ) {
            return null;
        }
        SimpleSource simpleSource = new SimpleSource();
        simpleSource.setName( destination.getName() );
        simpleSource.setDescription( destination.getDescription() );
        return simpleSource;
    }
}

@Mapper(componentModel = "spring")
public abstract class SimpleDestinationMapperUsingInjectedService

@Mapper(componentModel = "spring")
public abstract class SimpleDestinationMapperUsingInjectedService {

    @Autowired
    protected SimpleService simpleService;

    @Mapping(target = "name", expression = "java(simpleService.enrichName(source.getName()))")
    public abstract SimpleDestination sourceToDestination(SimpleSource source);
}

@Test
public void givenEmployeeDTOwithDiffNametoEmployee_whenMaps_thenCorrect() {
    EmployeeDTO dto = new EmployeeDTO();
    dto.setEmployeeId(1);
    dto.setEmployeeName("John");

    Employee entity = mapper.employeeDTOtoEmployee(dto);

    assertEquals(dto.getEmployeeId(), entity.getId());
    assertEquals(dto.getEmployeeName(), entity.getName());
}

private static final String DATE_FORMAT = "dd-MM-yyyy HH:mm:ss";
@Test
public void givenEmpStartDtMappingToEmpDTO_whenMaps_thenCorrect() throws ParseException {
    Employee entity = new Employee();
    entity.setStartDt(new Date());
    EmployeeDTO dto = mapper.employeeToEmployeeDTO(entity);
    SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
 
    assertEquals(format.parse(dto.getEmployeeStartDt()).toString(),
      entity.getStartDt().toString());
}
@Test
public void givenEmpDTOStartDtMappingToEmp_whenMaps_thenCorrect() throws ParseException {
    EmployeeDTO dto = new EmployeeDTO();
    dto.setEmployeeStartDt("01-04-2016 01:00:00");
    Employee entity = mapper.employeeDTOtoEmployee(dto);
    SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
 
    assertEquals(format.parse(dto.getEmployeeStartDt()).toString(),
      entity.getStartDt().toString());
}

9. 抽象クラスを使用したマッピング

@Mapping機能を超える方法でマッパーをカスタマイズしたい場合があります。

たとえば、型変換に加えて、以下の例のように、何らかの方法で値を変換したい場合があります。

このような場合、抽象クラスを作成してカスタマイズしたいメソッドを実装し、MapStructによって生成される必要のあるメソッドを抽象のままにしておくことができます。

9.1. 基本モデル

この例では、次のクラスを使用します。

public class Transaction {
    private Long id;
    private String uuid = UUID.randomUUID().toString();
    private BigDecimal total;

    //standard getters
}

および一致するDTO：

public class TransactionDTO {

    private String uuid;
    private Long totalInCents;

    // standard getters and setters
}

ここで注意が必要なのは、 BigDecimal合計の金額をLongtotalInCentsに変換することです。

9.2. マッパーの定義

これは、Mapperを抽象クラスとして作成することで実現できます。

@Mapper
abstract class TransactionMapper {

    public TransactionDTO toTransactionDTO(Transaction transaction) {
        TransactionDTO transactionDTO = new TransactionDTO();
        transactionDTO.setUuid(transaction.getUuid());
        transactionDTO.setTotalInCents(transaction.getTotal()
          .multiply(new BigDecimal("100")).longValue());
        return transactionDTO;
    }

    public abstract List<TransactionDTO> toTransactionDTO(
      Collection<Transaction> transactions);
}

ここでは、単一オブジェクト変換用に完全にカスタマイズされたマッピングメソッドを実装しました。

一方、CollectionをList abstractにマップするためのメソッドを残したので、MapStructが実装します。

9.3. 生成された結果

単一のTransactionをTransactionDTOにマップするメソッドをすでに実装しているため、MapStructは2番目のメソッドでそれを使用することを期待しています。

以下が生成されます。

@Generated
class TransactionMapperImpl extends TransactionMapper {

    @Override
    public List<TransactionDTO> toTransactionDTO(Collection<Transaction> transactions) {
        if ( transactions == null ) {
            return null;
        }

        List<TransactionDTO> list = new ArrayList<>();
        for ( Transaction transaction : transactions ) {
            list.add( toTransactionDTO( transaction ) );
        }

        return list;
    }
}

12行目でわかるように、 MapStruct は、生成されたメソッドで実装を使用します。

10. マッピング前とマッピング後の注釈

@BeforeMappingおよび@AfterMappingアノテーションを使用して、@Mapping機能をカスタマイズする別の方法を次に示します。 アノテーションは、マッピングロジックの直前と直後に呼び出されるメソッドをマークするために使用されます。

これらは、この動作をすべてのマップされたスーパータイプに適用したいシナリオで非常に役立ちます。

Car ElectricCarおよびBioDieselCarのサブタイプをCarDTOにマップする例を見てみましょう。

マッピング中に、タイプの概念をDTOの FuelTypeenumフィールドにマッピングします。 次に、マッピングが完了したら、DTOの名前を大文字に変更します。

10.1. 基本モデル

次のクラスを使用します。

public class Car {
    private int id;
    private String name;
}

車のサブタイプ：

public class BioDieselCar extends Car {
}

public class ElectricCar extends Car {
}

列挙型フィールドタイプFuelTypeのCarDTO：

public class CarDTO {
    private int id;
    private String name;
    private FuelType fuelType;
}

public enum FuelType {
    ELECTRIC, BIO_DIESEL
}

10.2. マッパーの定義

次に、CarをCarDTOにマップする抽象マッパークラスを作成しましょう。

@Mapper
public abstract class CarsMapper {
    @BeforeMapping
    protected void enrichDTOWithFuelType(Car car, @MappingTarget CarDTO carDto) {
        if (car instanceof ElectricCar) {
            carDto.setFuelType(FuelType.ELECTRIC);
        }
        if (car instanceof BioDieselCar) { 
            carDto.setFuelType(FuelType.BIO_DIESEL);
        }
    }

    @AfterMapping
    protected void convertNameToUpperCase(@MappingTarget CarDTO carDto) {
        carDto.setName(carDto.getName().toUpperCase());
    }

    public abstract CarDTO toCarDto(Car car);
}

@MappingTarget は、マッピングロジックが実行される直前にがターゲットマッピングDTOに入力するパラメータアノテーションです@BeforeMappingの場合およびの場合@AfterMappingアノテーション付きメソッドの。

10.3. 結果

上記で定義されたCarsMapperは、実装を生成します。

@Generated
public class CarsMapperImpl extends CarsMapper {

    @Override
    public CarDTO toCarDto(Car car) {
        if (car == null) {
            return null;
        }

        CarDTO carDTO = new CarDTO();

        enrichDTOWithFuelType(car, carDTO);

        carDTO.setId(car.getId());
        carDTO.setName(car.getName());

        convertNameToUpperCase(carDTO);

        return carDTO;
    }
}

注釈付きメソッドの呼び出しが、実装のマッピングロジックをどのように囲んでいるかに注目してください。

11. ロンボクのサポート

MapStructの最近のバージョンでは、Lombokのサポートが発表されました。 したがって、Lombokを使用してソースエンティティと宛先を簡単にマッピングできます。

Lombokサポートを有効にするには、アノテーションプロセッサパスに依存関係を追加する必要があります。 Lombokバージョン1.18.16以降、lombok-mapstruct-bindingへの依存関係も追加する必要があります。 これで、Mavenコンパイラプラグインにmapstruct-processorとLombokが追加されました。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.5.1</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <annotationProcessorPaths>
            <path>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct-processor</artifactId>
                <version>1.4.2.Final</version>
            </path>
            <path>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
	        <version>1.18.4</version>
            </path>
            <path>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok-mapstruct-binding</artifactId>
	        <version>0.2.0</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>