org.mapstruct

Annotation Type BeforeMapping

@Target(value=METHOD)
 @Retention(value=CLASS)
public @interface BeforeMapping

Marks a method to be invoked at the beginning of a generated mapping method. The method can be implemented in an abstract mapper class, be declared in a type (class or interface) referenced in Mapper.uses(), or in a type used as @Context parameter in order to be used in a mapping method.

The method invocation is only generated if the return type of the method (if non-void) is assignable to the return type of the mapping method and all parameters can be assigned by the available source, target or context parameters of the mapping method:

• A parameter annotated with @MappingTarget is populated with the target instance of the mapping.
• A parameter annotated with @TargetType is populated with the target type of the mapping.
• Parameters annotated with @Context are populated with the context parameters of the mapping method.
• Any other parameter is populated with a source parameter of the mapping.

For non-void methods, the return value of the method invocation is returned as the result of the mapping method if it is not null.

All before-mapping methods that can be applied to a mapping method will be used. @Qualifier / @Named can be used to filter the methods to use.

The order of the method invocation is determined by their their variant and their location of definition:

1. Methods without an @MappingTarget parameter are called before any null-checks on source parameters and constructing a new target bean.
2. Methods with an @MappingTarget parameter are called after constructing a new target bean.
3. Methods declared on @Context parameters, ordered by the parameter order.
4. Methods implemented in the mapper itself.
5. Methods from types referenced in Mapper.uses(), in the order of the type declaration in the annotation.
6. Methods declared in one type are used after methods declared in their super-type

Important: the order of methods declared within one type can not be guaranteed, as it depends on the compiler and the processing environment implementation.

Example:

 
 @BeforeMapping
 public void calledWithoutArgs() {
     // ...
 }

 @BeforeMapping
 public void calledWithSourceAndTargetType(SourceEntity anySource, @TargetType Class<?> targetType) {
     // ...
 }

 @BeforeMapping
 public void calledWithSourceAndTarget(Object anySource, @MappingTarget TargetDto target) {
     // ...
 }

 public abstract TargetDto toTargetDto(SourceEntity source);

 // generates:

 public TargetDto toTargetDto(SourceEntity source) {
     calledWithoutArgs();
     calledWithSourceAndTargetType( source, TargetDto.class );

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

     TargetDto targetDto = new TargetDto();

     calledWithSourceAndTarget( source, targetDto );

     // actual mapping code

     return targetDto;
 }
 
 

Author:

Andreas Gudian

See Also:

AfterMapping, Context