org.mapstruct

Annotation Type BeforeMapping

@Experimental
 @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 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.

If a before-mapping method does not contain a @MappingTarget parameter, it is invoked directly at the beginning of the applicable mapping method. If it contains a @MappingTarget parameter, the method is invoked after the target parameter has been initialized in the mapping method.

All before-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:

 
 @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