Uma API Java para gerar arquivos de origem Java [fechados]

Estou procurando uma estrutura para gerar arquivos de origem Java.

Algo como a seguinte API:

X clazz = Something.createClass("package name", "class name");
clazz.addSuperInterface("interface name");
clazz.addMethod("method name", returnType, argumentTypes, ...);

File targetDir = ...;
clazz.generate(targetDir);

Em seguida, um arquivo de origem java deve ser encontrado em um subdiretório do diretório de destino.

Alguém conhece essa estrutura?

EDIT :

1. Eu realmente preciso dos arquivos de origem.
2. Eu também gostaria de preencher o código dos métodos.
3. Estou procurando uma abstração de alto nível, não manipulação / geração direta de bytecode.
4. Eu também preciso da "estrutura da classe" em uma árvore de objetos.
5. O domínio do problema é geral: gerar uma grande quantidade de classes muito diferentes, sem uma "estrutura comum".

SOLUÇÕES
Postei 2 respostas com base em suas respostas ... com o CodeModel e com o Eclipse JDT .

Eu usei o CodeModel na minha solução: :-)

A Sun fornece uma API chamada CodeModel para gerar arquivos de origem Java usando uma API. Não é a coisa mais fácil de obter informações, mas existe e funciona muito bem.

A maneira mais fácil de se apossar dele é como parte do JAXB 2 RI - o gerador de esquema para java XJC usa o CodeModel para gerar sua fonte java e faz parte dos jars XJC. Você pode usá-lo apenas para o CodeModel.

Pegue-o em http://codemodel.java.net/

Solução encontrada com o CodeModel
Obrigado, skaffman .

Por exemplo, com este código:

JCodeModel cm = new JCodeModel();
JDefinedClass dc = cm._class("foo.Bar");
JMethod m = dc.method(0, int.class, "foo");
m.body()._return(JExpr.lit(5));

File file = new File("./target/classes");
file.mkdirs();
cm.build(file);

Eu posso obter esta saída:

package foo;
public class Bar {
    int foo() {
        return  5;
    }
}

Solução encontrada com o AST do Eclipse JDT
Obrigado, Giles .

Por exemplo, com este código:

AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();

PackageDeclaration p1 = ast.newPackageDeclaration();
p1.setName(ast.newSimpleName("foo"));
cu.setPackage(p1);

ImportDeclaration id = ast.newImportDeclaration();
id.setName(ast.newName(new String[] { "java", "util", "Set" }));
cu.imports().add(id);

TypeDeclaration td = ast.newTypeDeclaration();
td.setName(ast.newSimpleName("Foo"));
TypeParameter tp = ast.newTypeParameter();
tp.setName(ast.newSimpleName("X"));
td.typeParameters().add(tp);
cu.types().add(td);

MethodDeclaration md = ast.newMethodDeclaration();
td.bodyDeclarations().add(md);

Block block = ast.newBlock();
md.setBody(block);

MethodInvocation mi = ast.newMethodInvocation();
mi.setName(ast.newSimpleName("x"));

ExpressionStatement e = ast.newExpressionStatement(mi);
block.statements().add(e);

System.out.println(cu);

Eu posso obter esta saída:

package foo;
import java.util.Set;
class Foo<X> {
  void MISSING(){
    x();
  }
}

Você pode usar o Roaster ( https://github.com/forge/roaster ) para gerar o código.

Aqui está um exemplo:

JavaClassSource source = Roaster.create(JavaClassSource.class);
source.setName("MyClass").setPublic();
source.addMethod().setName("testMethod").setPrivate().setBody("return null;")
           .setReturnType(String.class).addAnnotation(MyAnnotation.class);
System.out.println(source);

exibirá a seguinte saída:

public class MyClass {
   private String testMethod() {
       return null;
   }
}

Outra alternativa é o AST do Eclipse JDT, que é bom se você precisar reescrever o código-fonte Java arbitrário em vez de apenas gerar o código-fonte. (e acredito que possa ser usado independentemente do eclipse).

O projeto Eclipse JET pode ser usado para gerar a fonte. Não acho que a API seja exatamente igual à que você descreveu, mas toda vez que ouvi falar de um projeto que gera geração de código-fonte Java, eles usaram o JET ou uma ferramenta caseira.

Não conhece uma biblioteca, mas um mecanismo de modelo genérico pode ser tudo o que você precisa. Existem vários deles , eu pessoalmente tive uma boa experiência com o FreeMarker

Eu criei algo que se parece muito com o seu DSL teórico, chamado "sourcegen", mas tecnicamente em vez de um projeto util para um ORM que escrevi. O DSL se parece com:

@Test
public void testTwoMethods() {
    GClass gc = new GClass("foo.bar.Foo");

    GMethod hello = gc.getMethod("hello");
    hello.arguments("String foo");
    hello.setBody("return 'Hi' + foo;");

    GMethod goodbye = gc.getMethod("goodbye");
    goodbye.arguments("String foo");
    goodbye.setBody("return 'Bye' + foo;");

    Assert.assertEquals(
    Join.lines(new Object[] {
        "package foo.bar;",
        "",
        "public class Foo {",
        "",
        "    public void hello(String foo) {",
        "        return \"Hi\" + foo;",
        "    }",
        "",
        "    public void goodbye(String foo) {",
        "        return \"Bye\" + foo;",
        "    }",
        "",
        "}",
        "" }),
    gc.toCode());
}

https://github.com/stephenh/joist/blob/master/util/src/test/java/joist/sourcegen/GClassTest.java

Ele também faz algumas coisas legais como "Organizar automaticamente importações" quaisquer FQCNs em parâmetros / tipos de retorno, removendo automaticamente todos os arquivos antigos que não foram tocados nessa execução de codegen, recuando corretamente as classes internas, etc.

A idéia é que o código gerado seja bonito de se ver, sem avisos (importações não usadas etc.), assim como o restante do código. Tanto código gerado é feio de ler ... é horrível.

De qualquer forma, não há muitos documentos, mas acho que a API é bem simples / intuitiva. O repo Maven está aqui se alguém estiver interessado.

Se você realmente precisa da fonte, não sei de nada que gere a fonte. No entanto, você pode usar o ASM ou o CGLIB para criar diretamente os arquivos .class.

Você pode gerar origem a partir deles, mas eu os usei apenas para gerar bytecode.

Eu mesmo estava fazendo isso por uma ferramenta de gerador simulado. É uma tarefa muito simples, mesmo se você precisar seguir as diretrizes de formatação da Sun. Aposto que você terminaria o código que faz isso mais rapidamente do que você encontrou algo que se encaixa no seu objetivo na Internet.

Você basicamente descreveu a API por conta própria. Basta preenchê-lo com o código real agora!

Há também StringTemplate . É do autor da ANTLR e é bastante poderoso.

Há um novo projeto write-it-once . Gerador de código baseado em modelo. Você escreve um modelo personalizado usando o Groovy e gera um arquivo dependendo das reflexões java. É a maneira mais simples de gerar qualquer arquivo. Você pode criar getters / settest / toString gerando arquivos AspectJ, SQL com base em anotações JPA, inserções / atualizações com base em enumerações e assim por diante.

Exemplo de modelo:

package ${cls.package.name};

public class ${cls.shortName}Builder {

    public static ${cls.name}Builder builder() {
        return new ${cls.name}Builder();
    }
<% for(field in cls.fields) {%>
    private ${field.type.name} ${field.name};
<% } %>
<% for(field in cls.fields) {%>
    public ${cls.name}Builder ${field.name}(${field.type.name} ${field.name}) {
        this.${field.name} = ${field.name};
        return this;
    }
<% } %>
    public ${cls.name} build() {
        final ${cls.name} data = new ${cls.name}();
<% for(field in cls.fields) {%>
        data.${field.setter.name}(this.${field.name});
<% } %>
        return data;
    }
}

Realmente depende do que você está tentando fazer. A geração de código é um tópico em si. Sem um caso de uso específico, sugiro examinar a biblioteca de geração / modelo de código de velocidade. Além disso, se você estiver gerando código offline, sugiro usar algo como ArgoUML para passar do diagrama UML / modelo de objeto para o código Java.

Exemplo: 1 /

private JFieldVar generatedField;

2 /

String className = "class name";
        /* package name */
        JPackage jp = jCodeModel._package("package name ");
         /*  class name  */
        JDefinedClass jclass = jp._class(className);
        /* add comment */
        JDocComment jDocComment = jclass.javadoc();
        jDocComment.add("By AUTOMAT D.I.T tools : " + new Date() +" => " + className);
        // génération des getter & setter & attribues

            // create attribue 
             this.generatedField = jclass.field(JMod.PRIVATE, Integer.class) 
                     , "attribue name ");
             // getter
             JMethod getter = jclass.method(JMod.PUBLIC, Integer.class) 
                     , "attribue name ");
             getter.body()._return(this.generatedField);
             // setter
             JMethod setter = jclass.method(JMod.PUBLIC, Integer.class) 
                     ,"attribue name ");
             // create setter paramétre 
             JVar setParam = setter.param(getTypeDetailsForCodeModel(Integer.class,"param name");
             // affectation  ( this.param = setParam ) 
             setter.body().assign(JExpr._this().ref(this.generatedField), setParam);

        jCodeModel.build(new File("path c://javaSrc//"));

Aqui está um projeto JSON para POJO que parece interessante:

http://www.jsonschema2pojo.org/