Mapstruct How to generate mapping source/target in txt file at build time - annotations

Question

I need to generate somewhere (maybe in directory "target/generated/annotations/..../ MyMapper.txt at buildtime) all the sources/target by mapper.
to then be able to read the txt files at runtime
example :
#Mapper
public interface MyMapper {
#Mapping(target = "a", source = "source.x.y.z")
#Mapping(target = "b", source = "source.r.s.t")
#Mapping(target = "c", source = "source.o.p.q")
MyObject map(MySource source);
}
Content of the generated file : target/generated/annotations/MyMapper.txt
mypackage.MyObject.a=mypackage.MySource.x.y.z
mypackage.MyObject.b=mypackage.MySource.r.s.t
mypackage.MyObject.c=mypackage.MySource.o.p.q
how can i do that?
thank you in advance for your help

Answer 1

MapStruct cannot do this out of the box.
You'll need to write your own annotation processor that will use the #Mapper annotation and generate your own text file.

Answer 2

Thank you #Filip for your advice,
I post here a solution, which maybe can help others.
#Filip : What do you think about this solution?
#SupportedAnnotationTypes({ "org.mapstruct.Mapping", "org.mapstruct.Mappings" })
#SupportedSourceVersion(SourceVersion.RELEASE_8)
#AutoService(Processor.class)
public class MapperProcessor extends AbstractProcessor {
private static final String SOURCE = "source";
private static final String TARGET = "target";
private static final Pattern PATTERN_TARGET = Pattern.compile(".*" + TARGET + "=\"([^\"]*)\".*");
private static final Pattern PATTERN_SOURCE = Pattern.compile(".*" + SOURCE + "=\"([^\"]*)\".*");
private static final String DEST_PATH = "META-INF/mapstruct/";
#Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, " MapperProcessor : creating metadata from mapstruct annotation");
// init param
Map<String, Map<String, String>> globalMapping = new HashMap<>();
/////////// annotation : #Mappings
for (Element element : roundEnv.getElementsAnnotatedWith(Mappings.class)) {
final String className = ((TypeElement) element.getEnclosingElement()).getQualifiedName().toString();
Map<? extends ExecutableElement, ? extends AnnotationValue> elementValues = element.getAnnotationMirrors().get(0).getElementValues();
elementValues.values().forEach(value -> {
Map<String, String> mapTargetSource = getTargetSourceValue((List<?>) value.getValue());
globalMapping.put(className, mapTargetSource);
});
}
/////////// annotation : #Mapping
for (Element element : roundEnv.getElementsAnnotatedWith(Mapping.class)) {
final String className = ((TypeElement) element.getEnclosingElement()).getQualifiedName().toString();
List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors();
Map<? extends ExecutableElement, ? extends AnnotationValue> elementValues = annotationMirrors.get(0).getElementValues();
String target = null;
String source = null;
for (Entry<? extends ExecutableElement, ? extends AnnotationValue> entrySet : elementValues.entrySet()) {
final ExecutableElement key = entrySet.getKey();
final AnnotationValue value = entrySet.getValue();
if (StringUtils.equals(key.getSimpleName(), TARGET)) {
target = value.getValue().toString();
}
if (StringUtils.equals(key.getSimpleName(), SOURCE)) {
source = value.getValue().toString();
}
if (StringUtils.isNoneBlank(target, source)) {
break;
}
}
Map<String, String> mapTargetSource = new HashMap<>();
mapTargetSource.put(target, source);
globalMapping.put(className, mapTargetSource);
}
writeMetaData(globalMapping);
return true;
}
///////////////// private methods
private Map<String, String> getTargetSourceValue(List<?> listValue) {
final Map<String, String> result = new HashMap<>();
listValue.forEach(objValueBrut -> {
String target = getValue(PATTERN_TARGET, objValueBrut.toString());
String source = getValue(PATTERN_SOURCE, objValueBrut.toString());
if (StringUtils.isNoneBlank(target, source)) {
result.put(target, source);
}
});
return result;
}
private static String getValue(Pattern pattern, String valueBrut) {
Matcher matcher = pattern.matcher(valueBrut);
if (matcher.matches()) {
return matcher.group(1);
}
return null;
}
private void writeMetaData(Map<String, Map<String, String>> globalMapping) {
for (Entry<String, Map<String, String>> entrySet : globalMapping.entrySet()) {
String className = entrySet.getKey();
Map<String, String> mapping = entrySet.getValue();
if (mapping.isEmpty()) {
continue;
}
try {
FileObject resource = processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", DEST_PATH + className + ".txt");
try (PrintWriter out = new PrintWriter(resource.openWriter())) {
mapping.forEach((k, v) -> out.println(k + "=" + v));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}