java反射与注解（二）：Constructor类理解

dodo_lihao

发布于 2018-09-12 10:37:27

6420

发布于 2018-09-12 10:37:27

Constructor类理解

这里Constructor，我们知道是构造函数为什么是数组形式的呢？因为可能有多个构造这个时候，我们写一个DummyClass2，这里有2个构造其他和前面一个Bean类似，有setter，getter，toString方法这个时候，我们分别打印一下DummyClass和 DummyClass2 的 Constructor

具体打印工具方法

private static void printConstructor(Constructor<?>[] cons){
    for(int i=0; i<cons.length; i++){
        System.out.println(cons[i]);
    }
}

具体打印方法

private void getAndPrintConstructors(Class cls){
    Class<?> c1 = cls;
    Constructor<?>[] cons= c1.getConstructors();
    DUtils.printConstructor(cons);
}

具体简单调用

DoConstructor doClass = new DoConstructor();
doClass.getAndPrintConstructors(DummyClass.class);
doClass.getAndPrintConstructors(DummyClass2.class);

具体我们可以看见结果

public com.aohuan.dodo.javacode.reflect.utils.DummyClass()
- - -
public com.aohuan.dodo.javacode.reflect.utils.DummyClass2(java.lang.String)
public com.aohuan.dodo.javacode.reflect.utils.DummyClass2(java.lang.String,int)

也就是，对象可以得到这个Class中，所有的构造方法对应的构造方法，会通过数组返回如果我们需要知道一个类中，有哪些构造方法，就可以这样去做了当然，得到构造，也就是为了创建实例，我们下面再一起回顾newInstance()方法

newInstance()方法，深入

我们先看一下源码

public T newInstance()
    throws InstantiationException, IllegalAccessException
{
    if (System.getSecurityManager() != null) {
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
    }

    // NOTE: the following code may not be strictly correct under
    // the current Java memory model.

    // Constructor lookup
    if (cachedConstructor == null) {
        if (this == Class.class) {
            throw new IllegalAccessException(
                "Can not call newInstance() on the Class for java.lang.Class"
            );
        }
        try {
            Class<?>[] empty = {};
            final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
            // Disable accessibility checks on the constructor
            // since we have to do the security check here anyway
            // (the stack depth is wrong for the Constructor's
            // security check to work)
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction<Void>() {
                    public Void run() {
                            c.setAccessible(true);
                            return null;
                        }
                    });
            cachedConstructor = c;
        } catch (NoSuchMethodException e) {
            throw new InstantiationException(getName());
        }
    }
    Constructor<T> tmpConstructor = cachedConstructor;
    // Security check (same as in java.lang.reflect.Constructor)
    int modifiers = tmpConstructor.getModifiers();
    if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
        Class<?> caller = Reflection.getCallerClass();
        if (newInstanceCallerCache != caller) {
            Reflection.ensureMemberAccess(caller, this, null, modifiers);
            newInstanceCallerCache = caller;
        }
    }
    // Run constructor
    try {
        return tmpConstructor.newInstance((Object[])null);
    } catch (InvocationTargetException e) {
        Unsafe.getUnsafe().throwException(e.getTargetException());
        // Not reached
        return null;
    }
}

前面的判断权限，判断调用不在对应的Class类型中也就是 throw new IllegalAccessException( "Can not call newInstance() on the Class for java.lang.Class"); 异常等问题的处理，我们略

下面通过getConstructor0(empty, Member.DECLARED); 获得一个 Constructor<T>，在执行方法（执行的方法，我们后面几节会提到）这里对应的getConstructor0方法

private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
                                    int which) throws NoSuchMethodException
{
    Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
    for (Constructor<T> constructor : constructors) {
        if (arrayContentsEq(parameterTypes,
                            constructor.getParameterTypes())) {
            return getReflectionFactory().copyConstructor(constructor);
        }
    }
    throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
}

这里大致 Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC)); 先获得Constructor数组（这里which传入的是Member.DECLARED，所以为false）这样就会拿到所有的构造，包括非public的再会 arrayContentsEq(parameterTypes,constructor.getParameterTypes()) for each循环去判断

private static boolean arrayContentsEq(Object[] a1, Object[] a2) {
    if (a1 == null) {
        return a2 == null || a2.length == 0;
    }

    if (a2 == null) {
        return a1.length == 0;
    }

    if (a1.length != a2.length) {
        return false;
    }

    for (int i = 0; i < a1.length; i++) {
        if (a1[i] != a2[i]) {
            return false;
        }
    }

    return true;
}

这里大体的判断逻辑我们外面对应的Class<?>[] empty = {}; 所以，走第一个 return a2 == null || a2.length == 0; 我们没有对应的构造（默认的构造，应该是后面的逻辑添加进去的，不会影响这里的逻辑）这样，我们可以知道，当我们不写构造的时候，会触发创建对象并且返回 tmpConstructor.newInstance((Object[])null);* 也就是默认调用参数为null的构造

换句话说， Class的newInstance，其实是调用的Constructor.newInstance((Object[])null);

修改构造，测试 这个时候，我们调用 DummyClass2 的 newInstance() 试试（因为 DummyClass2 有2个构造方法，而对应的Class的newInstance如果参数判断通过的前提下，传入的也是空的构造，这样肯定会报错）

我们运行测试

/**
 *  我们调用Class的getConstructor的 newInstance((Object[])null);
 *  具体的结果，我们可以看见，和前面DoClass类的newInstance方法结果一样
 * @throws IllegalAccessException
 * @throws InstantiationException
 * @throws NoSuchMethodException
 * @throws InvocationTargetException
 */
private void doConstructorNewInstance1() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    Class<?> c1 = DummyClass.class;
    DUtils.println(c1.getConstructor().newInstance((Object[])null).toString());
}

我们调用Class的getConstructor的 newInstance((Object[])null); 具体的结果， DummyClass{age=0, name='null'} 我们可以看见，和前面DoClass类的newInstance方法结果一样

再看看调用DummyClass2的构造方法

/**
 *  我们调用Class的getConstructor的 newInstance("dodo");
 *      会报错，因为源码中，只有没有写构造的时候，才会按上面的流程走
 * @throws IllegalAccessException
 * @throws InstantiationException
 * @throws NoSuchMethodException
 * @throws InvocationTargetException
 */
private void doConstructorNewInstance2E() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    Class<?> c2 = DummyClass2.class;
    DUtils.println(c2.getConstructor().newInstance("dodo").toString());
}

对应的结果，是

Exception in thread "main" java.lang.NoSuchMethodException: com.aohuan.dodo.javacode.reflect.utils.DummyClass2.<init>()
    at java.lang.Class.getConstructor0(Class.java:2971)
    at java.lang.Class.getConstructor(Class.java:1812)
    at com.aohuan.dodo.javacode.reflect.sample1.DoConstructor.doConstructorNewInstance2E(DoConstructor.java:61)
    at com.aohuan.dodo.javacode.reflect.sample1.DoConstructor.main(DoConstructor.java:23)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:483)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)

可以发现，对应的逻辑是正确的那如果构造中，有多个参数怎么办？我们试试newInstance方法后面，带下参数？发现，Class就只有newInstance()这一个创建对象的方法 ....

那我们回想下前面提到的Constructor类

Constructor 类 newInstance()

那我们尝试一下对应的 Constructor类调用2个构造的方法试试

/**
 *  DummyClass2 有2个自己的带参数的构造
 *  如果通过getConstructors得到构造的数组，在调用对应的构造，传入参数即可
 * @throws IllegalAccessException
 * @throws InstantiationException
 */
private void doConstructorNewInstance2R1() throws IllegalAccessException, InstantiationException, InvocationTargetException {
    Class<DummyClass2> c2 = DummyClass2.class;
    DUtils.println(c2.getConstructors()[1].newInstance("dodo", 23).toString());
}

这个时候，我们可以打印对应的bean2 结果为： DummyClass{age=23, name='dodo'}

这个时候，我们知道我们有2个构造同理，我们可以 c2.getConstructors()[0].newInstance("dodo").toString(); 拿到index为0的Constructor构造类，打印也可以得到结果 DummyClass{age=0, name='dodo'} 这里age是一般数据类型，不赋值，结果为0

具体Constructor 类的 public T newInstance(Object ... initargs) 我们就不继续跟了因为依赖的 ConstructorAccessor 类，和今天讨论的主题有点远了再加上没有源码就不继续扯了

其他简单说明

Constructor：

getConstructors() ：获取 public的 Constructor[]（public）
getDeclaredConstructors() ：获取所有的 Constructor[]
getConstructor(parameterTypes) ：根据参数类型（可变参数），获取具体 Constructor（public）
getDeclaredConstructor(parameterTypes)：根据参数类型（可变参数），获取具体 Constructor

这里

getConstructors()方法
- 是获取 public的构造函数数组
getDeclaredConstructors()方法
- 是获取所有的构造函数数组
getConstructor(parameterTypes) 方法
- 是根据参数类型（可以有多个Class<?>的可变参数），
- 获取具体public的 Constructor
getDeclaredConstructor(parameterTypes) 方法，
- 是根据参数类型（可以有多个Class<?>的可变参数），
- 获取具体的 Constructor

简单总结

这里大致了解下 Class的简单使用和大体作用

其他的内容，后续一起学习具体代码，可以见 https://github.com/2954722256/use_little_demo 对应 javacode 的 Module，对应的reflect包

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2016.11.27 ，如有侵权请联系 cloudcommunity@tencent.com 删除

其他

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

其他

登录后参与评论

0 条评论

热度