Class.forName("com.mysql.jdbc.Driver");

本篇博客是通过jdbc驱动的加载来深刻理解上下文类加载机制，博客有两篇，这是其一。通过分析Class.forName("com.mysql.jdbc.Driver");的运行过程，来深刻理解。

1.已经导入mysql的驱动包

	
	Class.forName("com.mysql.jdbc.Driver");
	
	//进入方法 forName，可以看到，是加载并且初始化了className类，所以需要进入分析Driver的类
	 @CallerSensitive
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }
 	/** Called after security check for system loader access checks have been made. */
    private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)
        throws ClassNotFoundException;

2.分析com.mysql.jdbc.Driver的初始化，即静态代码块的执行

	public class Driver extends NonRegisteringDriver implements java.sql.Driver {
	// ~ Static fields/initializers
	// ---------------------------------------------

	//
	// Register ourselves with the DriverManager
	//可以看到静态代码块中，是将自己创建的对象注册进DriverManager中，就是注册驱动。
	static {
		try {
			//有一条需要注意，Driver是被系统类加载器加载的，在这里使用到了被启动类加载器加载的DriverManager
			java.sql.DriverManager.registerDriver(new Driver());
		} catch (SQLException E) {
			throw new RuntimeException("Can't register driver!");
		}
	}

	public Driver() throws SQLException {
		// Required for Class.forName().newInstance()
	}	
}

3.java.sql.DriverManager源码分析

	//这是DriverManager的静态代码，是将驱动注册自己。首先分析下类的静态变量
	  public static synchronized void registerDriver(java.sql.Driver driver)
        throws SQLException {

        registerDriver(driver, null);
    }
	
	public static synchronized void registerDriver(java.sql.Driver driver,
            DriverAction da)
        throws SQLException {

        /* Register the driver if it has not already been added to our list */
        if(driver != null) {
        	//如果驱动尚未被注册，则写入到集合中
            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
        } else {
            // This is for compatibility with the original DriverManager
            throw new NullPointerException();
        }

        println("registerDriver: " + driver);

    }

	// List of registered JDBC drivers 存储注册的驱动集合
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = 
    												new CopyOnWriteArrayList<>();


	/**
     * Load the initial JDBC drivers by checking the System property
     * jdbc.properties and then use the {@code ServiceLoader} mechanism
     * 静态代码块，初始化类
     */
    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
	
	 private static void loadInitialDrivers() {
        String drivers;
        try {
        	//加载系统中是否设置了启动，默认没有
            drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
                public String run() {
                    return System.getProperty("jdbc.drivers");
                }
            });
        } catch (Exception ex) {
            drivers = null;
        }
        // If the driver is packaged as a Service Provider, load it.
        // Get all the drivers through the classloader
        // exposed as a java.sql.Driver.class service.
        // ServiceLoader.load() replaces the sun.misc.Providers()

        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
				//使用ServiceLoader去加载Driver.class的服务提供商，传入Driver.class即服务，
				//根据class获取到服务的二进制名字，去寻找服务提供商的二进制名
                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();

                /* Load these drivers, so that they can be instantiated.
                 * It may be the case that the driver class may not be there
                 * i.e. there may be a packaged driver with the service class
                 * as implementation of java.sql.Driver but the actual class
                 * may be missing. In that case a java.util.ServiceConfigurationError
                 * will be thrown at runtime by the VM trying to locate
                 * and load the service.
                 *
                 * Adding a try catch block to catch those runtime errors
                 * if driver not available in classpath but it's
                 * packaged as service and that service is there in classpath.
                 */
                try{//因为是懒加载，所以遍历一遍。
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                // Do nothing
                }
                return null;
            }
        });

        println("DriverManager.initialize: jdbc.drivers = " + drivers);
		//系统属性的驱动加载
        if (drivers == null || drivers.equals("")) {
            return;
        }
        String[] driversList = drivers.split(":");
        println("number of Drivers:" + driversList.length);
        for (String aDriver : driversList) {
            try {
                println("DriverManager.Initialize: loading " + aDriver);
                Class.forName(aDriver, true,
                        ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
                println("DriverManager.Initialize: load failed: " + ex);
            }
        }
    }

4.ServiceLoader分析
驱动加载步骤：
* 1.指定服务接口的class对象
* 2.ServiceLoader为加载服务提供商设定上下文类加载器
* 3.服务提供商在META-INF/services/ 创建与服务同名的文件，内容是服务实现的类名
* 4.惰性加载扫描加载服务提供商的服务

	ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
    Iterator<Driver> driversIterator = loadedDrivers.iterator();


public final class ServiceLoader<S> implements Iterable<S>{
	
	//指定服务的二进制名，获取上下文类加载器
	public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }
    
	public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }

   private ServiceLoader(Class<S> svc, ClassLoader cl) {
   		//service服务的class对象
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
        reload();
    }
    
    // Cached providers, in instantiation order
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    // The current lazy-lookup iterator
    private LazyIterator lookupIterator;
    
    //清空以前服务提供商的驱动缓存
	 public void reload() {
        providers.clear();
        lookupIterator = new LazyIterator(service, loader);
    }
    
    // Private inner class implementing fully-lazy provider lookup
    //私有的内部类，去完成驱动的寻找和迭代，懒加载实现
    private class LazyIterator
        implements Iterator<S>
    {

        Class<S> service;//服务的class对象
        ClassLoader loader;//上下文类加载器
        Enumeration<URL> configs = null;
        Iterator<String> pending = null;
        String nextName = null;//服务提供者的二进制名

        private LazyIterator(Class<S> service, ClassLoader loader) {
            this.service = service;
            this.loader = loader;
        }

        private boolean hasNextService() {
            if (nextName != null) {
                return true;
            }
            
            if (configs == null) {
            //第一次被调用时configs 会为nul，会进行服务提供商的查找
                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);
                }
            }
            while ((pending == null) || !pending.hasNext()) {
                if (!configs.hasMoreElements()) {
                    return false;
                }
                pending = parse(service, configs.nextElement());
            }
            //将服务提供商的类名返回
            nextName = pending.next();
            return true;
        }

        private S nextService() {
            if (!hasNextService())
                throw new NoSuchElementException();
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try {
            	//对服务提供商的驱动进行加载，采用上下文类加载器。
                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中
                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 boolean hasNext() {
            if (acc == null) {
                return hasNextService();
            } else {
                PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                    public Boolean run() { return hasNextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

        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);
            }
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    }
}