1. What is Java reflection?
Java reflection is a capability provided by Java that allows programs to inspect and modify the internal state of objects at runtime. Simply put, it allows you not to know the specific class or method name when coding, but you can dynamically load, explore and call classes and methods at runtime.
Basics: How to obtain the Class object of a class
To use reflection, you first need to obtain the Class object of the class. There are three main methods:
- Use
.classsyntax. For example:String.class - Use the object’s
.getClass()method. For example:"Hello".getClass() - Use the
Class.forName()method. For example:Class.forName("java.lang.String")
public class ReflectionExample {<!-- -->
public static void main(String[] args) {<!-- -->
// Obtained through .class syntax
Class<?> stringClass1 = String.class;
System.out.println(stringClass1.getName());
// Obtained through the object's .getClass() method
String s = "Hello";
Class<?> stringClass2 = s.getClass();
System.out.println(stringClass2.getName());
// Obtained through Class.forName() method
try {<!-- -->
Class<?> stringClass3 = Class.forName("java.lang.String");
System.out.println(stringClass3.getName());
} catch (ClassNotFoundException e) {<!-- -->
e.printStackTrace();
}
}
}
When you run the above code, you will get the same output three times: java.lang.String.
2. How to use reflection to create objects
Using the Class object, you can create new instances of the class. This is usually done by calling the newInstance() method.
public class CreateObjectExample {<!-- -->
public static void main(String[] args) {<!-- -->
try {<!-- -->
Class<?> stringClass = Class.forName("java.lang.String");
String stringInstance = (String) stringClass.getDeclaredConstructor().newInstance();
System.out.println(stringInstance);
} catch (Exception e) {<!-- -->
e.printStackTrace();
}
}
}
The above code creates a new String object. But since we didn’t provide any value to it, it prints out the empty string.
3. How to use reflection to call methods
In addition to creating objects, you can also use reflection to call methods on objects. Here is an example of how to call a method dynamically:
public class InvokeMethodExample {<!-- -->
public static void main(String[] args) {<!-- -->
try {<!-- -->
Class<?> stringClass = Class.forName("java.lang.String");
String stringInstance = "Hello, Reflection!";
Method method = stringClass.getMethod("substring", int.class);
String result = (String) method.invoke(stringInstance, 7);
System.out.println(result);
} catch (Exception e) {<!-- -->
e.printStackTrace();
}
}
}
This code will print “Reflection!” because we dynamically called the substring method and started taking the substring from the 7th character.
So far, we have introduced the basic concepts of Java reflection and how to use reflection to obtain Class objects, create new instances and call methods.
4. Reflection performance issues
Using reflection to perform common operations, such as method calls or property accesses, is generally slower than performing these operations directly. This is because reflection involves a series of parsing operations, causing the JVM to check whether each operation you do is valid. However, for many applications this performance degradation is acceptable because reflection gives you tremendous flexibility. However, for performance-sensitive applications, it is recommended to avoid using reflection in hot code.
5. Security issues of reflection
When you use reflection, you are actually skipping many of Java’s security checks. For example, you can use reflection to access private fields, methods, and constructors, which is not allowed under normal circumstances.
public class AccessPrivateField {<!-- -->
private String secret = "This is a secret!";
public static void main(String[] args) {<!-- -->
try {<!-- -->
AccessPrivateField instance = new AccessPrivateField();
Field field = AccessPrivateField.class.getDeclaredField("secret");
field.setAccessible(true); // Allows you to access private fields
String value = (String) field.get(instance);
System.out.println(value);
} catch (Exception e) {<!-- -->
e.printStackTrace();
}
}
}
The above example demonstrates how to use reflection to access a private field. This practice should be used with caution as it can break encapsulation and cause security and maintainability issues.
6. Reflection application cases
Although reflection has performance and security issues, the flexibility it provides makes it a valuable tool in certain scenarios. The following are common use cases for reflection:
a. Dynamic proxy
Java’s Proxy class and InvocationHandler interface allow you to dynamically create proxy objects. These objects can intercept calls to any method and allow you to execute code before and after calling the original method. This is useful in implementing transactions, logging, permission checks, etc.
public class DynamicProxyExample {<!-- -->
interface Greeting {<!-- -->
void sayHello(String name);
}
static class SimpleGreeting implements Greeting {<!-- -->
public void sayHello(String name) {<!-- -->
System.out.println("Hello, " + name);
}
}
static class GreetingHandler implements InvocationHandler {<!-- -->
private final Greeting original;
public GreetingHandler(Greeting original) {<!-- -->
this.original = original;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {<!-- -->
System.out.println("Before invoking method");
Object result = method.invoke(original, args);
System.out.println("After invoking method");
return result;
}
}
public static void main(String[] args) {<!-- -->
Greeting greeting = new SimpleGreeting();
Greeting proxy = (Greeting) Proxy.newProxyInstance(
Greeting.class.getClassLoader(),
new Class[]{<!-- -->Greeting.class},
new GreetingHandler(greeting)
);
proxy.sayHello("World");
}
}
The above code produces the following output:
Before invoking method Hello, World After invoking method
Dynamic proxy is a widely used design pattern in Java, such as in the Spring framework’s AOP (Aspect Oriented Programming).
7. Application of reflection in framework development
Many Java frameworks rely on reflection for their core functionality.
a. Spring framework
The Spring framework uses reflection in multiple places. For example, when you define a bean and ask Spring to inject its dependencies, Spring uses reflection to instantiate the bean, call setters or annotated methods, and inject the required dependencies. In addition, Spring’s AOP capabilities also use reflection and dynamic proxies to intercept method calls.
b. Hibernate ORM
Hibernate is an object-relational mapping (ORM) framework that allows developers to interact with databases in an object-oriented manner. Hibernate uses reflection to read and write properties of objects, as well as map objects to database tables.
8. Reflection for type checking and processing
Java’s generics are erased at compile time, which means that at runtime, you usually can’t determine the exact element type of a collection. However, sometimes you need this information. Reflection can help you get this information.
public class TypeCheckingWithReflection {<!-- -->
public static void printType(Object object) {<!-- -->
Class<?> clazz = object.getClass();
System.out.println("The type of the object is: " + clazz.getName());
}
public static void main(String[] args) {<!-- -->
List<String> list = new ArrayList<>();
printType(list);
int number = 10;
printType(number);
}
}
This code will output:
The type of the object is: java.util.ArrayList The type of the object is: java.lang.Integer
Note: Reflection can only help you determine the actual class of an object, but due to generic erasure, you cannot use it to determine that the element type of a list is String.
9. Conclusion
Java reflection is a powerful tool that allows developers to inspect and modify the state of objects at runtime. While it brings flexibility, it also brings performance and security challenges. When considering using reflection, always weigh its pros and cons and make sure you understand all its consequences.
Reflection is widely used in the development of frameworks and libraries because it allows these tools to provide a higher level of abstraction and automation. However, when used for general application development, its use should be avoided unless there is a good reason.
Finally, no matter how you decide to use reflection, always make sure your code is safe, tested, and meets its performance needs.