jdbc实现篇-源码（Oracle、MySQL）-第一部分-Dirver注册和获取及Connection获取原理

简单说下，本文是说源码的，但是不会一篇文章就说得很深入，本文是【jdbc源码入口篇】，分别会说明一些源码和使用细节，所提及的源码可能相对于jdbc的源码还是初级看源码，看个大概，细节上还有很多东西，后续有时间会跟进；

文章会以oracle、mysql jdbc的实现的源码作为说明的依据来参考；

首先，我们要创建一个链接（连接池是在内部做的），会操作：

Class.forName("xxx.xxx.xxxx.xxx");//类名通常为jdbc的Dirver；

oracle的一般是：

oracle.jdbc.driver.OracleDriver

而mysql通常是：

com.mysql.jdbc.Driver

sql server通常是(本人很少使用SQL Server，所以文章中不会出现SQL server的Driver细节)：

com.microsoft.sqlserver.jdbc.SQLServerDriver

然后我们才能用：

DriverManager.getConnection()

方法来获取链接；我们知道这个是获取一个Cnnection，那么我们首先来看看DriverManager的getConnection到底做了什么？为什么必须要Class.forName才行；

跟踪DriverManager类进去发现有四个getConnection方法：

1、所有参数全部通过URL传递过去

getConnection(String url);

2、用户名和密码单独传递：

getConnection(String url , String user , String password);

3、传递多个参数的K-V结构

getConnection(String url , Properties properties);

4、传递多个参数后，还加上指定的ClassLoader，很少用，当跨ClassLoader访问的时候需要使用到，默认使用当前线程的ClassLoader;

getConnection(String url , Properties properties , ClassLoader callerCL);

其实无论如何，会调用到最后一个方法，最后一个方法主要代码为：

private static Connection getConnection(
      String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {

      java.util.Vector drivers = null;
      synchronized(DriverManager.class) {
          if(callerCL == null) {
                callerCL = Thread.currentThread().getContextClassLoader();//如果没传递CLassLoader用当前线程的
          }    
      } 
 
      if(url == null) {
           throw new SQLException("The url cannot be null", "08001");//没有传递URL，则抛出异常
      }

      //注意这个日志，默认是打印不出来的，程序内部会去判定logWriter是否为空，若为空则不会输出，默认也没有值
      println("DriverManager.getConnection(\"" + url + "\")");
    
      if (!initialized) {//初始化，不过几乎可以忽略
        initialize();
      }


      synchronized (DriverManager.class){ 
          drivers = readDrivers; // readDrivers为一个类变量，下面的部分我们看看是如何被注册的
      }

      SQLException reason = null;
      for (int i = 0; i < drivers.size(); i++) {//循环扫描所有的Drivers
            DriverInfo di = (DriverInfo)drivers.elementAt(i);
            if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {//如果类和类的ClassLoader不匹配，跳过
               println("    skipping: " + di);
               continue;
            }
            try {
                 println("    trying " + di);
                 Connection result = di.driver.connect(url, info);//调用对应Driver的connect方法，得到Connection对象
                 if (result != null) {//如果得到了，则返回connection
                      // 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");//没有获取到链接会抛出一个SQL Exception
}

先不用看其他的代码，我们首先可以看出一点DriverManager中注册不止一个Driver驱动，如果一些系统中有多个驱动的时候，然后它循环扫描所有的驱动程序，然后通过connect方法获取是否来调用，这个connect方法每次去循环扫描，是不是会造成一些不必要的开销；为此，我们想看看里面到底有那些Driver，以及得到对应的Driver，输出Driver信息：

我们可以通过以下方式输出循环了那些内容：

方法1：

Enumeration<Driver> enumeration = DriverManager.getDrivers();

然后遍历这个迭代器，就可以得到这些Driver相关信息，可以自己根据实际情况作其他的操作也可以，可以看出Driver就是一个普通java类的实例，只是他有一些基于标准规范，类似于驱动链接的功能而已；

方法2：

设置将Log输出，将数据输出到控制台，我们这里简单输出到控制台：

DriverManager.setLogWriter(new PrintWriter(System.out));

运行这个getConnection方法、getDriver等方法的时候，就会打印出相应的日志信息在控制台上面；

例如运行getConnection方法：

DriverManager.getConnection("jdbc:oracle:thin:@10.20.149.82:1521:fuck")
    trying driver[className=sun.jdbc.odbc.JdbcOdbcDriver,sun.jdbc.odbc.JdbcOdbcDriver@14b9a74]
*Driver.connect (jdbc:oracle:thin:@10.20.149.82:1521:fuck)
    trying driver[className=com.mysql.jdbc.Driver,com.mysql.jdbc.Driver@1779e93]
    trying driver[className=oracle.jdbc.OracleDriver,oracle.jdbc.OracleDriver@1871e77]
getConnection returning driver[className=oracle.jdbc.OracleDriver,oracle.jdbc.OracleDriver@1871e77]

其实DirverManager里面还有一个方法是：

getDriver(String url)方法，其实更加确切的意思应该叫findDriverByUrl，入口参数为url，也就是jdbc url，它是负责匹配url是不是这个dirver可以接受的，每个driver都需要实现一个方法叫：acceptsURL来返回，当前这个Dirver是否可以接受这个URL；而acceptsURL方法是各个厂商提供的驱动程序自己编写的，也就是自己编写这个方法说明我是否支持这个URL，类似Oracle、Mysql、sql server等等数据库都会有不同的jdbc驱动包，所以他们自然就区分开了；而对应到类里面，就是前面在Class.forName("xxx")所对应的类。

在getConection方法中，会不断尝试的connect方法中，传入的URL也将会被先判定，然后再执行，jdbc通常认为connect方法本身需要判定一次，就不需要再调用acceptsURL判定一次再调用connection方法了，判定成功就直接返回connection，否则就返回null；只是有个问题是，如果有很多Driver，这里需要逐个遍历，所以文章后面我们建议是将自己的Driver保存起来；

接下来看看每个Driver的connect方法的细节，因为他是负责返回connection的，不过我们可以先看看其中调用解析URL是在哪里调用的，如下：

对于oracle的connect方法相关部分的源码为（OracleDirver类中）：

mysq相关的源码为（为com.mysql.jdbc.Dirver（你注册的MySQL驱动）类的父类的：NonRegisteringDriver（同一包）中）：

注意parseURL方法就是acceptURL方法调用的下一个目标，内部被隐藏了，例如Mysql jdbc的源码中：

public booleanacceptsURL(String url) throws SQLException {
return (parseURL(url, null) != null);
}

我们这里分别来说下parseURL的一些细节：

在OracleDriver中：

private Hashtable parseUrl(String s)
        throws SQLException
    {
        Hashtable hashtable = new Hashtable(5);
        int i = s.indexOf(':', s.indexOf(':') + 1) + 1;//第二个冒号(注意里面还有一个indexOf，所以是第二个)
        int j = s.length();
        if(i == j)
            return hashtable;
        int k = s.indexOf(':', i);//第三个冒号
        if(k == -1)
            return hashtable;
        hashtable.put("protocol", s.substring(i, k));//第二个冒号和第三个冒号之间的认为是协议，比如thin或oci等等
        int l = k + 1;
        int i1 = s.indexOf('/', l);//解析反斜杠
        int j1 = s.indexOf('@', l);//解析@符号的位置
        if(j1 > l && l > i && i1 == -1)//如果既没有反斜杠也没有@则返回null，解析失败
            return null;
        if(j1 == -1)
            j1 = j;
        if(i1 == -1)
            i1 = j1;
        if(i1 < j1)
        {//如果有反斜杠（在@前面），则认为在jdbc URL上传递了用户名和密码，当然可以不传递
            hashtable.put("user", s.substring(l, i1));
            hashtable.put("password", s.substring(i1 + 1, j1));
        }
        if(j1 < j)//如果传递了数据库信息，则将数据库连接串放进去，可以是IP:PORT:SID、describe、TNS等多种格式
            hashtable.put("database", s.substring(j1 + 1));
        return hashtable;
    }

它将jdbc url解析为一个Hash table，并且将协议、db信息解析出来，并且可以放用户名和密码，这样估计很少有人在oracle jdbc url上方用户名和密码，但是的确是可行的，例如你可以这样写你的oracle jdbc：

jdbc:oracle:thin:<user>/<passowrd>@ip:port:sid

然后在DriverManager.getConnection的参数时候就【无需传入用户名和密码】了；

通常的写法更多是：

jdbc:oracle:thin:@ip:port:sid

然后在getConnection的时候，带上用户名和密码

其实MYSQL也是这样，URL上可以传递，只是Oracle在URL上最多就加这些了，不能再加其他的了，而MySQL很麻烦的就在解析URL上面；

MySQL的解析部分：

mysql的解析部分比较复杂，以为内mysql大部分参数都可以通过URL来设置，所以解析很复杂，这里就简单列举部分代码：

public Properties parseURL(String url, Properties defaults)
    throws java.sql.SQLException {
        Properties urlProps = (defaults != null) ? new Properties(defaults) : new Properties();
        
        if (url == null) {//主要看看参数是不是空的
           return null;
        }


        //这几个常量就是mysql jdbc 的前缀特征，如果一个都不符合，则返回null，标示解析失败
        //REPLICATION_URL_PREFIX "jdbc:mysql:replication://"
        //URL_PREFIX   "jdbc:mysql://"
        //MXJ_URL_PREFIX  "jdbc:mysql:mxj://";
        //LOADBALANCE_URL_PREFIX "jdbc:mysql:loadbalance://"; 集群下使用
        if (!StringUtils.startsWithIgnoreCase(url ,URL_PREFIX) 
              && !StringUtils.startsWithIgnoreCase(url ,MXJ_URL_PREFIX)
              && !StringUtils.startsWithIgnoreCase(url , LOADBALANCE_URL_PREFIX)
              && !StringUtils.startsWithIgnoreCase(url , REPLICATION_URL_PREFIX)) { //$NON-NLS-1$
             return null;
       }

       int beginningOfSlashes = url.indexOf("//");//分析content部分，后面将会是IP、PORT、库名以及扩展串

       if (StringUtils.startsWithIgnoreCase(url, MXJ_URL_PREFIX)) {
            urlProps.setProperty("socketFactory" , "com.mysql.management.driverlaunched.ServerLauncherSocketFactory");
       }
       int index = url.indexOf("?"); //参数分隔符号
       if (index != -1) {//如果带有非默认参数，则循环
           String paramString = url.substring(index + 1, url.length());
           url = url.substring(0, index);


           StringTokenizer queryParams = new StringTokenizer(paramString, "&");//拆分每个参数，放在迭代器上


           while (queryParams.hasMoreTokens()) {//迭代每个参数
               String parameterValuePair = queryParams.nextToken();
               int indexOfEquals = StringUtils.indexOfIgnoreCase(0 , parameterValuePair, "=");//拆分K-V，即参数和值

               String parameter = null;
               String value = null;

               if (indexOfEquals != -1) {
                   parameter = parameterValuePair.substring(0, indexOfEquals);

                   if (indexOfEquals + 1 < parameterValuePair.length()) {
                       value = parameterValuePair.substring(indexOfEquals + 1);
                   }
              }

              //将数据放在urlProps中，为一个当前Driver全局参数配置Properties类型
              if ((value != null && value.length() > 0) && (parameter != null && parameter.length() > 0)) {
                 try {
                       urlProps.put(parameter, URLDecoder.decode(value , "UTF-8"));
                 } catch (UnsupportedEncodingException badEncoding) {
                       // punt
                       urlProps.put(parameter, URLDecoder.decode(value));
                 } catch (NoSuchMethodError nsme) {
                       // punt again
                       urlProps.put(parameter, URLDecoder.decode(value));
                 }
          }
       }
}
......

好了，还有些代码没贴，太多了，上面的URL解析知道是那个Driver去解析后，然后getConection就是newXXXConnection的问题，当然如果自己设置Properties这些参数会做相关的设置，例如Oracle的Properties参数中除了正常的参数外，还可以设置（一般情况下保持默认就可以了，后续的文章中我会提到一些参数，并根据源码说明它的默认值）：

database、server、protocol、dll、prefetch、rowPrefetch、defaultRowPrefetch、batch、executeBatch、defaultExecuteBatch、remarks、remarksReporting、synonyms、includeSynonyms、restrictGetTables、fixedString、dataSizeUnits、AccumulateBatchResult

等等参数；

如源码所示（还是在connect方法中）：

同时oracle还可能是：oracle.jdbc.ultra.client.Driver（一般用不到，知道有就可以，在源码中有体现）。也有可能是OCI接口（OracleOCIConnection）；如果是在我们大多数用thin的模式下，最终会调用：

neworacle.jdbc.driver.OracleConnection(dbaccess, s1, s2, s3, s4, properties);

这些参数细节，下一篇文章说，这里要说进去很多。

而mysql的参数都在parserURL里面被设置到Driver的全局变量中（PropertiesurlProps），在解析后，只需要解析后直接new一个com.mysql.jdbc.Connection就可以了；

我们现在知道connection通过【对应driver】的【connect】方法如何new出来了，也可以看出每次请求DirverManger.getConnection都会new 一个Connection出来（所以要注意连接池的用途，需要对connection提供调度等策略）；

调用getConection的时候，还会遍历所有【被注册的Dirver】，所以我们也想办法让它尽量【不要被反复遍历】，顺便提及下，大家别被Dirver吓怕了，其实我们看看源码，其实就是一个对象嘛，只是它的功能有点像驱动而已，他提供一些注册和链接的方法，被我们成为Driver；

回过头来，Driver是在什么时候被注册到DriverManager里面的呢？奇怪，如果未被注册，肯定是获取不到的，看看自己的代码：

Class.forName("dddd");

为什么要写这一句，这一句话简单来讲仅仅是用当前的CLassLoader将一个类进行装载的代码，若已经装载，什么也不会做；

但是DriverManager里面怎么知道的呢？难道所有的类都在里面，那要遍历起来太吓人了，而且我们开始输出过所有的Driver这是错误的，而且Dirver都要求有相应的方法，难道是都implements Driver？有这种可能性，在方法实现上可以做到；

到底是怎么样的呢？

其实在Oracle JDBC或MySQL JDBC里面都一个【static匿名块】，static 匿名块是当你【第一次访问这个Class（类）的时候】，会被调用，以后不会被重新初始化，分别如下：

Orale的oracle.jdbc.driver.OracleDriver类里面：

可见，他自己调用了DriverManager.registerDirever方法，注册进去，然后new了一个自己；使得自己是全局单例的；

再看看MySQL的：

在类：com.mysql.jdbc.Driver类中:

同样的方式，进行注册了，原来是这样，忽悠了很久，不是什么人名字，而是提供了registerDriver(Dirver driver)方法来注册；

我们再来看看注册到底做了什么：

DriverManager.registerDriver()我们看看：

说明什么，就是做了一个类似于List的东西(内部可以看出它是用Vector实现的，java用vector其实是很早的写法，不过由于这部分代码实际应用中一般不会被经常调用，所以先关的代码也没有做多少修改)，然后将数据写进去，原来注册这么简单，当你有一天要来注册某种链接的时候，你要基于一个统一标准来写的时候，就可以用这种方式注册了，例如，你自己写一个某种数据库库的链接对象，或对某些NoSQL做二次包装，这样上面的程序就可以变得比较通用了；

通过上面的可以看出，放在static匿名块中的代码是在第一次访问这个类的时候被调用，所以不一定非要用Class.forName()因为这样就是访问了这个类；你可以调用这个类里面的一个静态方法，或new一个出来都会访问到这个类，当然driver为了避免重复创建，所以我们一般不用new而已，因为他自己会内部创建一个注册到Driver中，除非调用DriverManager.deregisterDriver(Driver driver)来取消注册，将Driver中被注册的那个对象去掉；

原理上我们说得差不多了，有些地方其实我们可以节约一些开销，当然不是特别关键的；

其一：

我们发现每次通过DriverManager.getConnection都需要去遍历获取Driver然后去调用connect方法，其实我们认为Driver获取一次就可以了，对于相同类型的driver，一般我们的程序就可以认出来是mysql还是oracle；

所以我们可以通过DriverManager.getDriver(url)只获取一次，你可以放入一个模型就可以，分别表示：

oracleDriver、mySqlDriver，这样就直接调用对应的driver了；

例如：

private static OracleDriver oracleDriver = null;


static {
   try {
      //Class.forName("oracle.jdbc.driver.OracleDriver");
      OracleDriver.getCompileTime();//随便访问一个静态方法即可，其实只是想访问下这个类，Class.forName是最简单的访问。
      oracleDriver = (OracleDriver) DriverManager.getDriver("jdbc:oracle:thin:@ip:port:sid");
    } catch (Exception e) {
      e.printStackTrace();
   }
}

这样这个OracleDriver就被保存起来，以后就可以直接使用oracleDriver.connect来获取链接了。

其二：

你也可以new一个driver出来，但是注意这里请保持单利，这样会比较好，一些全局设置可以再全局生效，上面也说了，不推荐，只是说他是一种方法而已；

例如：

private final static Driver oracleDriver = new OracleDriver();

最后DriverManager里面还有些其他的方法，比如一些去掉注册的方法之类的，如果对于注册较多的情况下，需要将一些不需要的去掉，可以再这进行参考；

下一篇文章，会提及到Connection获取的一些细节，就是具体某个Driver中Connection类的实现体，以及PrepareStatement实现，setTimeout实现机制、fetchSize内部运行

后面还会继续介绍，和数据库交互过程中，反解析数据的过程，中断链接的原理等具体的实现。

不过肯定不会将所有的源码全部说到，因为有很多不常用，例如存储过程的调用之类的，暂时不是提到。