Mangiare Senza Glutine disponibile su App Store

Per altre informazioni scrivi a fabriziocaldarelli@negusweb.it

Process Manager: componente per la gestione di un processo

Da Programmazione Software.

Gestire l'avvio di un processo in Java è abbastanza semplice, se si utilizzano gli opportuni accorgimenti.

Innanzitutto bisogna dire che il processo viene eseguito in maniera asincrona. Quindi il Thread corrente continua la sua esecuzione mentre quello del processo lavora parallelamente.

Questo non è un problema, almeno fino a quando non si voglia collegare dei pipe allo standard in, out o err. Infatti quando si ha la necessità di collegare dei pipe, bisogna gestirli e sincronizzarli su thread separati.

Per questo ho sviluppato una classe apposita, per avere codice pronto da eseguire che avvii e gestisca un processo che abbia collegate le pipe standard in, out e err.

La classe principale, ProcessManager, si occupa appunto di creare il processo e agganciare le pipe stdin, stdout e stderr. Dopo aver istanziato l'oggetto con il comando da avviare, il processo vero e proprio parte chiamando il metodo RunProcess passandogli come parametro l'eventuale contenuto in input. RunProcess è un metodo sincrono rispetto al thread chiamante, quindi fino a che il processo non è completato, rimane bloccato anche il thread chiamante.

Poi per leggere il contenuto dello stdout e stderr basta chiamare i metodi get getProcessInputStream().getData() e getProcessErrorStream().getData().

Di seguito i files sorgenti, con un esempio di utilizzo:

	public ProcessManager AvviaProcesso(String pathProcess, String pipeStdin) throws Exception
	{
		ProcessManager pm = new ProcessManager(pathProcess);
		try
		{
			pm.RunProcess(pipeStdin);
		}
		catch (Exception excp)
		{
			throw excp;
		}
 
		return pm;
	}



ProcessManager.java

public class ProcessManager {
	String cmdProcess;
	Process process;
	ProcessInputStream processInputStream;
	ProcessErrorStream processErrorStream;
 
	public ProcessManager(String cmdProcess)
	{
		this.cmdProcess = cmdProcess;
	}
 
 
	public Integer RunProcess(String pipeStdin) throws Exception
	{
		Integer exitValue = null;
 
		// launch EXE and grab stdin/stdout and stderr
		try
		{
			process = Runtime.getRuntime ().exec (this.cmdProcess);
 
			// "write" the parms into stdin
			if (pipeStdin != null)
			{
				process.getOutputStream().write( pipeStdin.getBytes() );
				process.getOutputStream().flush();
				process.getOutputStream().close();
			}
 
			// clean up if any output in stdout
			processInputStream = new ProcessInputStream(this);
			processErrorStream = new ProcessErrorStream(this);
			processInputStream.start();
			processErrorStream.start();
 
			synchronized(processInputStream)
			{
				if (processInputStream.isAlive())
				{
					processInputStream.wait();
				}
			}
			synchronized(processErrorStream)
			{
				if (processErrorStream.isAlive())
				{
					processErrorStream.wait();
				}
			}
 
			exitValue = new Integer( process.waitFor() );
 
		}
		catch(Exception excp)
		{
			throw excp;
		}
 
		return exitValue;
	}
 
	protected Process getProcess() { return this.process; }
	public ProcessInputStream getProcessInputStream() { return this.processInputStream; }
	public ProcessErrorStream getProcessErrorStream() { return this.processErrorStream; }
}



ProcessErrorStream .java

import java.io.*;
 
public class ProcessErrorStream extends Thread {
 
	ProcessManager processManager;
    String data;
 
    ProcessErrorStream(ProcessManager pm)
    {
    	this.processManager = pm;
        this.data = null;
    }
 
    public void run()
    {
    	StringBuffer strTemp = new StringBuffer();
        try
        {
            InputStreamReader isr = new InputStreamReader( processManager.getProcess().getErrorStream() );
            BufferedReader br = new BufferedReader(isr);
            String line=null;
            while ( (line = br.readLine()) != null)
            {
            	strTemp.append(line);
            }
        } 
        catch (IOException ioe)
        {
        	ioe.printStackTrace();  
        }
 
        if(strTemp.length() != 0)
        {
        	this.data = new String( strTemp );
        }
 
        synchronized(this)
        {
        	this.notify();
        }
    }
 
    public String getData() { return this.data; }
}



ProcessInputStream .java

import java.io.*;
 
public class ProcessInputStream extends Thread {
 
	ProcessManager processManager;
    String data;
 
    ProcessInputStream(ProcessManager pm)
    {
    	this.processManager = pm;
        this.data = null;
    }
 
    public void run()
    {
    	StringBuffer strTemp = new StringBuffer();
        try
        {
            InputStreamReader isr = new InputStreamReader( processManager.getProcess().getInputStream() );
            BufferedReader br = new BufferedReader(isr);
            String line=null;
            while ( (line = br.readLine()) != null)
            {
            	strTemp.append(line);
            	strTemp.append(System.getProperty("line.separator"));
            }
        } 
        catch (IOException ioe)
        {
        	ioe.printStackTrace();  
        }
 
        if(strTemp.length() != 0)
        {
        	this.data = new String( strTemp );
        }
 
        synchronized(this)
        {
        	this.notify();
        }
 
    }
 
    public String getData() { return this.data; }
}