Java Reflection Drawbacks And Use cases

The concept of reflection in software means the ability to inspect, analyze and modify other code at runtime.
In Java, it is possible to inspect fields, classes, methods, annotations, interfaces, etc. at runtime. You do not need to know how
classes or methods are called, neither the parameters that are needed, all of that can be retrieved at runtime using reflection. It is
also possible to instantiate new classes, to create new instances and to execute their methods, all of it using reflection.

Drawbacks

• Poor Performance – Since java reflection resolve the types
  dynamically, it involves processing like scanning the classpath to
  find the class to load, causing slow performance.
• Security Restrictions – Reflection requires runtime permissions that
  might not be available for system running under security manager.
  This can cause you application to fail at runtime because of security
  manager.
• Security Issues – Using reflection we can access part of code that we
  are not supposed to access, for example we can access private fields
  of a class and change it’s value. This can be a serious security
  threat and cause your application to behave abnormally.
• High Maintenance – Reflection code is hard to understand and debug,
  also any issues with the code can’t be found at compile time because
  the classes might not be available, making it less flexible and hard
  to maintain.

Use cases

Despite all the limitations, reflection is a very powerful tool in Java that can be taken into consideration in several scenarios.
In general, reflection can be used to observe and modify the behavior of a program at runtime. Here is a list with the most
common use cases:

• IDEs can heavily make use of reflection in order to provide solutions for auto completion features, dynamic typing, hierarchy
  structures, etc. For example, IDEs like Eclipse or PHP Storm provide a mechanism to retrieve dynamically the arguments
  expected for a given method or a list of public methods starting by “get” for a given instance. All these are done using
  reflection.
• Debuggers use reflection to inspect dynamically the code that is being executed.
• Test tools like Junit or Mockito use reflection in order to invoke desired methods containing specific syntax or to mock specific
  classes, interfaces and methods.
• Dependency injection frameworks use reflection to inject beans and properties at runtime and initialize all the context of an
  application.
• Code analysis tools like PMD or Findbugs use reflection in order to analyze the code against the list of code violations that are
  currently configured.
• External tools that make use of the code dynamically may use reflection as well