{"id":1673,"date":"2017-06-07T18:26:34","date_gmt":"2017-06-07T18:26:34","guid":{"rendered":"http:\/\/blog.paranoidprofessor.com\/?p=1673"},"modified":"2017-06-07T18:26:34","modified_gmt":"2017-06-07T18:26:34","slug":"interrogating-your-code-dipping-your-toes-into-javas-reflection","status":"publish","type":"post","link":"https:\/\/blog.paranoidprofessor.com\/index.php\/2017\/06\/07\/interrogating-your-code-dipping-your-toes-into-javas-reflection\/","title":{"rendered":"interrogating your code – dipping your toes into java’s reflection"},"content":{"rendered":"

Perhaps the coolest programming language ability that I was never allowed to use was reflection in Java. Why? Well, thats another story.<\/p>\n

What exactly is reflection? Well, reflection is a set of low level methods that can be used to inspect code while the program that is doing the inspecting is running.<\/p>\n

This puts the program in a very unique situation where it can interrogate objects that it is working with. Thus the program can then make decisions based on what information it finds on the class that it is inspecting.<\/p>\n

This makes it possible to inspect an object to see if it contains a certain method. This allows your program to make the decision which method to use if multiple valid methods exist. One, perhaps somewhat contrived, example of this would be that your program could check and see if the new 2.0 version of your method existed.<\/p>\n

\r\nMethod method = null;\r\ntry {\r\n    method = financialCalcObj.getClass().getMethod("calcBreakEvenV2", null);\r\n}\r\ncatch (Exceptione ex)\r\n{\r\n    \/\/ not really an error, use standard method\r\n}\r\ntry {\r\n    if (method == null)\r\n        method = financialCalcObj.getClass().getMethod("calcBreakEvenV1", null);\r\n}\r\ncatch (Exceptione ex)\r\n{\r\n    \/\/ wow, thats bad\r\n    System.exit(1);\r\n}\r\nmethod.invoke(financialCalcObj, null);\r\n<\/pre>\n
If this doesn’t seem pretty amazing just remember that you cannot do the following unless you already have all methods defined at compile time.\u00a0 (which does defeat the idea of trying to future proof your code)<\/p>\n
\r\ntry {\r\n    financialCalcObj.calcBreakEvenV2();\r\n}\r\ncatch (Exception ex)\r\n{\r\n    financialCalcObj.calcBreakEvenV1();\r\n}\r\n<\/pre>\n
The difference between the two sets of code is that in the reflection example was compiled before version 2 of this method existed.\u00a0 We just knew that it would show up eventually. \u00a0This could be extended to either use the highest version that existed or to use the version of a method based on a command line argument.<\/p>\n
No magic just a bit of forethought required<\/h2>\n
A program that uses reflection in this manner might not make much of a difference if the same set of class files or jar files are used each time. \u00a0It does allow some flexibility but if the code base never really changes it is not necessary to go to these extremes just to change how the program behaves at runtime.<\/p>\n
The program that I had been envisioning \u00a0was going to use this technology to dynamically support multiple language text. \u00a0The dynamic part was the program would convert numbers into text of the desired language. \u00a0The program would run every few minutes so it would be possible to exchange jar files between runs, however I think there is an even better solution.<\/p>\n
ie.\r\n\r\n    numberToTextGerman\r\n    numberToTextEnglish\r\n    numberToTextFrench<\/pre>\n
Instead of continuously replacing the language jar – each time with more languages I would take a slightly different route.\u00a0 I would structure the program in such a way that each new language with its methods would exist in its own jar file.<\/p>\n
The actual program itself would retrieve the data which needs to be processed and this would include the form language. \u00a0Most of the form text might be read from a database table or a possibly a file but the conversion between numbers and their textual descriptions would need to be some sort of program.<\/p>\n
Because each language would exist in its own jar file and because the program would be receiving the target language in the input data, it would be possible to support new target languages whenever they were ready.<\/p>\n
Simply copy the new jar file to the program directory and change the list of supported languages in the application.\u00a0 The program would do the rest.\u00a0 Well, the script or batch file that calls the program does need to ensure that it will include the new jar file.<\/p>\n
I simply create the classpath from the list of jar files available and the script which runs the program would be called periodically from the crontab or other scheduler.\u00a0 So the simple act of adding the jar file to the programs library directory automatically adds support to the program for this new language each time the script is run.<\/p>\n
Reflection classes and methods<\/h2>\n
The Java API has the Method class which can be\u00a0used to retrieve and inspect methods. \u00a0It is possible to query the name, which parameters types it expects, the return type and of course the ability to call the method.<\/p>\n
class Method<\/h3>\n