Class类源码解析：一文给你搞定Class类！（非常详细）从零基础到精通，收藏这篇就够了-CSDN博客

本文链接：https://blog.csdn.net/Python_0011/article/details/147926587

谁说源码就得照本宣科？在网络安全的世界里，一切皆有可能被利用。Class类，这个Java反射的基石，你真的吃透了吗？别再人云亦云，听听我的另类解读！

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

Class，一个看似普通的类，实则暗藏玄机。它不只是个“类”，更像一把钥匙，一把解锁Java运行时类型信息的万能钥匙。Serializable？GenericDeclaration？Type？AnnotatedElement？每一个接口都暗示着Class类在类型系统、泛型、注解等方面的核心地位。但别忘了，能力越大，责任越大，也意味着潜在的安全风险越高！

Class != class？傻傻分不清楚？

Class类，它不是你敲代码时用的class关键字！这俩压根不是一回事儿。class是语法糖，编译后变成.class文件，而Class类，则是JVM在运行时对这些.class文件的抽象，是类型信息的载体。

构造器的秘密： Class类没有公开的构造函数，只有私有的。这说明啥？说明你不能随随便便new一个Class对象出来。Class对象的创建权，牢牢掌握在JVM手中！想想，如果能随意伪造Class对象，那反射机制还不得乱套？

java // 别想了，这行代码编译都过不去！ // Class<?> fakeClass = new Class<?>();

虚拟机在类加载时自动构造Class对象？没错，但你有没有想过，这个过程本身是否安全？如果类加载器被恶意篡改，加载了不该加载的类，后果不堪设想！

//防止生成默认的构造函数 private Class(ClassLoader loader) { // Initialize final field for classLoader. The initialization value of non-null // prevents future JIT optimizations from assuming this final field is null. classLoader = loader; }

独一无二的Class对象： 每个class定义的类，在JVM里只有一个对应的Class对象。这就像人的指纹，唯一标识一个类型。实例对象和Class对象是多对一的关系，无论创建多少个实例，都指向同一个Class对象。
Class对象的用途？ 提供运行时类型信息？没错，但这只是表象。更深层的意义在于，它为反射提供了基础。通过Class对象，我们可以动态地获取类的信息、调用方法、修改字段，甚至创建新的实例。这既是强大的武器，也是潜在的漏洞！

Class文件：JVM的“圣经”？

JVM只认class文件？没错，但你有没有想过，如果class文件本身就被篡改了呢？

class文件，是JVM的“输入”，不论你用Java、Kotlin、Groovy，最终都要编译成class文件才能跑起来。一个class文件对应一个Class对象，这没毛病。但是，类或接口不一定非得有对应的磁盘文件。为啥？因为你可以用类加载器直接在内存里“捏造”一个类出来！这种动态性，在某些场景下是福音，但在另一些场景下，可能就是灾难。

格式？那是给编译器看的！

class文件格式，说白了就是一堆二进制流，按严格的顺序排列。什么u1、u2、u4、u8，无符号数，表... 看起来很规范，但别忘了，这些都是给编译器和JVM看的。作为安全人员，我们更应该关注的是：这些数据是否可信？是否被恶意篡改？

无符号数： 描述数字、索引、数量... 听起来很安全？错！如果这些数字被篡改，指向了错误的内存地址，或者改变了数组的长度，会发生什么？缓冲区溢出？内存泄露？一切皆有可能！
表：描述层次关系？没错，但如果表的结构被恶意修改，指向了错误的类或方法，会发生什么？非法访问？权限绕过？细思极恐！

Class文件格式

从类加载到Class对象：一次危险的旅程

类的加载、验证、准备、解析、初始化... 这一系列过程，每一步都可能存在安全风险。

Class对象是类模板？没错，但这个“模板”是否可信？如果Class对象本身就被篡改了，那通过它创建的实例对象，还能保证安全吗？反射？反向控制实例对象？听起来很酷，但如果反射被滥用，恶意代码就可以绕过访问控制，为所欲为！

反射：潘多拉的魔盒

反射，Java最强大的特性之一，也是最危险的特性之一。

java.lang.reflect.Method：代表类的方法？没错，但如果Method对象被篡改，指向了私有方法或者系统关键方法，会发生什么？权限提升？代码注入？
java.lang.reflect.Field：代表类的成员变量？没错，但如果Field对象被篡改，修改了final变量或者系统关键变量，会发生什么？系统崩溃？数据泄露？
java.lang.reflect.Constructor：代表类的构造器？没错，但如果Constructor对象被篡改，创建了不该创建的实例，会发生什么？资源耗尽？拒绝服务？
java.lang.Class：代表一个类？没错，但如果Class对象本身就是假的，那反射还有意义吗？

创建Class对象的三种方式？每一种都暗藏杀机！

运行时类.class：看似安全？错！如果运行时类本身就被替换了呢？
java Class c = Student.class; // String.class？还是EvilStudent.class？
对象.getClass()：看似可靠？错！如果对象是恶意构造的呢？
java Student s = new Student(); // 还是EvilStudent？ Class c = s.getClass();
Class.forName()：最常用的方式？也最危险！
java Class<?> c = Class.forName("com.carl.test.classObject.TestClass"); // 确定加载的是你想要的类吗？

Class.forName()？别掉以轻心！Class.forName("EvilClass")，一句代码，就能让你的系统万劫不复！

Class类的常用方法？每一个都值得深挖！

`toString()`：看似无害，实则暴露信息？

toString()返回类的字符串表示？没错，但如果恶意代码通过toString()获取了类的全限定名，就能进一步进行反射攻击！

public String toString() { return (isInterface() ? "interface " : (isPrimitive() ? "" : "class ")) + getName(); }

`toGenericString()`：更详细的信息，更大的风险！

toGenericString()返回更详细的类信息，包括修饰符和泛型参数？没错，但暴露的信息越多，攻击面就越大！

`forName()`：类加载的入口，也是攻击的突破口！

forName(String className)？这是类加载的入口，也是最容易被攻击的地方！

@CallerSensitive public static Class<?> forName(String className) throws ClassNotFoundException { //获取类加载器，来加载驱动 Class<?> caller = Reflection.getCallerClass(); //forName0方法参数说明：类的全路径名、加载后是否初始化该类、使用哪个类加载器、调用forName方法的类 return forName0(className, true, ClassLoader.getClassLoader(caller), caller); } private static native Class<?> forName0(String name, boolean initialize, ClassLoader loader, Class<?> caller) throws ClassNotFoundException;

初始化？不初始化？看似简单的参数，实际上控制着类的生命周期。如果恶意代码利用forName()加载但不初始化某个类，就可以绕过某些安全检查，为后续攻击埋下伏笔！

`newInstance()`：创建实例？还是制造麻烦？

newInstance()？通过空参构造器创建实例？没错，但如果空参构造器被恶意修改，或者根本就不存在，会发生什么？InstantiationException？IllegalAccessException？这些异常本身，也可能被利用来探测系统信息！

@CallerSensitive 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. // 构造函数查找 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 = {}; //调用getConstructor0方法，Member.DECLARED表示当前类或接口已声明的方法集合 //这里是抛出NoSuchMethodException的位置，如果找不到空参构造则会抛出异常 final Constructor<T> c = getConstructor0(empty, Member.DECLARED); //不支持访问构造函数检查，必须在这里进行安全检查 java.security.AccessController.doPrivileged( new java.security.PrivilegedAction<Void>() { public Void run() { //检查当前构造函数是否可访问后，设置访问标志 //true为可访问，不需要执行访问检查 //false为不可访问，需要强制执行访问检查 //这里是抛出SecurityException异常的位置 c.setAccessible(true); return null; } }); cachedConstructor = c; } catch (NoSuchMethodException e) { //捕获NoSuchMethodException并抛出InstantiationException异常 throw (InstantiationException) new InstantiationException(getName()).initCause(e); } } Constructor<T> tmpConstructor = cachedConstructor; // 安全检查 //获取权限修饰符 //public=0x00000001 private=0x00000002 protected=0x00000004 int modifiers = tmpConstructor.getModifiers(); //快速检查成员访问权限 //检查当前实例化的类和构造函数是否为public权限，如果不是public，则进入，是public则跳过 if (!Reflection.quickCheckMemberAccess(this, modifiers)) { //获取当前类的反射调用 Class<?> caller = Reflection.getCallerClass(); //如果当前创建的实例和反射调用的类不一样 if (newInstanceCallerCache != caller) { //就会去检查反射调用的类的空参构造函数的访问权限是否是public //这里是抛出IllegalAccessException的位置，确认不可访问，则会抛出异常 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; } }