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

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

[java]  view plaincopy

1. private static Connection getConnection(  
2.       String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {  
3.   
4.       java.util.Vector drivers = null;  
5.       synchronized(DriverManager.class) {  
6.           if(callerCL == null) {  
7.                 callerCL = Thread.currentThread().getContextClassLoader();//如果没传递CLassLoader用当前线程的  
8.           }      
9.       }   
10.    
11.       if(url == null) {  
12.            throw new SQLException("The url cannot be null", "08001");//没有传递URL，则抛出异常  
13.       }  
14.   
15.       //注意这个日志，默认是打印不出来的，程序内部会去判定logWriter是否为空，若为空则不会输出，默认也没有值  
16.       println("DriverManager.getConnection(\"" + url + "\")");  
17.       
18.       if (!initialized) {//初始化，不过几乎可以忽略  
19.         initialize();  
20.       }  
21.   
22.   
23.       synchronized (DriverManager.class){   
24.           drivers = readDrivers; // readDrivers为一个类变量，下面的部分我们看看是如何被注册的  
25.       }  
26.   
27.       SQLException reason = null;  
28.       for (int i = 0; i < drivers.size(); i++) {//循环扫描所有的Drivers  
29.             DriverInfo di = (DriverInfo)drivers.elementAt(i);  
30.             if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {//如果类和类的ClassLoader不匹配，跳过  
31.                println("    skipping: " + di);  
32.                continue;  
33.             }  
34.             try {  
35.                  println("    trying " + di);  
36.                  Connection result = di.driver.connect(url, info);//调用对应Driver的connect方法，得到Connection对象  
37.                  if (result != null) {//如果得到了，则返回connection  
38.                       // Success!  
39.                       println("getConnection returning " + di);  
40.                       return (result);  
41.                  }  
42.            } catch (SQLException ex) {  
43.                  if (reason == null) {  
44.                     reason = ex;  
45.                  }  
46.           }  
47.      }  
48.       
49.      // if we got here nobody could connect.  
50.      if (reason != null)    {  
51.           println("getConnection failed: " + reason);  
52.           throw reason;  
53.      }  
54.       
55.       println("getConnection: no suitable driver found for "+ url);  
56.       throw new SQLException("No suitable driver found for "+ url, "08001");//没有获取到链接会抛出一个SQL Exception  
57. }  

先不用看其他的代码，我们首先可以看出一点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方法：

[java]  view plaincopy

1. DriverManager.getConnection("jdbc:oracle:thin:@10.20.149.82:1521:fuck")  
2.     trying driver[className=sun.jdbc.odbc.JdbcOdbcDriver,sun.jdbc.odbc.JdbcOdbcDriver@14b9a74]  
3. *Driver.connect (jdbc:oracle:thin:@10.20.149.82:1521:fuck)  
4.     trying driver[className=com.mysql.jdbc.Driver,com.mysql.jdbc.Driver@1779e93]  
5.     trying driver[className=oracle.jdbc.OracleDriver,oracle.jdbc.OracleDriver@1871e77]  
6. 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 boolean acceptsURL(String url) throws SQLException {
   return (parseURL(url, null) != null);
}

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

在OracleDriver中：

[java]  view plaincopy

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

它将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来设置，所以解析很复杂，这里就简单列举部分代码：

[java]  view plaincopy

1. public Properties parseURL(String url, Properties defaults)  
2.     throws java.sql.SQLException {  
3.         Properties urlProps = (defaults != null) ? new Properties(defaults) : new Properties();  
4.           
5.         if (url == null) {//主要看看参数是不是空的  
6.            return null;  
7.         }  
8.   
9.   
10.         //这几个常量就是mysql jdbc 的前缀特征，如果一个都不符合，则返回null，标示解析失败  
11.         //REPLICATION_URL_PREFIX "jdbc:mysql:replication://"  
12.         //URL_PREFIX   "jdbc:mysql://"  
13.         //MXJ_URL_PREFIX  "jdbc:mysql:mxj://";  
14.         //LOADBALANCE_URL_PREFIX "jdbc:mysql:loadbalance://"; 集群下使用  
15.         if (!StringUtils.startsWithIgnoreCase(url ,URL_PREFIX)   
16.               && !StringUtils.startsWithIgnoreCase(url ,MXJ_URL_PREFIX)  
17.               && !StringUtils.startsWithIgnoreCase(url , LOADBALANCE_URL_PREFIX)  
18.               && !StringUtils.startsWithIgnoreCase(url , REPLICATION_URL_PREFIX)) { //$NON-NLS-1$  
19.              return null;  
20.        }  
21.   
22.        int beginningOfSlashes = url.indexOf("//");//分析content部分，后面将会是IP、PORT、库名以及扩展串  
23.   
24.        if (StringUtils.startsWithIgnoreCase(url, MXJ_URL_PREFIX)) {  
25.             urlProps.setProperty("socketFactory" , "com.mysql.management.driverlaunched.ServerLauncherSocketFactory");  
26.        }  
27.        int index = url.indexOf("?"); //参数分隔符号  
28.        if (index != -1) {//如果带有非默认参数，则循环  
29.            String paramString = url.substring(index + 1, url.length());  
30.            url = url.substring(0, index);  
31.   
32.   
33.            StringTokenizer queryParams = new StringTokenizer(paramString, "&");//拆分每个参数，放在迭代器上  
34.   
35.   
36.            while (queryParams.hasMoreTokens()) {//迭代每个参数  
37.                String parameterValuePair = queryParams.nextToken();  
38.                int indexOfEquals = StringUtils.indexOfIgnoreCase(0 , parameterValuePair, "=");//拆分K-V，即参数和值  
39.   
40.                String parameter = null;  
41.                String value = null;  
42.   
43.                if (indexOfEquals != -1) {  
44.                    parameter = parameterValuePair.substring(0, indexOfEquals);  
45.   
46.                    if (indexOfEquals + 1 < parameterValuePair.length()) {  
47.                        value = parameterValuePair.substring(indexOfEquals + 1);  
48.                    }  
49.               }  
50.   
51.               //将数据放在urlProps中，为一个当前Driver全局参数配置Properties类型  
52.               if ((value != null && value.length() > 0) && (parameter != null && parameter.length() > 0)) {  
53.                  try {  
54.                        urlProps.put(parameter, URLDecoder.decode(value , "UTF-8"));  
55.                  } catch (UnsupportedEncodingException badEncoding) {  
56.                        // punt  
57.                        urlProps.put(parameter, URLDecoder.decode(value));  
58.                  } catch (NoSuchMethodError nsme) {  
59.                        // punt again  
60.                        urlProps.put(parameter, URLDecoder.decode(value));  
61.                  }  
62.           }  
63.        }  
64. }  
65. ......  

好了，还有些代码没贴，太多了，上面的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的全局变量中（Properties urlProps），在解析后，只需要解析后直接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了；

例如：

[java]  view plaincopy

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

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

 

其二：

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

例如：

[java]  view plaincopy

1. private final static Driver oracleDriver = new OracleDriver();  

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