Finding a code converter to convert normal Java code to reflection style code

Question

I am looking for a converter to make Java code in the style of reflection from regular Java code. I do this to throw exceptions such as NoClassDefFoundError (I want to be class dependent, but I want Java to just ignore the code if the library I'm using doesn't have this class of dependencies).

I expect such a converter:

initial code:

 com.foo.MyClass myClass = new com.foo.MyClass() myClass.meth1(); 

after conversion:

 Object myClass = Class.forName("com.foo.MyClass").newInstance(); myClass.getMethods("meth1").invoke(myClass); 

Answer 1

You should try to avoid using reflection in your java code as much as possible. You can use other approaches, such as those suggested by @mwittrock , to avoid getting these NoClassDefFoundError .

You may be able to solve the problem using reflection, but you will probably introduce new ones in your design. Consider the cost of execution, as well as the verbosity of the reflection code.

The object of the main reflection was originally intended for component builder application tools ... There are several complex applications that require reflection. Examples include class browsers, object inspectors, code analysis and interpretation tools, embedded systems ... if you have doubts as to whether you are using an application that falls into one of these categories, this is probably not.

Joshua Bloch, Effective Java, 2nd Edition.

Answer 2

This may be a technically feasible approach, but, like other posters, I strongly recommend that you consider whether this solves your problem correctly (and you asked how to implement this solution, and not how to solve your original problem, so I can’t tell you if you are on the right track or not).

Perhaps you are not necessarily interested in depending on the library, but not forcing your customers to provide it? Depending on your build system, this is not so difficult to accomplish. For example, Maven allows you to specify a dependency as <scope>optional</scope> , which allows you to compile code, but does not include it as a transitive dependency.

At the same time, you can apparently optionally depend on some libraries and use an alternative route if they are not available. In my experience, this is easiest to do by hiding the details behind the interface.

As an example, I have a ProfilingAdvisor interface that works with the AspectJ aspect for profile methods marked with a special annotation. I have a rudimentary implementation of this interface called SimpleProfilingAdvisor that has no external dependencies. I have a more detailed implementation that uses the Simon Java library to get more information called SimonProfilingAdvisor.

If customers prefer to include the Java Simon library, they get a "better" implementation. If they don’t want to, the “basic” approach is used (which in your case may not do anything at all).

My code always works with the ProfilingAdvisor interface, but when creating an instance of an instance variable of this type, I must determine if there is an additional Simon library in the classpath:

  private ProfilingAdvisor advisor; /* ... */ try { Class.forName("org.javasimon.SimonManager"); this.advisor = new SimonProfilingAdvisor(); } catch (ClassNotFoundException classNotFoundException) { this.advisor = new SimpleProfilingAdvisor(); } 

The last point. Although you can determine the existence of a class using reflection, as you suggest, I can’t think of anything you type by accessing it in a reflective manner after creating the instance, and you effectively bypass the compiler’s ability to check your spelling for method names and etc.

At the very least, you should work with a build that allows you to compile the library at compile time, but you don't have to include it in your distribution later (for example, Maven).