写JDBC连接数据库的时候，首先第一步是要加载对应数据库的驱动，但是如果删除加载驱动的代码，也是可以连接数据库来执行的，这是为什么？
1.加载驱动代码：
Class.forName("com.mysql.jdbc.Driver");点击查看forName的底层代码是
public static Class<?> forName(String className)
throws ClassNotFoundException {
Class<?> caller = Reflection.getCallerClass();
return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}java.lang.Class类提供了两个静态方法
public static Class<?> forName(String name) throws ClassNotFoundException;
public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException;java.lang.Class的forName通过传入一个类的全名，将类加载到虚拟机。这两个方法的区别就是，单参数forName方法 initialize 默认是true，是默认进行初始化的，会执行类的static区域，其实就是执行了
forName(className,true,ClassLoader.getClassLoader(Reflection.getCallerClass()))。
三参数的forName方法，可以指定类的加载器，以及是否初始化。
private static native Class<?> forName0(String name, boolean initialize,
ClassLoader loader,
Class<?> caller)
throws ClassNotFoundException;（native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。Java语言本身不能对操作系统底层进行访问和操作，但是可以通过JNI接口调用其他语言来实现对底层的访问。）
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);
}这个里面并没有提及加载驱动的东西，接下来再看一个方法
2.驱动连接代码：
conn=DriverManager.getConnection(url, user, pwd);这个方法的底层代码为：
public static Connection getConnection(String url,
String user, String password) throws SQLException {
java.util.Properties info = new java.util.Properties();
if (user != null) {
info.put("user", user);
}
if (password != null) {
info.put("password", password);
}
return (getConnection(url, info, Reflection.getCallerClass()));
} private static Connection getConnection(
String url, java.util.Properties info, Class<?> caller) throws SQLException {
/*
* When callerCl is null, we should check the application's
* (which is invoking this class indirectly)
* classloader, so that the JDBC driver class outside rt.jar
* can be loaded from here.
*/
ClassLoader callerCL = caller != null ? caller.getClassLoader() : 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 + "\")");
// Walk through the loaded registeredDrivers attempting to make a connection.
// Remember the first exception that gets raised so we can reraise it.
SQLException reason = null;
for(DriverInfo aDriver : registeredDrivers) {
// If the caller does not have permission to load the driver then
// skip it.
if(isDriverAllowed(aDriver.driver, callerCL)) {
try {
println(" trying " + aDriver.driver.getClass().getName());
Connection con = aDriver.driver.connect(url, info);
if (con != null) {
// Success!
println("getConnection returning " + aDriver.driver.getClass().getName());
return (con);
}
} catch (SQLException ex) {
if (reason == null) {
reason = ex;
}
}
} else {
println(" skipping: " + aDriver.getClass().getName());
}
}
// 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");
}
这个方法一开始就要得到调用类caller的类加载器callerCL，为的是后面再去加载数据库的driver，做一下验证，
具体在 isDriverAllowed(aDriver.driver, callerCL) 里面的代码里。
那问题来了，为什么就不能用加载DriverManager的类加载器呢？？？
因为DriverManager在rt.jar里面，它的类加载器上启动类加载器。而数据库的driver（com.mysql.jdbc.Driver）是放在classpath里面的，启动类加载器是不能加载的。所以，如果严格按照双亲委派模型，是没办法解决的。而这里的解决办法是：通过调用类的类加载器去加载。而如果调用类的加载器是null，就设置为线程的上下文类加载器：
Thread.currentThread().getContextClassLoader()
好的，下面通过Thread类的源码，分析线程的上下文类加载器。
/* The context ClassLoader for this thread */
private ClassLoader contextClassLoader;
// 这段if---else代码出自init方法
if (security == null || isCCLOverridden(parent.getClass()))
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
public ClassLoader getContextClassLoader() {
if (contextClassLoader == null)
return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader.checkClassLoaderPermission(contextClassLoader,
Reflection.getCallerClass());
}
return contextClassLoader;
}
public void setContextClassLoader(ClassLoader cl) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setContextClassLoader"));
}
contextClassLoader = cl;
}
init方法里面代码的逻辑是：把父线程的上下文类加载器给继承过来。这里的父子关系是指谁启动谁的关系，比如在线程A里面启动了线程B，那B线程的父线程就是A。
既然都是一路继承，那第一个启动的线程（包含main方法的那个线程）里面的contextClassLoader是谁设置的呢？？？
这就要看 sun.misc.Launcher 这个类的源码。Launcher是JRE中用于启动程序入口main()的类。
loader = AppClassLoader.getAppClassLoader(extcl);
Thread.currentThread().setContextClassLoader(loader);这里截取的两行代码出自 Launcher 的构造方法。第一行用一个扩展类加载器extcl构造了一个系统类加载器loader，第二行把loader设置为当前线程（包含main方法）的类加载器。所以，我们启动一个线程的时候，如果之前都没有调用 setContextClassLoader 方法明确指定的话，默认的就是系统类加载器。
for(DriverInfo aDriver : registeredDrivers) {
// If the caller does not have permission to load the driver then
// skip it.
if(isDriverAllowed(aDriver.driver, callerCL)) {
try {
println(" trying " + aDriver.driver.getClass().getName());
Connection con = aDriver.driver.connect(url, info);
if (con != null) {
// Success!
println("getConnection returning " + aDriver.driver.getClass().getName());
return (con);
}
} catch (SQLException ex) {
if (reason == null) {
reason = ex;
}
}
} else {
println(" skipping: " + aDriver.getClass().getName());
}
}DriverManager的getConnection 最后返回一个connection，但是在一个循环里面。也就是说，当我们注册了多个数据库驱动，mysql，oracle等；DriverManager都帮我们管理了，它会取出一个符合条件的driver，就不用我们在程序里自己去控制了。
3.加载驱动时候怎么初始化的?
前面说到Class.forName单参数方法会默认类的初始化。而类初始化会执行类的静态代码块、静态属性初始化。以下就是com.mysql.jdbc.Driver类的静态代码块:
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}registerDriver方法的实现：加载驱动时，将数据库驱动添加到DriverManager类的registeredDrivers属性中；
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);
}获取数据库连接就是遍历registeredDrivers属性 来获取 ，连接成功则直接返回，失败则继续下一个
public static Driver getDriver(String url)
throws SQLException {
println("DriverManager.getDriver(\"" + url + "\")");
Class<?> callerClass = Reflection.getCallerClass();
// Walk through the loaded registeredDrivers attempting to locate someone
// who understands the given URL.
for (DriverInfo aDriver : registeredDrivers) {
// If the caller does not have permission to load the driver then
// skip it.
if(isDriverAllowed(aDriver.driver, callerClass)) {
try {
if(aDriver.driver.acceptsURL(url)) {
// Success!
println("getDriver returning " +
aDriver.driver.getClass().getName());
return (aDriver.driver);
}
} catch(SQLException sqe) {
// Drop through and try the next driver.
}
} else {
println(" skipping: " + aDriver.driver.getClass().getName());
}
}
println("getDriver: no suitable driver");
throw new SQLException("No suitable driver", "08001");
}4.DriverManager文档
扫一扫
1712
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
