Normally a command-line Java application will have an entry method that looks something like:<\/p>\n
\r\npublic static void main(String... args) {\r\n \/* Code that launches the application\/deals with command line params here *\/\r\n}\r\n<\/pre>\nThis is far too easy, there must be a way to NIH it \u00ac_\u00ac. There are a few annoyances with the public static void main method.<\/p>\n
There is a common way to execute code on app startup without using a static void main method. You can use a static initialization block:<\/p>\n
\r\nstatic {\r\n \/* Code here run on class load. *\/\r\n}\r\n<\/pre>\nSo we could launch our application from within a static initialization block. However this presents a number of problems:<\/p>\n
\n- We get a nasty error when the application finishes (Exception in thread “main” java.lang.NoSuchMethodError: main)<\/li>\n
- We have no access to the command line arguments<\/li>\n
- We can’t have multiple “Main” classes with this method (Both static initialization blocks will be run, if both classes are loaded)<\/li>\n
- It doesn’t really provide any benefits over static void main.<\/li>\n<\/ol>\n
These problems can, however, all be overcome. <\/p>\n
Suppressing NoSuchMethodError<\/h3>\n
We can just call System.err.close(); at the end of our initialization method.<\/p>\n
Access to the command line arguments<\/h3>\n
This one is probably the most difficult. I’ve not found any “good” way to do this, but there is a hack that works at present on Sun’s Java, though it may stop working at any point. <\/p>\n
\r\nsun.misc.VMSupport.getAgentProperties().get(\"sun.java.command\")\r\n<\/pre>\nThis will give the command line string used to start the application. There are alternatives involving attaching to the currently running VM with the Agent API or shelling out to external processes and using platform-specific commands to work out the command used to start the application. If anyone knows a proper way to access the command line arguments using the public API then please let me know.<\/p>\n
Multiple Main Classes<\/h3>\n
We need to get our initialization system to ignore invocations from classes other than the one used to start our application. This can be done by checking the length of the StackTrace. e.g.<\/p>\n
\r\nnew Throwable().fillInStackTrace().getStackTrace().length == 2;\r\n<\/pre>\nReflection Examples<\/h3>\n
With these 3 issues solved it’s possible to do things like:<\/p>\n
\r\npackage MainlessDemo;\r\n\r\nimport java.util.List;\r\nimport static uk.co.benjiweber.realjava.mainless.Bootstrap.init;\r\n\r\npublic class ReflectionMainless {\r\n\tstatic { init(); }\r\n\tpublic void main(final List args) {\r\n\t\tSystem.out.println(\"Hello World\");\r\n\t\tSystem.err.println(\"From std err\");\r\n\t\tfor (String arg : args) {\r\n\t\t\tSystem.out.println(arg);\t\r\n\t\t}\r\n\t}\r\n}\r\n\/* Output:\r\n$ javac -cp .:.\/RealJava.jar .\/MainlessDemo\/*.java && java -cp .:.\/RealJava.jar MainlessDemo.ReflectionMainless Foo Bar Baz\r\nHello World\r\nFrom std err\r\nFoo\r\nBar\r\nBaz\r\n*\/\r\n<\/pre>\nHere a statically imported “init” method instantiates our main class, invokes our non-static main method, and passes it the command line arguments. The class to instantiate can be determined by walking back up the stack trace again.<\/p>\n
We can also inject constructor arguments if we wish:<\/p>\n
\r\npackage MainlessDemo;\r\n\r\nimport java.util.List;\r\nimport static uk.co.benjiweber.realjava.mainless.Bootstrap.init;\r\n\r\npublic class ReflectionMainlessWithArgs {\r\n\t\r\n\t\/\/ This time we pass in the constructor argument\r\n\tstatic { init(\"Hello World\"); }\r\n\t\r\n\tprivate final String message;\r\n\t\r\n\t\/\/ Even though we load another class that is Launchable it doesn't get launched.\r\n\tstatic final ReflectionMainless test = new ReflectionMainless(); \r\n\t\r\n\tpublic ReflectionMainlessWithArgs(final String message) {\r\n\t\tthis.message = message;\r\n\t}\r\n\t\r\n\tpublic void main(final List args) {\r\n\t\tSystem.out.println(message + \" (Passed in through constructor)\");\r\n\t\tfor (String arg : args) {\r\n\t\t\tSystem.out.println(arg);\t\r\n\t\t}\r\n\t}\r\n}\r\n\/* Output:\r\n$ javac -cp .:.\/RealJava.jar .\/MainlessDemo\/*.java && java -cp .:.\/RealJava.jar MainlessDemo.ReflectionMainlessWithArgs Foo Bar Baz\r\nHello World (Passed in through constructor)\r\nFoo\r\nBar\r\nBaz\r\n\r\n*\/\r\n<\/pre>\nInterface Examples<\/h3>\n
Unfortunately, apart from substituting an argument Array for a List, we ‘ve not really improved anything. However, now that we’re in control of the initialization process we can do more interesting things, like use an interface:<\/p>\n
\r\npublic interface Launchable {\r\n\tpublic void main(List args);\r\n}\r\n<\/pre>\n\r\npackage MainlessDemo;\r\n\r\nimport java.util.List;\r\nimport uk.co.benjiweber.realjava.mainless.Launchable;\r\nimport static uk.co.benjiweber.realjava.mainless.Bootstrap.init;\r\n\r\npublic class SaferMainless implements Launchable {\r\n\tstatic { init(new SaferMainless()); }\r\n\t\r\n\tpublic void main(final List args) {\r\n\t\tSystem.out.println(\"Hello from a Launchable\");\r\n\t\tfor (String arg : args) {\r\n\t\t\tSystem.out.println(arg);\t\r\n\t\t}\r\n\t}\r\n}\r\n\r\n\/*\r\nOutput:\r\n$ javac -cp .:.\/RealJava.jar .\/MainlessDemo\/*.java && java -cp .:.\/RealJava.jar MainlessDemo.SaferMainless Foo Bar Baz\r\nHello from a Launchable\r\nFoo\r\nBar\r\nBaz\r\n*\/\r\n<\/pre>\nNow it’s clearer how the initialization process works, you can use your IDE to follow execution through from the init block to the main method. This also gives us the freedom to call our main method something different, and inject dependencies before reaching the main method.<\/p>\n
\r\npackage MainlessDemo;\r\n\r\nimport java.util.List;\r\nimport uk.co.benjiweber.realjava.mainless.Launchable;\r\nimport static uk.co.benjiweber.realjava.mainless.Bootstrap.init;\r\n\r\npublic class SaferAnonymousMainless {\r\n\t\r\n\tstatic { init(new Launchable() {\r\n\t\tpublic void main(final List args) {\r\n\t\t\tSaferAnonymousMainless mainless = new SaferAnonymousMainless();\r\n\t\t\tmainless.setMessage(\"I was injected manually\");\r\n\t\t\tmainless.someMethodNotCalledMain(args);\r\n\t\t}\r\n\t}); }\r\n\t\r\n\tprivate String message;\r\n\t\r\n\tpublic void setMessage(final String message) {\r\n\t\tthis.message = message;\r\n\t}\r\n\t\r\n\tpublic void someMethodNotCalledMain(final List args) {\r\n\t\tSystem.out.println(message);\r\n\t\tfor (String arg : args) {\r\n\t\t\tSystem.out.println(arg);\t\r\n\t\t}\r\n\t}\r\n}\r\n\/* \r\nOutput:\r\n$ javac -cp .:.\/RealJava.jar .\/MainlessDemo\/*.java && java -cp .:.\/RealJava.jar MainlessDemo.SaferAnonymousMainless Foo Bar Baz\r\nI was injected manually\r\nFoo\r\nBar\r\nBaz\r\n\r\n*\/\r\n<\/pre>\nSource for the BootStrap.init method is here<\/a><\/p>\nThanks to Faux<\/a> for some of the ideas.<\/p>\nYes I know this isn’t remotely a good idea, no need to tell me :) <\/p>\n","protected":false},"excerpt":{"rendered":"
Normally a command-line Java application will have an entry method that looks something like: public static void main(String… args) { \/* Code that launches the application\/deals with command line params here *\/ } This is far too easy, there must be a way to NIH it \u00ac_\u00ac. There are a few annoyances with the public… Read more »<\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[1],"tags":[],"yoast_head":"\n\n\n\n\n\n\n\n\n\n\n