sirve - settitle java

Reemplazo de código con un procesador de anotaciones.

Question

Estoy tratando de escribir un procesador de anotaciones para insertar métodos y campos en una clase ... y la documentación es muy escasa. No estoy llegando muy lejos y no sé si me estoy acercando correctamente.

El entorno de procesamiento proporciona un objeto de Filer que tiene métodos prácticos para crear nuevos archivos de origen y de clase. Funcionan bien, pero luego traté de averiguar cómo leer los archivos de origen existentes, y todo lo que proporciona es "getResource". Así que en mi implementación de Procesador he hecho esto:

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    try {
        for (TypeElement te : annotations) {
            for (Element element : roundEnv.getElementsAnnotatedWith(te)) {
                FileObject in_file = processingEnv.getFiler().getResource(
                    StandardLocation.SOURCE_PATH, "",
                    element.asType().toString().replace(".", "/") + ".java");

                FileObject out_file = processingEnv.getFiler().getResource(
                    StandardLocation.SOURCE_OUTPUT, "",
                    element.asType().toString().replace(".", "/") + ".java");

                //if (out_file.getLastModified() >= in_file.getLastModified()) continue;

                CharSequence data = in_file.getCharContent(false);

                data = transform(data); // run the macro processor

                JavaFileObject out_file2 = processingEnv.getFiler().createSourceFile(
                    element.asType().toString(), element);
                Writer w = out_file2.openWriter();
                w.append(data);
                w.close();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getMessage());
    }
    return true;
}

Mi primer dilema es que no puedo evitar sentir ese element.asType().toString().replace(".", "/") + ".java" (para obtener el nombre de tipo calificado y convertirlo en un paquete y la ruta del archivo fuente) no es una buena manera de abordar el problema. El resto de la API está demasiado diseñada, pero no parece haber un método útil para recuperar el código fuente original.

El problema real es que el compilador se enoja espontáneamente con el segundo archivo de origen en el directorio de salida ("error: duplicar clase") y ahora estoy atascado.

Ya he escrito el resto de esto, un analizador y analizador de macros y todo lo demás para calcular algunos datos e insertar los valores y métodos de campo, pero funciona como un paso inicial fuera del compilador. Excepto por el hecho de que los archivos originales no pueden tener una extensión .java (para evitar que el compilador los vea), esto funciona bien. Luego escuché que las anotaciones pueden generar código, lo cual supongo que será más apropiado y conveniente, pero no puedo encontrar mucha orientación al respecto.

Answer 1

La intención detrás del procesador de anotaciones es permitir que un desarrollador agregue nuevas clases, no que reemplace las clases existentes. Dicho esto, hay un error que le permite agregar código a las clases existentes. El Proyecto Lombok ha leveraged esto para agregar getter y setter (entre otras cosas) a sus clases compiladas en java.

El enfoque que he adoptado para "reemplazar" los métodos / campos se extiende o se delega a la clase de entrada. Esto le permite anular / desviar llamadas a la clase objetivo.

Así que si esta es tu clase de entrada:

InputImpl.java:

public class InputImpl implmements Input{
    public void foo(){
        System.out.println("foo");
    }
    public void bar(){
        System.out.println("bar");
    }
}

Podrías generar lo siguiente para "reemplazarlo":

InputReplacementImpl.java:

public class InputReplacementImpl implmements Input{

    private Input delegate;

    //setup delegate....

    public void foo(){
        System.out.println("foo replacement");
    }
    public void bar(){
        delegate.bar();
    }
}

Esto plantea la pregunta, ¿cómo hacer referencia a InputReplacementImpl lugar de InputImpl . Puede generar más código para realizar el ajuste o simplemente llamar al constructor del código que se espera generar.

No estoy realmente seguro de cuál es tu pregunta, pero espero que esto arroje algo de luz sobre tus problemas.