使用Java 注解处理器（Annotation Processor）来避免Spring事务抛出受检异常Exception无法回滚

@Transactional(rollbackFor = Exception.class)

 <dependency>
      <groupId>com.google.auto.service</groupId>
      <artifactId>auto-service</artifactId>
      <version>1.1.1</version>
    </dependency>

package org.renzhikeji;

import com.google.auto.service.AutoService;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;


/**
 * @author 认知科技技术团队
 * 微信公众号：认知科技技术团队
 */
@SupportedAnnotationTypes("org.springframework.transaction.annotation.Transactional")
@AutoService(Processor.class)
public class TransactionalProcessor extends AbstractProcessor {
    private static ConcurrentHashMap<Element, Element> message = new ConcurrentHashMap<>();

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        System.out.println("=======Transactional rollbackFor=Exception.class== 处理 ");

        Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(Transactional.class);
        for (Element element : elementsAnnotatedWith) {
            if (!element.getKind().isExecutable()) {
                continue;
            }

            Map<String, Object> keyValues = getAnnotation(element, Transactional.class.getName());

            if (keyValues.isEmpty()) {
                message.put(element, element);
                continue;
            }


            Set<String> rollbackFor = Optional.ofNullable((List<Object>) keyValues.get("rollbackFor")).stream()
                                              .map(Object::toString).collect(Collectors.toSet());



            if ( !rollbackFor.contains("java.lang.Exception.class")) {
                message.put(element, element);
            }
        }


        if (!message.isEmpty()) {
            throw new RuntimeException("使用spring的事务注解Transactional，请配置rollbackFor=Exception.class，防止事务失效");
        }

        return true;
    }


    private static Map<String, Object> getAnnotation(Element element, String name) {
        for (AnnotationMirror mirror : element.getAnnotationMirrors()) {
            if (mirror.getAnnotationType().toString().equals(name)) {
                return annotationKeyValues(mirror);
            }
        }
        throw new IllegalArgumentException(String.format("%s has no annotation %s", element, name));
    }

    private static Map<String, Object> annotationKeyValues(AnnotationMirror mirror) {
        Map<String, Object> result = new LinkedHashMap<>();
        for (ExecutableElement key : mirror.getElementValues().keySet()) {
            result.put(key.getSimpleName().toString(), mirror.getElementValues().get(key).getValue());
        }
        return result;
    }

}