Runtime.exec Usage

Runtime.exec Usage

My program calls Runtime.exec(String) to run another external java application, it runs well in windows, but in Linux platform, it always throws error:
The java class is not found:  com/**/MainClass
From the error message, it is obvious that JVM can not find the main class; usually this is because class path is not correctly configured.
But when I paste that string to shell, external program can be successfully started.
After goggle search, I figured out the root cause,
It's recommended to use Runtime.exec(String[]), and add each argument in its own element of the string array. Never add 2 arguments in one element.
Normally, in each element, we should not add ' or ", if we did that, it may cause exception or incorrect value that is not we want.

The following is a sample application to call another java application:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class AppInvoker
{
    public static void main(String[] args)
    {
        try
        {
            String[] cmds = new String[] { "C:\\Program Files\\Java\\jdk1.6.0_23\\bin\\java",
                // with "-ms64m -mx512m", it would fail: Invalid initial heap size: -Xms64m -mx512m
                "-ms64m",
                "-mx512m",
                // if -Dfoo='D:\java projects', the foo value would be 'D:\java projects'
                // if -Dfoo=\"D:\\java projects\", java.lang.ClassNotFoundException: projects, projects would be thought as main class.
                // with "-Dfoo=D:\\java projects -Dbar=bar", value of foo would be - D:\java projects -Dbar=bar -.,
                // bar is null, as it's not set.
                "-Dfoo=D:\\java projects",
                "-Dbar=bar",
                "-classpath",
                // don't add ' before classpath, otherwise it will throw ClassNotFoundException.
                // "" is ok.
                // safe way is to not add ' or " at all.
                "D:\\java projects\\arguments.jar",
                "CommandArguments",
                "-nickname",
                // with 'johnny depp', then value of nickname would be 'johnny depp'.
                // with \"johnny depp\", then value of nickname is still johnny depp.
                "johnny depp",
                "-user",
                "depp",
                "-passwd",
                "depp",
                "-cfg",
                "D:\\java projects\\my.cfg" };

            final Process p = Runtime.getRuntime().exec(cmds);

            // read input stream
            new Thread()
            {
                public void run()
                {
                    try
                    {
                        BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
                        String line;
                        while ((line = in.readLine()) != null)
                        {
                            System.out.println(line);
                        }
                    }
                    catch (Exception e)
                    {
                        e.printStackTrace();
                    }
                };
            }.start();

            // read error stream
            new Thread()
            {
                public void run()
                {
                    try
                    {
                        BufferedReader errReader = new BufferedReader(new InputStreamReader(p.getErrorStream()));
                        String line;
                        while ((line = errReader.readLine()) != null)
                        {
                            System.err.println(line);
                        }
                    }
                    catch (Exception e)
                    {
                        e.printStackTrace();
                    }
                };
            }.start();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

public class CommandArguments
{
    public static void main(String[] args)
    {
        // ready system property
        System.out.println("foo:" + System.getProperty("foo"));
        System.out.println("bar:" + System.getProperty("bar"));
        System.out.println("infile:" + System.getProperty("infile"));
        // read parameters
        for (int i = 0; i < args.length; i++)
        {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

From JDK5, it's recommended to use ProcessBuilder, which provides more functions and deal with spaces much better than Runtime.exec().


Coding Notes 1

Coding Notes 1

Builder Pattern
The intention is to abstract steps of construction of objects so that different implementations of these steps can construct different representations of objects.
Usage
The client calls a constructor (or static factory) with all of the required parameters and gets a builder object. Then the client calls setter-like methods on the builder object to set each optional parameter of interest. Finally, the client calls a parameter-less build method to generate the object, which is immutable.
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).
calories(100).sodium(35).carbohydrate(27).build();
The Builder pattern is a good choice when designing classes whose constructors or static factories would have more than a handful of parameters, especially if most of those parameters are optional.
Telescoping constructor pattern
Provide a constructor with only the required parameters, another with a single optional parameter, a third with two optional parameters, and so on, culminating in a constructor with all the optional parameters.
Disadvantages:
Long sequences of identically typed parameters can causesubtle bugs.
JavaBeans constructor pattern
Disadvantages:
It allows inconsistency, mandates mutability
Factory pattern is typically used to create an object in a single step.
If you need to create an object in multiple steps, and those steps may change (some times you may want to ignore some steps), in this case you would use the builder pattern.
Method chaining enables terser and more natural interaction with objects.
To achieve this, return this in method such as setter instead of return void.
toast.makeText(text).setGravity(Gravity.TOP,
0, 0).setView(layout).show();
Status transition
private static final String[] STATUS = new String[] { // used in toString()
"STATUS1",
"STATUS2",
"STATUS3",
"STATUS4",
};
private static final boolean STATUS_CONVERTIBLE[][] = new boolean[][] {
/*********** STATUS1 STATUS2 STATUS3 STATUS4 */
/* STATUS1 */{ false, true, true, true},
/* STATUS2 */{ false, false, true, true},
/* STATUS3 */{ false, false, false, true},
/* STATUS4 */{ false, false, false, false}};
public boolean accept(int newStatus)
{
return STATUS_CONVERTIBLE[this.status][newStatus];
}
Use ByteArray Stream to deep clone object
Sometimes we want to create a deep clone object, but we don't want to implement the class's clone method, maybe this way we have to implement clone method in many classes.
In this situation, we can use stream to create a new same object.
public class DeepClone
{
public static void main(String[] args) throws IOException, ClassNotFoundException
{
Student ra = new Student("Jane", 20);
byte[] resultBtye = serialize(ra);
Student rb = (Student) deserialize(resultBtye);
System.err.println("ra == rb: " + (ra == rb)); // false
System.err.println(ra.name.equals(rb.name)); // true
System.err.println(ra.age == rb.age); // true
}
private static byte[] serialize(Object o) throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(o);
return baos.toByteArray();
}
private static Object deserialize(byte[] data) throws IOException, ClassNotFoundException
{
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
}
}
class Student implements Serializable
{
private static final long serialVersionUID = 1L;
public String name;
public int age;
public Student(String name, int age)
{
this.name = name;
this.age = age;
}
}
Interface Names
public interface Closeable {
public void close() throws IOException;
}

Labels

Java (159) Lucene-Solr (112) Interview (61) All (58) J2SE (53) Algorithm (45) Soft Skills (38) Eclipse (33) Code Example (31) Linux (25) JavaScript (23) Spring (22) Windows (22) Web Development (20) Tools (19) Nutch2 (18) Bugs (17) Debug (16) Defects (14) Text Mining (14) J2EE (13) Network (13) Troubleshooting (13) PowerShell (11) Chrome (9) Design (9) How to (9) Learning code (9) Performance (9) Problem Solving (9) UIMA (9) html (9) Http Client (8) Maven (8) Security (8) bat (8) blogger (8) Big Data (7) Continuous Integration (7) Google (7) Guava (7) JSON (7) Shell (7) ANT (6) Coding Skills (6) Database (6) Lesson Learned (6) Programmer Skills (6) Scala (6) Tips (6) css (6) Algorithm Series (5) Cache (5) Dynamic Languages (5) IDE (5) System Design (5) adsense (5) xml (5) AIX (4) Code Quality (4) GAE (4) Git (4) Good Programming Practices (4) Jackson (4) Memory Usage (4) Miscs (4) OpenNLP (4) Project Managment (4) Spark (4) Testing (4) ads (4) regular-expression (4) Android (3) Apache Spark (3) Become a Better You (3) Concurrency (3) Eclipse RCP (3) English (3) Happy Hacking (3) IBM (3) J2SE Knowledge Series (3) JAX-RS (3) Jetty (3) Restful Web Service (3) Script (3) regex (3) seo (3) .Net (2) Android Studio (2) Apache (2) Apache Procrun (2) Architecture (2) Batch (2) Bit Operation (2) Build (2) Building Scalable Web Sites (2) C# (2) C/C++ (2) CSV (2) Career (2) Cassandra (2) Distributed (2) Fiddler (2) Firefox (2) Google Drive (2) Gson (2) How to Interview (2) Html Parser (2) Http (2) Image Tools (2) JQuery (2) Jersey (2) LDAP (2) Life (2) Logging (2) Python (2) Software Issues (2) Storage (2) Text Search (2) xml parser (2) AOP (1) Application Design (1) AspectJ (1) Chrome DevTools (1) Cloud (1) Codility (1) Data Mining (1) Data Structure (1) ExceptionUtils (1) Exif (1) Feature Request (1) FindBugs (1) Greasemonkey (1) HTML5 (1) Httpd (1) I18N (1) IBM Java Thread Dump Analyzer (1) JDK Source Code (1) JDK8 (1) JMX (1) Lazy Developer (1) Mac (1) Machine Learning (1) Mobile (1) My Plan for 2010 (1) Netbeans (1) Notes (1) Operating System (1) Perl (1) Problems (1) Product Architecture (1) Programming Life (1) Quality (1) Redhat (1) Redis (1) Review (1) RxJava (1) Solutions logs (1) Team Management (1) Thread Dump Analyzer (1) Visualization (1) boilerpipe (1) htm (1) ongoing (1) procrun (1) rss (1)

Popular Posts