关闭

JAVA JDBC(MySQL)驱动源码分析

812人阅读 评论(0) 收藏 举报
分类:

JAVA连接数据库是其众多功能中的一部分,主要有两种方式连接DataBase: 一种是采用JDBC-ODBC桥,另一种则是称之为纯驱动连接DataBase,第一种方式在大型项目中基本上不再使用,本系列文章主要分析纯驱动源码。
对于初学JAVA者,甚至那些使用JAVA做过几年开发的程序员来讲,对于JDBC的工作原理都不一定能够明白。知其然,不知其所以然。遇到问题就不知所 措了。通过针对于MYSQL JDBC源码的分析,对于JAVA是如何连接数据库,其中到底做了些什么工作,一步步解剖开来,更好的理解JDBC。
使用JAVA连接数据库,首先要做的就是在程序中导入sql包,然后装载驱动类、获取连接、获取语句对象、发送SQL命令然后得到结果
请看以下代码片段:

 

 

package javaT.sql;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class MysqlDemo {
    public static void main(String[] args) throws Exception {
        Connection conn = null;
        String sql;
        // MySQL的JDBC URL编写方式:jdbc:mysql://主机名称:连接端口/数据库的名称?参数=值
        // 避免中文乱码要指定useUnicode和characterEncoding
        // 执行数据库操作之前要在数据库管理系统上创建一个数据库,名字自己定,
        // 下面语句之前就要先创建javademo数据库
        String url = "jdbc:mysql://192.168.1.111:3306/appcenter_new?useUnicode=true&characterEncoding=utf8";
 
        try {
            // 之所以要使用下面这条语句,是因为要使用MySQL的驱动,所以我们要把它驱动起来,
            // 可以通过Class.forName把它加载进去,也可以通过初始化来驱动起来,下面三种形式都可以
            Class.forName("com.mysql.jdbc.Driver");// 动态加载mysql驱动
            // or:
//             com.mysql.jdbc.Driver driver = new com.mysql.jdbc.Driver();
            // or:
//             new com.mysql.jdbc.Driver();
 
            System.out.println("成功加载MySQL驱动程序");
            // 一个Connection代表一个数据库连接
            conn = DriverManager.getConnection(url,"jbjava","jb98");
            // Statement里面带有很多方法,比如executeUpdate可以实现插入,更新和删除等
            Statement stmt = conn.createStatement();
            sql = "create table student(NO char(20),name varchar(20),primary key(NO))";
            int result = stmt.executeUpdate(sql);// executeUpdate语句会返回一个受影响的行数,如果返回-1就没有成功
            if (result != -1) {
                System.out.println("创建数据表成功");
                sql = "insert into student(NO,name) values('2012001','陶伟基')";
                result = stmt.executeUpdate(sql);
                sql = "insert into student(NO,name) values('2012002','周小俊')";
                result = stmt.executeUpdate(sql);
                sql = "select * from student";
                ResultSet rs = stmt.executeQuery(sql);// executeQuery会返回结果的集合,否则返回空值
                System.out.println("学号\t姓名");
                while (rs.next()) {
                    System.out
                            .println(rs.getString(1) + "\t" + rs.getString(2));// 入如果返回的是int类型可以用getInt()
                }
            }
        } catch (SQLException e) {
            System.out.println("MySQL操作错误");
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            conn.close();
        }
 
    }
 
}

 

   

    /* 连接mysql 时装载的驱动类以及连接字符串 */  
    Class.forName(“com.mysql.jdbc.Driver”);//1  
    DriverManager.getConnection(“jdbc:mysql://localhost:3306/test”,”root”,”123”);//2  
    /* 连接SQLServer2005 时装载的驱动类以及连接字符串 */  
    Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);  
    DriverManager.getConnection(“jdbc:sqlserver://localhost:1433;databaseName=pubs”,”sa”, ””);  
 

 

此段代码有两部分,连接不同数据库时所需要装载的驱动类以及连接字符串,以此获取连接。
Class.forName()装载类,在调用一个类的构造方法,初始化静态成员或者这个类有main方法时,JVM都会装载对应的类。
首先我们就看看com.mysql.jdbc.Driver类做了什么事情,找到MYSQL-JDBC驱动源码,解压之后找到src目录,然后找到com.mysql.jdbc下的Driver.java类

 

 

    package com.mysql.jdbc;  
    import java.sql.SQLException;  
    public class Driver extends NonRegisteringDriver implements java.sql.Driver {  
        static {  
            try {  
                java.sql.DriverManager.registerDriver(new Driver()); //1  
            } catch (SQLException E) {  
                throw new RuntimeException("Can't register driver!");  
            }  
        }  
        // ~ Constructors  
        // -----------------------------------------------------------  
        /** 
         * Construct a new driver and register it with DriverManager 
         *  
         * @throws SQLException 
         *             if a database error occurs. 
         */  
        public Driver() throws SQLException {  
            // Required for Class.forName().newInstance()  
        }  
    }  
 

Driver类继承NonRegisteringDriver 同时实现接口java.sql.Driver
此类会有一个静态块

 

 

 
    static {  
            try {  
                java.sql.DriverManager.registerDriver(new Driver()); //1  
            } catch (SQLException E) {  
                throw new RuntimeException("Can't register driver!");  
            }  
        }  

 

Class.forName的作用是要求JVM查找并加载指定的类, 也就是说JVM装载此类并执行静态块代码
此静态块只有一句关键部分,1处
在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己,即任何一个JDBC 驱动
的Driver类的代码都必须类似下面这段
java.sql.DriverManager.registerDriver(new Driver());
所以,如果你要自己实现一个数据库的JDBC驱动,那么就得实现java.sql.Driver接口,并且需要在实现类中使用 java.sql.DriverManager.registerDriver(new Driver())注册自己,new Driver()就是创建一个Driver对象,所以此类会有一个无参数的构造函数:

    public Driver() throws SQLException {  
     }  
 

 

下面再看看DriverManager.registerDriver()这个方法,源码如下:

 

    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();  
        // Not Required -- drivers.addElement(di);  
        writeDrivers.addElement(di);   
        println("registerDriver: " + di);  
          
        /* update the read copy of drivers vector */  
        readDrivers = (java.util.Vector) writeDrivers.clone();  
    }  

 
此方法是一个静态同步的方法,形式参数是java.sql.Driver接口类型,因为com.mysql.jdbc.Driver这个类实现了 java.sql.Driver接口,所以com.mysql.jdbc.Driver实例对象new Driver()是可以作为实参传入到此方法中来的。在DriverManager类中都是使用的Driver接口类型,也就是说驱动的使用不依赖于任何 实现。如果需要更换你所连接的数据库,只需要在Class.forName传入的参数换成另一个数据库的驱动类,但要求此类必须实现Driver接口。

 
    registerDriver方法是一个静态方法,它所要做的工作就是加载所有系统提供的驱动,并把它们添加到具体的类中,形成对象。同时还创建连接,是一个管理驱动的工具类。如果我们使用的是mysql,那么加载的也就是它的驱动。
    此方法的源码如下:

 

    public static synchronized void registerDriver(java.sql.Driver driver)  
        throws SQLException {  
        if (!initialized) {  //1  
            initialize();  
        }        
        DriverInfo di = new DriverInfo();  
        di.driver = driver;  
        di.driverClass = driver.getClass();  
        di.driverClassName = di.driverClass.getName();  
        // Not Required -- drivers.addElement(di);  
        writeDrivers.addElement(di);   
        println("registerDriver: " + di);  
        /* update the read copy of drivers vector */  
        readDrivers = (java.util.Vector) writeDrivers.clone();  
    }  
 

 

一、初始化操作
1、看看1处的代码,判断是否初始化,这个判断的变量是一个静态全局boolean值,初始为false

    private static boolean initialized = false;



如果此变量的值为false那么它将会进入初始化方法,源码如下:

 

    static void initialize() {  
            if (initialized) {  
                return;  
            }  
            initialized = true;  
            loadInitialDrivers();  
            println("JDBC DriverManager initialized");  
        }  
 

 

2、Initialize方法中判断initialized值是否为真(其实就是通过此boolean变量判断是否已经初始化完成),之后设置 initialized值为true,接着又会调用另一个方法loadInitialDrivers() 同样是静态方法,用于调用系统类装载器,装载所有系统提供的驱动:
loadInitialDrivers()源码:

 

    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;  
            }  
              
            // 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.  
          
         DriverService ds = new DriverService();  
         // Have all the privileges to get all the   
         // implementation of java.sql.Driver  
         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);  
                }  
            }  
        }  
 

主要代码分析:
    下面这段创建了一个内部类对象,创建此对象时,它会从系统服务中加载驱动

 

 
    DriverService ds = new DriverService();  
 

 

DriverService内部类的具体代码:

 

    class DriverService implements java.security.PrivilegedAction {  
            Iterator ps = null;  
        public DriverService() {};  
            public Object run() {  
        ps = Service.providers(java.sql.Driver.class);  //从系统服务中加载驱动  
        try {  
               while (ps.hasNext()) { //遍历驱动  
                   ps.next();  
               } // end while  
        } catch(Throwable t) {  
            // Do nothing  
        }  
            return null;  
        } //end run  
    } //end DriverService  
 

 

此句代码就是找到所有的拥有权限的java.sql.Driver的实现

java.security.AccessController.doPrivileged(ds);  

 

下面这段,意思是得到系统属性jdbc.drivers对应驱动的驱动名称,使用了JAVA的安全许可

 

    drivers = (String) java.security.AccessController.doPrivileged(  
            new sun.security.action.GetPropertyAction("jdbc.drivers"));  
 

 

再看看后面的判断和循环
首先判断驱动服务对象是否为null,如果为null则返回,否则进入while循环,这个循环会依次遍历多个数据库驱动,因为jdbc:drivers 会有多个数据库驱动,驱动名是以:分割,接下来就是通过Class.forName依次装载驱动类,在其中使用了 ClassLoader.getSystemClassLoader()系统类装载器。

 

    if (drivers == null) {  
                return;  
            }  
     while (drivers.length() != 0) {  
    …  
    Class.forName(driver, true, ClassLoader.getSystemClassLoader());  
    …  
    }  
 

 

上面分析的就是在registerDriver方法中所要做的第一件事情:初始化。可以看到initialize()做的工作就是装载驱动,同时还 需要使用到系统的一些功能。如: java.security.AccessController.doPrivileged,此方法允许在一个类实例中的代码通知这个 AccessController,它的代码主体享受特权(Privileged),它不管这个请求是由什么代码所引发的,只是单独负责对它可得到的资源 的访问请求。比如说,一个调用者在调用doPrivileged方法时,可被标识为特权。AccessController做访问控制决策时,如果 checkPermission方法遇到一个通过doPrivileged方法调用而被视为特权调用者,那么checkPermission方法不会作许 可检查,表示那个访问请求是被允许的,如果调用者没有许可,则会抛出一个异常。

如:ClassLoader.getSystemClassLoader(),java中所有类都是通过ClassLoader装载的,ClassLoader可以为java程序提供很好的动态特性,有必要去深入理解哦。

接下来再看初始化之后的代码:

 

    DriverInfo di = new DriverInfo();  
        di.driver = driver;  
        di.driverClass = driver.getClass();  
        di.driverClassName = di.driverClass.getName();  
        // Not Required -- drivers.addElement(di);  
        writeDrivers.addElement(di);   
        println("registerDriver: " + di);  
        /* update the read copy of drivers vector */  
        readDrivers = (java.util.Vector) writeDrivers.clone();  
 

 

创建DriverInfo对象
DriverInfo di = new DriverInfo();
DriverInfo驱动信息类,是一个内部类,
源码如下:

 

    class DriverInfo {  
        Driver         driver;  
        Class          driverClass;  
        String         driverClassName;  
        public String toString() {  
        return ("driver[className=" + driverClassName + "," + driver + "]");  
        }  
    }  
 

 

此类就是添加了三个属性,分别表示驱动对象,驱动的Class对象,以及驱动的类名;同时重写了toString方法。此内部类的作用就是以可以创建DriverInfo对象,以对象的形式保存驱动信息。

接下来就是设置对象的三个属性:

 

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

 

然后添加到集合writeDrivers中,这个集合是Vector类型,定义为DriverManager的属性

writeDrivers定义:

 

 
    private static java.util.Vector writeDrivers = new java.util.Vector();  

 

驱动添加到集合

 

 
writeDrivers.addElement(di);  

 

最后就是调用writeDrivers对象的clone方法

 

 
readDrivers = (java.util.Vector) writeDrivers.clone();  

 


readDrivers也是一个类型为Vector的集合,定义为DriverManager的属性

 

    private static java.util.Vector readDrivers = new java.util.Vector();  
 

 

为什么要先添加到writeDrivers然后再 clone到readDrivers中呢?
writeDrivers和 readDrivers两个都是驱动集合,无论是注册驱动抑或是取消注册,都是先对writeDrivers驱动集合中的数据进行添加或删除,然后再把 writeDrivers中的驱动都clone到readDrivers中,每次取出Driver并不是在writeDrivers中,而是在 readDrivers中取得。那么这两个驱动集合便可以这样理解,writeDrivers驱动集合负责注册驱动和注销驱动,readDrivers驱 动集合负责提供可用的驱动对象,readDrivers中的驱动对象应该都是可用的。把二者分开,使用者就不需加任何判断,很方便。
这里又涉及到一个知识就是clone, 有兴趣的朋友可以查看相关JAVA文档,Thinking in java 中也有详细描述。
这就是初始化的全过程,写了这么多,实际上只做一件事情,就是完成所有驱动的加载。装载之后就是连接了,在连载三当中我会详细描述。

 

下面分析一下连接数据库时使用的获取数据库连接的代码:


 

    DriverManager.getConnection(“jdbc:mysql://localhost:3306/test”,”root”,”123”);  
 

 

DriverManager.getConnection方法有三种重载方式,这里我们使用带有三个参数的方法,第一个表示数据库的URL, 第二、三个分别
是用户名和密码。获取数据库连接如此简单,只要把三个参数准确无误的写上去,连接肯定就能获取。但是连接方法中到底给我们做
了哪些工作呢? 下面找到DriverManager类的静态方法getConnection源码一探究竟。

 

    public static Connection getConnection(String url,   
        String user, String password) throws SQLException {  
            java.util.Properties info = new java.util.Properties(); ///1  
            // Gets the classloader of the code that called this method, may   
        // be null.  
        ClassLoader callerCL = DriverManager.getCallerClassLoader(); ///2  
        if (user != null) {  
            info.put("user", user);  
        }  
        if (password != null) {  
            info.put("password", password);  
        }  
            return (getConnection(url, info, callerCL)); ///3  
        }  
 

 

1处定义了一个Properties对象,java.util.Properties它是用来在文件中存储键值对的,其中键和值是用等号分隔的。可以将值以
key-value的形式存入Properties.
2处调用方法getCallerClassLoader得到类装载器对象, 这个地方有点意思,既然是调用方法,怎么变成了下面这种形式呢?根本就
不见方法体。
源码:

    private static native ClassLoader getCallerClassLoader();  
 

 

getCallerClassLoader()是一个静态原生方法,返回类型为ClassLoader, 被声明为native, 说明这个方法是一个原生方法,也就是说
这个方法是用C/C++语言实现的,并且被编译成了DLL,由JAVA调用。这些函数的实体在DLL中,JDK源码并不包含,在JAVA源文件中是
找不到源代码的。不同的平台其实现也有所差异。这也是JAVA的底层机制,实际上JAVA就是在不同的平台上调用不同的native方法实
现对操作系统的访问。native关键字一般是和C/C++联合开发的时候使用。如果标明为native 要求运行时通知操作系统,这个函数必
须给我实现,JAVA需要调用。如果未实现,那么调用时会抛出一个异常java.lang.UnsatisfiedLinkError
接下来判断用户名和密码,并将其存放到Properties对象中:

 

    if (user != null) {  
            info.put("user", user);  
        }  
        if (password != null) {  
            info.put("password", password);  
        }  
 

 

调用获取连接的另一个重载方法

 

getCollection(String url, java.util.Properties info, ClassLoader callerCL)

 

    return (getConnection(url, info, callerCL));  

 

 

getConnection(url, info, callerCL) 源码:

 

  private static Connection getConnection(  
String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {  
java.util.Vector drivers = null;  
synchronized(DriverManager.class) {    
  // synchronize loading of the correct classloader.  
  if(callerCL == null) {  
      callerCL = Thread.currentThread().getContextClassLoader();  
   }      
}   
   
if(url == null) {  
    throw new SQLException("The url cannot be null", "08001");  
}  
     
println("DriverManager.getConnection(/"" + url + "/")");  
     
if (!initialized) {  
    initialize();  
}  
synchronized (DriverManager.class){   
           // use the readcopy of drivers  
    drivers = readDrivers;    
       }  
// Walk through the loaded drivers attempting to make a connection.  
// Remember the first exception that gets raised so we can reraise it.  
SQLException reason = null;  
for (int i = 0; i < drivers.size(); i++) {  
    DriverInfo di = (DriverInfo)drivers.elementAt(i);  
       
    // If the caller does not have permission to load the driver then   
    // skip it.  
    if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {  
    println("    skipping: " + di);  
    continue;  
    }  
    try {  
    println("    trying " + di);  
    Connection result = di.driver.connect(url, info);  
    if (result != null) {  
        // Success!  
        println("getConnection returning " + di);  
        return (result);  
    }  
    } catch (SQLException ex) {  
    if (reason == null) {  
        reason = ex;  
    }  
    }  
}  
     
// if we got here nobody could connect.  
if (reason != null)    {  
    println("getConnection failed: " + reason);  
    throw reason;  
}  
     
println("getConnection: no suitable driver found for "+ url);  
throw new SQLException("No suitable driver found for "+ url, "08001");  
   }  
 

 

此方法代码较多,我们一步步来分析。
1、    传参
从前面的那个getConnection方法中形成的三个参数传递到这个getConnection方法中, 参数包括连接数据库的URL,包装了用户名和
密码的对象info, 通过调用原生函数返回的类装载器callerCL
2、    同步DriverManager.class
同步DriverManager的Class对象,synchronized同步的对象为DriverManager.class,是为同步正确的类加载器来加载类,在同步块
中判断传入的类装载器对象是否存在,如果为null, 通过当前线程来获取上下文类装载器,保证JDBC驱动程序类以外的rt.jar中的类
可以在这里被加载。有关于Thread和synchronized读者可以参考java多线程编程

 

    synchronized(DriverManager.class) {    
          if(callerCL == null) {  
              callerCL = Thread.currentThread().getContextClassLoader();  
           }  
        }   
 

 

3、    判断URL,如果为null则抛出SQLException异常
判断initialized的值,如果未初始化,继续调用初始化方法,此处在第二篇中已详细解释初始化过程,初始化之后writeDrivers 和readDrivers 将会有系统所有驱动数据,接下来使用synchronized同步DriverManager.class对象, 将方法中定义的集合drivers 引用 readDrivers对象,readDrivers是从writeDrivers拷贝过来

 

    if(url == null) {  
        throw new SQLException("The url cannot be null", "08001");  
    }  
    println("DriverManager.getConnection(/"" + url + "/")");  
    if (!initialized) {  
    initialize();  
    }  
    synchronized (DriverManager.class) {   
        // use the readcopy of drivers  
    drivers = readDrivers;    
     }  

 
4、    遍历驱动

通过for循环,遍历drivers集合,其中每个元素的类型为DriverInfo, 这个在第二篇中也有详细描述
首先取得集合中的每一个对象元素,调用getCallerClass()方法

 

  for (int i = 0; i < drivers.size(); i++) {  
        DriverInfo di = (DriverInfo)drivers.elementAt(i);  
        if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {  
            println("    skipping: " + di);  
            continue;  
        }  
……  
}  
 

 

getCallerClass方法源码:

    private static Class getCallerClass(ClassLoader callerClassLoader,   
                        String driverClassName) {  
    Class callerC = null;  
    try {  
    callerC = Class.forName(driverClassName, true, callerClassLoader);  
    }  
    catch (Exception ex) {  
            callerC = null;             
        }  
        return callerC;  
        }  
 

 

    这个方法返回一个Class对象,通过指定的类装载器来装载驱动类。这个方法内做得非常小心,如果出现异常都会把需要返
回的Class对象置为null.
    在if语句中调用getCallerClass方法得到的Class 对象和每一个驱动的Class对象比较,不相等的话就继续执行下一次循环
,否则都调用Driver的connect方法,传入url, 和 info,通过这个方法返回Connection连接对象

Connection result = di.driver.connect(url, info);   

Driver接口的实现类中的connect方法具体所做的工作将在下一篇中详述

 

connect 方法是java.sql.Driver接口中定义的方法,如果连接的数据库不同,那么为不同的数据库编写JDBC驱动将变得很灵活,实现Driver接口 即可。连接数据库时首先得装载JDBC驱动,也就是调用 Class.forName(“com.mysql.jdbc.Driver”)方法,在第一篇中已经列出mysql jdbc Driver类的源码,此类继承NonRegisteringDriver同时实现了java.sql.Driver接口。找到 NonRegisteringDriver类会发现它也实现了java.sql.Driver接口:

 

 
    public class NonRegisteringDriver implements java.sql.Driver {  
        ……  
    }  

 


在getConnection方法中有如下一句代码,
Connection result = di.driver.connect(url, info);

di是DriverInfo类型的对象,此对象中包含了Driver的引用,但是在com.mysql.jdbc.Driver类中只有一个静态块和一个 构造方法,那么connect方法有可能是在其父类中实现。如前所述,父类为NonRegisteringDriver,在mysql驱动包的源码中可以 找到此类,:
com.mysql.jdbc.NonRegisteringDriver

那么di.driver.connect(url, info) 调用的connect方法就是NonRegisteringDriver类中的connect方法,源码如下:

 

 

    public java.sql.Connection connect(String url, Properties info)  
                throws SQLException {  
            if (url != null) {  
                if (StringUtils.startsWithIgnoreCase(url, LOADBALANCE_URL_PREFIX)) {  
                    return connectLoadBalanced(url, info);  
                } else if (StringUtils.startsWithIgnoreCase(url,  
                        REPLICATION_URL_PREFIX)) {  
                    return connectReplicationConnection(url, info);  
                }  
            }  
            Properties props = null;  
            if ((props = parseURL(url, info)) == null) {  
                return null;  
            }  
            try {  
                Connection newConn = com.mysql.jdbc.ConnectionImpl.getInstance(  
                        host(props), port(props), props, database(props), url);  
                return newConn;  
            } catch (SQLException sqlEx) {  
                // Don't wrap SQLExceptions, throw  
                // them un-changed.  
                throw sqlEx;  
            } catch (Exception ex) {  
                SQLException sqlEx = SQLError.createSQLException(Messages  
                        .getString("NonRegisteringDriver.17") //$NON-NLS-1$  
                        + ex.toString()  
                        + Messages.getString("NonRegisteringDriver.18"), //$NON-NLS-1$  
                        SQLError.SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE, null);  
                  
                sqlEx.initCause(ex);  
                  
                throw sqlEx;  
            }  
        }  
 

 

在connect方法中传入了两个参数,一个是String 类型的url, 另一个是Properties类型的连接属性信息。
首先判断url是否为null,此判断逻辑中使用了如下类的方法
调用类com.mysql.jdbc.StringUtils
方法 startsWithIgnoreCase 其中使用了String 类中的方法regionMatches
regionMatches方法两种原型为:

 

 

    public boolean regionMatches(int toffset, String other,   
    int ooffset,int len) { }  
    public boolean regionMatches(boolean ignoreCase, int toffset,  
                               String other, int ooffset, int len) {}  

 
这两个重载的方法用来比较两个字符串中指定区域的子串。

 


传入的静态常量参数:

 

 

    private static final String LOADBALANCE_URL_PREFIX = "jdbc:mysql:loadbalance://";  
    private static final String REPLICATION_URL_PREFIX = "jdbc:mysql:replication://";  
 

 

根据下面的判断调用不同的方法返回Connection对象

 

 

    if (StringUtils.startsWithIgnoreCase(url, LOADBALANCE_URL_PREFIX)) {  
                    return connectLoadBalanced(url, info);  
                } else if (StringUtils.startsWithIgnoreCase(url,  
                        REPLICATION_URL_PREFIX)) {  
                    return connectReplicationConnection(url, info);  
                }  
 

 

如果url为null, 则通过如下方法返回Connection

    try {  
        Connection newConn = com.mysql.jdbc.ConnectionImpl.getInstance(  
                        host(props), port(props), props, database(props), url);  
                return newConn;  
            } catch (SQLException sqlEx) {  
                ……  
            } catch (Exception ex) {  
                  ……  
    }  
    }  
 

 PreparedStatement stmt = conn.prepareStatement(sql);使用得到的connection创建一个Statement。Statement有许多种,我们常用的就是PreparedStatement,用于执行预编译好的SQL语句,CallableStatement用于调用数据库的存储过程。它们的继承关系如下图所示。



一旦有了一个statement,就可以通过执行statement.executeQuery()并通过ResultSet对象读出查询结果(如果查询有返回结果的话)。

创建statement的方法一般都有重载,我们看下面的prepareStatement:

Java代码  收藏代码
  1. public java.sql.PreparedStatement prepareStatement(String sql)  
  2.         throws SQLException {  
  3.     return prepareStatement(sql, java.sql.ResultSet.TYPE_FORWARD_ONLY,  
  4.             java.sql.ResultSet.CONCUR_READ_ONLY);  
  5. }  
  6.   
  7.        public java.sql.PreparedStatement prepareStatement(String sql,  
  8.         int resultSetType, int resultSetConcurrency) throws SQLException;  


如果没有指定resultSetType和resultSetConcurrency的话,会给它们默认设置一个值。
ResultSet中的参数常量主要有以下几种:
TYPE_FORWARD_ONLY: ResultSet的游标只能向前移动。
TYPE_SCROLL_INSENSITIVE:ResultSet的游标可以滚动,但对于resultSet下的数据改变不敏感。
TYPE_SCROLL_SENSITIVE:ResultSet的游标可以滚动,但对于resultSet下的数据改变是敏感的。
CONCUR_READ_ONLY:不可以更新的ResultSet的并发模式。
CONCUR_UPDATABLE:可以更新的ResultSet的并发模式。
FETCH_FORWARD:按正向(即从第一个到最后一个)处理结果集中的行。
FETCH_REVERSE:按反向(即从最后一个到第一个)处理结果集中的行处理。
FETCH_UNKNOWN:结果集中的行的处理顺序未知。
CLOSE_CURSORS_AT_COMMIT:调用Connection.commit方法时应该关闭 ResultSet 对
HOLD_CURSORS_OVER_COMMIT:调用Connection.commit方法时不应关闭ResultSet对象。

prepareStatement的创建如下图所示:



在new ParseInfo中,会对这个sql语句进行分析,例如看看这个sql是什么语句;有没有limit条件语句,还有一个重要的工作,如果使用的是PreparedStatement来准备sql语句的话,会在这里把sql语句进行分解。我们知道PreparedStatement对象在实例化创建时就被设置了一个sql语句,使用PreparedStatement对象执行的sql语句在首次发送到数据库时,sql语句就会被编译,这样当多次执行同一个sql语句时,mysql就不用每次都去编译sql语句了。这个sql语句如果包含参数的话,可以用问号(”?”)来为参数进行占位,而不需要立即为参数赋值,而在语句执行之前,必须通过适当的set***()来为问号处的参数赋值。New ParseInfo()中,包含了参数的sql语句就会被分解为多段,放在staticSql中,以便需要设置参数时定位参数的位置。假如sql语句为“select * from adv where id = ? and name = ?”的话,那么staticSql中的元素就是3个,staticSql[3]={ ”select * from adv where id = ”, ” and name = ” , ””}。注意数组中最后一个元素,在这个例子中是””,因为我的例子里面最后一个就是”?”,如果sql语句是这样的“select * from adv where id = ? and name = ? order by id”的话,staticSql就变成是这样的{ ”select * from adv where id = ”, ” and name = ” , ” order by id”}。


3、stmt.setInt(1, new Integer(1));
设置sql语句中的参数值。
对于参数而言,PreparedStatement中一共有四个变量来储存它们,分别是
a) byte[][] parameterValues:参数转换为byte后的值。
b) InputStream[] parameterStreams:只有在调用存储过程batch(CallableStatement)的时候才会用到它,否则它的数组中的值设置为null。
c) boolean[] isStream:是否为stream的标志,如果调用的是preparedStatement,isStream数组中的值均为false,若调用的是CallableStatement,则均设置为true。
d) boolean[] isNull:标识参数是否为空,设置为false。
这四个变量的一维数组的大小都是一样的,sql语句中有几个待set的参数(几个问号),一维的元素个数就是多大。


4、ResultSet rs = stmt.executeQuery();
一切准备就绪,开始执行查询罗!
a) 检查preparedStatement是否已关闭,如果已关闭,抛出一个SQLError.SQL_STATE_CONNECTION_NOT_OPEN的错误。

b) fillSendPacket:创建数据包,其中包含了要发送到服务器的查询。
这个sendPacket就是mysql驱动要发送给数据库服务器的协议数据。一般来说,协议的数据格式有两种,一种是二进制流的格式,还有一种是文本的格式。文本协议就是基本上人可以直接阅读的协议,一般是用ascii字符集,也有用utf8格式的,优点是便于理解,读起来方便,扩充容易,缺点就是解析的时候比较麻烦,而且占用的空间比较大,冗余的数据比较多。二进制格式话,就需要服务器与客户端协议规定固定的数据结构,哪个位置放什么数据,如果单独看协议内容的话,很难理解数据含义,优点就是数据量小,解析的时候只要根据固定位置的值就能知道具体标识什么意义。
在这里使用的是二进制流的格式,也就是说协议中的数据格式是固定的,而且都要转换成二进制。格式为第一个byte标识操作信号,后面开始就是完整的sql语句的二进制流,请看下面的代码分析。

Java代码  收藏代码
  1.     protected Buffer fillSendPacket(byte[][] batchedParameterStrings,  
  2.             InputStream[] batchedParameterStreams, boolean[] batchedIsStream,  
  3.             int[] batchedStreamLengths) throws SQLException {  
  4.         // 从connection的IO中得到发送数据包,首先清空其中的数据  
  5.         Buffer sendPacket = this.connection.getIO().getSharedSendPacket();  
  6.         sendPacket.clear();  
  7.           
  8.         /* 数据包的第一位为一个操作标识符(MysqlDefs.QUERY),表示驱动向服务器发送的连接的操作信号,包括有QUERY, PING, RELOAD, SHUTDOWN, PROCESS_INFO, QUIT, SLEEP等等,这个操作信号并不是针对sql语句操作而言的CRUD操作,从提供的几种参数来看,这个操作是针对服务器的一个操作。一般而言,使用到的都是MysqlDefs.QUERY,表示发送的是要执行sql语句的操作。 
  9. */  
  10.         sendPacket.writeByte((byte) MysqlDefs.QUERY);  
  11.   
  12.         boolean useStreamLengths = this.connection  
  13.                 .getUseStreamLengthsInPrepStmts();  
  14.   
  15.         int ensurePacketSize = 0;  
  16.         for (int i = 0; i < batchedParameterStrings.length; i++) {  
  17.             if (batchedIsStream[i] && useStreamLengths) {  
  18.                 ensurePacketSize += batchedStreamLengths[i];  
  19.             }  
  20.         }  
  21.   
  22.         /* 判断这个sendPacket的byte buffer够不够大,不够大的话,按照1.25倍来扩充buffer 
  23. */  
  24.         if (ensurePacketSize != 0) {  
  25.             sendPacket.ensureCapacity(ensurePacketSize);  
  26.         }  
  27.   
  28.         /* 遍历所有的参数。在prepareStatement阶段的new ParseInfo()中,驱动曾经对sql语句进行过分割,如果含有以问号标识的参数占位符的话,就记录下这个占位符的位置,依据这个位置把sql分割成多段,放在了一个名为staticSql的字符串中。这里就开始把sql语句进行拼装,把staticSql和parameterValues进行组合,放在操作符的后面。 
  29. */  
  30.         for (int i = 0; i < batchedParameterStrings.length; i++) {  
  31.   
  32.         /* batchedParameterStrings就是parameterValues,batchedParameterStreams就是parameterStreams,如果两者都为null,说明在参数的设置过程中出了错,立即抛出错误。 
  33. */  
  34.             if ((batchedParameterStrings[i] == null)  
  35.                     && (batchedParameterStreams[i] == null)) {  
  36.                 throw SQLError.createSQLException(Messages  
  37.                         .getString("PreparedStatement.40"//$NON-NLS-1$  
  38.                         + (i + 1), SQLError.SQL_STATE_WRONG_NO_OF_PARAMETERS);  
  39.             }  
  40.   
  41.         /*在sendPacket中加入staticSql数组中的元素,就是分割出来的没有”?”的sql语句,并把字符串转换成byte。 
  42. */  
  43.             sendPacket.writeBytesNoNull(this.staticSqlStrings[i]);  
  44.   
  45.         /* batchedIsStream就是isStream,如果参数是通过CallableStatement传递进来的话,batchedIsStream[i]==true,就用batchedParameterStreams中的值填充到问号占的参数位置中去。 
  46. */  
  47.             if (batchedIsStream[i]) {  
  48.                 streamToBytes(sendPacket, batchedParameterStreams[i], true,  
  49.                         batchedStreamLengths[i], useStreamLengths);  
  50.             } else {  
  51.               
  52.         /*否则的话,就用batchedParameterStrings,也就是parameterValues来填充参数位置。在循环中,这个操作是跟在staticSql后面的,因此就把第i个参数加到了第i个staticSql段中。参考前面的staticSql的例子,发现当循环结束的时候,原始sql语句最后一个”?”之前的sql语句就拼成了正确的语句了。 
  53. */  
  54.     sendPacket.writeBytesNoNull(batchedParameterStrings[i]);  
  55.             }  
  56.         }  
  57.   
  58.         /*由于在原始的包含问号的sql语句中,在最后一个”?”后面可能还有order by等语句,因此staticSql数组中的元素个数一定比参数的个数多1,所以这里把staticSqlString中的最后一段sql语句放入sendPacket中。 
  59. */  
  60.         sendPacket  
  61.                 .writeBytesNoNull(this.staticSqlStrings[batchedParameterStrings.length]);  
  62.   
  63.         return sendPacket;  
  64.     }  


假如sql语句为“select * from adv where id = ?”的话,这个sendPacket中第一个byte的值就是3(MysqlDefs.QUERY的int值),后面接着的就是填充了参数值的完整的sql语句字符串(例如:select * from adv where id = 1)转换成的byte格式。

于是,我们看到,好像sql语句在这里就已经不是带”?”的preparedStatement,而是在驱动里面把参数替代到”?”中,再把完整的sql语句发送给mysql server来编译,那么尽管只是参数改变,但对于mysql server来说,每次都是新的sql语句,都要进行编译的。这与我们之前一直理解的PreparedStatement完全不一样。照理来说,应该把带”?”的sql语句发送给数据库server,由mysql server来编译这个带”?”的sql语句,然后用实际的参数来替代”?”,这样才是实现了sql语句只编译一次的效果。sql语句预编译的功能取决于server端,oracle就是支持sql预编译的。

所以说,从mysql驱动的PreparedStatement里面,好像我们并没有看到mysql支持预编译功能的证据。(实际测试也表明,如果server没有预编译功能的话,PreparedStatement和Statement的效率几乎一样,甚至当使用次数不多的时候,PreparedStatement比Statement还要慢一些)。
但是并不是说PreparedStatement除了给我们带来高效率就没有其他作用了,它还有非常好的其他作用:
i. 极大的提高了sql语句的安全性,可以防止sql注入
ii. 代码结构清晰,易于理解,便于维护。

2009-07-02增加(感谢gembler):其实,在mysql5上的版本是支持预编译sql功能的。我用的驱动是5.0.6的,在com.mysql.jdbc.Connection中有一个参数useServerPreparedStmts,表明是否使用预编译功能,所以如果把useServerPreparedStmts置为true的话,mysql驱动可以通过PreparedStatement的子类ServerPreparedStatement来实现真正的PreparedStatement的功能。在这个类的serverExecute方法里面,就负责告诉server,用现在提供的参数来动态绑定到编译好的sql语句上。所以说,ServerPreparedStatement才是真正实现了所谓prepare statement。


c) 设置当前的数据库名,并把之前的数据库名记录下来,在查询完成之后还要恢复原状。

d) 检查一下之前是否有缓存的数据,如果不久之前执行过这个查询,并且缓存了数据的话,就直接从缓存中取出。

e) 如果sql查询没有限制条件的话,为其设置默认的返回行数,若preparedStatement中已经设置了maxRows的话,就使用它。

f) executeInternal:执行查询。
i. 设置当前数据库连接,并调用connection的execSQL来执行查询.然后继续把要发送的查询包,就是之间组装完毕的sendPacket传递进入MysqlIO的sqlQueryDirect()。
ii.接下来就要往server端发送我们的查询指令啦(sendCommand),说到发送数据,不禁要问,如果这个待发送的数据包超级大,难道每次都是一次性的发送吗?当然不是,如果数据包超过规定的最大值的话,就会把它分割一下,分成几个不超过最大值的数据包来发送。
所以可以肯定,在分割的过程中,除了最后一个数据包,其他数据包的大小都是一样的。那就这样的数据包直接切割了进行发送的话,假如现在被分成了三个数据包,发送给mysql server,服务器怎么知道那个包是第一个呢,它读数据该从什么地方开始读呢,这都是问题,所以,我们要给每个数据包的前面加上一点属性标志,这个标志一共占了4个byte。从代码①处开始就是头标识位的设置。第一位表示数据包的开始位置,就是数据存放的起始位置,一般都设置为0,就是从第一个位置开始。第二和第三个字节标识了这个数据包的大小,注意的是,这个大小是出去标识的4个字节的大小,对于非最后一个数据包来说,这个大小都是一样的,就是splitSize,也就是maxThreeBytes,它的值是255 * 255 * 255。
最后一个字节中存放的就是数据包的编号了,从0开始递增。
在标识位设置完毕之后,就可以把255 * 255 * 255大小的数据从我们准备好的待发送数据包中copy出来了,注意,前4位已经是标识位了,所以应该从第五个位置开始copy数据。
在数据包都装配完毕之后,就可以往socket的outputSteam中发送数据了。接下来的事情,就是由mysql服务器接收数据并解析,执行查询了。

Java代码  收藏代码
  1. while (len >= this.maxThreeBytes) {  
  2.     this.packetSequence++;  
  3.     /*设置包的开始位置*/  
  4.    headerPacket.setPosition(0);   
  5.     /*设置这个数据包的大小,splitSize=255 * 255 * 255*/  
  6.     headerPacket.writeLongInt(splitSize);   
  7.     /*设置数据包的序号*/  
  8.     headerPacket.writeByte(this.packetSequence);   
  9.     /*origPacketBytes就是sendPacket,所以这里就是把sendPacket中大小为255 * 255 * 255的数据放入headPacket中,headerPacketBytes是headPacket的byte buffer*/  
  10.     System.arraycopy(origPacketBytes, originalPacketPos,  
  11.         headerPacketBytes, 4, splitSize);  
  12.   
  13.     int packetLen = splitSize + HEADER_LENGTH;  
  14.     if (!this.useCompression) {  
  15.         this.mysqlOutput.write(headerPacketBytes, 0,  
  16.             splitSize + HEADER_LENGTH);  
  17.         this.mysqlOutput.flush();  
  18.     } else {  
  19.         Buffer packetToSend;  
  20.   
  21.         headerPacket.setPosition(0);  
  22.         packetToSend = compressPacket(headerPacket, HEADER_LENGTH,  
  23.                 splitSize, HEADER_LENGTH);  
  24.         packetLen = packetToSend.getPosition();  
  25.         /*往IO的output stream中写数据*/  
  26.         this.mysqlOutput.write(packetToSend.getByteBuffer(), 0,  
  27.             packetLen);  
  28.         this.mysqlOutput.flush();  
  29.     }  
  30.   
  31.     originalPacketPos += splitSize;  
  32.     len -= splitSize;  
  33. }  


iii.通过readAllResults方法读取查询结果。这个读取的过程与发送过程相反,如果接收到的数据包有多个的话,通过IO不断读取,并根据第packet第4个位置上的序号来组装这些packet。然后把读到的数据组装成resultSet中的rowData,这个结果就是我们要的查询结果了。

结合下面的executeQuery的时序图再理一下思路就更清楚了。



至此,把resultSet一步步的返回给dao,接下来的过程,就是从resultSet中取出rowData,组合成我们自己需要的对象数据了。

总结一下,经过这次对mysql驱动的探索,我发现了更多关于mysql的底层细节,对于以后分析问题解决问题有很大帮助,当然,这里面还有很多细节文中没有写。另外一个就是对于PreparedStatement有了重新的认识,有些东西往往都是想当然得出来的结论,真相还是要靠实践来发现。

 

 

未完待续......

(选自 http://blog.csdn.net/brilliancezhou/article/details/5425655)

 


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:12656次
    • 积分:512
    • 等级:
    • 排名:千里之外
    • 原创:40篇
    • 转载:1篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档