Java 类加载与双亲委派模型

public class Student {


    String name;
    
    String gender;
    
    public Student() {}
}


public class TestLoad {


    public static void main(String[] args) {


        Class<Student> studentClass = Student.class;
    }
}

// 在准备阶段a的值为0
static int a = 1;
// 在准备阶段b的值为1
final static b = 1;

// ClassLoader$loadClass源码
protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    // 加锁保证并发时的类加载
    synchronized (getClassLoadingLock(name)) {
        // 检查类是否被加载
        Class<?> c = findLoadedClass(name);
        // 如果类没有被加载
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                // 如果父加载器不为空就委托给父类加载器
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else { 
                // 为空代表顶层是启动类加载器或自定义类加载器没设置父类加载器
                // 交给启动类加载器加载
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父类加载器加载失败后会抛出ClassNotFoundException异常
                // 子类加载器catch异常后，调用自己的findClass()方法进行加载
            }


            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                // 根据名称或位置加载.class字节码
                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(c);
        }
        return c;
    }
}

// 锁对象集合：key->value, 全类名->ObjectLock
private final ConcurrentHashMap<String, Object> parallelLockMap;


// ClassLoader$getClassLoadingLock源码
protected Object getClassLoadingLock(String className) {
    Object lock = this;
    if (parallelLockMap != null) {
        Object newLock = new Object();
        // 以全类名为key，如果不存在就set，并将该key的value返回
        lock = parallelLockMap.putIfAbsent(className, newLock);
        if (lock == null) {
            lock = newLock;
        }
    }
    return lock;
}

Connection conn = DriverManager
  .getConnection("jdbc:mysql://localhost:3306/mysql", "账号", "密码");

// Driver注册集合
private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();


//  Worker method called by the public getConnection() methods.
private static Connection getConnection(
   
    for(DriverInfo aDriver : registeredDrivers) {
        // 检查该类加载器是否有权限加载Driver
        if(isDriverAllowed(aDriver.driver, callerCL)) {
            try {
                println("trying " + aDriver.driver.getClass().getName());
                // 通过url、账号、密码等信息获取链接，如果为null就遍历下一个
                Connection con = aDriver.driver.connect(url, info);
                if (con != null) {
                    // Success!
                    println("getConnection returning " + aDriver.driver.getClass().getName());
                    return (con);
                }
            } catch (SQLException ex) {
                if (reason == null) {
                    reason = ex;
                }
            }
        } else {
            println("skipping: " + aDriver.getClass().getName());
        }
    }
}

// DriverManager类内的静态方法去加载驱动
static {
    loadInitialDrivers();
    println("JDBC DriverManager initialized");
}

// DriverManager类内的loadInitialDrivers()方法
private static void loadInitialDrivers() {
    ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
    Iterator<Driver> driversIterator = loadedDrivers.iterator();
    try{
        // 内部实现了迭代器，在调用next方法时候去真正加载类
        while(driversIterator.hasNext()) {
            driversIterator.next();
        }
    } catch(Throwable t) {
    // Do nothing
    }
    return null;
}

public static <S> ServiceLoader<S> load(Class<S> service) {
    // 使用线程上下文加载器，可以显示指定，默认是AppClassLoader,
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    // 使用线程上下文加载器去发现服务并加载
    return ServiceLoader.load(service, cl);
}

// 内部重写迭代器的hasNext方法
public boolean hasNext() {
    if (acc == null) {
        // 该方法根据路径寻找SPI配置的全类名
        return hasNextService();
    } else {
        PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
            public Boolean run() { return hasNextService(); }
        };
        return AccessController.doPrivileged(action, acc);
    }
}


// SPI配置路径
private static final String PREFIX = "META-INF/services/";


private boolean hasNextService() {
    if (nextName != null) {
        return true;
    }
    if (configs == null) {
        try {
            // 拼成全类名
            String fullName = PREFIX + service.getName();
            if (loader == null)
                configs = ClassLoader.getSystemResources(fullName);
            else
                configs = loader.getResources(fullName);
        } catch (IOException x) {
            fail(service, "Error locating configuration files", x);
        }
    }
}

// 内部重写迭代器的next方法
public S next() {
    if (acc == null) {
        return nextService();
    } else {
        PrivilegedAction<S> action = new PrivilegedAction<S>() {
            public S run() { return nextService(); }
        };
        return AccessController.doPrivileged(action, acc);
    }
}


private S nextService() {
    if (!hasNextService())
        throw new NoSuchElementException();
    String cn = nextName;
    nextName = null;
    Class<?> c = null;
    try {
        // 根据全类名和设置的AppClassLoader去加载SPI实现类
        c = Class.forName(cn, false, loader);
    } catch (ClassNotFoundException x) {
        fail(service,
             "Provider " + cn + " not found");
    }
    if (!service.isAssignableFrom(c)) {
        fail(service,
             "Provider " + cn  + " not a subtype");
    }
    try {
        // 实例化
        S p = service.cast(c.newInstance());
        // 放进providers集合，后续根据全类名找SPI实现
        providers.put(cn, p);
        return p;
    } catch (Throwable x) {
        fail(service,
             "Provider " + cn + " could not be instantiated",
             x);
    }
    throw new Error();          // This cannot happen
}

public interface SpiService {


    public void spiMethod();
}


public class SpiServiceImpl implements SpiService {


    @Override
    public void spiMethod() {
        System.out.println("快关注「阿东编程之路」！");
    }
}

com.beiting.spi.impl.SpiServiceImpl

public abstract class SpiManager {
    // 服务注册集合
    private static final Map<String, SpiService> spiServices = new ConcurrentHashMap();


    private static final SpiService defaultService = new DefaultSpiService();


    static {
        loadSpiServices();
    }
    // SPI服务发现和注册逻辑
    private static void loadSpiServices() {


        ServiceLoader<SpiService> load = ServiceLoader.load(SpiService.class);
        Iterator<SpiService> iterator = load.iterator();
        while (iterator.hasNext()) {
            SpiService next = iterator.next();
            spiServices.put(next.getClass().getName(), next);
        }
    }
    // 获取SPI实现
    public static SpiService getSpiService(String name) {


        return spiServices.getOrDefault(name, defaultService);
    }
    // 默认SPI方法实现
    static class DefaultSpiService implements SpiService {


        @Override
        public void spiMethod() {
            System.out.println("和阿东一起进步！");
        }
    }
}

public class SpiDemo {


    public static void main(String[] args) {


        // 自定义SPI方法实现
        SpiManager.getSpiService("com.beiting.spi.impl.SpiServiceImpl").spiMethod();
        // 默认实现
        SpiManager.getSpiService("xxx").spiMethod();
    }
}