jdk源码分析——Class类

Posted 2021-04-05 自由水鸟

我们在中讲了Object类，今天要讲的Class类同样非常基础。java程序中所有正在运行中的类和接口都是Class类的实例。枚举类型，数据，所有的java基础类型以及关键字void都是Class实例。
类声明：

public final class Class<T> implements java.io.Serializable,
        java.lang.reflect.GenericDeclaration,
        java.lang.reflect.Type,
        java.lang.reflect.AnnotatedElement

Class类中方法非常多，有超过50个方法，但是经过梳理，我们可以发现，其实方法主要有三类：生成实例、获取类信息、类型转换。

下面我们分别来看一下这三类方法。

二.生成实例

此类方法的主要目的是根据给定的类名，加载类信息并执行初始化。然后可以根据已经完成初始化的信息生成类的实例。
这一类方法主要有两个：
forName方法和newInstance方法。

我们先来看forName方法，这个方法相信大家都不陌生，如果你曾经使用过jdbc进行mysql数据库操作，那么你一定写过如下代码：

String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/test";
String username = "root";
String password = "123456";
Connection conn = null;
try {
    Class.forName(driver);
    conn = DriverManager.getConnection(url, username, password);
} catch (ClassNotFoundException e) {
    e.printStackTrace();
} catch (SQLException e) {
    e.printStackTrace();
}

我们这里只看forName方法。forName方法有两种声明：

public static Class<?> forName(String className)
            throws ClassNotFoundException {
    return forName0(className, true, ClassLoader.getCallerClassLoader());
}

public static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)
            throws ClassNotFoundException {
    // 如果传入的类加载器为null，则获取调用类的类加载器
    if (loader == null) {
        // 获取安全管理器
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            // 获取调用类的类加载器
            ClassLoader ccl = ClassLoader.getCallerClassLoader();
            if (ccl != null) {
                // 使用安全管理器检查是否有获取类加载器的权限
                sm.checkPermission(
                    SecurityConstants.GET_CLASSLOADER_PERMISSION);
            }
        }
    }
    return forName0(name, initialize, loader)
}

从以上代码可以看到，第一个forName方法相当于调用

forName(name, true, null)

最终两个forName方法都调用了forName0方法：

private static native Class forName0(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException;

这是一个本地方法，我们暂且不深究，只需知道forName0方法将根据指定类完全限定名，以及类加载器完成类的加载，如果需要，还将执行类的初始化操作。

在forName方法实现中，出现了两个类，一个是SecurityManager，另一个是ClassLoader，其中SecurityManager是jvm提供的在应用层进行安全检查的机制，应用程序可以根据策略文件被赋予一定的权限，例如是否可以读写文件，是否可以读写网络端口，是否可以读写内存，是否可以获取类加载器……。在进行特殊操作时，需要进行安全检查，从而给程序的运行安全提供一定保障。

而ClassLoader则涉及到另一个大的话题：类加载，此处我们暂时先不深入展开，只需知道我们程序运行中使用的类都需要由类加载器来完成加载，并执行一定的初始化，随后才可以被我们使用。

类完成加载后，通常需要被实例化，而这就会用到newInstance方法了。

// 获取类的实例
public T newInstance()
        throws InstantiationException, IllegalAccessException {
    // 进行安全检查
    if (System.getSecurityManager() != null) {
        checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader(), false);
    }
    return newInstance0();
}

/**
 * 检查客户端是否有成员的访问权限
 * @param which 权限识别码，整数类型
 * @param ccl 类加载器
 * @param checkProxyInterfaces
 */
private void checkMemberAccess(int which, ClassLoader ccl, boolean checkProxyInterfaces) {
    SecurityManager s = System.getSecurityManager();
    if (s != null) {
        // 检查客户端能否有权限访问该类
        s.checkMemberAccess(this, which);
        ClassLoader cl = getClassLoader0();
        if (ReflectUtil.needsPackageAccessCheck(ccl, cl)) {
            // 获取类的完全限定名
            String name = this.getName();
            int i = name.lastIndexOf('.');
            // 类的完全限定名中含有.（例如com.Test）
            if (i != -1) {
                // 获取包名
                String pkg = name.substring(0, i);
                // 如果该类是com.sun.proxy包下的代理类，则不需要进行包访问权限验证，否则需要验证
                // 代理类指使用Proxy.getProxyClass或Proxy.newProxyInstance动态生成的类
                if (!Proxy.isProxyClass(this) || !pkg.equals(ReflectUtil.PROXY_PACKAGE)) {
                    s.checkPackageAccess(pkg);
                }
            }
        }
        // 如果该类是代理类，并且需要检查代理类的接口，则检查接口的访问权限
        if (checkProxyInterfaces && Proxy.isProxyClass(this)) {
            ReflectUtil.checkProxyPackageAccess(ccl, this.getInterfaces());
        }
    }
}

private T newInstance0() throws InstantiationException, IllegalAccessException {
    // 每次先检查是否有已经缓存过的构造器，如果没有，则重新获取
    if (cachedConstructor == null) {
        // 如果该类是Class类，则直接抛出异常，意思是，我们不能利用此方法生成Class类的实例
        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);
            // 此处是为了使无参构造方法可以被访问，因为有时，构造方法被声明为private的
            java.security.AccessController.doPrivileged
                    (new java.security.PrivilegedAction() {
                        public Object run() {
                            c.setAccessible(true);
                            return null;
                        }
                    });
            // 将获取的无参构造方法缓存
            cachedConstructor = c;
        } catch (NoSuchMethodException e) {
            throw new InstantiationException(getName());
        }
    }
    Constructor<T> tmpConstructor = cachedConstructor;
    // 获取构造方法的语言修饰符，诸如public,private,static,final等
    int modifiers = tmpConstructor.getModifiers();
    // 根据已经获取的语言修饰符判断是否具有访问权限，如果没有，则执行以下操作
    if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
        // 获取调用者的类
        Class caller = Reflection.getCallerClass(3);
        // 与之前缓存的调用者类进行对比，如果不是之前的，则需重新确保调用者类可以访问无参构造方法
        if (newInstanceCallerCache != caller) {
            Reflection.ensureMemberAccess(caller, this, null, modifiers);
            newInstanceCallerCache = caller;
        }
    }
    try {
        // 整个方法的核心，使用类的构造方法来生成实例
        return tmpConstructor.newInstance((Object[]) null);
    } catch (InvocationTargetException e) {
        Unsafe.getUnsafe().throwException(e.getTargetException());
        return null;
    }
}

以上就是newInstance的具体实现，本质上是获取的类的无参构造方法，然后执行无参构造方法来生成实例。

三.获取类信息

这一类方法非常多，作用包括获取类的构造方法，已经声明的字段、方法，获取类或者方法的注解，获取类的包名、父类，以及判断类是否是数组、是否是枚举、是否是接口。由于方法众多，此处不一一列举，只选择一个看看究竟，不妨看看getDeclaredMethods方法。

// 返回类中声明的方法，核心实现在privateGetDeclaredMethods和copyMethods中
public Method[] getDeclaredMethods() throws SecurityException {
    checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader(), true);
    return copyMethods(privateGetDeclaredMethods(false));
}

// 拷贝方法数组，使用ReflectionFactory来拷贝
//个人理解之所以需要拷贝是因为不想让获取的方法被随意修改
private static Method[] copyMethods(Method[] arg) {
    Method[] out = new Method[arg.length];
    ReflectionFactory fact = getReflectionFactory();
    for (int i = 0; i < arg.length; i++) {
        out[i] = fact.copyMethod(arg[i]);
    }
    return out;
}

/**
 * 获取类中声明方法的具体实现
 * @param publicOnly 是否只获取public方法
 * @return 方法数组
 */
private Method[] privateGetDeclaredMethods(boolean publicOnly) {
    // 等待系统内部类初始化完成，系统属性(sun.reflect.noCaches)被解析完成
    checkInitted();
    Method[] res = null;
    // 根据用户指定的系统属性sun.reflect.noCaches值来决定是否使用缓存，默认使用缓存
    if (useCaches) {
        // 清空缓存，将缓存的declaredFields、declaredMethods、annotations等设置为null
        clearCachesOnClassRedefinition();
        // 如果只获取public方法
        if (publicOnly) {
            // 如果declaredPublicFields缓存可用，则直接从缓存中获取
            if (declaredPublicMethods != null) {
                res = (Method[]) declaredPublicMethods.get();
            }
        } else {
            // 如果declaredMethods缓存可用，则直接从缓存中获取
            if (declaredMethods != null) {
                res = (Method[]) declaredMethods.get();
            }
        }
        if (res != null) return res;
    }
    // 不使用缓存，则需要调用本地方法进行获取
    res = getDeclaredMethods0(publicOnly);
    // 如果可以使用缓存，则设置缓存，以备下次使用
    if (useCaches) {
        if (publicOnly) {
            declaredPublicMethods = new SoftReference(res);
        } else {
            declaredMethods = new SoftReference(res);
        }
    }
    return res;
}

private native Method[] getDeclaredMethods0(boolean publicOnly);

四.类型转换

该类方法主要有两个：

/**
 * 将类转换为它的子类Class
 * @param clazz 父类的Class
 * @param <U> 父类
 * @return U的子类Class
 */
public <U> Class<? extends U> asSubclass(Class<U> clazz) {
    // 判断clazz是否是当前类，或者是当前类的父类
    if (clazz.isAssignableFrom(this))
        return (Class<? extends U>) this;
    else
        throw new ClassCastException(this.toString());
}

/**
 * 将给定的类转换为当前Class所代表的类
 * @param obj 需要转换的类
 * @return 当前Class所代表的类
 */
public T cast(Object obj) {
    // obj不为null，并且可以被转换为当前Class代表的类
    // isInstance为native方法，类似于instanceOf的作用
    if (obj != null && !isInstance(obj))
        throw new ClassCastException();
    return (T) obj;
}

五.使用示例

class Car {
    private String name = "car";
    public String getName() {
        return name;
    }
}

class SUV extends Car {
    private String name = "suv";

    @Override
    public String getName() {
        return name;
    }
}

class Tiguan extends SUV {
    private String name = "tiguan";

    @Override
    public String getName() {
        return name;
    }
}

public class ClassTest {

    public static void main(String[] args) {
        try {
            // 使用forName方法与newInstance方法生成实例
            Car tiguanCar = (Car) Class.forName("Tiguan").newInstance();
            // 输出"tiguan"
            System.out.println(tiguanCar.getName());
            // 从上面的输出可以看出，tiguanCar是一个Tiguan实例，将其转换为SUV的类
            // 注意，此处只能窄化tiguanCar的范围，本质上仍然是Tiguan.class
            Class<? extends SUV> tiguanClass = tiguanCar.getClass().asSubclass(SUV.class);
            // 输出"class Tiguan"
            System.out.println(tiguanClass);
            // 将tiguanCar转换为SUV实例,tiguanCar是一个Tiguan类的实例，作用与(SUV) tiguanCar一样。
            SUV suv = SUV.class.cast(tiguanCar);
            // 输出"tiguan"
            System.out.println(suv.getName());
            // 获取Tiguan类声明的字段
            Field[] tiguanFields = tiguanClass.getDeclaredFields();
            // 输出"name"
            for (Field field : tiguanFields) {
                System.out.println(field.getName());
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

参考资料

1. java Class类详解

2. Java反射相关类源码浅析-Class类

3. Class.asSubclass浅谈

4. Class.asSubclass signature

5. Java安全管理器——SecurityManager

6. java Class.forName详解

另外本文中结构图使用了ProcessOn免费在线作图工具，感觉很赞，推荐一下。