Objenesis 底层探究

Objenesis 简介

Objenesis 是一个 Java 库，用于在不调用构造方法的情况下创建对象。由于绕过了构造方法，所以无法调用构造方法中的初始化逻辑。相应的，Objenesis 无法创建抽象类、枚举、接口的实例对象。

起源

与其称之为起源，不如说这是 Java 中反射创建对象的一种应用，先来看看 java.lang.reflect.Constructor 中的一段代码：

    @CallerSensitive
    @ForceInline // to ensure Reflection.getCallerClass optimization
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, clazz, modifiers);
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

可以看到，当我们通过获取 Constructor 对象，反射创建实例对象时，实际上是通过ConstructorAccessor 中的 newInstance 方法来创建对象。这是一个 JDK 内部接口，全名是jdk.internal.reflect.ConstructorAccessor。

此处主要关注它的一个子类：jdk.internal.reflect.SerializationConstructorAccessorImpl，一个内部抽象类。

这些类都是一些特殊的类，可以被 JVM 识别，来进入其它类进行操作，而不受语言限制。

而 Objenesis 的核心，就是通过动态生成 ConstructorAccessor，来绕过原有 ConstructorAccessor 对象，调用 newInstance 方法，实现实例化。

核心

ObjenesisBase，调用入口，通过不同策略来实例化对象：

   public <T> T newInstance(Class<T> clazz) {
      return getInstantiatorOf(clazz).newInstance();
   }

标准实现，采用的策略为 StdInstantiatorStrategy：

   public <T> ObjectInstantiator<T> newInstantiatorOf(Class<T> type) {

      if(PlatformDescription.isThisJVM(HOTSPOT) || PlatformDescription.isThisJVM(OPENJDK)) {
         // Java 7 GAE was under a security manager so we use a degraded system
         if(PlatformDescription.isGoogleAppEngine() && PlatformDescription.SPECIFICATION_VERSION.equals("1.7")) {
            if(Serializable.class.isAssignableFrom(type)) {
               return new ObjectInputStreamInstantiator<>(type);
            }
            return new AccessibleInstantiator<>(type);
         }
         // The UnsafeFactoryInstantiator would also work. But according to benchmarks, it is 2.5
         // times slower. So I prefer to use this one
         return new SunReflectionFactoryInstantiator<>(type);
      }
      else if(PlatformDescription.isThisJVM(DALVIK)) {
         if(PlatformDescription.isAndroidOpenJDK()) {
            // Starting at Android N which is based on OpenJDK
            return new UnsafeFactoryInstantiator<>(type);
         }
         if(ANDROID_VERSION <= 10) {
            // Android 2.3 Gingerbread and lower
            return new Android10Instantiator<>(type);
         }
         if(ANDROID_VERSION <= 17) {
            // Android 3.0 Honeycomb to 4.2 Jelly Bean
            return new Android17Instantiator<>(type);
         }
         // Android 4.3 until Android N
         return new Android18Instantiator<>(type);
      }
      else if(PlatformDescription.isThisJVM(GNU)) {
         return new GCJInstantiator<>(type);
      }
      else if(PlatformDescription.isThisJVM(PERC)) {
         return new PercInstantiator<>(type);
      }

      // Fallback instantiator, should work with most modern JVM
      return new UnsafeFactoryInstantiator<>(type);

   }

主要是针对不同平台，调用不同的类，此处只关注 SunReflectionFactoryInstantiator：

   public SunReflectionFactoryInstantiator(Class<T> type) {
      Constructor<Object> javaLangObjectConstructor = getJavaLangObjectConstructor();
      mungedConstructor = SunReflectionFactoryHelper.newConstructorForSerialization(
          type, javaLangObjectConstructor);
      mungedConstructor.setAccessible(true);
   }

   public T newInstance() {
      try {
         return mungedConstructor.newInstance((Object[]) null);
      }
      catch(Exception e) {
         throw new ObjenesisException(e);
      }
   }

可以看到，就是通过这个动态生成的 mungedConstructor 来创建对象。

下面来看看这个 mungedConstructor 是如何生成的？

   public static <T> Constructor<T> newConstructorForSerialization(Class<T> type,
      Constructor<?> constructor) {
      Class<?> reflectionFactoryClass = getReflectionFactoryClass();
      Object reflectionFactory = createReflectionFactory(reflectionFactoryClass);

      Method newConstructorForSerializationMethod = getNewConstructorForSerializationMethod(
         reflectionFactoryClass);

      try {
         return (Constructor<T>) newConstructorForSerializationMethod.invoke(
            reflectionFactory, type, constructor);
      }
      catch(IllegalArgumentException | IllegalAccessException | InvocationTargetException e) {
         throw new ObjenesisException(e);
      }
   }

通过上文知道，ConstructorAccessor 这些 JDK 内部类，由于安全考虑，外部无法直接使用，但是 JDK 又留了特殊的入口供开发者使用，这个入口就是：sun.reflect.ReflectionFactory。

    public Constructor<?> newConstructorForSerialization(Class<?> cl,
                                                         Constructor<?> constructorToCall)
    {
        return delegate.newConstructorForSerialization(cl,
                                                       constructorToCall);
    }

而这个 delegate 就是 jdk.internal.reflect.ReflectionFactory：

    public final Constructor<?> newConstructorForSerialization(Class<?> cl,
                                                               Constructor<?> constructorToCall)
    {
        if (constructorToCall.getDeclaringClass() == cl) {
            constructorToCall.setAccessible(true);
            return constructorToCall;
        }
        return generateConstructor(cl, constructorToCall);
    }

    private final Constructor<?> generateConstructor(Class<?> cl,
                                                     Constructor<?> constructorToCall) {


        ConstructorAccessor acc = new MethodAccessorGenerator().
            generateSerializationConstructor(cl,
                                             constructorToCall.getParameterTypes(),
                                             constructorToCall.getExceptionTypes(),
                                             constructorToCall.getModifiers(),
                                             constructorToCall.getDeclaringClass());
        Constructor<?> c = newConstructor(constructorToCall.getDeclaringClass(),
                                          constructorToCall.getParameterTypes(),
                                          constructorToCall.getExceptionTypes(),
                                          constructorToCall.getModifiers(),
                                          langReflectAccess().
                                          getConstructorSlot(constructorToCall),
                                          langReflectAccess().
                                          getConstructorSignature(constructorToCall),
                                          langReflectAccess().
                                          getConstructorAnnotations(constructorToCall),
                                          langReflectAccess().
                                          getConstructorParameterAnnotations(constructorToCall));
        setConstructorAccessor(c, acc);
        c.setAccessible(true);
        return c;
    }

可以看到，最终是通过 jdk.internal.reflect.MethodAccessorGenerator 来动态的生成了 ConstructorAccessor。顺便说一下，具体的生成是采用了 JDK 内部的 ASM 操作类（jdk.internal.reflect.ClassFileAssembler）生成类的字节码，然后加载字节码，得到 Class 对象，调用 Class#newInstance 方法，得到了这个动态生成的 ConstructorAccessor 的具体对象。

下面来看看这个动态生成的 ConstructorAccessor 具体是什么。

动态 ConstructorAccessor 实现类

通读了生成这个类的字节码操作代码，翻译出的伪代码如下：

public jdk.internal.reflect.GeneratedSerializationConstructorAccessor1 extends jdk.internal.reflect.SerializationConstructorAccessorImpl {
	public GeneratedSerializationConstructorAccessor1 () {
		this.super();
	}
	public Object newInstance(Object[] args) {
		try {
		// new targetClass
		// 校验参数	
		// 1. args 为 null，跳过校验
		// 2. args 不为 null，校验参数数组长度和参数类型数组长度是否一致
		} catch (NullPointerException | ClassCastException var) {
			throw new IllegalArgumentException(var.toString());
		}
		
		try {
			// 调用 constructorToCall 的构造方法，此处由于传入 Object，即调用 Object 的无参构造
		}
		catch (Throwable var) {
			throw new InvocationTargetException(var);
		}
		
	}
}

应用

Spring 集成了Objenesis，作为在 AOP 时采用 Cglib 代理生成 Class 类后的实例化操作。

默认采用的实例化策略就是StdInstantiatorStrategy。这样，就避开了目标类的构造方法，实现了采用 Cglib 实现 AOP 时通过 ASM 动态生成的 proxyClass 的实例化。