1、JDBC概念
1.1 什么是 JDBC
JDBC 一般指 Java 数据库连接，（Java Database Connectivity，简称为 JDBC）。是 Java 语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了比如查询、更新数据库中数据的方法，我们常说的 JDBC 是面向关系型数据库的。
1.2 JDBC 基本结构图
一般情况下，在 application 中进行数据库连接，调用 JDBC 接口，首先需要将指定的 JDBC 驱动实现加载到 jvm 中，然后再进行使用，基本的结构图如下
2、驱动加载
2.1 加载
驱动是一个 class，将驱动进行加载到 jvm 中与加载普通类一样，使用 Class.forName("driverName") 进行加载
//加载MySQL 数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//加载Oracle数据库驱动
Class.forName("oracle.jdbc.driver.OracleDriver");
2.2 Driver 接口
驱动，首先需要实现 java.sql.Driver 接口，连接不同数据库的驱动类不同，但每个驱动类都需要提供一个实现了 java.sql.Driver 接口的类。在程序中由驱动器管理类 java.sql.DriverManager 去调用这些 Driver 实现
Driver 接口源码
package java.sql;
import java.util.logging.Logger;
public interface Driver {
// 试图创建一个给定 url 的数据库连接，创建 Connection 对象
Connection connect(String url, java.util.Properties info) throws SQLException;
// 驱动程序是否可以打开 url 连接，判断 url 是否符合协议，符合协议形式的 url 才可以
boolean acceptsURL(String url) throws SQLException;
// 获取驱动的属性信息
DriverPropertyInfo[] getPropertyInfo(String url, java.util.Properties info) throws SQLException;
// 获取驱动主版本号
int getMajorVersion();
// 获取驱动的次版本号
int getMinorVersion()#;
// 驱动程序是否是一个真正的 JDBC Compliant
boolean jdbcCompliant();
public Logger getParentLogger() throws SQLFeatureNotSupportedException;
}
手动加载 Driver
// 加载 mysql 驱动类，并实例化
Driver driver = (Driver)Class.forName("com.mysql.jdbc.Driver);
// 判断 url 是否符合 mysql 的 url 形式
boolean flag = driver.acceptsURL("jdbc:mysql://localhost:3306/test");
// 创建数据库连接
String url = "jdbc:mysql://localhost:3306/test";
Properties props = new Properties();
props.put("user", "root");
props.put("password", "root");
Connection connection = driver.connect(url, props);
2.3DriverManager 驱动器管理类
如果有多个驱动 Driver，JDBC 提供了 DriverManager 对多个驱动进行统一管理
DriverManager 可以注册和删除加载的驱动程序，根据给定的 url 获取符合 url 协议的 Driver 或者建立 Connection 连接
DriverManager 源码
/**
* Load the initial JDBC drivers by checking the System property
* jdbc.properties and then use the {@code ServiceLoader} mechanism
*/
static {
loadInitialDrivers(); // 加载配置在 jdbc.drivers 系统变量中的驱动
println("JDBC DriverManager initialized");
}
private static void loadInitialDrivers() {
String drivers;
try {
drivers = AccessController.doPrivileged(new PrivilegedAction
public String run() {
return System.getProperty("jdbc.drivers");
}
});
} catch (Exception ex) {
drivers = 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);
}
}
}
使用 Class.forName(“driverName”) 加载驱动类到 jvm 的时候，同时会执行这个驱动类中的静态代码块，创建一个 Driver 实例，然后调用 DriverManager 进行注册 Driver。
DriverManager 在第一次被调用时，它会被加载到内存中，然后执行它内部的 static 静态代码块，执行其中的 loadIntialDrivers() 静态方法，加载配置在 jdbc.driver 中的 Driver，配置在 jdbc.drivers 中的驱动 driver 会先被加载
注册 Driver 到 DriverManager
在加载某一个 Driver 类时，应该创建自己的实例并像 DriverManager 中注册自己的实例。比如 com.mysql.jdbc.Driver 的源码，使用静态代码块进行实现
在我们使用 Class.forName("com.mysql.jdbc.Driver"); 方法获取它的 Class 对象，com.mysql.jdbc.Driver 就会被 jvm 加载，连接，初始化，初始化就会执行其中的静态代码块，执行下面的 java.sql.DriverManager.registerDriver(new Driver()); 进行注册
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
注册实例源码
将要注册的驱动信息放到一个 DriverInfo 中，然后再放到一个 List 中，在后面连接时候会用到
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);
}
3、为什么加载驱动使用 Class.forName()
3.1 Class.forName
Class.forName() 的作用就是让 JVM 查找并加载指定的类，如果类中有 static 代码块，就会执行 static 代码块中的内容
通过下面的 Class.forName 源码可以看到，Class.forName(className); 方法调用的是 Class.forName(className, true, classLoader); 方法，第一个参数是类名，第二个参数是是否进行初始化，默认为 true 进行初始化，初始化就会执行 static 代码块中的内容，static 参数也会被初始化
@CallerSensitive
public static Class forName(String className)
throws ClassNotFoundException {
Class caller = Reflection.getCallerClass();
return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}
@CallerSensitive
public static Class forName(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException
{
Class caller = null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
// Reflective call to get caller class is only needed if a security manager
// is present. Avoid the overhead of making this call otherwise.
caller = Reflection.getCallerClass();
if (sun.misc.VM.isSystemDomainLoader(loader)) {
ClassLoader ccl = ClassLoader.getClassLoader(caller);
if (!sun.misc.VM.isSystemDomainLoader(ccl)) {
sm.checkPermission(
SecurityConstants.GET_CLASSLOADER_PERMISSION);
}
}
}
return forName0(name, initialize, loader, 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;
Class.forName() 方法，除了会将类的 .class 文件加载到 jvm 中，默认还会对类进行初始化，执行类中的 static 代码块
JDBC 规范中，每个 Driver 类都必须向 DriverManager 中注册自己，都会执行下面的代码，静态代码块内容在初始化的时候就进行了一次执行，所以后面可以直接使用，通过 DriverManager.getConnection() 连接
static {
try {
// 注册 Driver 到 DriverManager
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
3.2 其它加载类方法
使用 ClassLoader.getSystemClassLoader().loadClass() ，通过下面的源码可以看到，调用了一个重载的 loadClass(className, false); 方法，第二个参数默认为 false 表示不进行连接，只是将类加载到 jvm 中，不会进行初始化，也不会执行 static 代码块中的内容
public Class loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
protected Class loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}