Mastering Java Reflections

When you start learning Java, you typically focus on the basics: classes, objects, constructors, methods, inheritance, and more.

However, when developing frameworks, you'll often need more dynamic control over external code. This is where Reflection comes into play.

Let me show you what it’s all about.

What is Reflection in Java?

Imagine you're trying to access or change an object's properties, methods, or class structure at runtime—without knowing their names beforehand.

That’s exactly what Java Reflection allows you to do! It gives you the power to peek under the hood of any object, even if you have no clue what it looks like during compile time.

There is a class in Java named java.lang.Class that keeps all the information about each objects and classes at runtime. Using this Class object java allows you to perform reflection.

Why Would You Even Need Reflection?

Sometimes you want to work with code that's not fully in your control. Maybe you're building a framework and need to inject dependencies, or you're working with a tool that has to inspect objects at runtime.

Java Reflection is perfect for these kinds of tasks.

Here are some common ways it’s used:

• Dependency Injection: Frameworks like Spring rely on reflection to inject dependencies into objects at runtime.
• Runtime Inspection: Tools use reflection to inspect objects during runtime for debugging, testing, or even serialization.
• Dynamic Method Invocation: Want to call a method when you don’t know its name ahead of time? Reflection lets you invoke methods dynamically.
• Proxy and AOP (Aspect-Oriented Programming): Reflection is a key player when it comes to creating proxy objects or handling cross-cutting concerns like logging and transaction management.

Reflection API Overview

Key Components of the Reflection API

Reflection in Java revolves around a few core components, mostly found in the java.lang.reflect package. This includes classes like Class, Field, Method, and Constructor, along with the java.lang.Class class itself.

Let’s break this down.

What is java.lang.Class?

Now, think of java.lang.Class as the blueprint that holds the metadata of any Java class. This Class object is automatically created when the class gets loaded into the Java Virtual Machine (JVM).

Here’s the cool part—this happens only once, the first time the class is referenced. So, whether you create an object, call a static method, or access a static field, the JVM loads the class and associates it with a Class object.

It’s worth noting that this Class object isn’t tied to individual instances. So, even if you don’t create any objects, that Class object is still there, representing the class.

🔗Read more: java.lang.Class (opens in a new tab)

Steps to perform reflection in java

Alright, now let’s get practical. To do anything with reflection, you first need to get hold of the Class object.

Useful Methods to perform reflection:

Here’s a concise list of useful Class object methods for performing reflection in Java, including methods to access class information, methods, fields, annotations, constructors, and also Boolean methods to check certain characteristics of the class and its members:

1. Class Information

• getName(): Returns the fully qualified name of the class.

• getSimpleName(): Returns the simple name of the class.

• getSuperclass(): Returns the superclass of the class.

• getModifiers(): Returns the class's modifiers (e.g., public, abstract).

• getPackage(): Returns the package of the class.

• Boolean Methods:

  • isInterface(): Checks if the class is an interface.
  • isEnum(): Checks if the class is an enum.
  • isArray(): Checks if the class is an array.
  • isPrimitive(): Checks if the class represents a primitive type.
  • isAnnotation(): Checks if the class is an annotation type.

2. Methods (Including Public & Private)

• getMethods(): Returns an array of public methods, including inherited ones.
• getDeclaredMethods(): Returns an array of all declared methods, including private methods.
• getMethod(String name, Class<?>... parameterTypes): Gets a specific public method.
• getDeclaredMethod(String name, Class<?>... parameterTypes): Gets a specific declared method, including private.
• invoke(Object obj, Object... args): Invokes the method on the given object with specified arguments.

3. Fields (Including Public & Private)

• getFields(): Returns an array of public fields, including inherited ones.
• getDeclaredFields(): Returns an array of all declared fields, including private fields.
• getField(String name): Gets a specific public field.
• getDeclaredField(String name): Gets a specific declared field, including private.
• set(Object obj, Object value): Sets the value of the field on the given object.
• get(Object obj): Gets the value of the field from the given object.

4. Annotations

• getAnnotations(): Returns an array of all annotations, including inherited ones.
• getDeclaredAnnotations(): Returns an array of all declared annotations.
• getAnnotation(Class<T> annotationClass): Returns a specific annotation if present.
• isAnnotationPresent(Class<? extends Annotation> annotationClass): Checks if the class or member has a specific annotation.

  boolean hasAnnotation = clazz.isAnnotationPresent(MyAnnotation.class);

5. Constructors

• getConstructors(): Returns an array of public constructors.
• getDeclaredConstructors(): Returns an array of all declared constructors, including private.
• getConstructor(Class<?>... parameterTypes): Gets a specific public constructor.
• getDeclaredConstructor(Class<?>... parameterTypes): Gets a specific declared constructor, including private.
• newInstance(Object... initargs): Creates a new instance using the specified constructor.

Coding Exercises

Problem 1 - Basic Reflection

Given the following setup with an ExecutorService and a Task interface, we want to explore the class details of ServiceA using Java Reflection.

Problem Statement:

Write a program that:

1. Uses Java Reflection to inspect the ServiceA class.
2. Prints the name of the class.
3. Prints the name of its superclass.
4. Prints the names and modifiers of all public methods declared in the class.

Use the following interfaces and class structure for the exercise:

public interface ExecutorService {
    void execute();
}
 
public class ServiceA implements ExecutorService {
 
    private Task task;
 
    public void execute() {
        System.out.println("ServiceA is executing");
        task.doSomething();
    }
}
 
public interface Task {
    void doSomething();
}

Hints:

• You can retrieve the class name, superclass, and methods of ServiceA using the Class object and methods like getName(), getSuperclass(), and getMethods().
• The public methods include both declared and inherited methods.

Expected Output:

Your program should output something similar to this:

Class Name: ServiceA
Superclass: java.lang.Object
Public Methods:
 - public void execute()
 - public final native void wait(long)
 - public final native void wait(long, int)
 - public void wait()
 - public boolean equals(java.lang.Object)
 - public java.lang.String toString()
 - public int hashCode()
 - public final native java.lang.Class getClass()
 - public final native void notify()
 - public final native void notifyAll()

Problem 2 - Build ReflectionUtils

Problem Statement:

Create a utility class, ReflectionUtils, to demonstrate various functionalities of Java Reflection. The class should be able to:

1. Print Class Information: Display the class name, superclass, and implemented interfaces.
2. Print Methods: List all public methods and also provide an option to list all methods, including private ones.
3. Invoke Methods: Invoke all public methods, and provide functionality to invoke private methods as well.
4. Print Fields: List all public fields, and provide an option to include private fields.
5. Handle Annotations: Print all annotations on the class, its methods, and fields.
6. Create Instances Dynamically: Dynamically create a new instance of any class, even if it has private constructors.

Problem 3 - Build a SimpleDIFramework like Spring

Problem Statement:

Build a simple Dependency Injection (DI) framework using Java Reflection. The goal is to automatically inject dependencies into a target object's fields annotated with @Inject, without requiring manual initialization.

The framework should:

1. Register Dependencies: Allow registering pre-existing dependencies into a map for future injections.
2. Inject Dependencies: Automatically inject the necessary dependencies into the target object's fields that are marked with @Inject.
3. Handle Missing Dependencies: If a dependency is not already registered, the framework should create it using its no-argument constructor and register it for future use.
4. Support Private Fields: Ensure that private fields can also have dependencies injected.

Coding Exercises - Solution

• All Solutions are available on github (opens in a new tab).