java反射与注解(二):Constructor类理解


Constructor类理解

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

具体打印工具方法

private static void printConstructor(Constructor[] cons){
    for(int i=0; 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 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() {
                    public Void run() {
                            c.setAccessible(true);
                            return null;
                        }
                    });
            cachedConstructor = c;
        } catch (NoSuchMethodException e) {
            throw new InstantiationException(getName());
        }
    }
    Constructor 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,在执行方法(执行的方法,我们后面几节会提到)
这里对应的getConstructor0方法

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

这里大致
Constructor[] 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.()
    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 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包

你可能感兴趣的:(java反射与注解(二):Constructor类理解)