JDBC驱动初始化-Mysql

JDBC驱动初始化-Mysql:http://donald-draper.iteye.com/blog/2342010
JDBC连接的获取：http://donald-draper.iteye.com/blog/2342011
Mysql负载均衡连接的获取：http://donald-draper.iteye.com/blog/2342089
Mysql主从复制读写分离连接的获取：http://donald-draper.iteye.com/blog/2342108
ConnectionImp创建MysqlIO ：http://donald-draper.iteye.com/blog/2342959
Mysql预编译SQL：http://donald-draper.iteye.com/blog/2342960
MysqlSQL PreparedStatement的查询:http://donald-draper.iteye.com/blog/2343083
MySQL ServerPreparedStatement查询：http://donald-draper.iteye.com/blog/2343124
用hibernate和mybatis做持久层时候，屏蔽jdbc的东西，现在有时间，我们来看一下jdbc底层东西。
首先创建mysql测试实例如下;
测试实例：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.Date;
public class testMysqlX {
	public static void main(String[] args){
		testMysqlConnection();
	}
	@SuppressWarnings("deprecation")
	public static void testMysqlConnection()
	{
	    Connection con = null;// 创建一个数据库连接
	    PreparedStatement pre = null;// 创建预编译语句对象，一般都是用这个而不用Statement
	    ResultSet result = null;// 创建一个结果集对象
	    try
	    {
	        Class.forName("com.mysql.jdbc.Driver");// 加载驱动程序
	        System.out.println("开始尝试连接数据库！");
	        String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8";
			String user = "root";// 用户名,系统默认的账户名
			String password = "123456";// 你安装时选设置的密码	
	        long startTime = System.currentTimeMillis();
	        con = DriverManager.getConnection(url, user, password);// 获取连接
	        PreparedStatement ps = con.prepareStatement("select count(*) from ?"); 
	        ps.setString(1, "user");
	        result = ps.executeQuery();
	        //result 初始游标为head，移动next到第一个记录
	          while(result.next()){
		         int sum = result.getInt(1);
	        	 System.out.println("============sum:"+sum);
	         }
	        long endTime = System.currentTimeMillis();
	 
	        System.out.println("============time:"+ (endTime-startTime));
	        System.out.println("============hashCode:"+ con.hashCode());
	        if(!con.isClosed()){
	        	 System.out.println("============连接成功！");
	        }
	    }
	    catch (Exception e)
	    {
	    	System.out.println("=============连接失败："+e.getMessage());
	    	e.printStackTrace();
	    }
	    finally
	    {
	        try
	        {
	            // 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源
	            // 注意关闭的顺序，最后使用的最先关闭
	            if (result != null)
	                result.close();
	            if (pre != null)
	                pre.close();
	            if (con != null)
	                con.close();
	            System.out.println("数据库连接已关闭！");  
	        }
	        catch (Exception e)
	        {
	            e.printStackTrace();
	        }
	    }
	}
}

下面我们来看一下，从驱动加载，获取连接，及获取PreparedStatement，执行查询，结果集的处理的整个过程；
先看加载驱动
从这一句开始：

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

//Class

 public final
    class Class<T> implements java.io.Serializable, 
			      java.lang.reflect.GenericDeclaration, 
			      java.lang.reflect.Type,
                              java.lang.reflect.AnnotatedElement {
    private static final int ANNOTATION= 0x00002000;
    private static final int ENUM      = 0x00004000;
    private static final int SYNTHETIC = 0x00001000;

    private static native void registerNatives();
    static {
        registerNatives();
    }
//根据类名加载对应class
   public static Class<?> forName(String className) 
                throws ClassNotFoundException {
        return forName0(className, true, ClassLoader.getCallerClassLoader());
    }
 /** Called after security checks have been made. */
    private static native Class forName0(String name, boolean initialize,
					    ClassLoader loader)
	throws ClassNotFoundException;
}

来看一下的mysql的Driver类
//com.mysql.jdbc.Driver 

 public class Driver extends NonRegisteringDriver
    implements java.sql.Driver
{
    public Driver()
        throws SQLException
    {
    }
    static 
    {
        try
        {
	    //将驱动注册到驱动管理器
            DriverManager.registerDriver(new Driver());
        }
        catch(SQLException E)
        {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

//DriverManager

public class DriverManager {
    /* write copy of the drivers vector */
    private static java.util.Vector writeDrivers = new java.util.Vector();

    /* write copy of the drivers vector */
    private static java.util.Vector readDrivers = new java.util.Vector();

    private static int loginTimeout = 0;
    private static java.io.PrintWriter logWriter = null;
    private static java.io.PrintStream logStream = null;
    private static boolean initialized = false;
        //注册驱动
	public static synchronized void registerDriver(java.sql.Driver driver)
	throws SQLException {
	if (!initialized) {
	    initialize();
	}
        //初始化驱动信息
	DriverInfo di = new DriverInfo();

	di.driver = driver;
	di.driverClass = driver.getClass();
	di.driverClassName = di.driverClass.getName();

        //将driver信息添加到writeDrivers集合中
	writeDrivers.addElement(di); 
	println("registerDriver: " + di);
	//克隆writeDrivers到readDrivers
	readDrivers = (java.util.Vector) writeDrivers.clone();

    }
     //初始化
    static void initialize() {
        if (initialized) {
            return;
        }
        initialized = true;
	//加载驱动，初始化
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
    //加载驱动
     private static void loadInitialDrivers() {
        String drivers;
        try {
	    drivers = (String) java.security.AccessController.doPrivileged(
		new sun.security.action.GetPropertyAction("jdbc.drivers"));
        } catch (Exception ex) {
            drivers = null;
        }
	//如果driver是放在jar包中，通过类型加载器加载，所有Driver，每个java.sql.Driver.class是一个Service
	 DriverService ds = new DriverService();

	 //获取所有驱动的访问权限
	 java.security.AccessController.doPrivileged(ds);		
	        
         println("DriverManager.initialize: jdbc.drivers = " + drivers);
        if (drivers == null) {
            return;
        }
        while (drivers.length() != 0) {
            int x = drivers.indexOf(':');
            String driver;
            if (x < 0) {
                driver = drivers;
                drivers = "";
            } else {
                driver = drivers.substring(0, x);
                drivers = drivers.substring(x+1);
            }
            if (driver.length() == 0) {
                continue;
            }
            try {
                println("DriverManager.Initialize: loading " + driver);
		//加载驱动
                Class.forName(driver, true,
			      ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
                println("DriverManager.Initialize: load failed: " + ex);
            }
        }
    }
    class DriverService implements java.security.PrivilegedAction {
        Iterator ps = null;
	public DriverService() {};
        public Object run() {

	// uncomment the followin line before mustang integration 	
        // Service s = Service.lookup(java.sql.Driver.class);
	// ps = s.iterator();
        //通过Service加载所有Driver
	ps = Service.providers(java.sql.Driver.class);

	/* 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 sun.misc.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 (ps.hasNext()) {
	       //初始化Driver
               ps.next();
           } // end while
	} catch(Throwable t) {
	    // Do nothing
	}
        return null;
    } //end run

} //end DriverService
    //驱动信息类
    class DriverInfo {
    Driver         driver;
    Class          driverClass;
    String         driverClassName;

    public String toString() {
	return ("driver[className=" + driverClassName + "," + driver + "]");
    }
}

从DriverManager的初始化过程可以看出，Driver的加载是委托给DriverService，而DriverService是通过
Service去加载,我们来看一下Service

public final class Service
{
    //加载驱动，委托给providers(Class class1, ClassLoader classloader)
    public static Iterator providers(Class class1)
        throws ServiceConfigurationError
    {
        ClassLoader classloader = Thread.currentThread().getContextClassLoader();
        return providers(class1, classloader);
    }
    public static Iterator providers(Class class1, ClassLoader classloader)
        throws ServiceConfigurationError
    {
         //实际上返回的为一个Iterater，LazyIterator为Service的静态内部类
        return new LazyIterator(class1, classloader);
    }
    //LazyIterator,懒加载驱动集合
    private static class LazyIterator
        implements Iterator
    {

        public boolean hasNext()
            throws ServiceConfigurationError
        {
            if(nextName != null)
                return true;
            if(configs == null)
                try
                {
                    String s = (new StringBuilder()).append("META-INF/services/").append(service.getName()).toString();
                    if(loader == null)
                        configs = ClassLoader.getSystemResources(s);
                    else
                        configs = loader.getResources(s);
                }
                catch(IOException ioexception)
                {
                    Service.fail(service, (new StringBuilder()).append(": ").append(ioexception).toString());
                }
            for(; pending == null || !pending.hasNext(); pending = Service.parse(service, (URL)configs.nextElement(), returned))
                if(!configs.hasMoreElements())
                    return false;

            nextName = (String)pending.next();
            return true;
        }
        //next函数在DriverService，有调用，通过遍历LazyIterator，加载驱动
        public Object next()
            throws ServiceConfigurationError
        {
            String s;
            Class class1;
            if(!hasNext())
                throw new NoSuchElementException();
            s = nextName;
            nextName = null;
            class1 = null;
            try
            {
                class1 = Class.forName(s, false, loader);
            }
            catch(ClassNotFoundException classnotfoundexception)
            {
                Service.fail(service, (new StringBuilder()).append("Provider ").append(s).append(" not found").toString());
            }
            if(!service.isAssignableFrom(class1))
                Service.fail(service, (new StringBuilder()).append("Provider ").append(s).append(" not a subtype").toString());
            return service.cast(class1.newInstance());
            Throwable throwable;
            throwable;
            Service.fail(service, (new StringBuilder()).append("Provider ").append(s).append(" could not be instantiated: ").append(throwable).toString(), throwable);
            return null;
        }

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

        Class service;
        ClassLoader loader;
        Enumeration configs;
        Iterator pending;
        Set returned;
        String nextName;

        private LazyIterator(Class class1, ClassLoader classloader)
        {
            configs = null;
            pending = null;
            returned = new TreeSet();
            nextName = null;
            service = class1;
            loader = classloader;
        }
	
    private static void fail(Class class1, String s, Throwable throwable)
        throws ServiceConfigurationError
    {
        ServiceConfigurationError serviceconfigurationerror = new ServiceConfigurationError((new StringBuilder()).append(class1.getName()).append(": ").append(s).toString());
        serviceconfigurationerror.initCause(throwable);
        throw serviceconfigurationerror;
    }
    //驱动加载失败的处理，抛出异常
    private static void fail(Class class1, String s)
        throws ServiceConfigurationError
    {
        throw new ServiceConfigurationError((new StringBuilder()).append(class1.getName()).append(": ").append(s).toString());
    }

    private static void fail(Class class1, URL url, int i, String s)
        throws ServiceConfigurationError
    {
        fail(class1, (new StringBuilder()).append(url).append(":").append(i).append(": ").append(s).toString());
    }
}

//ServiceConfigurationError

public class ServiceConfigurationError extends Error
{
    public ServiceConfigurationError(String s)
    {
        super(s);
    }
    public ServiceConfigurationError(Throwable throwable)
    {
        super(throwable);
    }
}

至此,driver的加载结束，我们来回顾一下整个过程，Class加载com.mysql.jdbc.Driver，com.mysql.jdbc.Driver通过静态语句块，将Driver注册到DriverManager，DriverManager首先检查有没有初始化，没有则加载驱动类，整个驱动加载过程是通过DriverService，而DriverService则委托给Service，Service加载驱动是返回的是，所有java.sql.Driver实现的Iterator,Iterator为LazyIterator，
DriverService通过遍历LazyIterator，加载驱动所有驱动;最后将Driver包装成DriverInfo，添加到writeDrivers集合中，并clone到readDrivers。