前提

Java反射的API在JavaSE1.7的时候已经基本完善，但是本文编写的时候使用的是Oracle JDK11，因为JDK11对于sun包下的源码也上传了，可以直接通过IDE查看对应的源码和进行Debug。

本文主要介绍反射调用的底层实现，当然还没有能力分析JVM的实现，这里只分析到最终Native方法的调用点。底层会依赖到Unsafe类，可以的话可以看下笔者之前写的一篇文章《神奇的魔法类和双刃剑-Unsafe》。

反射调用的底层实现探究

主要考虑下面的情况：

  • 属性操作：java.lang.reflect.Field#set(Object obj, Object value)和java.lang.reflect.Field#get(Object obj)。
  • 构造器调用：java.lang.reflect.Constructor#newInstance(Object ... initargs)。
  • 方法调用：java.lang.reflect.Method#invoke(Object obj, Object... args)。

处理属性操作的底层实现

属性操作方法Field#set(Object obj, Object value)和Field#get(Object obj)底层都是委托到jdk.internal.reflect.FieldAccessor实现：

  1. public interface FieldAccessor {
  2.     /** Matches specification in {@link java.lang.reflect.Field} */
  3.     public Object get(Object obj) throws IllegalArgumentException;
  5.     /** Matches specification in {@link java.lang.reflect.Field} */
  6.     public boolean getBoolean(Object obj) throws IllegalArgumentException;
  8.     /** Matches specification in {@link java.lang.reflect.Field} */
  9.     public byte getByte(Object obj) throws IllegalArgumentException;
  11.     /** Matches specification in {@link java.lang.reflect.Field} */
  12.     public char getChar(Object obj) throws IllegalArgumentException;
  14.     /** Matches specification in {@link java.lang.reflect.Field} */
  15.     public short getShort(Object obj) throws IllegalArgumentException;
  17.     /** Matches specification in {@link java.lang.reflect.Field} */
  18.     public int getInt(Object obj) throws IllegalArgumentException;
  20.     /** Matches specification in {@link java.lang.reflect.Field} */
  21.     public long getLong(Object obj) throws IllegalArgumentException;
  23.     /** Matches specification in {@link java.lang.reflect.Field} */
  24.     public float getFloat(Object obj) throws IllegalArgumentException;
  26.     /** Matches specification in {@link java.lang.reflect.Field} */
  27.     public double getDouble(Object obj) throws IllegalArgumentException;
  29.     /** Matches specification in {@link java.lang.reflect.Field} */
  30.     public void set(Object obj, Object value)
  31.         throws IllegalArgumentException, IllegalAccessException;
  33.     /** Matches specification in {@link java.lang.reflect.Field} */
  34.     public void setBoolean(Object obj, boolean z)
  35.         throws IllegalArgumentException, IllegalAccessException;
  37.     /** Matches specification in {@link java.lang.reflect.Field} */
  38.     public void setByte(Object obj, byte b)
  39.         throws IllegalArgumentException, IllegalAccessException;
  41.     /** Matches specification in {@link java.lang.reflect.Field} */
  42.     public void setChar(Object obj, char c)
  43.         throws IllegalArgumentException, IllegalAccessException;
  45.     /** Matches specification in {@link java.lang.reflect.Field} */
  46.     public void setShort(Object obj, short s)
  47.         throws IllegalArgumentException, IllegalAccessException;
  49.     /** Matches specification in {@link java.lang.reflect.Field} */
  50.     public void setInt(Object obj, int i)
  51.         throws IllegalArgumentException, IllegalAccessException;
  53.     /** Matches specification in {@link java.lang.reflect.Field} */
  54.     public void setLong(Object obj, long l)
  55.         throws IllegalArgumentException, IllegalAccessException;
  57.     /** Matches specification in {@link java.lang.reflect.Field} */
  58.     public void setFloat(Object obj, float f)
  59.         throws IllegalArgumentException, IllegalAccessException;
  61.     /** Matches specification in {@link java.lang.reflect.Field} */
  62.     public void setDouble(Object obj, double d)
  63.         throws IllegalArgumentException, IllegalAccessException;
  64. }

FieldAccessor接口有很多的实现，FieldAccessor接口实例是通过jdk.internal.reflect.ReflectionFactory这个工厂构造的：

  1.     public FieldAccessor newFieldAccessor(Field field, boolean override) {
  2.         checkInitted();
  4.         Field root = langReflectAccess.getRoot(field);
  5.         if (root != null) {
  6.             // FieldAccessor will use the root unless the modifiers have
  7.             // been overrridden
  8.             if (root.getModifiers() == field.getModifiers() || !override) {
  9.                 field = root;
  10.             }
  11.         }
  12.         return UnsafeFieldAccessorFactory.newFieldAccessor(field, override);
  13.     }

最终委托到UnsafeFieldAccessorFactory#newFieldAccessor()：

  1. class UnsafeFieldAccessorFactory {
  2.     static FieldAccessor newFieldAccessor(Field field, boolean override) {
  3.         Class<?> type = field.getType();
  4.         boolean isStatic = Modifier.isStatic(field.getModifiers());
  5.         boolean isFinal = Modifier.isFinal(field.getModifiers());
  6.         boolean isVolatile = Modifier.isVolatile(field.getModifiers());
  7.         boolean isQualified = isFinal || isVolatile;
  8.         boolean isReadOnly = isFinal && (isStatic || !override);
  9.         if (isStatic) {
  10.             // This code path does not guarantee that the field's
  11.             // declaring class has been initialized, but it must be
  12.             // before performing reflective operations.
  13.             UnsafeFieldAccessorImpl.unsafe.ensureClassInitialized(field.getDeclaringClass());
  15.             if (!isQualified) {
  16.                 if (type == Boolean.TYPE) {
  17.                     return new UnsafeStaticBooleanFieldAccessorImpl(field);
  18.                 } else if (type == Byte.TYPE) {
  19.                     return new UnsafeStaticByteFieldAccessorImpl(field);
  20.                 } else if (type == Short.TYPE) {
  21.                     return new UnsafeStaticShortFieldAccessorImpl(field);
  22.                 } else if (type == Character.TYPE) {
  23.                     return new UnsafeStaticCharacterFieldAccessorImpl(field);
  24.                 } else if (type == Integer.TYPE) {
  25.                     return new UnsafeStaticIntegerFieldAccessorImpl(field);
  26.                 } else if (type == Long.TYPE) {
  27.                     return new UnsafeStaticLongFieldAccessorImpl(field);
  28.                 } else if (type == Float.TYPE) {
  29.                     return new UnsafeStaticFloatFieldAccessorImpl(field);
  30.                 } else if (type == Double.TYPE) {
  31.                     return new UnsafeStaticDoubleFieldAccessorImpl(field);
  32.                 } else {
  33.                     return new UnsafeStaticObjectFieldAccessorImpl(field);
  34.                 }
  35.             } else {
  36.                 if (type == Boolean.TYPE) {
  37.                     return new UnsafeQualifiedStaticBooleanFieldAccessorImpl(field, isReadOnly);
  38.                 } else if (type == Byte.TYPE) {
  39.                     return new UnsafeQualifiedStaticByteFieldAccessorImpl(field, isReadOnly);
  40.                 } else if (type == Short.TYPE) {
  41.                     return new UnsafeQualifiedStaticShortFieldAccessorImpl(field, isReadOnly);
  42.                 } else if (type == Character.TYPE) {
  43.                     return new UnsafeQualifiedStaticCharacterFieldAccessorImpl(field, isReadOnly);
  44.                 } else if (type == Integer.TYPE) {
  45.                     return new UnsafeQualifiedStaticIntegerFieldAccessorImpl(field, isReadOnly);
  46.                 } else if (type == Long.TYPE) {
  47.                     return new UnsafeQualifiedStaticLongFieldAccessorImpl(field, isReadOnly);
  48.                 } else if (type == Float.TYPE) {
  49.                     return new UnsafeQualifiedStaticFloatFieldAccessorImpl(field, isReadOnly);
  50.                 } else if (type == Double.TYPE) {
  51.                     return new UnsafeQualifiedStaticDoubleFieldAccessorImpl(field, isReadOnly);
  52.                 } else {
  53.                     return new UnsafeQualifiedStaticObjectFieldAccessorImpl(field, isReadOnly);
  54.                 }
  55.             }
  56.         } else {
  57.             if (!isQualified) {
  58.                 if (type == Boolean.TYPE) {
  59.                     return new UnsafeBooleanFieldAccessorImpl(field);
  60.                 } else if (type == Byte.TYPE) {
  61.                     return new UnsafeByteFieldAccessorImpl(field);
  62.                 } else if (type == Short.TYPE) {
  63.                     return new UnsafeShortFieldAccessorImpl(field);
  64.                 } else if (type == Character.TYPE) {
  65.                     return new UnsafeCharacterFieldAccessorImpl(field);
  66.                 } else if (type == Integer.TYPE) {
  67.                     return new UnsafeIntegerFieldAccessorImpl(field);
  68.                 } else if (type == Long.TYPE) {
  69.                     return new UnsafeLongFieldAccessorImpl(field);
  70.                 } else if (type == Float.TYPE) {
  71.                     return new UnsafeFloatFieldAccessorImpl(field);
  72.                 } else if (type == Double.TYPE) {
  73.                     return new UnsafeDoubleFieldAccessorImpl(field);
  74.                 } else {
  75.                     return new UnsafeObjectFieldAccessorImpl(field);
  76.                 }
  77.             } else {
  78.                 if (type == Boolean.TYPE) {
  79.                     return new UnsafeQualifiedBooleanFieldAccessorImpl(field, isReadOnly);
  80.                 } else if (type == Byte.TYPE) {
  81.                     return new UnsafeQualifiedByteFieldAccessorImpl(field, isReadOnly);
  82.                 } else if (type == Short.TYPE) {
  83.                     return new UnsafeQualifiedShortFieldAccessorImpl(field, isReadOnly);
  84.                 } else if (type == Character.TYPE) {
  85.                     return new UnsafeQualifiedCharacterFieldAccessorImpl(field, isReadOnly);
  86.                 } else if (type == Integer.TYPE) {
  87.                     return new UnsafeQualifiedIntegerFieldAccessorImpl(field, isReadOnly);
  88.                 } else if (type == Long.TYPE) {
  89.                     return new UnsafeQualifiedLongFieldAccessorImpl(field, isReadOnly);
  90.                 } else if (type == Float.TYPE) {
  91.                     return new UnsafeQualifiedFloatFieldAccessorImpl(field, isReadOnly);
  92.                 } else if (type == Double.TYPE) {
  93.                     return new UnsafeQualifiedDoubleFieldAccessorImpl(field, isReadOnly);
  94.                 } else {
  95.                     return new UnsafeQualifiedObjectFieldAccessorImpl(field, isReadOnly);
  96.                 }
  97.             }
  98.         }
  99.     }
  100. }

这里注意一下属性修饰符的判断：

  • isStatic：静态属性，也就是static关键字修饰的属性。
  • isFinal：final关键字修饰的属性。
  • isVolatile：valatile关键字修饰的属性。
  • isQualified：valatile关键字或者final关键字修饰的属性。
  • isReadOnly：是否只读属性，final关键字修饰的属性或者static关键字修饰并且不能覆盖(override = false)的属性。

通过上面修饰符做判断，得到最终的FieldAccessor实现。这里挑一个例子进行分析，例如一个普通非静态没有volatile和final关键字修饰属性最终就会得到UnsafeObjectFieldAccessorImpl的实例：

  1. class UnsafeObjectFieldAccessorImpl extends UnsafeFieldAccessorImpl {
  2.     UnsafeObjectFieldAccessorImpl(Field field) {
  3.         super(field);
  4.     }
  6.     public Object get(Object obj) throws IllegalArgumentException {
  7.         ensureObj(obj);
  8.         return unsafe.getObject(obj, fieldOffset);
  9.     }
  11.     public void set(Object obj, Object value)
  12.         throws IllegalArgumentException, IllegalAccessException{
  13.         ensureObj(obj);
  14.         if (isFinal) {
  15.             throwFinalFieldIllegalAccessException(value);
  16.         }
  17.         if (value != null) {
  18.             if (!field.getType().isAssignableFrom(value.getClass())) {
  19.                 throwSetIllegalArgumentException(value);
  20.             }
  21.         }
  22.         unsafe.putObject(obj, fieldOffset, value);
  23.     }  
  25.     public boolean getBoolean(Object obj) throws IllegalArgumentException {
  26.         throw newGetBooleanIllegalArgumentException();
  27.     }
  29.     public byte getByte(Object obj) throws IllegalArgumentException {
  30.         throw newGetByteIllegalArgumentException();
  31.     }     
  33.     // 省略其他直接抛出异常的方法
  34. }

可见UnsafeObjectFieldAccessorImpl中除了get(Object obj)和set(Object obj, Object value)方法，其他方法都是直接抛出IllegalArgumentException。而get(Object obj)和set(Object obj, Object value)底层分别依赖于jdk.internal.misc.Unsafe的putObject(obj, fieldOffset, value)和getObject(obj, fieldOffset)方法。而属性的内存偏移地址是在UnsafeObjectFieldAccessorImpl的父类UnsafeFieldAccessorImpl的构造函数中计算出来的：

  1. abstract class UnsafeFieldAccessorImpl extends FieldAccessorImpl {
  2.     static final Unsafe unsafe = Unsafe.getUnsafe();
  4.     protected final Field   field;
  5.     protected final long    fieldOffset;
  6.     protected final boolean isFinal;
  8.     UnsafeFieldAccessorImpl(Field field) {
  9.         this.field = field;
  10.         if (Modifier.isStatic(field.getModifiers()))
  11.             fieldOffset = unsafe.staticFieldOffset(field);
  12.         else
  13.             fieldOffset = unsafe.objectFieldOffset(field);
  14.         isFinal = Modifier.isFinal(field.getModifiers());
  15.     }
  16.     // 省略其他方法
  17. }

这里可以做个小结，属性反射操作Field的setXX和getXX方法最终委托到jdk.internal.misc.Unsafe的putXX和getXX方法，而属性的内存偏移地址是通过jdk.internal.misc.Unsafe的staticFieldBase()、staticFieldOffset和objectFieldOffset几个方法计算的。

处理构造器调用的底层实现

Constructor#newInstance()方法调用依赖到ConstructorAccessor：

  1.     public T newInstance(Object ... initargs)
  2.         throws InstantiationException, IllegalAccessException,
  3.                IllegalArgumentException, InvocationTargetException
  4.     {
  5.         if (!override) {
  6.             Class<?> caller = Reflection.getCallerClass();
  7.             checkAccess(caller, clazz, clazz, modifiers);
  8.         }
  9.         if ((clazz.getModifiers() & Modifier.ENUM) != 0)
  10.             throw new IllegalArgumentException("Cannot reflectively create enum objects");
  11.         ConstructorAccessor ca = constructorAccessor;   // read volatile
  12.         if (ca == null) {
  13.             ca = acquireConstructorAccessor();
  14.         }
  15.         @SuppressWarnings("unchecked")
  16.         T inst = (T) ca.newInstance(initargs);
  17.         return inst;
  18.     }
  20. // ConstructorAccessor接口
  21. public interface ConstructorAccessor {
  22.     /** Matches specification in {@link java.lang.reflect.Constructor} */
  23.     public Object newInstance(Object[] args)
  24.         throws InstantiationException,
  25.                IllegalArgumentException,
  26.                InvocationTargetException;
  27. }

而获取ConstructorAccessor实例也是通过反射工厂类ReflectionFactory，具体是ReflectionFactory#newConstructorAccessor：

  1.     public ConstructorAccessor newConstructorAccessor(Constructor<?> c) {
  2.         checkInitted();
  3.         Class<?> declaringClass = c.getDeclaringClass();
  4.         // 抽象方法会进入此if分支
  5.         if (Modifier.isAbstract(declaringClass.getModifiers())) {
  6.             return new InstantiationExceptionConstructorAccessorImpl(null);
  7.         }
  8.         // 宿主类直接是Class类型，则无法实例化
  9.         if (declaringClass == Class.class) {
  10.             return new InstantiationExceptionConstructorAccessorImpl
  11.                 ("Can not instantiate java.lang.Class");
  12.         }
  14.         // use the root Constructor that will not cache caller class
  15.         Constructor<?> root = langReflectAccess.getRoot(c);
  16.         if (root != null) {
  17.             c = root;
  18.         }
  20.         // 当前声明构造的宿主类是ConstructorAccessorImpl的子类
  21.         if (Reflection.isSubclassOf(declaringClass,
  22.                                     ConstructorAccessorImpl.class)) {
  23.             return new BootstrapConstructorAccessorImpl(c);
  24.         }
  25.         //
  26.         if (noInflation && !ReflectUtil.isVMAnonymousClass(c.getDeclaringClass())) {
  27.             return new MethodAccessorGenerator().
  28.                 generateConstructor(c.getDeclaringClass(),
  29.                                     c.getParameterTypes(),
  30.                                     c.getExceptionTypes(),
  31.                                     c.getModifiers());
  32.         } else {
  33.             NativeConstructorAccessorImpl acc =
  34.                 new NativeConstructorAccessorImpl(c);
  35.             DelegatingConstructorAccessorImpl res =
  36.                 new DelegatingConstructorAccessorImpl(acc);
  37.             acc.setParent(res);
  38.             return res;
  39.         }
  40.     }

可见最终得到的ConstructorAccessor实例为DelegatingConstructorAccessorImpl，而DelegatingConstructorAccessorImpl只是一个委托实现，底层是调用NativeConstructorAccessorImpl：

  1. class NativeConstructorAccessorImpl extends ConstructorAccessorImpl {
  2.     private final Constructor<?> c;
  3.     private DelegatingConstructorAccessorImpl parent;
  4.     private int numInvocations;
  6.     NativeConstructorAccessorImpl(Constructor<?> c) {
  7.         this.c = c;
  8.     }
  10.     public Object newInstance(Object[] args)
  11.         throws InstantiationException,
  12.                IllegalArgumentException,
  13.                InvocationTargetException
  14.     {
  15.         // We can't inflate a constructor belonging to a vm-anonymous class
  16.         // because that kind of class can't be referred to by name, hence can't
  17.         // be found from the generated bytecode.
  18.         if (++numInvocations > ReflectionFactory.inflationThreshold()
  19.                 && !ReflectUtil.isVMAnonymousClass(c.getDeclaringClass())) {
  20.             ConstructorAccessorImpl acc = (ConstructorAccessorImpl)
  21.                 new MethodAccessorGenerator().
  22.                     generateConstructor(c.getDeclaringClass(),
  23.                                         c.getParameterTypes(),
  24.                                         c.getExceptionTypes(),
  25.                                         c.getModifiers());
  26.             parent.setDelegate(acc);
  27.         }
  29.         return newInstance0(c, args);
  30.     }
  32.     void setParent(DelegatingConstructorAccessorImpl parent) {
  33.         this.parent = parent;
  34.     }
  35.     // 这个就是最终构造实例化对象的native方法
  36.     private static native Object newInstance0(Constructor<?> c, Object[] args)
  37.         throws InstantiationException,
  38.                IllegalArgumentException,
  39.                InvocationTargetException;
  40. }

NativeConstructorAccessorImpl#newInstance0()就是最终构造实例化对象的Native方法。当然有例外的情况，例如非正常调用下，如果构造器的宿主类是一个抽象类，那么最终会返回一个InstantiationExceptionConstructorAccessorImpl实例，里面直接抛出InstantiationException异常。

处理方法调用的底层实现

Method#invoke()调用依赖于MethodAccessor：

  1. // MethodAccessor接口
  2. public interface MethodAccessor {
  3.     /** Matches specification in {@link java.lang.reflect.Method} */
  4.     public Object invoke(Object obj, Object[] args)
  5.         throws IllegalArgumentException, InvocationTargetException;
  6. }
  8.     public Object invoke(Object obj, Object... args)
  9.         throws IllegalAccessException, IllegalArgumentException,
  10.            InvocationTargetException{
  11.         if (!override) {
  12.             Class<?> caller = Reflection.getCallerClass();
  13.             checkAccess(caller, clazz,
  14.                         Modifier.isStatic(modifiers) ? null : obj.getClass(),
  15.                         modifiers);
  16.         }
  17.         MethodAccessor ma = methodAccessor;             // read volatile
  18.         if (ma == null) {
  19.             ma = acquireMethodAccessor();
  20.         }
  21.         return ma.invoke(obj, args);
  22.     }

获取MethodAccessor实例的逻辑和前两节类似，是通过ReflectionFactory#newMethodAccessor()：

  1.     public MethodAccessor newMethodAccessor(Method method) {
  2.         checkInitted();
  4.         if (Reflection.isCallerSensitive(method)) {
  5.             Method altMethod = findMethodForReflection(method);
  6.             if (altMethod != null) {
  7.                 method = altMethod;
  8.             }
  9.         }
  11.         // use the root Method that will not cache caller class
  12.         Method root = langReflectAccess.getRoot(method);
  13.         if (root != null) {
  14.             method = root;
  15.         }
  17.         if (noInflation && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
  18.             return new MethodAccessorGenerator().
  19.                 generateMethod(method.getDeclaringClass(),
  20.                                method.getName(),
  21.                                method.getParameterTypes(),
  22.                                method.getReturnType(),
  23.                                method.getExceptionTypes(),
  24.                                method.getModifiers());
  25.         } else {
  26.             NativeMethodAccessorImpl acc =
  27.                 new NativeMethodAccessorImpl(method);
  28.             DelegatingMethodAccessorImpl res =
  29.                 new DelegatingMethodAccessorImpl(acc);
  30.             acc.setParent(res);
  31.             return res;
  32.         }
  33.     }

最终会委托到NativeMethodAccessorImpl#invoke(Object obj, Object[] args)：

  1. class NativeMethodAccessorImpl extends MethodAccessorImpl {
  2.     private final Method method;
  3.     private DelegatingMethodAccessorImpl parent;
  4.     private int numInvocations;
  6.     NativeMethodAccessorImpl(Method method) {
  7.         this.method = method;
  8.     }
  10.     public Object invoke(Object obj, Object[] args)
  11.         throws IllegalArgumentException, InvocationTargetException
  12.     {
  13.         // We can't inflate methods belonging to vm-anonymous classes because
  14.         // that kind of class can't be referred to by name, hence can't be
  15.         // found from the generated bytecode.
  16.         if (++numInvocations > ReflectionFactory.inflationThreshold()
  17.                 && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
  18.             MethodAccessorImpl acc = (MethodAccessorImpl)
  19.                 new MethodAccessorGenerator().
  20.                     generateMethod(method.getDeclaringClass(),
  21.                                    method.getName(),
  22.                                    method.getParameterTypes(),
  23.                                    method.getReturnType(),
  24.                                    method.getExceptionTypes(),
  25.                                    method.getModifiers());
  26.             parent.setDelegate(acc);
  27.         }
  29.         return invoke0(method, obj, args);
  30.     }
  32.     void setParent(DelegatingMethodAccessorImpl parent) {
  33.         this.parent = parent;
  34.     }
  36.     private static native Object invoke0(Method m, Object obj, Object[] args);
  37. }

而NativeMethodAccessorImpl#invoke0()就是方法调用的最终调用的Native方法。

小结

学习知识过程总是阶梯式上升的，JDK中的类库设计也类似这样，如果提前熟悉Unsafe类的相关方法，其实反射调用的底层实现也能够相对轻易地理解。属性、构造和方法反射调用底层的实现(只考虑正常调用的情况下)如下：

  • 对于属性(Field)：Field#setXX()和Field#getXX()分别对应Unsafe的putXX()和getXX()方法，也就是说完全依赖Unsafe中的Native方法。
  • 对于构造(Constructor)：Constructor#newInstance()底层调用NativeConstructorAccessorImpl#newInstance0()。
  • 对于方法(Method)：Method#invoke()底层调用NativeMethodAccessorImpl#invoke0()

个人博客

(本文完 e-a-20181216 c-1-d)

深入分析Java反射(七)-简述反射调用的底层实现的更多相关文章

  1. 深入分析Java反射(八)-优化反射调用性能

    Java反射的API在JavaSE1.7的时候已经基本完善,但是本文编写的时候使用的是Oracle JDK11,因为JDK11对于sun包下的源码也上传了,可以直接通过IDE查看对应的源码和进行Deb ...

  2. 深入分析Java反射(六)-反射调用异常处理

    前提 Java反射的API在JavaSE1.7的时候已经基本完善,但是本文编写的时候使用的是Oracle JDK11,因为JDK11对于sun包下的源码也上传了,可以直接通过IDE查看对应的源码和进行 ...

  3. Java反射机制demo（七）—反射机制与工厂模式

    Java反射机制demo(七)—反射机制与工厂模式 工厂模式 简介 工厂模式是最常用的实例化对象模式. 工厂模式的主要作用就是使用工厂方法代替new操作. 为什么要使用工厂模式?直接new不好吗? 直 ...

  4. 深入分析Java反射(五)-类实例化和类加载

    前提 其实在前面写过的<深入分析Java反射(一)-核心类库和方法>已经介绍过通过类名或者java.lang.Class实例去实例化一个对象,在<浅析Java中的资源加载>中也 ...

  5. 深入分析Java反射(四)-动态代理

    动态代理的简介 Java动态代理机制的出现,使得Java开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类.代理类会负责将所有的方法调用分派到委托对象上反射执行,在分 ...

  6. 反射工具类.提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class,被AOP过的真实类等工具函数.java

    import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.Validate; import org.ap ...

  7. Java基础：（七）反射

    一.什么是反射 理解反射之前,先要搞懂一件事情,类加载到底是怎么一回事? 类加载相当于Class对象的加载.每个类都有一个Class对象,包含了与类有关的信息.当编译一个新类时,会产生一个同名的.cl ...

  8. Java反射学习-4 - 反射调用方法

    反射调用方法: package cn.tx.reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Method ...

  9. 深入分析Java反射(一)-核心类库和方法

    前提 Java反射的API在JavaSE1.7的时候已经基本完善,但是本文编写的时候使用的是Oracle JDK11,因为JDK11对于sun包下的源码也上传了,可以直接通过IDE查看对应的源码和进行 ...

随机推荐

  1. Vulkan Device Memory

    1.通过下面的接口,可以获得显卡支持的所有内存类型: MemoryType的类型如下: 2.引用索引3对内存的描述 我们可以通过调用vkGetPhysicalDeviceMemoryPropertie ...

  2. sqlserver插入图片数据

    -- 插入 insert into [CHOLPOR].[dbo].[t_image](id, name) select '1', BulkColumn from openrowset(bulk N' ...

  3. 026-PHP常用字符串函数(三)

    <?php //颠倒字串 print("abcdefg 颠倒 "); print(strrev("abcdefg")."<hr>&q ...

  4. 黑马oracle_day01：02.oracle的基本操作

    01.oracle体系结构 02.oracle的基本操作 03.oracle的查询 04.oracle对象 05.oracle编程 02.oracle的基本操作 PLSQL中文乱码问题解决1.查看服务 ...

  5. h5页面列表滚动加载数据

    h5列表滚动加载数据很常见,以下分享下今天做的案例: 前言 这个效果实现需要知道三个参数 1. scrollTop -- 滚动条距离顶部的高度 2. scrollHeight -- 当前页面的总高度( ...

  6. IT日常技能：VMware网络配置

    1.0 基本概念 集线器:把一流量为M的端口分为N个端口,每个端口流量为M/N 交换机:把一流量为M的端口分为N个端口,每个端口流量仍为M 路由器:相当于两块网卡,一块连接外网并负责NAT, 另一块负 ...

  7. UVA - 1151 Buy or Build （买还是建）（并查集+二进制枚举子集）

    题意:平面上有n个点(1<=n<=1000),你的任务是让所有n个点连通.可以新建边,费用等于两端点欧几里德距离的平方.也可以购买套餐(套餐中的点全部连通).问最小费用. 分析: 1.先将 ...

  8. UVA - 12716 GCD XOR（GCD等于XOR）（数论）

    题意:输入整数n(1<=n<=30000000),有多少对整数(a, b)满足:1<=b<=a<=n,且gcd(a,b)=a XOR b. 分析:因为c是a的约数,所以枚 ...

  9. Vulkan SDK之 CommandBuff

    Basic Command Buffer Operation 调用指定的api, 驱动将命令放入指定的buff当中. 在其他图形API(dx,or opengl) ,glsetlinewidth驱动会 ...

  10. C语言-字符类型

    C语言-字符类型 char不仅是一种整数,也是一种特殊的类型:字符(character). 常用单引号表示字符的字面量,如'a', '1'. 单引号''也是一个字符,printf和scanf里用的%c ...