Java程序设计（高级及专题）- 类的加载和反射(1)

System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());

//下面我们看下获取非我们定义的类,比如System ArrayList 等常用类

System.out.println(System.class.getClassLoader());

System.out.println(ArrayList.class.getClassLoader());

}

}

控制台输出：

sun.misc.Launcher$AppClassLoader@1c78e57

sun.misc.Launcher$AppClassLoader

null

null

分析：

ClassLoaderTest的类加载器的名称是AppClassLoader。也就是这个类是由AppClassLoader这个类加载器加载的。

System/ArrayList的类加载器是null。这说明这个类加载器是由BootStrap加载的。因为我们上面说了BootStrap不是java类，不需要类加载器加载。所以他的类加载器是null。

---

java给我们提供了三种类加载器：BootStrap，ExtClassLoader，AppClassLoader。这三种类加载器是有父子关系组成了一个树形结构。BootStrap是根节点，BootStrap下面挂着ExtClassLoader，ExtClassLoader下面挂着AppClassLoader.

案例：

package study.javaenhance;

import java.util.ArrayList;

public class ClassLoaderTest

{

public static void main(String[] args) throws Exception

{

//获取类加载器,那么这个获取的是一个实例对象,我们知道类加载器也有很多种,那么因此也有其对应的类存在,因此可以获取到对应的字节码

System.out.println(ClassLoaderTest.class.getClassLoader());

//获取类加载的字节码,然后获取到类加载字节码的名字

System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());

//下面我们看下获取非我们定义的类,比如System ArrayList 等常用类

System.out.println(System.class.getClassLoader());

System.out.println(ArrayList.class.getClassLoader());

//演示java 提供的类加载器关系

ClassLoader classloader = ClassLoaderTest.class.getClassLoader();

while(classloader != null)

{

System.out.print(classloader.getClass().getName()+“–>”);

classloader = classloader.getParent();

}

System.out.println(classloader);

}

控制台输出：

sun.misc.Launcher$AppClassLoader-->sun.misc.Launcher$ExtClassLoader–>null

分析：

通过这段程序可以看出来，ClassLoaderTest由AppClassLoader加载，AppClassLoader的父类节点是ExtClassLoader，ExtClassLoader的父节点是BootStrap。

每一个类加载器都有自己的管辖范围。 BootStrap根节点，只负责加载rt.jar里的类，刚刚那个System就是属于rt.jar包里面的，ExtClassLoader负责加载JRE/lib/ext/*.jar这个目录文件夹下的文件。而AppClassLoader负责加载ClassPath目录下的所有jar文件及目录。

最后一级是我们自定义的加载器，他们的父类都是AppClassLoader。

类加载器的双亲委派机制

---

除了系统自带了类加载器，我们还可以自定义类加载器。然后把自己的类加载器挂在树上。作为某个类加载器的孩子。所有自定义类加载器都要继承ClassLoader。实现里面的一个方法ClassLoader（）。

当Java虚拟机要加载第一个类的时候，到底派出哪个类加载器去加载呢？

(1). 首先当前线程的类加载器去加载线程中的第一个类(当前线程的类加载器：Thread类中有一个get/setContextClassLoader(ClassLoader cl);方法，可以获取/指定本线程中的类加载器)

(2). 如果类A中引用了类B,Java虚拟机将使用加载类A的类加载器来加载类B

(3). 还可以直接调用ClassLoader.loadClass(String className)方法来指定某个类加载器去加载某个类

每个类加载器加载类时，又先委托给其上级类加载器当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则会抛出ClassNotFoundException,不是再去找发起者类加载器的儿子，因为没有getChild()方法。例如：如上图所示： MyClassLoader->AppClassLoader->Ext->ClassLoader->BootStrap.自定定义的MyClassLoader1首先会先委托给AppClassLoader,AppClassLoader会委托给ExtClassLoader,ExtClassLoader会委托给BootStrap，这时候BootStrap就去加载，如果加载成功，就结束了。如果加载失败，就交给ExtClassLoader去加载，如果ExtClassLoader加载成功了，就结束了，如果加载失败就交给AppClassLoader加载，如果加载成功，就结束了，如果加载失败，就交给自定义的MyClassLoader1类加载器加载，如果加载失败，就报ClassNotFoundException异常，结束。

这样的好处在哪里呢？可以集中管理，不会出现多份字节码重复的现象。

有两个类要再在System，如果让底层的类加载器加载，可能会出现两份字节码。而都让爷爷加载，爷爷加载到已有，当再有请求过来的时候，爷爷说：哎，我加载过啊，直接把那份拿出来给你用啊。就不会出现多份字节码重复的现象。

自定义类加载器

---

自定义的类加载器必须继承抽象类ClassLoader然后重写findClass方法，其实他内部还有一个loadClass方法和defineClass方法，这两个方法的作用是：

loadClass方法的源代码：

public Class<?> loadClass(String name) throws ClassNotFoundException {

return loadClass(name, false);

}

再来看一下loadClass(name,false)方法的源代码：

protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{

//加上锁，同步处理，因为可能是多线程在加载类

synchronized (getClassLoadingLock(name)) {

//检查，是否该类已经加载过了，如果加载过了，就不加载了

Class c = findLoadedClass(name);

if (c == null) {

long t0 = System.nanoTime();

try {

//如果自定义的类加载器的parent不为null,就调用parent的loadClass进行加载类

if (parent != null) {

c = parent.loadClass(name, false);

} else {

//如果自定义的类加载器的parent为null，就调用findBootstrapClass方法查找类，就是Bootstrap类加载器

c = findBootstrapClassOrNull(name);

}

} catch (ClassNotFoundException e) {

// ClassNotFoundException thrown if class not found

// from the non-null parent class loader

}

if (c == null) {

// If still not found, then invoke findClass in order

// to find the class.

long t1 = System.nanoTime();

//如果parent加载类失败，就调用自己的findClass方法进行类加载

c = findClass(name);

// this is the defining class loader; record the stats

sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);

sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

sun.misc.PerfCounter.getFindClasses().increment();

}

}

if (resolve) {

resolveClass©;

}

return c;

}

}

在loadClass代码中也可以看到类加载机制的原理，这里还有这个方法findBootstrapClassOrNull,看一下源代码：

private Class findBootstrapClassOrNull(String name)

{

if (!checkName(name)) return null;

return findBootstrapClass(name);

}

就是检查一下name是否是否正确，然后调用findBootstrapClass方法，但是findBootstrapClass方法是个native本地方法，看不到源代码了，但是可以猜测是用Bootstrap类加载器进行加载类的，这个方法我们也不能重写，因为如果重写了这个方法的话，就会破坏这种委托机制，我们还要自己写一个委托机制。

defineClass这个方法很简单就是将class文件的字节数组编程一个class对象，这个方法肯定不能重写，内部实现是在C/C++代码中实现的findClass这个方法就是根据name来查找到class文件，在loadClass方法中用到，所以我们只能重写这个方法了，只要在这个方法中找到class文件，再将它用defineClass方法返回一个Class对象即可。

这三个方法的执行流程是：每个类加载器：loadClass->findClass->defineClass

Class对象

=====================================================================

java中把生成Class对象和实例对象弄混了，更何况生成Class对象和生成 instance都有多种方式。所以只有弄清其中的原理，才可以深入理解。首先要生成Class对象，然后再生成Instance。那Class对象的生 成方式有哪些呢，以及其中是如何秘密生成的呢？

Class对象的生成方式如下：

1.Class.forName(“类名字符串”) （注意：类名字符串必须是全称，包名+类名）

2.类名.class

3.实例对象.getClass()

例如：

public class TestClass {

public static void main(String[] args)

{

try {

//测试Class.forName()

Class testTypeForName=Class.forName(“TestClassType”);

System.out.println(“testForName—”+testTypeForName);

//测试类名.class

Class testTypeClass=TestClassType.class;

System.out.println(“testTypeClass—”+testTypeClass);

//测试Object.getClass()

TestClassType testGetClass= new TestClassType();

System.out.println(“testGetClass—”+testGetClass.getClass());

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

}

class TestClassType{

//构造函数

public TestClassType(){

System.out.println(“----构造函数—”);

}

//静态的参数初始化

static{

System.out.println(“—静态的参数初始化—”);

}

//非静态的参数初始化

{

System.out.println(“----非静态的参数初始化—”);

}

}

控制台输出如下：

—静态的参数初始化—

testForName—class TestClassType

testTypeClass—class TestClassType

----非静态的参数初始化—

----构造函数—

testGetClass—class TestClassType

根据结果可以发现，三种生成的Class对象一样的。并且三种生成Class对象只打印一次“静态的参数初始化”。

我们知道，静态的方法属性初始化，是在加载类的时候初始化。而非静态方法属性初始化，是new类实例对象的时候加载。

因此，这段程序说明，三种方式生成Class对象，其实只有一个Class对象。在生成Class对象的时候，首先判断内存中是否已经加载。

所以，生成Class对象的过程其实是如此的：

当我们编写一个新的java类时,JVM就会帮我们编译成class对象,存放在同名 的.class文件中。在运行时，当需要生成这个类的对象，JVM就会检查此类是否已经装载内存中。若是没有装载，则把.class文件装入到内存中。若 是装载，则根据class文件生成实例对象。

反射

================================================================

Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的內部信息，并能直接操作任意对象的内部属性及方法。

Java反射机制主要提供了以下功能：

• 在运行时构造任意一个类的对象

• 在运行时获取任意一个类所具有的成员变量和方法

• 在运行时调用任意一个对象的方法（属性）

• 生成动态代理

Class 是一个类;

• 一个描述类的类.

• 封装了描述方法的 Method,

• 描述字段的 Filed,

• 描述构造器的 Constructor 等属性.

例如：描述方法-Method

public class ReflectionTest {

@Test

public void testMethod() throws Exception{

Class clazz = Class.forName(“com.atguigu.java.fanshe.Person”);

//

//1.获取方法

// 1.1 获取取clazz对应类中的所有方法–方法数组（一）

// 不能获取private方法,且获取从父类继承来的所有方法

Method[] methods = clazz.getMethods();

for(Method method:methods){

System.out.print(" "+method.getName());

}

System.out.println();

//

// 1.2.获取所有方法，包括私有方法 --方法数组（二）

// 所有声明的方法，都可以获取到，且只获取当前类的方法

methods = clazz.getDeclaredMethods();

for(Method method:methods){

System.out.print(" "+method.getName());

}

System.out.println();

//

// 1.3.获取指定的方法

// 需要参数名称和参数列表，无参则不需要写

// 对于方法public void setName(String name) { }

Method method = clazz.getDeclaredMethod(“setName”, String.class);

System.out.println(method);

// 而对于方法public void setAge(int age) { }

method = clazz.getDeclaredMethod(“setAge”, Integer.class);

System.out.println(method);

// 这样写是获取不到的，如果方法的参数类型是int型

// 如果方法用于反射，那么要么int类型写成Integer： public void setAge(Integer age) { }

// 要么获取方法的参数写成int.class

//

//2.执行方法

// invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数

Object obje = clazz.newInstance();

method.invoke(obje,2);

//如果一个方法是私有方法，第三步是可以获取到的，但是这一步却不能执行

//私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）;

}

}

主要用到的两个方法:

/**

• @param name the name of the method

• @param parameterTypes the list of parameters

• @return the {@code Method} object that matches the specified

*/

public Method getMethod(String name, Class<?>… parameterTypes){

}

/**

• @param obj the object the underlying method is invoked from

• @param args the arguments used for the method call

• @return the result of dispatching the method represented by

*/

public Object invoke(Object obj, Object… args){

}

自定义工具方法

---

自定义一个方法

比如Person里有一个方法

public void test(String name,Integer age){

System.out.println(“调用成功”);

}

• 把类对象和类方法名作为参数，执行方法

/**

• @param obj: 方法执行的那个对象.

• @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法.

• @param args: 调用该方法需要传入的参数

• @return: 调用方法后的返回值

*/

public Object invoke(Object obj, String methodName, Object … args) throws Exception{

//1. 获取 Method 对象

// 因为getMethod的参数为Class列表类型，所以要把参数args转化为对应的Class类型。

Class [] parameterTypes = new Class[args.length];

for(int i = 0; i < args.length; i++){

parameterTypes[i] = args[i].getClass();

System.out.println(parameterTypes[i]);

}

Method method = obj.getClass().getDeclaredMethod(methodName, parameterTypes);

//如果使用getDeclaredMethod，就不能获取父类方法，如果使用getMethod，就不能获取私有方法

//

//2. 执行 Method 方法

//3. 返回方法的返回值

return method.invoke(obj, args);

}

调用：通过对象名，方法名，方法参数执行了该方法

@Test

public void testInvoke() throws Exception{

Object obj = new Person();

invoke(obj, “test”, “wang”, 1);

}

2.把全类名和方法名作为参数，执行方法

=================================================================================

/**

• @param className: 某个类的全类名

• @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法.

• @param args: 调用该方法需要传入的参数

• @return: 调用方法后的返回值

*/

public Object invoke(String className, String methodName, Object … args){

Object obj = null;

try {

obj = Class.forName(className).newInstance();

//调用上一个方法

return invoke(obj, methodName, args);

}catch(Exception e) {

e.printStackTrace();

}

return null;

}

调用:

@Test

public void testInvoke() throws Exception{

invoke(“com.atguigu.java.fanshe.Person”,

“test”, “zhagn”, 12);

}

使用系统方法（前提是此类有一个无参的构造器（查看API））

@Test

public void testInvoke() throws Exception{

Object result =

invoke(“java.text.SimpleDateFormat”, “format”, new Date());

System.out.println(result);

}

这种反射实现的主要功能是可配置和低耦合。只需要类名和方法名，而不需要一个类对象就可以执行一个方法。如果我们把全类名和方法名放在一个配置文件中，就可以根据调用配置文件来执行方法.

如何获取父类定义的（私有）方法

---

前面说一般使用getDeclaredMethod获取方法（因为此方法可以获取类的私有方法，但是不能获取父类方法）

如何获取父类方法呢，上一个例子format方法其实就是父类的方法（获取的时候用到的是getMethod）

首先我们要知道，如何获取类的父亲：

比如有一个类，继承自Person

使用：

public class ReflectionTest {

@Test

public void testGetSuperClass() throws Exception{

String className = “com.atguigu.java.fanshe.Student”;

Class clazz = Class.forName(className);

Class superClazz = clazz.getSuperclass();

System.out.println(superClazz);

}

}

//结果是 “ class com.atguigu.java.fanshe.Person ”

此时如果Student中有一个方法是私有方法method1(int age); Person中有一个私有方法method2();

怎么调用

定义一个方法，不但能访问当前类的私有方法，还要能父类的私有方法.

/**

• @param obj: 某个类的一个对象

• @param methodName: 类的一个方法的方法名.

• 该方法也可能是私有方法, 还可能是该方法在父类中定义的(私有)方法

• @param args: 调用该方法需要传入的参数

• @return: 调用方法后的返回值

*/

public Object invoke2(Object obj, String methodName,

Object … args){

//1. 获取 Method 对象

Class [] parameterTypes = new Class[args.length];

for(int i = 0; i < args.length; i++){

parameterTypes[i] = args[i].getClass();

}

try {

Method method = getMethod(obj.getClass(), methodName, parameterTypes);

method.setAccessible(true);

//2. 执行 Method 方法

//3. 返回方法的返回值

return method.invoke(obj, args);

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

• 获取 clazz 的 methodName 方法. 该方法可能是私有方法, 还可能在父类中(私有方法)

• 如果在该类中找不到此方法，就向他的父类找，一直到Object类为止

• 这个方法的另一个作用是根据一个类名，一个方法名，追踪到并获得此方法

• @param clazz

• @param methodName

• @param parameterTypes

• @return

*/

public Method getMethod(Class clazz, String methodName,

Class … parameterTypes){

for(;clazz != Object.class; clazz = clazz.getSuperclass()){

try {

Method method = clazz.getDeclaredMethod(methodName, parameterTypes);

return method;

} catch (Exception e) {}

}

return null;

}

如何描述字段-Field

---

@Test

public void testField() throws Exception{

String className = “com.atguigu.java.fanshe.Person”;

Class clazz = Class.forName(className);

//1.获取字段

// 1.1 获取所有字段 – 字段数组

// 可以获取公用和私有的所有字段，但不能获取父类字段

Field[] fields = clazz.getDeclaredFields();

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
e) {}

}

return null;

}

如何描述字段-Field

---

@Test

public void testField() throws Exception{

String className = “com.atguigu.java.fanshe.Person”;

Class clazz = Class.forName(className);

//1.获取字段

// 1.1 获取所有字段 – 字段数组

// 可以获取公用和私有的所有字段，但不能获取父类字段

Field[] fields = clazz.getDeclaredFields();

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-qT5WzKf5-1715760171754)]

[外链图片转存中…(img-GDJhVAao-1715760171755)]

[外链图片转存中…(img-SsLUMYMa-1715760171755)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！