JDBC中为什么Class.forname("driverName")就可以创建驱动对象

  使用JDBC时，我们都会很自然得使用下列语句：

java 代码

Class.forName("com.mysql.jdbc.Driver");
 String url = "jdbc:mysql://127.0.0.1/test?useUnicode=true&characterEncoding=utf-8";
 String user = "";
 String psw = "";
Connection con = DriverManager.getConnection(url,user,psw);

    为什么说很自然呢，因为无论是网上还是书本教程上得例子都是这样的，而且程序也确实正常运行了，于是大家也就心安理得的找葫芦画瓢下去了。
    一定要有这一句吗？不是的，我们完全可以用这样一句代替它：

java 代码

com.mysql.jdbc.Driver driver = new com.mysql.jdbc.Driver();
 //or：
 //new com.mysql.jdbc.Driver();
 String url = "jdbc:mysql://127.0.0.1/test?useUnicode=true&characterEncoding=utf-8";
 String user = "";
 String psw = "";
Connection con = DriverManager.getConnection(url,user,psw);

    大家可能都看出个大概来了，我们只需要在调用DriverManager的getConnection方法之前，保证相应的Driver类已经被加载到 jvm中，并且完成了类的初始化工作就行了，而具体是怎样实现这个功能却是没有讲究的。上面两种方法都可以实现这个功能，因此程序可以正常运行。注意了， 如果我们进行如下操作，程序是不能正常运行的，因为这样仅仅使Driver类被装载到jvm中，却没有进行相应的初始化工作。

java 代码

com.mysql.jdbc.Driver driver = null;
 //or：
 ClassLoader cl = new ClassLoader();
 cl.loadClass("com.mysql.jdbc.Driver");

     我们都知道JDBC是使用Bridge模式进行设计的，DriverManager就是其中的Abstraction，java.sql.Driver是 Implementor，com.mysql.jdbc.Driver是Implementor的一个具体实现（请参考GOF的Bridge模式的描 述）。大家注意了，前一个Driver是一个接口，后者却是一个类，它实现了前面的Driver接口。
     Bridge模式中，Abstraction（DriverManager）是要拥有一个Implementor（Driver）的引用的，但是我们在使 用过程中，并没有将Driver对象注册到DriverManager中去啊，这是怎么回事呢？jdk文档对Driver的描述中有这么一句：
     When a Driver class is loaded, it should create an instance of itself and register it with the DriverManager
哦，原来是com.mysql.jdbc.Driver在装载完后自动帮我们完成了这一步骤。源代码是这样的：

java 代码

package com.mysql.jdbc

 public class Driver extends NonRegisteringDriver implements java.sql.Driver {
  // ~ Static fields/initializers
  // --------------------------------------------- //
  // Register ourselves with the DriverManager
  //
  static {
    t ry {
               java.sql.DriverManager.registerDriver(new Driver());
           } 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()
 }

 

××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

 

 

 

 

   开始接触JDBC时，一直有一个疑虑，为什么执行 Class.forName(“com.mysql.jdbc.Driver“)就可以载入MySql的驱动程序？JDBC的驱动程序初始化过程是怎么样 的？连接具体的数据库时，JDBC的DriverManager又是如何运作的？带着这么几个疑惑，本人下载了MySql的驱动源代码，结合J2SDK的 源代码，分析了一下JDBC的驱动管理机制。
    
1.     分析JDBC的驱动程序管理部分的实现代码：
    
        在 JDBC的层次上，sun主要定义了1个接口Driver和两个类：DirverManager和DriverInfo。每个JDBC驱动程序必须实现 Driver接口（在MySql的Connector/J驱动中，这个叫做com.mysql.jdbc.Driver）。而DriverManager 则负责管理所有的Driver对象，包含注册Driver；选择合适的Driver来建立到某个数据库的连接；以及进行一些Driver的信息管理等。 DriverInfo非常简单，用于保存Driver的信息，只有3个成员变量，Driver，DriverClass和 DriverClassName，意义非常明显。

        先看一下在DriverManager.java中的关键代码：
        private static java.util.Vector drivers = new java.util.Vector();
        所有的Driver对象保存在一个Vector数组中。

        注册Driver的函数叫registerDriver，将需要注册的Driver对象传入即可：
        public static synchronized void registerDriver(java.sql.Driver driver)
         throws SQLException {
             if (!initialized) {                                    //如果没有初始化，则先初始化
                 initialize();
             }      
             DriverInfo di = new DriverInfo();         //实际保存的不是Driver，而是一个DriverInfo对象，但是DriverInfo的其它成员 完全可以由Driver推导出来，所以个人觉得DriverInfo对象可有可无，直接使用Driver应该就可以了。
             di.driver = driver;
             di.driverClass = driver.getClass();
             di.driverClassName = di.driverClass.getName();
             drivers.addElement(di);                        //将DriverInfo对象添加到数组中
             println("registerDriver: " + di);
        }

        这样就完成了驱动程序的注册过程。然后重点看一下建立数据库连接的代码，在getConnection函数中，省略了一些非关键代码：
            private static synchronized Connection getConnection(
 String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {

         SQLException reason = null;
         //轮询所有的DriverInfo对象。
         for (int i = 0; i < drivers.size(); i++) {
             DriverInfo di = (DriverInfo)drivers.elementAt(i);
             try {
                  //使用DriverInfo中的Driver对象去做实际的连接数据库的工作
                  Connection result = di.driver.connect(url, info);
                  if (result != null) {
                      // Success!
                      println("getConnection returning " + di);
                      return (result);    //一旦成功连接，直接返回Connection对象，然后推出
                  }
                 } catch (SQLException ex) {
                        ...
                  }
             }        
             //这就是经常看到的出错信息－－找不到合适的驱动程序。
             println("getConnection: no suitable driver");    
             throw new SQLException("No suitable driver", "08001");
        }
        由 上面的getConnection函数可以看到，真正实现数据库连接的是Driver对象的connect函数。而且可以看到，由于 DriverManager.getConnection使用的是一种轮询的方式，注册的驱动程序越多，连接速度会越慢。JDBC连接数据库的速度很慢， 是不是和这种实现方式有关联呢？怀着这个问题，本人下载了MySql的Connector/J驱动包，开始分析其connect函数的实现。

2.    分析MySql的注册和建立连接部分的代码：
        打开MySql的源码包，首先分析其Driver类的实现。发现Driver类的实现非常简单，
        public class Driver extends NonRegisteringDriver implements java.sql.Driver {
        static {
                try {
                    java.sql.DriverManager.registerDriver(new Driver());
                    } catch (SQLException E) {
                        throw new RuntimeException("Can't register driver!");
                }
            }                public Driver() throws SQLException {
                // Required for Class.forName().newInstance()
        }            
        可 以看到，有一段static代码，调用了DriverManager的registerDriver方法。这其实就解释了 Class.forName（“com.mysql.jdbc.Driver”）能够完成MySql驱动注册的问题。因为forName会导致这段 static代码被调用，从而间接调用了registerDriver，完成注册过程。
        
        com.mysql.jdbc.Driver 从com.mysql.jdbc.NonRegisteringDriver继承而来，实际上是NonReisteringDriver完成了 java.sql.Driver接口的实现工作。转移目标，分析NonRegisteringDriver的connect函数。

        NonRegisteringDriver.connect的实现也比较简单，正合我意：

        public java.sql.Connection connect(String url, Properties info)
        throws SQLException {

        //1.    分析传入的连接字符串.
        if ((props = parseURL(url, info)) == null) {        
            return null;
        }
        try {
            //2.     建立一个Connection对象完成实际的数据库连接工作
            Connection newConn = new com.mysql.jdbc.Connection(host(props),
                    port(props), props, database(props), url, this);
            return newConn;
        非 常简单，先parseURL，然后使用Connection去建立连接。parseURL只是简单的字符串分析，主要是分析传入的连接字符串是否满足 “jdbc:mysql://host:port/database“的格式，如果不满足，直接返回null，然后由DriverManager去试验下 一个Driver。如果满足，则建立一个Connection对象建立实际的数据库连接，这不是本人关注的问题，源码分析就此打住。

        这也就解释了第二个问题，DriverManager的轮询查询注册的Driver对象的工作方式所带来的性能代价并不是很大，主工作量只是parseURL函数。
        
        以上是本人分析JDBC的驱动管理机制和建立数据库连接的一个一段分析笔记，本人是java新手，如果出现错误或者遗漏，欢迎指正，也欢迎鄙视，^_^

 

 

 

 

 ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

 

 

 

 

Class.forName方法介绍

在java.lang.Class中，有两个重载的forName方法，分别是：

1. static Class<?>forName(String className)，该方法等价于Class.forName(className, true, this.getClass().getClassLoader())
2. static Class<?>forName(String className, boolean initialize,ClassLoader loader)，其中3个参数分别表示：className - 所需类的完全限定名，initialize - 是否必须初始化类，loader - 用于加载类的类加载器。

forName方法的作用就是：
使用给定的类加载器，返回与带有给定字符串名的类或接口相关联的 Class 对象。给定一个类或接口的完全限定名，此方法会试图定位、加载和链接该类或接口。指定的类加载器用于加载该类或接口，如果参数loader 为 null，则该类通过引导类加载器加载。只有 initialize 参数为 true且以前未被初始化时，才初始化该类。

其他的都很容易懂，就是当第二个参数为true时，到底初始化的是什么呢？可以通过下面这个例子来了解：

package wen.hui.test.forname;

/**
 * @author whwang
 *
 */
public class TestClassForName {

    public static void main(String[] args) throws ClassNotFoundException {
        (new TestClassForName()).loadClass();
    }

    @SuppressWarnings("unchecked")
    public Class<Test> loadClass() throws ClassNotFoundException {
//      Class<Test> clazz = (Class<Test>) Class.forName("wen.hui.test.forname.Test");
        Class<Test> clazz = (Class<Test>) Class.forName("wen.hui.test.forname.Test", true, getClass().getClassLoader());
        return clazz;
    }

}

class Test {

    static {
        System.err.println("类的静态初始化块");
    }

    public Test() {
        System.err.println("实例化类");
    }

 运行后，打印：类的静态初始化块

没错，Class.forName的第二个参数为true时，就是要求JVM在加载类后，初始化类的静态字段和静态块。

JDBC中使用Class.forName("xxx")的意义

在Java开发特别是数据库开发中，经常会用到Class.forName( )这个方法。通过上面的介绍，已经了解了Class.forName()方法的作用就是为了动态加载类，并决定是否需要初始化类的静态部分，而在JDBC 规范中明确要求Driver(数据库驱动)类必须向DriverManager注册自己。写到这里，相信大家都应该明白为什么在我们加载数据库驱动包的时 候有的仅仅需要Class.forName(xxx);而有的需要Class.forName(xxx).newInstance()。

下面以MySQL为例子，来看看MySQL的com.mysql.jdbc.Driver类是怎么写的，MySQL的Driver类源码（5.x)

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    // ~ Static fields/initializers
    // ---------------------------------------------

    //
    // Register ourselves with the DriverManager
    //
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } 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()
    }
}

在使用JDBC连接MySQL数据库时，使用Class.forName("com.mysql.jdbc.Driver")就是为了向 DriverManager注册自己；当然使用 Class.forName("com.mysql.jdbc.Driver").newInstance()当然也没错，只是没有必要，因为后者还会生 成Driver类的实例，而这个是我们没有用的，没有必要创建它。如果在Driver类中那个static块里面的部分写在了构造方法中，那么就必须使用 Class.forName("com.mysql.jdbc.Driver").newInstance()来向DriverManager注册了。