Java Runtime.getRuntime ().exec() les solutions de rechange

j'ai trouvé une solution dans cet article , fondamentalement l'idée est que vous créez un processus au début du démarrage de votre application que vous communiquez avec (via des flux d'entrée) et puis que le sous-processus exécute vos commandes pour vous.

//you would probably want to make this a singleton
public class ProcessHelper
{
    private OutputStreamWriter output;
    public ProcessHelper()
    {
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec("java ProcessHelper");
        output = new OutputStreamWriter(process.getOutputStream());
    }
    public void exec(String command)
    {
        output.write(command, 0, command.length());
    }
}

alors vous feriez un programme Java helper

public class ProcessHelper
{
    public static void main(String[] args)
    {
         BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
         String command;
         while((command = in.readLine()) != null)
         {
             Runtime runtime = Runtime.getRuntime();
             Process process = runtime.exec(command);
         }
    }
}

ce que nous avons essentiellement fait est de créer un petit serveur "exec" pour votre application. Si vous initialiser votre ProcessHelper classe dès le début de votre application, il va créer avec succès ce processus, alors il vous suffit de tuyau de commandes de l'un à l'autre, parce que le deuxième processus est beaucoup plus petite, il faut toujours réussir.

vous pourriez aussi faire votre protocole un peu plus en profondeur, comme retourner exitcodes, notification des erreurs et ainsi de suite.

Essayez d'utiliser un ProcessBuilder . Les médecins disent que c'est la façon "préférée" de démarrer un sous-processus ces jours-ci. Vous devriez également envisager d'utiliser la carte d'environnement (docs sont dans le lien) pour spécifier les allocations de mémoire pour le nouveau processus. Je soupçonne (mais je ne sais pas avec certitude) que la raison pour laquelle il a besoin de tant de mémoire est qu'il hérite des paramètres du processus tomcat. L'utilisation de la carte d'environnement devrait vous permettre d'outrepasser ce comportement. Cependant, notez que le démarrage d'un processus est très spécifique à OS, donc YMMV.

je penser c'est un unix (fork () problème, le besoin de mémoire vient de la façon que fork() fonctionne, c'premiers clones le processus de l'enfant de l'image (à la taille que c'est le cas actuellement) remplace alors l'image parent avec l'enfant de l'image. Je sais que sur Solaris il y a un moyen de contrôler ce comportement, mais je ne sais pas du tout ce que c'est.

mise à jour : cela est déjà expliqué dans de ce que Linux kernel / libc la version est Java Runtime.exec() la sécurité en ce qui concerne la mémoire?

ça m'aiderait. Je sais que c'est un vieux fil, juste pour les futurs arbitres... http://wrapper.tanukisoftware.com/doc/english/child-exec.html

une autre solution consiste à avoir un processus exec distinct qui exécute un fichier ou un autre type de"file". Vous ajoutez la commande désirée à ce fichier, et le serveur exec la repère, exécute la commande et, d'une manière ou d'une autre, écrit les résultats à un autre endroit que vous pouvez obtenir.

la meilleure solution que j'ai trouvée jusqu'à présent était d'utiliser un shell sécurisé avec des clés publiques. En utilisant http://www.jcraft.com/jsch / j'ai créé une connexion avec localhost et exécuté les commandes comme ça. Peut-être qu'il y a un peu plus de frais généraux, mais pour ma situation, ça a fonctionné comme un charme.