mysql的jdbc驱动分析

public class DBHelper {
	public static Connection getConnection() {
		Connection conn = null;
		try {
			Class.forName("com.mysql.jdbc.Driver");
			conn = DriverManager.getConnection("jdbc:mysql://localhost/ad?useUnicode=true&characterEncoding=GBK&jdbcCompliantTruncation=false",
					"root", "root");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return conn;
	}
}

        /*dao中的方法*/
	public List<Adv> getAllAdvs() {
		
		Connection conn = null;
		ResultSet rs = null;
		PreparedStatement stmt = null;
		String sql = "select * from adv";
		List<Adv> advs = new ArrayList<Adv>();

		conn = DBHelper.getConnection();
		if (conn != null) {
			try {
				stmt = conn.prepareStatement(sql);
				rs = stmt.executeQuery();

				if (rs != null) {
					while (rs.next()) {
						Adv adv = new Adv();
						adv.setId(rs.getLong(1));
						adv.setName(rs.getString(2));
						adv.setDesc(rs.getString(3));
						adv.setPicUrl(rs.getString(4));

						advs.add(adv);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			} finally {
				try {
					stmt.close();
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}
		return advs;
	}

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 {
	}
}

    public static synchronized void registerDriver(java.sql.Driver driver)
	throws SQLException {
	if (!initialized) {
	    initialize();
	}
      
	DriverInfo di = new DriverInfo();

   /*把driver的信息封装一下，组成一个DriverInfo对象*/
	di.driver = driver;
	di.driverClass = driver.getClass();
	di.driverClassName = di.driverClass.getName();

	writeDrivers.addElement(di); 
	println("registerDriver: " + di);
	
	readDrivers = (java.util.Vector) writeDrivers.clone();

    }

    public static Connection getConnection(String url, 
	String user, String password) throws SQLException {
        java.util.Properties info = new java.util.Properties();
	ClassLoader callerCL = DriverManager.getCallerClassLoader();

	if (user != null) {
	    info.put("user", user);
	}
	if (password != null) {
	    info.put("password", password);
	}

        return (getConnection(url, info, callerCL));
     }

    private static Connection getConnection(
	String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {
	java.util.Vector drivers = null;
	...
	if (!initialized) {
	    initialize();
	}
    /*取得连接使用的driver从readDrivers中取*/
	synchronized (DriverManager.class){ 
	    drivers = readDrivers;  
        }

	SQLException reason = null;
	for (int i = 0; i < drivers.size(); i++) {
	    DriverInfo di = (DriverInfo)drivers.elementAt(i);
      
	    if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {
		continue;
	    }
	    try {
        /*找到可供使用的驱动，连接数据库server*/
		Connection result = di.driver.connect(url, info);
		if (result != null) {
		    return (result);
		}
	    } catch (SQLException ex) {
		if (reason == null) {
		    reason = ex;
		}
	    }
	}
    
	if (reason != null)    {
	    println("getConnection failed: " + reason);
	    throw reason;
	}    
	throw new SQLException("No suitable driver found for "+ url, "08001");
    }

	public java.sql.Connection connect(String url, Properties info)
			throws SQLException {
		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) {
			throw sqlEx;
		} catch (Exception ex) {
			throw SQLError.createSQLException(...);
		}
	}

	public java.sql.PreparedStatement prepareStatement(String sql)
			throws SQLException {
		return prepareStatement(sql, java.sql.ResultSet.TYPE_FORWARD_ONLY,
				java.sql.ResultSet.CONCUR_READ_ONLY);
	}

        public java.sql.PreparedStatement prepareStatement(String sql,
			int resultSetType, int resultSetConcurrency) throws SQLException;

	protected Buffer fillSendPacket(byte[][] batchedParameterStrings,
			InputStream[] batchedParameterStreams, boolean[] batchedIsStream,
			int[] batchedStreamLengths) throws SQLException {
        // 从connection的IO中得到发送数据包，首先清空其中的数据
		Buffer sendPacket = this.connection.getIO().getSharedSendPacket();
		sendPacket.clear();
        
        /* 数据包的第一位为一个操作标识符（MysqlDefs.QUERY），表示驱动向服务器发送的连接的操作信号，包括有QUERY, PING, RELOAD, SHUTDOWN, PROCESS_INFO, QUIT, SLEEP等等，这个操作信号并不是针对sql语句操作而言的CRUD操作，从提供的几种参数来看，这个操作是针对服务器的一个操作。一般而言，使用到的都是MysqlDefs.QUERY，表示发送的是要执行sql语句的操作。
*/
		sendPacket.writeByte((byte) MysqlDefs.QUERY);

		boolean useStreamLengths = this.connection
				.getUseStreamLengthsInPrepStmts();

		int ensurePacketSize = 0;
		for (int i = 0; i < batchedParameterStrings.length; i++) {
			if (batchedIsStream[i] && useStreamLengths) {
				ensurePacketSize += batchedStreamLengths[i];
			}
		}

        /* 判断这个sendPacket的byte buffer够不够大，不够大的话，按照1.25倍来扩充buffer
*/
		if (ensurePacketSize != 0) {
			sendPacket.ensureCapacity(ensurePacketSize);
		}

        /* 遍历所有的参数。在prepareStatement阶段的new ParseInfo()中，驱动曾经对sql语句进行过分割，如果含有以问号标识的参数占位符的话，就记录下这个占位符的位置，依据这个位置把sql分割成多段，放在了一个名为staticSql的字符串中。这里就开始把sql语句进行拼装，把staticSql和parameterValues进行组合，放在操作符的后面。
*/
		for (int i = 0; i < batchedParameterStrings.length; i++) {

        /* batchedParameterStrings就是parameterValues，batchedParameterStreams就是parameterStreams，如果两者都为null，说明在参数的设置过程中出了错，立即抛出错误。
*/
			if ((batchedParameterStrings[i] == null)
					&& (batchedParameterStreams[i] == null)) {
				throw SQLError.createSQLException(Messages
						.getString("PreparedStatement.40") //$NON-NLS-1$
						+ (i + 1), SQLError.SQL_STATE_WRONG_NO_OF_PARAMETERS);
			}

        /*在sendPacket中加入staticSql数组中的元素，就是分割出来的没有”?”的sql语句，并把字符串转换成byte。
*/
			sendPacket.writeBytesNoNull(this.staticSqlStrings[i]);

        /* batchedIsStream就是isStream，如果参数是通过CallableStatement传递进来的话，batchedIsStream[i]==true，就用batchedParameterStreams中的值填充到问号占的参数位置中去。
*/
			if (batchedIsStream[i]) {
				streamToBytes(sendPacket, batchedParameterStreams[i], true,
						batchedStreamLengths[i], useStreamLengths);
			} else {
			
        /*否则的话，就用batchedParameterStrings，也就是parameterValues来填充参数位置。在循环中，这个操作是跟在staticSql后面的，因此就把第i个参数加到了第i个staticSql段中。参考前面的staticSql的例子，发现当循环结束的时候，原始sql语句最后一个”?”之前的sql语句就拼成了正确的语句了。
*/
	sendPacket.writeBytesNoNull(batchedParameterStrings[i]);
			}
		}

        /*由于在原始的包含问号的sql语句中，在最后一个”?”后面可能还有order by等语句，因此staticSql数组中的元素个数一定比参数的个数多1，所以这里把staticSqlString中的最后一段sql语句放入sendPacket中。
*/
		sendPacket
				.writeBytesNoNull(this.staticSqlStrings[batchedParameterStrings.length]);

		return sendPacket;
	}

            while (len >= this.maxThreeBytes) {
                this.packetSequence++;
                /*设置包的开始位置*/
    ①          headerPacket.setPosition(0); 
                /*设置这个数据包的大小，splitSize=255 * 255 * 255*/
                headerPacket.writeLongInt(splitSize); 
                /*设置数据包的序号*/
                headerPacket.writeByte(this.packetSequence); 
                /*origPacketBytes就是sendPacket，所以这里就是把sendPacket中大小为255 * 255 * 255的数据放入headPacket中，headerPacketBytes是headPacket的byte buffer
*/
                System.arraycopy(origPacketBytes, originalPacketPos,
                    headerPacketBytes, 4, splitSize);

                int packetLen = splitSize + HEADER_LENGTH;
                if (!this.useCompression) {
                    this.mysqlOutput.write(headerPacketBytes, 0,
                        splitSize + HEADER_LENGTH);
                    this.mysqlOutput.flush();
                } else {
                    Buffer packetToSend;

                    headerPacket.setPosition(0);
                    packetToSend = compressPacket(headerPacket, HEADER_LENGTH,
                            splitSize, HEADER_LENGTH);
                    packetLen = packetToSend.getPosition();
                    /*往IO的output stream中写数据*/
                    this.mysqlOutput.write(packetToSend.getByteBuffer(), 0,
                        packetLen);
                    this.mysqlOutput.flush();
                }

                originalPacketPos += splitSize;
                len -= splitSize;
            }