24

Let us assume a Java application, accepting an integer command line argument, say bubu.

Assuming one uses a decent command line parser (and I do - https://github.com/jopt-simple/jopt-simple) plus keeping in mind the -D java switch, these are some of the typical ways to pass this command line parameter:

  1. --bubu 5 (or --bubu=5 or --bubu5)
  2. -Dbubu=5

Where the first one is the program argument and must be handled by the application using some command line parser, whereas the second is the VM argument and is already parsed by java, making it available as Integer.getInteger("bubu")

I am kinda puzzled. What should I use? Using the system property facility:

  • seems to cost nothing
  • does not depend on any command line parser library
  • provides convenient (albeit unexpected) API to obtain the values

As far as I can see, the only cons is that all the command line options have to use the -D flag.

Please, advice.

Thanks.

EDIT

Another pros for the system parameters - "they're usable even when the application is not a stand-alone app starting from a main, but also when the app is a webapp or a unit test." - thanks https://stackoverflow.com/users/571407/jb-nizet

EDIT2

Let me be more focused here. Is there any serious reason (besides esthetics) not to use the system parameters, like always?

EDIT3

OK, I think I get it now. If my code is likely to be loaded by a web application, then there is an issue of a potential name clash, since other web applications hosted by the same web container share the system property space with my code.

Therefore, I have to be prudent and disambiguate my system properties beforehand. So, no more bubu, it is com.shunra.myapp.bubu now. Meaning that instead of a simple 

-Dbubu=5

I have

-Dcom.shunra.myapp.bubu=5

which becomes less attractive for a simple command line application.

Another reason is given by Mark Peters, which is pretty good to me.

Improve this question
5
  • 3
    Well, you summed it up. Another advantage of system properties is that they're usable even when the application is not a stand-alone app starting from a main, but also when the app is a webapp or a unit test. If the app is a command-line utility, you might want to conform to conventions, and provide regular options (like -help, etc.). otherwise, system properties are more verbose, but simpler. Commented Dec 28, 2011 at 7:53
  • So, your advice is always use the -D flag? Commented Dec 28, 2011 at 7:55
  • 2
    No. I edited my comment. If it's a command line tool where the user has to pass options each time it invokes the program, using standard options is more user-friendly. If the options are just config options that must be set once in a batch file, then system properties are easier. Commented Dec 28, 2011 at 7:58
  • @JB Nizet - your responses are worthy of upvoting, please arrange them as an answer. Commented Dec 28, 2011 at 8:02
  • Well, you give all the arguments in the question. My answer to your question, as it is now, would be "No". But that wouldn't be a long-enough answer. Commented Dec 28, 2011 at 8:09

3 Answers 3

Reset to default
14

I'd argue that the advantage Fortyrunner cites is actually the most significant negative for system properties--they are available to anyone who asks for them.

If the flag or option is meant to be a command-line option, it should be available to the layer or module of your code that deals with taking input from the command line, not any code that asks for it.

You can get some destructive coupling from global state, and system properties are no different than any other global state.

That said, if you're just trying to make a quick and dirty CLI program, and separation of concerns and coupling is not a big concern for you, system properties give you an easy method that however leads to (IMO) poor user experience. Some getopt library will give you a lot more support for building a good CLI user experience.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

So, what you are saying is that using -D clutters the system properties space, shared by all the web applications hosted by the same container. Hence it presents a potential name clash issue, that is why I should have used something like com.shunra.myapp.bubu instead of bubu, is that it?
Agreed, all global variables should be treated with care.
@mark: It's not just the namespacing, but also keeping your code isolated and decoupled. You should try to invert your dependencies; low-level code should be told what its parameters are, it shouldn't have to query for its parameters. But with global information it's easy for that low-level code to simply query for its parameters (through System.getProperty()), which couples it to its invocation context (the command line). Thus, it becomes harder to unit test or to reuse in a different context. But the namespacing problem is another concern.
Also, this answer assumes that the configuration you're trying to specify from the CLI are program parameters (like the directory to act on, etc). If it is something like "max threads in the thread pool" then that is something that is very well geared towards system properties; they are indeed intended to be used to tweak the program at runtime.
4

One of the main advantages of system properties is that they are available at any time during the life of you program.

Command line arguments are only available in the main method (unless you persist them).

Improve this answer

Comments

-1

I feel that there are many things that an average user like me do not need to know. System properties will help the developer of a system preset a number of value that will enable a system to run. For example, when I download GlassFish app server, it always come with many preset parameters that I have no ideas what they're for. I am not very experienced at dealing with server's setting. If you ask me to start GlassFish server with 20 parameters in the command line, I would have to learn what these parameters are for and how much should I set, etc. It's too troublesome.

In brief, when a system gets larger and larger, it may have more and more properties. With system properties preset, users may only need to know what they are when they really need to. For example, I only need to know about GlassFish's -XX:PermSize when I need to increase memory.

Improve this answer

2 Comments

Nothing says command line options can't be optional. In fact, PermSize isn't even a system property; it's a command line option.
Of course many options can be optional. But there are also many compulsory options which users may not need to know. I am not very experienced with these things. Hence, My PermSize example is not a good one. However, I believe you can think of many GlassFish's system properties that are compulsory.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.