Spécifier le chemin de sortie pour la compilation dynamique

Question

Ma compilation dynamique dans Java 6 fonctionne parfaitement. Cependant, je voudrais changer le chemin de sortie. J'ai essayé des tonnes de choses (je vous épargnerai) en vain. Quoi qu'il en soit, voici le code de travail

String[] filesToCompile = { "testFiles/Something.java" }; 
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); 
Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjects(filesToCompile); 
CompilationTask task = compiler.getTask(null, fileManager, null,null, null, compilationUnits); 
System.out.println("Good? " + task.call()); 

Mais la sortie va dans le répertoire source, ce qui est pas ce que je veux.

Je suppose que la réponse peut se trouver dans le compiler.getTask mais l'API n'est pas très explicite quant à ce que certains des paramètres pourraient signifier. Ou peut-être quelque chose avec le gestionnaire de fichiers. J'ai essayé

fileManager.setLocation(StandardLocation.locationFor("testFiles2"), null); 

mais encore une fois, deviner n'est probablement pas une bonne idée.

Merci!

Edit: J'ai essayé d'utiliser des options aussi, comme ça (désolé s'il y a une façon plus compacte):

final List<String> optionsList = new ArrayList<String>(); 
    optionsList.add("-d what"); 
    Iterable<String> options = new Iterable<String>() {   
     public Iterator<String> iterator() { 
      return optionsList.iterator(); 
     } 
    }; 

et en faisant passer les options à getTask, mais le message d'erreur est « non valide Drapeau."

Answer 1

code dans le premier poste travaillerait, mais ce get d'erreur suivant jeté:

java.lang.IllegalArgumentException: invalid flag: -d folder 

En effet, en passant "-d folder" fait penser à l'analyseur qu'il analyse une option. Les options doivent être séparées comme "-d", "folder".

Exemple de travail suit:

JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); 
StandardJavaFileManager sjfm = javaCompiler.getStandardFileManager(null, null, null); 

String[] options = new String[] { "-d", "output" }; 
File[] javaFiles = new File[] { new File("src/gima/apps/flip/TestClass.java") }; 

CompilationTask compilationTask = javaCompiler.getTask(null, null, null, 
     Arrays.asList(options), 
     null, 
     sjfm.getJavaFileObjects(javaFiles) 
); 
compilationTask.call(); 

Answer 2

J'ai 0 expérience avec les outils du compilateur dynamique Java 6. Mais personne d'autre n'a répondu :)

La tâche de compilation obtient un objet FileManager. Si vous utilisez le standard, les classes sont générées dans l'arborescence du répertoire source. Ce que vous pouvez faire est de fournir votre propre sous-classe FileManager avec une méthode getFileForOutput substituée. La description de l'API de getFileForOutput indique que cela influencera l'emplacement des fichiers de sortie (= classe).

Mise à jour

Comment raccorder les gestionnaires de fichiers

ForwardingJavaFileManager, ForwardingFileObject et ForwardingJavaFileObject Subclassing ne sont pas disponibles pour des raisons impérieuses le comportement d'un gestionnaire de fichiers standard est créé en appelant un méthode sur un compilateur, pas en invoquant un constructeur. Au lieu de transmettre (ou délégation) devrait être utilisé. Ces classes facilitent le transfert de la plupart des appels vers un gestionnaire de fichiers ou un objet fichier donné tout en permettant le comportement de personnalisation. Par exemple, considérez comment enregistrer tous les appels à JavaFileManager.flush():

final Logger logger = ...; 
    Iterable<? extends JavaFileObject> compilationUnits = ...; 
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 
    StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, null, null); 
    JavaFileManager fileManager = new ForwardingJavaFileManager(stdFileManager) { 
     public void flush() { 
      logger.entering(StandardJavaFileManager.class.getName(), "flush"); 
      super.flush(); 
      logger.exiting(StandardJavaFileManager.class.getName(), "flush"); 
     } 
    }; 
    compiler.getTask(null, fileManager, null, null, null, compilationUnits).call(); 

Mise à jour 2

j'ai lu sur la compilation dynamique et construit ma propre application pour le faire. Ce code contient un peu trop de cérémonie (c'est-à-dire qu'il pourrait être simplifié) mais ça marche! Je ne suis pas sûr comment obtenir ce code pour fonctionner avec une liste générée dynamiquement de fichiers Java; Je ferais probablement juste compiler.run séparément pour chaque fichier source.

Answer 3

Je faisais face à ce même problème aujourd'hui.

La réponse (en utilisant la méthode getTask régulière au lieu de'Exécuter) est de spécifier la sortie dir dans le gestionnaire de fichiers:

fileManager.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(outputDir)); 

Et voilà !! :)

La documentation est un peu trompeuse, je veux dire, un échantillon pourrait être très utile. Mais finalement, il m'a fallu là-bas.

EDIT

Voici un exemple de fonctionnement:

// write the test class 
    File sourceFile = new File("First.java"); 
    FileWriter writer = new FileWriter(sourceFile); 

    writer.write(
      "package load.test;\n" + 
      "public class First{}" 
    ); 
    writer.close(); 

    // Get the java compiler for this platform 
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(
      null, 
      null, 
      null); 

    //--   H E R E --// 
    // Specify where to put the genereted .class files 
    fileManager.setLocation(StandardLocation.CLASS_OUTPUT, 
          Arrays.asList(new File("/tmp"))); 
    // Compile the file 
    compiler 
     .getTask(null, 
       fileManager, 
       null, 
       null, 
       null, 
       fileManager.getJavaFileObjectsFromFiles(Arrays.asList(sourceFile))) 
     .call(); 
    fileManager.close(); 

    // delete the file 
    sourceFile.deleteOnExit();