org.mapstruct

Annotation Type AfterMapping

@Experimental
 @Target(value=METHOD)
 @Retention(value=CLASS)
public @interface AfterMapping

Marks a method to be invoked at the end of a generated mapping method, right before the last return statement of the mapping method. The method can be implemented in an abstract mapper class or be declared in a type (class or interface) referenced in Mapper.uses() in order to be used in a mapping method.

Only methods with return type void may be annotated with this annotation.

If the method has parameters, the method invocation is only generated if all parameters can be assigned by the source or target 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.
• Any other parameter is populated with a source parameter of the mapping, whereas each source parameter is used once at most.

All after-mapping methods that can be applied to a mapping method will be used. Their order is determined by their location of definition:

• The order of methods within one type can not be guaranteed, as it depends on the compiler and the processing environment implementation.
• Methods declared in one type are used after methods declared in their super-type.
• Methods implemented in the mapper itself are used before methods from types referenced in Mapper.uses().
• Types referenced in Mapper.uses() are searched for after-mapping methods in the order specified in the annotation.

Example:

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

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

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

 public abstract TargetDto toTargetDto(SourceEntity source);

 // generates:

 public TargetDto toTargetDto(SourceEntity source) {
     if ( source == null ) {
         return null;
     }

     TargetDto targetDto = new TargetDto();

     // actual mapping code

     calledWithoutArgs();
     calledWithSourceAndTargetType( source, TargetDto.class );
     calledWithSourceAndTarget( source, targetDto );

     return targetDto;
 }
 
 

Author:

Andreas Gudian

See Also:

BeforeMapping