几种常见的类加载方式

在 Java 中，有多种方式可以加载类，以下是几种常见的类加载方式：

1. 使用 Class.forName() 方法

Class.forName() 方法是一种动态加载类的方式，它会使用调用者的类加载器加载类，并会执行类的静态初始化块。

public class ClassLoadingExample {
    public static void main(String[] args) {
        try {
            // 加载类并初始化
            Class<?> clazz = Class.forName("com.example.MyClass");
            System.out.println("Class loaded: " + clazz);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

代码解释：

• Class.forName("com.example.MyClass")：
  • 尝试加载 com.example.MyClass 类。
  • 该方法会触发类的静态初始化块（如果存在）。
  • 通常用于加载 JDBC 驱动程序，因为 JDBC 驱动程序通常在静态初始化块中注册自己。

2. 使用 ClassLoader.loadClass() 方法

可以使用 ClassLoader 的 loadClass() 方法加载类，此方法不会执行类的静态初始化块，除非你显式调用 Class.forName() 或创建类的实例。

public class ClassLoadingExample {
    public static void main(String[] args) {
        try {
            ClassLoader classLoader = ClassLoadingExample.class.getClassLoader();
            // 加载类，但不初始化
            Class<?> clazz = classLoader.loadClass("com.example.MyClass");
            System.out.println("Class loaded: " + clazz);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

代码解释：

• ClassLoadingExample.class.getClassLoader()：
  • 获取当前类的类加载器。
• classLoader.loadClass("com.example.MyClass")：
  • 使用类加载器加载 com.example.MyClass 类。
  • 不会自动触发类的静态初始化。

3. 使用 Class.newInstance() 创建实例

在加载类之后，可以使用 Class.newInstance() 方法创建类的实例，此方法会调用类的无参构造函数。

public class ClassLoadingExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.MyClass");
            // 创建类的实例
            Object instance = clazz.newInstance();
            System.out.println("Instance created: " + instance);
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

代码解释：

• clazz.newInstance()：
  • 创建 com.example.MyClass 的实例。
  • 调用无参构造函数，如果没有无参构造函数或不可访问，会抛出异常。

4. 使用 Constructor.newInstance() 创建实例

更灵活的方式是使用 Constructor.newInstance() 方法，它允许你调用指定的构造函数创建实例。

import java.lang.reflect.Constructor;


public class ClassLoadingExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.MyClass");
            // 获取构造函数
            Constructor<?> constructor = clazz.getConstructor(String.class);
            // 创建类的实例
            Object instance = constructor.newInstance("Hello");
            System.out.println("Instance created: " + instance);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码解释：

• clazz.getConstructor(String.class)：
  • 获取 com.example.MyClass 的 String 参数的构造函数。
• constructor.newInstance("Hello")：
  • 使用获取的构造函数创建实例，传入 "Hello" 作为参数。

5. 使用自定义类加载器加载类

自定义类加载器可以从自定义的位置（如文件系统、网络）加载类，允许你实现特殊的类加载逻辑。

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;


class CustomClassLoader extends ClassLoader {
    private String classPath;


    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }


    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            String fileName = classPath + File.separator + name.replace('.', File.separatorChar) + ".class";
            byte[] classBytes = loadClassBytes(fileName);
            return defineClass(name, classBytes, 0, classBytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("Class not found: " + name, e);
        }
    }


    private byte[] loadClassBytes(String fileName) throws IOException {
        try (InputStream inputStream = new FileInputStream(fileName);
             ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int length;
            while ((length = inputStream.read(buffer))!= -1) {
                outputStream.write(buffer, 0, length);
            }
            return outputStream.toByteArray();
        }
    }
}


public class ClassLoadingExample {
    public static void main(String[] args) {
        try {
            CustomClassLoader classLoader = new CustomClassLoader("/path/to/classes");
            Class<?> clazz = classLoader.loadClass("com.example.MyClass");
            System.out.println("Class loaded by custom class loader: " + clazz);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

代码解释：

• CustomClassLoader：
  • 自定义类加载器，从指定的文件路径加载类。
  • findClass 方法从文件中读取类字节数据并使用 defineClass 方法将其转换为类对象。

6. 使用 ServiceLoader 加载服务提供者

ServiceLoader 是一种加载服务提供者的机制，通过 META-INF/services 目录下的配置文件查找并加载实现类。

import java.util.ServiceLoader;


interface MyService {
    void doService();
}


class MyServiceImpl implements MyService {
    @Override
    public void doService() {
        System.out.println("Service is running.");
    }
}


public class ClassLoadingExample {
    public static void main(String[] args) {
        ServiceLoader<MyService> serviceLoader = ServiceLoader.load(MyService.class);
        for (MyService service : serviceLoader) {
            service.doService();
        }
    }
}

代码解释：

• ServiceLoader.load(MyService.class)：
  • 查找 META-INF/services 目录下的配置文件，根据配置文件中的实现类名加载服务提供者。
  • 遍历 ServiceLoader 加载的服务实现并调用其方法。

总结

• Class.forName()：
  • 适合需要执行类的静态初始化的情况，常用于 JDBC 驱动加载。
• ClassLoader.loadClass()：
  • 仅加载类，不触发静态初始化，提供更灵活的类加载控制。
• Class.newInstance() 和 Constructor.newInstance()：
  • 用于创建类的实例，后者更灵活，可调用指定构造函数。
• 自定义类加载器：
  • 从自定义位置加载类，实现特殊的类加载逻辑，如文件系统或网络加载。
• ServiceLoader：
  • 用于加载服务提供者，遵循 SPI 机制，实现服务发现和加载。

根据不同的需求，可以选择合适的类加载方式。在使用反射创建实例或自定义类加载器时，要注意异常处理和权限问题，确保有足够的权限访问类文件和构造函数。同时，对于自定义类加载器，要注意类加载的一致性和安全性，避免破坏 Java 的类加载机制。