Four ways to obtain a Class object#

If we want to obtain this information dynamically, we need to rely on the Class object. The Class object provides information about a class’s methods, variables, etc. Java provides four ways to obtain a Class object:

1. If you know the concrete class, you can use:

   1
   Class alunbarClass = TargetObject.class;

   However, we generally don’t know the concrete class; we usually obtain the Class object by iterating over the classes under a package. Obtaining the Class object this way will not initialize the class.

2. Through Class.forName() to obtain by fully-qualified name:

1
Class alunbarClass1 = Class.forName("cn.javaguide.TargetObject");

1. Through an object instance instance.getClass() to obtain:

1
TargetObject o = new TargetObject();
2
Class alunbarClass2 = o.getClass();

1. Through a class loader xxxClassLoader.loadClass() to obtain by path:

1
ClassLoader.getSystemClassLoader().loadClass("cn.javaguide.TargetObject");

Obtaining a Class object via a class loader does not initialize the class, which means a series of steps including initialization are not performed; static blocks and static objects will not be executed.

Some basic operations of reflection#

1. Create a class that we will operate on with reflection, TargetObject.

1
package cn.javaguide;
2

3
public class TargetObject {
4
    private String value;
5

6
    public TargetObject() {
7
        value = "JavaGuide";
8
    }
9

10
    public void publicMethod(String s) {
11
        System.out.println("I love " + s);
12
    }
13

14
    private void privateMethod() {
15
        System.out.println("value is " + value);
16
    }
17
}

2. Use reflection to operate on this class’s methods and parameters

1
package cn.javaguide;
2

3
import java.lang.reflect.Field;
4
import java.lang.reflect.InvocationTargetException;
5
import java.lang.reflect.Method;
6

7
public class Main {
8
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
9
        /**
10
         * Get the Class object of the TargetObject class and create an instance of TargetObject
11
         */
12
        Class<?> targetClass = Class.forName("cn.javaguide.TargetObject");
13
        TargetObject targetObject = (TargetObject) targetClass.newInstance();
14
        /**
15
         * Get all methods defined in TargetObject
16
         */
17
        Method[] methods = targetClass.getDeclaredMethods();
18
        for (Method method : methods) {
19
            System.out.println(method.getName());
20
        }
21

22
        /**
23
         * Get a specific method and call it
24
         */
25
        Method publicMethod = targetClass.getDeclaredMethod("publicMethod",
26
                String.class);
27

28
        publicMethod.invoke(targetObject, "JavaGuide");
29

30
        /**
31
         * Get a specific parameter and modify it
32
         */
33
        Field field = targetClass.getDeclaredField("value");
34
        //To modify the field's value, disable the security check
35
        field.setAccessible(true);
36
        field.set(targetObject, "JavaGuide");
37

38
        /**
39
         * Call a private method
40
         */
41
        Method privateMethod = targetClass.getDeclaredMethod("privateMethod");
42
        //To call a private method, disable the security check
43
        privateMethod.setAccessible(true);
44
        privateMethod.invoke(targetObject);
45
    }
46
}

JDK Dynamic Proxy Mechanism#

In the Java dynamic proxy mechanism, the InvocationHandler interface and the Proxy class are core.

The most frequently used method in the Proxy class is: newProxyInstance(), which is mainly used to generate a proxy object.

1
public static Object newProxyInstance(ClassLoader loader,
2
                                      Class<?>[] interfaces,
3
                                      InvocationHandler h)
4
        throws IllegalArgumentException
5
    {
6
        ......
7
    }

This method has three parameters:

1. loader : the class loader used to load the proxy object.
2. interfaces : the interfaces implemented by the proxied class;
3. h : the object that implements the InvocationHandler interface;

To implement dynamic proxies, you must also implement InvocationHandler to customize the handling logic. When our dynamic proxy object calls a method, that call will be forwarded to the invoke method of the class implementing the InvocationHandler interface.

1
public interface InvocationHandler {
2

3
    /**
4
     * When you call a method on the proxy object, this method is actually invoked
5
     */
6
    public Object invoke(Object proxy, Method method, Object[] args)
7
        throws Throwable;
8
}

invoke() method has three parameters:

1. proxy : the dynamically generated proxy class
2. method : the method being invoked on the proxy object
3. args : the parameters of the current method

In other words: the proxy object created by the Proxy class’s newProxyInstance() will actually call the invoke() method of the class that implements InvocationHandler when a method is invoked. You can customize the handling logic in the invoke() method, such as what to do before or after the method execution.

• JDK dynamic proxy usage steps

  1. Define an interface and its implementation class;
  2. Create a custom InvocationHandler and override the invoke method; in the invoke method we will call the native method (the method of the proxied class) and add some custom processing;
  3. Create the proxy object via Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h);

• Code example

  1. Define the Sms sending interface

     1
     public interface SmsService {
     2
         String send(String message);
     3
     }

  2. Implement the Sms sending interface

     1
     public class SmsServiceImpl implements SmsService {
     2
         public String send(String message) {
     3
             System.out.println("send message:" + message);
     4
             return message;
     5
         }
     6
     }

  3. Define a JDK dynamic proxy class

     1
     import java.lang.reflect.InvocationHandler;
     2
     import java.lang.reflect.InvocationTargetException;
     3
     import java.lang.reflect.Method;
     4
     
     5
     /**
     6
      * @author shuang.kou
     7
      * @createTime 2020年05月11日 11:23:00
     8
      */
     9
     public class DebugInvocationHandler implements InvocationHandler {
     10
         /**
     11
          * The real object inside the proxy
     12
          */
     13
         private final Object target;
     14
     
     15
         public DebugInvocationHandler(Object target) {
     16
             this.target = target;
     17
         }
     18
     
     19
         @Override
     20
         public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
     21
             // Before invoking, we can add our own operations
     22
             System.out.println("before method " + method.getName());
     23
             Object result = method.invoke(target, args);
     24
             // After invoking, we can also add our own operations
     25
             System.out.println("after method " + method.getName());
     26
             return result;
     27
         }
     28
     }

     The invoke() method: when our dynamic proxy object calls a native method, what is ultimately called is the invoke() method, and then the invoke() method handles calling the proxied object’s native method.

  4. Factory class to obtain proxy objects

     1
     public class JdkProxyFactory {
     2
         public static Object getProxy(Object target) {
     3
             return Proxy.newProxyInstance(
     4
                     target.getClass().getClassLoader(), // target class's class loader
     5
                     target.getClass().getInterfaces(),  // interfaces to implement by the proxy, can specify multiple
     6
                     new DebugInvocationHandler(target)   // the custom InvocationHandler for the proxy object
     7
             );
     8
         }
     9
     }

     getProxy() mainly uses Proxy.newProxyInstance() to obtain a proxy object for a class.

  5. Usage

     1
     SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
     2
     smsService.send("java");

  After running the above code, the console prints:

  1
  before method send
  2
  send message:java
  3
  after method send

CGLIB Dynamic Proxy Mechanism#

One of the most critical limitations of JDK dynamic proxies is that they can only proxy classes that implement interfaces.

To solve this, you can use CGLIB dynamic proxy to avoid this limitation.

CGLIB(Code Generation Library) is a bytecode generation library based on ASM that allows us to modify and dynamically generate bytecode at runtime. CGLIB proxies by inheritance. Many well-known open-source frameworks use CGLIB, for example in Spring’s AOP module: if the target object implements an interface, the default is to use a JDK dynamic proxy; otherwise, CGLIB dynamic proxy is used.

In the CGLIB dynamic proxy mechanism MethodInterceptor interface and Enhancer class are core.

You need to customize a MethodInterceptor and override the intercept method; intercept is used to intercept and enhance the proxied class’s methods.

1
public interface MethodInterceptor
2
extends Callback{
3
    // Intercept methods in the proxied class
4
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,MethodProxy proxy) throws Throwable;
5
}

1. obj : the proxied object (the object to be enhanced)
2. method : the intercepted method (the method to be enhanced)
3. args : method parameters
4. proxy : used to call the original method

You can dynamically obtain the proxied class via the Enhancer class; when the proxy class calls a method, the actual call goes to the intercept method in the MethodInterceptor.

• CGLIB dynamic proxy usage steps

  1. Define a class;
  2. Create a custom MethodInterceptor and override the intercept method; intercept is used to intercept and enhance the proxied class’s methods, similar to the invoke method in JDK dynamic proxies;
  3. Use the Enhancer class’s create() to create the proxy class;

• Code example

  Unlike JDK dynamic proxy, no extra dependency is required. CGLIB(Code Generation Library) is actually an open-source project; if you want to use it, you need to manually add the related dependency.

  1
  <dependency>
  2
    <groupId>cglib</groupId>
  3
    <artifactId>cglib</artifactId>
  4
    <version>3.3.0</version>
  5
  </dependency>

  1. Implement a class that uses Alibaba Cloud to send SMS

     1
     package github.javaguide.dynamicProxy.cglibDynamicProxy;
     2
     
     3
     public class AliSmsService {
     4
         public String send(String message) {
     5
             System.out.println("send message:" + message);
     6
             return message;
     7
         }
     8
     }

  2. Create a custom MethodInterceptor** (method interceptor)**

     1
     import net.sf.cglib.proxy.MethodInterceptor;
     2
     import net.sf.cglib.proxy.MethodProxy;
     3
     
     4
     import java.lang.reflect.Method;
     5
     
     6
     /**
     7
      * Custom MethodInterceptor
     8
      */
     9
     public class DebugMethodInterceptor implements MethodInterceptor {
     10
     
     11
         /**
     12
          * @param o           the proxied object (the object to be enhanced)
     13
          * @param method      the intercepted method (the method to be enhanced)
     14
          * @param args        method arguments
     15
          * @param methodProxy used to call the original method
     16
          */
     17
         @Override
     18
         public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
     19
             // Before invoking, we can add our own operations
     20
             System.out.println("before method " + method.getName());
     21
             Object object = methodProxy.invokeSuper(o, args);
     22
             // After invoking, we can also add our own operations
     23
             System.out.println("after method " + method.getName());
     24
             return object;
     25
         }
     26
     
     27
     }

  3. Get the proxy class

     1
     import net.sf.cglib.proxy.Enhancer;
     2
     
     3
     public class CglibProxyFactory {
     4
     
     5
         public static Object getProxy(Class<?> clazz) {
     6
             // Create dynamic proxy enhancement class
     7
             Enhancer enhancer = new Enhancer();
     8
             // Set the class loader
     9
             enhancer.setClassLoader(clazz.getClassLoader());
     10
             // Set the proxied class
     11
             enhancer.setSuperclass(clazz);
     12
             // Set the method interceptor
     13
             enhancer.setCallback(new DebugMethodInterceptor());
     14
             // Create the proxy class
     15
             return enhancer.create();
     16
         }
     17
     }

  4. Usage

     1
     AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
     2
     aliSmsService.send("java");

  After running the above code, the console prints:

  1
  before method send
  2
  send message:java
  3
  after method send

JDK Dynamic Proxy vs CGLIB Dynamic Proxy#

1. JDK dynamic proxies can only proxy classes that implement interfaces, whereas CGLIB can proxy classes that do not implement any interfaces. Additionally, CGLIB proxies by generating a subclass of the proxied class, so it cannot proxy final classes and final methods.
2. In terms of efficiency, in most cases JDK dynamic proxies are better; with newer JDK versions, this advantage becomes more pronounced.