Question

为正在制作的应用程序创建语言文件时，我遇到了很多样板代码。我目前有一个包含所有语言字符串的类，然后使用反射将这些字符串写入文件。

我经常碰到的是，我的字符串中有一些要替换的占位符，例如，我可能有一个这样的字符串：

public static String USER_INFO = "Username: %name% money: %balance%";

我想实现的是基于注释生成一些方法，例如我可以使用lombok生成getter / setter和其他方法。根据上面的字符串，我将有一个名为Arguments的注释（应正确地命名为Replacers或更有意义的东西），如下所示：

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.FIELD)
public @interface Arguments {
  String[] value();
}

我想做的就是添加这样的注释：

@Arguments(
        value = {"%balance%", "%name%"}
)
public static String USER_INFO = "Username: %name% - money: %balance%";

并获得以下自动生成的替换方法：

public static String USER_INFONameReplacement(String name) {
    return USER_INFO.replace("%name%", name);
}
public static String USER_INFOAllReplacement(String name, String balance) {
    return USER_INFO.replace("%name%", name).replace("%balance%", balance);
}
public static String USER_INFOBalanceReplacement(String balance) {
    return USER_INFO.replace("%balance%", balance);
}

进行一些搜索后，我最终尝试在这样的类中实现AbstractProcessor：

@SupportedAnnotationTypes(
    {"io.github.freakyville.configHelper.annotations.Arguments"})
@SupportedSourceVersion(SourceVersion.RELEASE_8)
@AutoService(Processor.class)
public class SuggestProcessor extends AbstractProcessor {

@Override
public synchronized void init(ProcessingEnvironment env) {
}

@Override
public boolean process(Set<? extends TypeElement> annoations, RoundEnvironment env) {
    for (TypeElement annoation : annoations) {
        Set<? extends Element> annotatedElements = env.getElementsAnnotatedWith(annoation);
        Map<Boolean, List<Element>> annotatedFields = annotatedElements.stream().collect(
                Collectors.partitioningBy(element ->
                        ((ArrayType) element.asType()).getComponentType().getClass().equals(PrimitiveType.class)));
        List<Element> setters = annotatedFields.get(true);
        if (setters.isEmpty()) {
            continue;
        }
        String className = ((TypeElement) setters.get(0)
                .getEnclosingElement()).getQualifiedName().toString();

        Map<String, List<String>> setterMap = setters.stream().collect(Collectors.toMap(
                setter -> setter.getSimpleName().toString(),
                setter -> Arrays.asList(setter.getAnnotation(Arguments.class).value()))
        );
        try {
            writeBuilderFile(className, setterMap);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return true;
}

private void writeBuilderFile(
        String className, Map<String, List<String>> setterMap)
        throws IOException {

    String packageName = null;
    int lastDot = className.lastIndexOf('.');
    if (lastDot > 0) {
        packageName = className.substring(0, lastDot);
    }

    String builderSimpleClassName = className
            .substring(lastDot + 1);

    JavaFileObject builderFile = processingEnv.getFiler()
            .createSourceFile(className);

    try (PrintWriter out = new PrintWriter(builderFile.openWriter())) {

        if (packageName != null) {
            out.print("package ");
            out.print(packageName);
            out.println(";");
            out.println();
        }

        out.print("public class ");
        out.print(builderSimpleClassName);
        out.println(" {");
        out.println();

        setterMap.forEach((key, orgArgNames) -> {

            for (int i = 0; i < orgArgNames.size(); i++) {
                List<String> subList = orgArgNames.subList(0, i + 1);
                List<String> argNames = subList.stream().map(v -> v.replace("%", "") + "Replacement").collect(Collectors.toList());
                List<String> argsWithTypes = argNames.stream().map(v -> "String " + v).collect(Collectors.toList());
                String argumentList = "(" + String.join("", argsWithTypes).substring(0, argsWithTypes.size() - 3) + ")";
                String methodName;

                if (orgArgNames.size() <= 1) {
                    methodName = key + "Replace" + subList.stream().map(v -> v.replace("%", "")).collect(Collectors.joining(""));
                } else {
                    methodName = key + "Replace" + subList.stream().map(v -> v.replace("%", "").substring(0, 1).toUpperCase() + v.substring(1)).collect(Collectors.joining(""));
                }

                out.print("    public static ");
                out.print(methodName);
                out.print(argumentList);
                out.println("{");
                StringBuilder replaceSB = new StringBuilder();
                replaceSB.append(key);
                for (int i1 = 0; i1 < subList.size(); i1++) {
                    replaceSB
                            .append(".replace(")
                            .append("\"")
                            .append(subList.get(i))
                            .append("\"")
                            .append(",")
                            .append(argNames.get(i))
                            .append(")");

                }
                String replace = replaceSB.toString();
                out.println("return " + replace + ";");
                out.println("}");
                out.println("");
            }
        });

        out.println("}");
    }
}


}

但是我似乎无法获取它进行注册？

所以我的第一个问题是，如果要实现此目标，那么AbstractProcessor是可行的方法吗？如果没有怎么办？如果是，那为什么不注册？我正在使用IntelliJ并进入设置->构建->编译器，并将注释处理器更改为启用，并将处理器路径设置为我的AskingProcessor

Answer 1

Java注释处理（APT）插件旨在基于其他类生成代码。这些类最终位于生成的sources文件夹中，然后再对其进行编译。这些APT插件是从classpath / build工具配置中发现的，并且也由IntelliJ编译器运行。请记住：APT是用于生成的源代码，而不是用于替换现有的类。 Lombok仍然能够执行此操作的唯一原因是因为它们非常深入编译器，并且能够操纵正在编译的类的AST。

由于这种方法在Java的未来版本中存在很大争议并且容易出错，因此几乎没有人会尝试构建基于APT的类替换框架或能够做到这一点的Lombok扩展（不是因为Lombok是唯一可以被视为这种APT使用类型的“框架”的工具，而Lombok本身根本不是以可扩展的方式构建的。）

结论：APT可能是解决之道，但是您的处理器将不得不创建一个新类，而不是尝试修改现有类。

有关如何创建注释处理器的示例，您可以查看以下存储库：https://github.com/galberola/java-apt-simple-example

我不确定为什么当前的注释处理器未与编译器正确关联。如果使用的是Maven，则可以尝试在本地安装处理器的工件，并将其作为编译依赖项添加到其他项目中。别忘了在您的编译器中将类注册为注释处理器，我引用的示例项目在此处进行了操作：https://github.com/galberola/java-apt-simple-example/blob/master/example/pom.xml#L29-L31。相同的配置也可以应用于其他构建系统。

Java中没有真正的方法来修改正在编译的类，因此，如果您确实必须在同一个类中具有该方法，那么很遗憾，这意味着它无法完成。

Answer 2

您可以像Lombok一样修改抽象语法树（AST），而不是实际创建文件并写入文件。不建议这样做，并且不同的编译器以不同的方式实现AST，但是您可以从github（https://github.com/rzwitserloot/lombok）扩展Lombok源代码，并根据需要创建注释处理程序。但是，这有点困难，因此请确保您确实需要它。

抱歉，我没有正确阅读您的问题。要注册它，您想在使用注释和注释处理器的项目中建立一个META-INF \ services目录。在该目录中，创建一个名为“ javax.annotation.processing.Processor”的txt文件，其中包含处理器的名称，例如mypackage.SuggestProcessor。如果决定使用Java 9，则还可以在module-info文件中声明处理器。处理器的模块必须包括“为javax.annotation.processing.Processor提供某些东西。SuggestProcessor”，而使用注释的模块必须包括“ uses javax.annotation.processing.Processor”。这就是javac注册注解处理器的方式。

自动生成替换方法

2 个答案: