Class.forName()做了什么？

JDBC连接一般需要以下步骤：
1 加载驱动

Class.forName("com.mysql.jdbc.Driver");

2 获取连接对象

Connection con=
    DriverManager.getConnection("jdbc:mysql://localhost:3306/homeworksubmit?user=root&password=root&useUnicode=true&characterEncoding=UTF-8");

3 创建命令对象

Statement stmt =
     con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
                                       ResultSet.CONCUR_READ_ONLY);

4 执行sql语句

Result rs=stmt.executeQuery(sql);

但是有疑问的是第一步，没有返回对像，追踪到源码：

Returns the {@code Class} object associated with the class or
interface with the given string name.
equivalent to:
{@code Class.forName(className, true, currentLoader)}

后面几步获取的对象一般都是方便下一步的调用，所以Class.forName()到底如何执行的，以及做了哪些工作，知悉了这些，才能对JDBC连接的理解更加透彻。
在这里首先贴出Driver类源码：

* The Java SQL framework allows for multiple database drivers. Each driver
 * should supply a class that implements the Driver interface
 * 
 * <p>
 * The DriverManager will try to load as many drivers as it can find and then
 * for any given connection request, it will ask each driver in turn to try to
 * connect to the target URL.
 * 
 * <p>
 * It is strongly recommended that each Driver class should be small and
 * standalone so that the Driver class can be loaded and queried without
 * bringing in vast quantities of supporting code.
 * 
 * <p>
 * When a Driver class is loaded, it should create an instance of itself and
 * register it with the DriverManager. This means that a user can load and
 * register a driver by doing Class.forName("foo.bah.Driver")

从中可以获取以下信息：
每个驱动类都必须实现Driver接口
当驱动被加载的时候，它首先实例化对象，并将其注册到DriverManager。
com.mysql.jdbc.Driver中的部分代码：

在初始化Driver类的时候，其中的静态代码也会执行，于是乎自动执行下面的语句：

java.sql.DriverManager.registerDriver(new Driver());

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!");
        }
    }

    ……
}

就这样，使用forName()初始化Driver后，MySql驱动就自动向DriverManagemer类注册了，使得我们能通过DriverManager获得对MysqL的连接。
贴出registerDriver()源码解释：

* Registers the given driver with the <code>DriverManager</code>.

部分实现代码：

public static synchronized void registerDriver(java.sql.Driver driver)
        throws SQLException {

        /* Register the driver if it has not already been added to our list */
        if(driver != null) {
            registeredDrivers.addIfAbsent(new DriverInfo(driver));
        } else {
            // This is for compatibility with the original DriverManager
            throw new NullPointerException();
        }

        println("registerDriver: " + driver);

    }

new DriverInfo(driver)，接下来在看一下DriverInfo(driver)类：
DriverInfo非常简单，用于保存Driver的信息，只有3个成员变量，Driver，DriverClass和 DriverClassName，意义非常明显。

在一个类加载入内存的时候，类中的静态初始化过程会执行，这样就完成了驱动程序的注册过程。然后重点看一下建立数据库连接的代码，在getConnection函数中，

/**
     * Attempts to establish a connection to the given database URL.
     * The <code>DriverManager</code> attempts to select an appropriate driver from
     * the set of registered JDBC drivers.
     *
     * @param url a database url of the form
     *  <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
     * @return a connection to the URL
     * @exception SQLException if a database access error occurs
     */

实现函数：

 @CallerSensitive
    public static Connection getConnection(String url)
        throws SQLException {

        java.util.Properties info = new java.util.Properties();
        return (getConnection(url, info, Reflection.getCallerClass()));
    }

到这里基本完成连接了。接下来，考虑一下，源码中说尝试一个合适的驱动从注册的JDBC驱动中，轮询方式，当注册的驱动多了，连接速度会越慢。JDBC连接数据库的速度很慢， 是不是和这种实现方式有关联呢？看一下Driver类：

public class Driver extends NonRegisteringDriver implements java.sql.Driver

看一下NonRegisteringDriver的实现：

public java.sql.Connection connect(String url, Properties info)
            throws SQLException {
        if (url != null) {
            if (StringUtils.startsWithIgnoreCase(url, LOADBALANCE_URL_PREFIX)) {
                return connectLoadBalanced(url, info);
            } else if (StringUtils.startsWithIgnoreCase(url,
                    REPLICATION_URL_PREFIX)) {
                return connectReplicationConnection(url, info);
            }
        }

        Properties props = null;

        if ((props = parseURL(url, info)) == null) {
            return null;
        }

        try {
            Connection newConn = new com.mysql.jdbc.Connection(host(props),
                    port(props), props, database(props), url);

            return newConn;
        } catch (SQLException sqlEx) {
            // Don't wrap SQLExceptions, throw
            // them un-changed.
            throw sqlEx;
        } catch (Exception ex) {
            throw SQLError.createSQLException(Messages
                    .getString("NonRegisteringDriver.17") //$NON-NLS-1$
                    + ex.toString()
                    + Messages.getString("NonRegisteringDriver.18"), //$NON-NLS-1$
                    SQLError.SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE);
        }
    }

先parseURL，然后使用Connection去建立连接。parseURL只是简单的字符串分析，主要是分析传入的连接字符串是否满足 “jdbc:mysql://host:port/database“的格式，如果不满足，直接返回null，然后由DriverManager去试验下 一个Driver。如果满足，则建立一个Connection对象建立实际的数据库连接，由此可见刚刚的问题答案是：DriverManager的轮询查询注册的Driver对象的工作方式所带来的性能代价并不是很大，主工作量只是parseURL函数。

源码追溯到这里结束了，剩下的就不去管了。