Y-a-t-il la technique de compilation dynamique dans java pour exercer un code java ?

bon jour
j'ai développer une application java de comptabilité de la paie , mais je veut ajouter une option qui consiste a introduire une formule personnaliser par l'utilisateur pour saisir la formule de calcule d'une prime, et pour cela j'ai deux méthode :
- la premier et de développer un mini compilateur pour interpréter les formules de l'etulisater
- la deuxième et de compiler la formuler qui est écrite en code java
ma question est : es que il y une compilation dynamique dans java pour exercer un code en dynamique
merci de donner un coud main par ce que cette dernière technique est plus sur pou mon application

Salut,

Tu peux utiliser l'API de Scripting : http://docs.oracle.com/javase/6/docs...grammer_guide/

En standard elle ne gère que le JavaScript, mais si besoin il existe des implémentations tierces pour divers langages de script...

a++

merci beaucoup

La troisième: utiliser un moteur de règles type "drools", qui permet d'exprimer les besoins de l'utilisateur dans un format proche de la langue naturelle. Il y a même un GUI pour aider à construire le jeu de règles (drools-guvnor je crois).

Le problème dans le scripting type Java, c'est que l'utilisateur va rien capter (déjà expérimenté personnellement, les gens du business font en général un blocage psychologique dès que ça devient technique)

Cf. guvnor screenshots: https://www.google.ch/search?q=drool...S6f3PVItdnM%3A

Bonjour,

Tu peux également utiliser un langage de templating (freemarker, velocity, handlebar..) et évaluer le template en Java via l'api fournie.

Cependant je partirais personnellement sur un moteur de règles (Drools) qui sera un peu plus coûteux à mettre en place mais beaucoup plus efficace pour les utilisateurs finaux non issus du monde de la technique.

Même si je pense que l’interpréteur JavaScript est probablement la meilleure solution (en attendant un eventuel interperteur Java dans le futur), il ne faut pas oublier qu'il y a aussi l'API du compilateur mais il faut avoir le JDK et non pas le JRE sous la main pour que cela fonctionne (ou alors il faut rajouter les JAR du compilateur dans l'application). Le code suivant est adapté de Java Compiler API sur javacodegeek :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package javacompiler;
 
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
 
public class Main {
 
    public static void main(final String... args) {
        final Optional<JavaCompiler> compilerOpt = Optional.ofNullable(ToolProvider.getSystemJavaCompiler());
        compilerOpt.ifPresent(compiler -> {
            try {
                // Supported source version.
                compiler.getSourceVersions().stream().forEach(System.out::println);
                // Compile file.
                final StringBuilder sourceCode = new StringBuilder();
                sourceCode.append("public class SampleClass {\n")
                        .append("    public static void main(String[] args) {\n")
                        .append("        System.out.println( \"SampleClass has been compiled!\" );\n")
                        .append("    }\n")
                        .append("}");
                final Path home = Files.createTempDirectory("Test-compiler");
                final Path sourceFile = Paths.get(home.toString(), "SampleClass.java");
                Files.write(sourceFile, Arrays.asList(sourceCode.toString()));
                final DiagnosticCollector< JavaFileObject> diagnostics = new DiagnosticCollector<>();
                final StandardJavaFileManager manager = compiler.getStandardFileManager(diagnostics, null, null);
                final Iterable< ? extends JavaFileObject> sources = manager.getJavaFileObjectsFromFiles(Arrays.asList(sourceFile.toFile()));
                final CompilationTask task = compiler.getTask(null, manager, diagnostics, null, null, sources);
                task.call();
                if (diagnostics.getDiagnostics().isEmpty()) {
                    final URLClassLoader sysloader = (URLClassLoader) ClassLoader.getSystemClassLoader();
                    final Class sysclass = URLClassLoader.class;
                    final Method addUrlMethod = sysclass.getDeclaredMethod("addURL", URL.class);
                    addUrlMethod.setAccessible(true);
                    addUrlMethod.invoke(sysloader, new Object[]{home.toUri().toURL()});
                    final Class aClass = Class.forName("SampleClass");
                    final Method mainMethod = aClass.getMethod("main", String[].class);
                    mainMethod.invoke(null, new Object[]{new String[0]}); // Issue when using varargs.
                } else {
                    System.err.println("Compilation failed");
                    diagnostics.getDiagnostics()
                            .stream()
                            .forEach(diagnostic -> {
                                System.out.format("%s, line %d in %s",
                                        diagnostic.getMessage(null),
                                        diagnostic.getLineNumber(),
                                        diagnostic.getSource().getName());
                            });
                }
            } catch (IOException | ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
        });
    }
}

Ceci aura pour effet d’écrire le code de la classe dans un fichier situe dans un répertoire temporaire et de compiler le fichier class au même endroit. Après, il faut faire une pirouette via l’introspection pour changer le CLASSPATH et charger la classe nouvellement compilée et invoquer son main(). Hum pas sur que ça fonctionne en l’état dans le futur JDK 9 a moins d'utiliser un ClassLoader custom.

merci beaucoup
ca m intéresse très bien
En particulier DROOLS