jdbc-sql语句在sql developer中可以运行，JDBC中报错ORA-01861
sql语句在sql developer中可以运行，JDBC中报错ORA-01861
一个非常奇怪的问题
语句如下：
SELECT * FROM T_BUILD_DAY where F_BUILDID = 'daa37e0b' and TO_DATE(substr(F_STARTTIME),'yyyy-MM-dd') = TO_DATE(substr('',1,10),'yyyy-MM-dd')
其中F_STARTTIME在表中的格式为 date
在sql developer中运行该语句完全没问题，但是在jdbc中却出现了问题
java.sql.SQLDataException: ORA-01861: 文字与格式字符串不匹配
我直接就凌乱了凌乱了啊
网上搜了好久，不少人说是to_date的问题，但是没人给出来解决的方法。。。。
/*****************最终分割线**********************/
问题果然出在格式上，sql developer坑啊，你如何乱写他都会自动纠正成正确的格式，原因在这
但是jdbc中就没那么好，jdbc中要采用原本的格式
后来我把语句改成了这个
SELECT * FROM T_BUILD_DAY where F_BUILDID = 'daa37e0b' and TO_DATE(substr(F_STARTTIME),'DD-MON-RR') = TO_DATE(substr('',1,10),'yyyy-MM-dd')
于是一切都可以了！
看看yyyy-MM-dd格式与表内的格式是否相同博客分类：
三、动态SQL语句
有些时候，sql语句where条件中，需要一些安全判断，例如按某一条件查询时如果传入的参数是空，此时查询出的结果很可能是空的，也许我们需要参数为空时，是查出全部的信息。使用Oracle的序列、mysql的函数生成Id。这时我们可以使用动态sql。
下文均采用mysql语法和函数（例如字符串链接函数CONCAT）。
3.1 selectKey 标签
在insert语句中，在Oracle经常使用序列、在MySQL中使用函数来自动生成插入表的主键，而且需要方法能返回这个生成主键。使用myBatis的selectKey标签可以实现这个效果。
下面例子，使用mysql数据库自定义函数nextval('student')，用来生成一个key，并把他设置到传入的实体类中的studentId属性上。所以在执行完此方法后，边可以通过这个实体类获取生成的key。
&!-- 插入学生 自动主键--&
&insert id="createStudentAutoKey" parameterType="liming.student.manager.data.model.StudentEntity" keyProperty="studentId"&
&selectKey keyProperty="studentId" resultType="String" order="BEFORE"&
select nextval('student')
&/selectKey&
INSERT INTO STUDENT_TBL(STUDENT_ID,
STUDENT_NAME,
STUDENT_SEX,
STUDENT_BIRTHDAY,
STUDENT_PHOTO,
VALUES (#{studentId},
#{studentName},
#{studentSex},
#{studentBirthday},
#{studentPhoto, javaType=byte[], jdbcType=BLOB, typeHandler=org.apache.ibatis.type.BlobTypeHandler},
#{classId},
#{placeId})
调用接口方法，和获取自动生成key
StudentEntity entity = new StudentEntity();
entity.setStudentName("黎明你好");
entity.setStudentSex(1);
entity.setStudentBirthday(DateUtil.parse(""));
entity.setClassId("");
entity.setPlaceId("");
this.dynamicSqlMapper.createStudentAutoKey(entity);
System.out.println("新增学生ID: " + entity.getStudentId());
selectKey语句属性配置细节：
keyProperty
selectKey 语句生成结果需要设置的属性。
resultType
生成结果类型，MyBatis 允许使用基本的数据类型，包括String 、int类型。
1：BEFORE，会先选择主键，然后设置keyProperty，再执行insert语句；
2：AFTER，就先运行insert 语句再运行selectKey 语句。
statementType
MyBatis 支持STATEMENT，PREPARED和CALLABLE 的语句形式， 对应Statement ，PreparedStatement 和CallableStatement 响应
3.2 if标签
if标签可用在许多类型的sql语句中，我们以查询为例。首先看一个很普通的查询：
&!-- 查询学生list，like姓名 --&
&select id="getStudentListLikeName" parameterType="StudentEntity" resultMap="studentResultMap"&
SELECT * from STUDENT_TBL ST
WHERE ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName}),'%')
但是此时如果studentName或studentSex为null，此语句很可能报错或查询结果为空。此时我们使用if动态sql语句先进行判断，如果值为null或等于空字符串，我们就不进行此条件的判断，增加灵活性。
参数为实体类StudentEntity。将实体类中所有的属性均进行判断，如果不为空则执行判断条件。
&!-- 2 if(判断参数) - 将实体类不为空的属性作为where条件 --&
&select id="getStudentList_if" resultMap="resultMap_studentEntity" parameterType="liming.student.manager.data.model.StudentEntity"&
SELECT ST.STUDENT_ID,
ST.STUDENT_NAME,
ST.STUDENT_SEX,
ST.STUDENT_BIRTHDAY,
ST.STUDENT_PHOTO,
ST.CLASS_ID,
ST.PLACE_ID
FROM STUDENT_TBL ST
&if test="studentName !=null "&
ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName, jdbcType=VARCHAR}),'%')
&if test="studentSex != null and studentSex != '' "&
AND ST.STUDENT_SEX = #{studentSex, jdbcType=INTEGER}
&if test="studentBirthday != null "&
AND ST.STUDENT_BIRTHDAY = #{studentBirthday, jdbcType=DATE}
&if test="classId != null and classId!= '' "&
AND ST.CLASS_ID = #{classId, jdbcType=VARCHAR}
&if test="classEntity != null and classEntity.classId !=null and classEntity.classId !=' ' "&
AND ST.CLASS_ID = #{classEntity.classId, jdbcType=VARCHAR}
&if test="placeId != null and placeId != '' "&
AND ST.PLACE_ID = #{placeId, jdbcType=VARCHAR}
&if test="placeEntity != null and placeEntity.placeId != null and placeEntity.placeId != '' "&
AND ST.PLACE_ID = #{placeEntity.placeId, jdbcType=VARCHAR}
&if test="studentId != null and studentId != '' "&
AND ST.STUDENT_ID = #{studentId, jdbcType=VARCHAR}
使用时比较灵活， new一个这样的实体类，我们需要限制那个条件，只需要附上相应的值就会where这个条件，相反不去赋值就可以不在where中判断。
public void select_test_2_1() {
StudentEntity entity = new StudentEntity();
entity.setStudentName("");
entity.setStudentSex(1);
entity.setStudentBirthday(DateUtil.parse(""));
entity.setClassId("");
//entity.setPlaceId("");
List&StudentEntity& list = this.dynamicSqlMapper.getStudentList_if(entity);
for (StudentEntity e : list) {
System.out.println(e.toString());
3.3 if + where 的条件判断
当where中的条件使用的if标签较多时，这样的组合可能会导致错误。我们以在3.1中的查询语句为例子，当java代码按如下方法调用时：
public void select_test_2_1() {
StudentEntity entity = new StudentEntity();
entity.setStudentName(null);
entity.setStudentSex(1);
List&StudentEntity& list = this.dynamicSqlMapper.getStudentList_if(entity);
for (StudentEntity e : list) {
System.out.println(e.toString());
如果上面例子，参数studentName为null，将不会进行STUDENT_NAME列的判断，则会直接导“WHERE AND”关键字多余的错误SQL。
这时我们可以使用where动态语句来解决。这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。
上面例子修改为：
&!-- 3 select - where/if(判断参数) - 将实体类不为空的属性作为where条件 --&
&select id="getStudentList_whereIf" resultMap="resultMap_studentEntity" parameterType="liming.student.manager.data.model.StudentEntity"&
SELECT ST.STUDENT_ID,
ST.STUDENT_NAME,
ST.STUDENT_SEX,
ST.STUDENT_BIRTHDAY,
ST.STUDENT_PHOTO,
ST.CLASS_ID,
ST.PLACE_ID
FROM STUDENT_TBL ST
&if test="studentName !=null "&
ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName, jdbcType=VARCHAR}),'%')
&if test="studentSex != null and studentSex != '' "&
AND ST.STUDENT_SEX = #{studentSex, jdbcType=INTEGER}
&if test="studentBirthday != null "&
AND ST.STUDENT_BIRTHDAY = #{studentBirthday, jdbcType=DATE}
&if test="classId != null and classId!= '' "&
AND ST.CLASS_ID = #{classId, jdbcType=VARCHAR}
&if test="classEntity != null and classEntity.classId !=null and classEntity.classId !=' ' "&
AND ST.CLASS_ID = #{classEntity.classId, jdbcType=VARCHAR}
&if test="placeId != null and placeId != '' "&
AND ST.PLACE_ID = #{placeId, jdbcType=VARCHAR}
&if test="placeEntity != null and placeEntity.placeId != null and placeEntity.placeId != '' "&
AND ST.PLACE_ID = #{placeEntity.placeId, jdbcType=VARCHAR}
&if test="studentId != null and studentId != '' "&
AND ST.STUDENT_ID = #{studentId, jdbcType=VARCHAR}
3.4 if + set 的更新语句
当update语句中没有使用if标签时，如果有一个参数为null，都会导致错误。
当在update语句中使用if标签时，如果前面的if没有执行，则或导致逗号多余错误。使用set标签可以将动态的配置SET 关键字，和剔除追加到条件末尾的任何不相关的逗号。
使用if+set标签修改后，如果某项为null则不进行更新，而是保持数据库原值。如下示例：
&!-- 4 if/set(判断参数) - 将实体类不为空的属性更新 --&
&update id="updateStudent_if_set" parameterType="liming.student.manager.data.model.StudentEntity"&
UPDATE STUDENT_TBL
&if test="studentName != null and studentName != '' "&
STUDENT_TBL.STUDENT_NAME = #{studentName},
&if test="studentSex != null and studentSex != '' "&
STUDENT_TBL.STUDENT_SEX = #{studentSex},
&if test="studentBirthday != null "&
STUDENT_TBL.STUDENT_BIRTHDAY = #{studentBirthday},
&if test="studentPhoto != null "&
STUDENT_TBL.STUDENT_PHOTO = #{studentPhoto, javaType=byte[], jdbcType=BLOB, typeHandler=org.apache.ibatis.type.BlobTypeHandler},
&if test="classId != '' "&
STUDENT_TBL.CLASS_ID = #{classId}
&if test="placeId != '' "&
STUDENT_TBL.PLACE_ID = #{placeId}
WHERE STUDENT_TBL.STUDENT_ID = #{studentId};
3.5 if + trim代替where/set标签
trim是更灵活的去处多余关键字的标签，他可以实践where和set的效果。
3.5.1trim代替where
&!-- 5.1 if/trim代替where(判断参数) - 将实体类不为空的属性作为where条件 --&
&select id="getStudentList_if_trim" resultMap="resultMap_studentEntity"&
SELECT ST.STUDENT_ID,
ST.STUDENT_NAME,
ST.STUDENT_SEX,
ST.STUDENT_BIRTHDAY,
ST.STUDENT_PHOTO,
ST.CLASS_ID,
ST.PLACE_ID
FROM STUDENT_TBL ST
&trim prefix="WHERE" prefixOverrides="AND|OR"&
&if test="studentName !=null "&
ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName, jdbcType=VARCHAR}),'%')
&if test="studentSex != null and studentSex != '' "&
AND ST.STUDENT_SEX = #{studentSex, jdbcType=INTEGER}
&if test="studentBirthday != null "&
AND ST.STUDENT_BIRTHDAY = #{studentBirthday, jdbcType=DATE}
&if test="classId != null and classId!= '' "&
AND ST.CLASS_ID = #{classId, jdbcType=VARCHAR}
&if test="classEntity != null and classEntity.classId !=null and classEntity.classId !=' ' "&
AND ST.CLASS_ID = #{classEntity.classId, jdbcType=VARCHAR}
&if test="placeId != null and placeId != '' "&
AND ST.PLACE_ID = #{placeId, jdbcType=VARCHAR}
&if test="placeEntity != null and placeEntity.placeId != null and placeEntity.placeId != '' "&
AND ST.PLACE_ID = #{placeEntity.placeId, jdbcType=VARCHAR}
&if test="studentId != null and studentId != '' "&
AND ST.STUDENT_ID = #{studentId, jdbcType=VARCHAR}
3.5.2 trim代替set
&!-- 5.2 if/trim代替set(判断参数) - 将实体类不为空的属性更新 --&
&update id="updateStudent_if_trim" parameterType="liming.student.manager.data.model.StudentEntity"&
UPDATE STUDENT_TBL
&trim prefix="SET" suffixOverrides=","&
&if test="studentName != null and studentName != '' "&
STUDENT_TBL.STUDENT_NAME = #{studentName},
&if test="studentSex != null and studentSex != '' "&
STUDENT_TBL.STUDENT_SEX = #{studentSex},
&if test="studentBirthday != null "&
STUDENT_TBL.STUDENT_BIRTHDAY = #{studentBirthday},
&if test="studentPhoto != null "&
STUDENT_TBL.STUDENT_PHOTO = #{studentPhoto, javaType=byte[], jdbcType=BLOB, typeHandler=org.apache.ibatis.type.BlobTypeHandler},
&if test="classId != '' "&
STUDENT_TBL.CLASS_ID = #{classId},
&if test="placeId != '' "&
STUDENT_TBL.PLACE_ID = #{placeId}
WHERE STUDENT_TBL.STUDENT_ID = #{studentId}
3.6 choose (when, otherwise)
有时候我们并不想应用所有的条件，而只是想从多个选项中选择一个。而使用if标签时，只要test中的表达式为true，就会执行if标签中的条件。MyBatis提供了choose 元素。if标签是与(and)的关系，而choose比傲天是或（or）的关系。
choose标签是按顺序判断其内部when标签中的test条件出否成立，如果有一个成立，则choose结束。当choose中所有when的条件都不满则时，则执行otherwise中的sql。类似于Java 的switch 语句，choose为switch，when为case，otherwise则为default。
例如下面例子，同样把所有可以限制的条件都写上，方面使用。choose会从上到下选择一个when标签的test为true的sql执行。安全考虑，我们使用where将choose包起来，放置关键字多于错误。
&!-- 6 choose(判断参数) - 按顺序将实体类第一个不为空的属性作为where条件 --&
&select id="getStudentList_choose" resultMap="resultMap_studentEntity" parameterType="liming.student.manager.data.model.StudentEntity"&
SELECT ST.STUDENT_ID,
ST.STUDENT_NAME,
ST.STUDENT_SEX,
ST.STUDENT_BIRTHDAY,
ST.STUDENT_PHOTO,
ST.CLASS_ID,
ST.PLACE_ID
FROM STUDENT_TBL ST
&when test="studentName !=null "&
ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName, jdbcType=VARCHAR}),'%')
&when test="studentSex != null and studentSex != '' "&
AND ST.STUDENT_SEX = #{studentSex, jdbcType=INTEGER}
&when test="studentBirthday != null "&
AND ST.STUDENT_BIRTHDAY = #{studentBirthday, jdbcType=DATE}
&when test="classId != null and classId!= '' "&
AND ST.CLASS_ID = #{classId, jdbcType=VARCHAR}
&when test="classEntity != null and classEntity.classId !=null and classEntity.classId !=' ' "&
AND ST.CLASS_ID = #{classEntity.classId, jdbcType=VARCHAR}
&when test="placeId != null and placeId != '' "&
AND ST.PLACE_ID = #{placeId, jdbcType=VARCHAR}
&when test="placeEntity != null and placeEntity.placeId != null and placeEntity.placeId != '' "&
AND ST.PLACE_ID = #{placeEntity.placeId, jdbcType=VARCHAR}
&when test="studentId != null and studentId != '' "&
AND ST.STUDENT_ID = #{studentId, jdbcType=VARCHAR}
&otherwise&
&/otherwise&
3.7 foreach
对于动态SQL 非常必须的，主是要迭代一个集合，通常是用于IN 条件。List 实例将使用“list”做为键，数组实例以“array” 做为键。
foreach元素是非常强大的，它允许你指定一个集合，声明集合项和索引变量，它们可以用在元素体内。它也允许你指定开放和关闭的字符串，在迭代之间放置分隔符。这个元素是很智能的，它不会偶然地附加多余的分隔符。
注意：你可以传递一个List实例或者数组作为参数对象传给MyBatis。当你这么做的时候，MyBatis会自动将它包装在一个Map中，用名称在作为键。List实例将会以“list”作为键，而数组实例将会以“array”作为键。
这个部分是对关于XML配置文件和XML映射文件的而讨论的。下一部分将详细讨论Java API，所以你可以得到你已经创建的最有效的映射。
3.7.1参数为array示例的写法
接口的方法声明：
public List&StudentEntity& getStudentListByClassIds_foreach_array(String[] classIds);
动态SQL语句：
&!— 7.1 foreach(循环array参数) - 作为where中in的条件 --&
&select id="getStudentListByClassIds_foreach_array" resultMap="resultMap_studentEntity"&
SELECT ST.STUDENT_ID,
ST.STUDENT_NAME,
ST.STUDENT_SEX,
ST.STUDENT_BIRTHDAY,
ST.STUDENT_PHOTO,
ST.CLASS_ID,
ST.PLACE_ID
FROM STUDENT_TBL ST
WHERE ST.CLASS_ID IN
&foreach collection="array" item="classIds"
open="(" separator="," close=")"&
#{classIds}
&/foreach&
测试代码，查询学生中，在、这两个班级的学生：
public void test7_foreach() {
String[] classIds = { "", "" };
List&StudentEntity& list = this.dynamicSqlMapper.getStudentListByClassIds_foreach_array(classIds);
for (StudentEntity e : list) {
System.out.println(e.toString());
3.7.2参数为list示例的写法
接口的方法声明：
public List&StudentEntity& getStudentListByClassIds_foreach_list(List&String& classIdList);
动态SQL语句：
&!-- 7.2 foreach(循环List&String&参数) - 作为where中in的条件 --&
&select id="getStudentListByClassIds_foreach_list" resultMap="resultMap_studentEntity"&
SELECT ST.STUDENT_ID,
ST.STUDENT_NAME,
ST.STUDENT_SEX,
ST.STUDENT_BIRTHDAY,
ST.STUDENT_PHOTO,
ST.CLASS_ID,
ST.PLACE_ID
FROM STUDENT_TBL ST
WHERE ST.CLASS_ID IN
&foreach collection="list" item="classIdList"
open="(" separator="," close=")"&
#{classIdList}
&/foreach&
测试代码，查询学生中，在、这两个班级的学生：
public void test7_2_foreach() {
ArrayList&String& classIdList = new ArrayList&String&();
classIdList.add("");
classIdList.add("");
List&StudentEntity& list = this.dynamicSqlMapper.getStudentListByClassIds_foreach_list(classIdList);
for (StudentEntity e : list) {
System.out.println(e.toString());
浏览 307258
limingnihao
浏览: 1563749 次
来自: 北京
好详细，写的真全面
哪里有源代码啊，？能否发一份？还有就是 ClassEntity ...
classentity是啥？哪个包的类啊？这教程并不完整啊！
shift+alt+a
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'访问页面出不来，也不报错。后台报错。求助，不知道什么原因？_百度知道
访问页面出不来，也不报错。后台报错。求助，不知道什么原因？
大神能帮我看看什么原因吗
我有更好的答案
29行空指针异常了，可能是没有获取到数据库连接对象，检查一下数据库的url，用户名密码，打个断点单步调试
enter password：1314我这数据库和DBUtil对应吗，我搞不大明白
端口号都没有 应该是这样jdbc:mysql://localhost:8080/lt
采纳率：9%
获取的Connection为空吧
debug调试value显示不为空呀
为您推荐：
其他类似问题
等待您来回答2010年2月 Java大版内专家分月排行榜第二
2011年7月 Java大版内专家分月排行榜第三2010年1月 Java大版内专家分月排行榜第三2009年12月 Java大版内专家分月排行榜第三
2011年10月 Web 开发大版内专家分月排行榜第二2011年8月 Web 开发大版内专家分月排行榜第二2011年7月 Web 开发大版内专家分月排行榜第二
本帖子已过去太久远了，不再提供回复功能。/**
*作者:annegu
*日期:
*/
Mysql是一个中小型关系型数据库管理系统，目前使用的也比较广泛。为了对开发中间dao层的问题能有更深的理解，在遇到问题的时候能够有更多的思路，于是研究了一下mysql驱动的使用，并且在这过程中也发现了一直以来关于PreparedStatement常识理解上的错误，与大家分享。
下面是个最简单的使用jdbc取得数据的应用。在例子之后我将分成4步，分别是①取得连接，②创建PreparedStatement，③设置参数，④执行查询，来分步分析这个过程。除了设置参数那一步之外，其他的我都画了时序图，如果不想看文字的话，可以对着时序图 。文中的第4步是组装mysql协议并发送数据包的关键，而且在这部分的(b)环节，我对于PreparedStatement的应用有详细的代码注释分析，建议大家关注一下。
public class DBHelper {
public static Connection getConnection() {
Connection conn =
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();
/*dao中的方法*/
public List&Adv& getAllAdvs() {
Connection conn =
ResultSet rs =
PreparedStatement stmt =
String sql = "select * from adv where id = ?";
List&Adv& advs = new ArrayList&Adv&();
conn = DBHelper.getConnection();
if (conn != null) {
stmt = conn.prepareStatement(sql);
stmt.setInt(1, new Integer(1));
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 {
stmt.close();
conn.close();
} catch (SQLException e) {
e.printStackTrace();
1、首先我们看到要的到一个数据库连接，得到数据库连接这部分放在DBHelper类中的getConnection方法中实现。Class.forName("com.mysql.jdbc.Driver");用来加载mysql的jdbc驱动。
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
public Driver() throws SQLException {
Mysql的Driver类实现了java.sql.Driver接口，任何数据库提供商的驱动类都必须实现这个接口。在DriverManager类中使用的都是接口Driver类型的驱动，也就是说驱动的使用不依赖于具体的实现，这无疑给我们的使用带来很大的方便。如果需要换用其他的数据库的话，只需要把Class.forName()中的参数换掉就可以了，可以说是非常方便的。
在com.mysql.jdbc.Driver类中，除了构造方法，就是一个static的方法体，它调用了DriverManager的registerDriver()方法，这个方法会加载所有系统提供的驱动，并把它们都假如到具体的驱动类中，当然现在就是mysql的Driver。在这里我们第一次看到了DriverManager类，这个类中提供了jdbc连接的主要操作，创建连接就是在这里完成的，可以说这是一个管理驱动的工具类。
public static synchronized void registerDriver(java.sql.Driver driver)
throws SQLException {
if (!initialized) {
initialize();
DriverInfo di = new DriverInfo();
/*把driver的信息封装一下，组成一个DriverInfo对象*/
di.driver =
di.driverClass = driver.getClass();
di.driverClassName = di.driverClass.getName();
writeDrivers.addElement(di);
println("registerDriver: " + di);
readDrivers = (java.util.Vector) writeDrivers.clone();
注册驱动首先就是初始化，然后把驱动的信息封装一下放进一个叫做DriverInfo的驱动信息类中，最后放入一个驱动的集合中。初始化工作主要是完成所有驱动的加载。
至于驱动的集合writeDrivers和readDrivers，很有趣的是，无论是registerDriver还是deregisterDriver，都是先对writeDrivers中的数据进行添加或者删除，然后再把writeDrivers中的驱动都拷贝到readDrivers中，但每次取出driver却从来不从writeDrivers中取，都是通过readDrivers来获得。我认为可以这样理解，writeDrivers只负责注册driver与注销driver，而readDrivers只负责提供可用的driver，只有当writeDrivers中准备好了驱动，这些驱动才是可以使用的，所以才能被copy至readDrivers中以备使用。这样一来，对内的注册注销与对外的提供使用就分开来了。
第二步就要根据url和用户名，密码来获得数据库的连接了。url一般都是这样的格式：jdbc:protocol://host_name:port/db_name?parameter_name=param_value。开头部分的protocal是对应于不同的数据库提供商的协议，例如mysql的就是mysql。
DriverManager中有重载了四个getConnection()，因为我们有用户名和密码，就把用户和密码存放在Properties中，最后进入终极getConnection()，如下：
private static Connection getConnection(
String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {
java.util.Vector drivers =
if (!initialized) {
initialize();
/*取得连接使用的driver从readDrivers中取*/
synchronized (DriverManager.class){
drivers = readD
SQLException reason =
for (int i = 0; i & drivers.size(); i++) {
DriverInfo di = (DriverInfo)drivers.elementAt(i);
if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {
/*找到可供使用的驱动，连接数据库server*/
Connection result = di.driver.connect(url, info);
if (result != null) {
return (result);
} catch (SQLException ex) {
if (reason == null) {
if (reason != null)
println("getConnection failed: " + reason);
throw new SQLException("No suitable driver found for "+ url, "08001");
Initialize()简直无所不在，DriverManager中只要使用driver之前，就要检查一下有没有初始化，非常小心。然后开始遍历所有驱动，直到找到一个可用的驱动，用这个驱动来取得一个数据库连接，最后返回这个连接。当然，这是正常的情况，从上面我们可以看到，程序中对异常的处理很仔细。如果连接失败，会记录抛出的第一个异常信息，如果没有找到合适的驱动，就抛出一个08001的错误。
现在重点就是假如一切正常，就应该从driver.connect()返回一个数据库连接，所以我们来看看如何通过url提供的数据库。
public java.sql.Connection connect(String url, Properties info)
throws SQLException {
Properties props =
if ((props = parseURL(url, info)) == null) {
Connection newConn = new com.mysql.jdbc.Connection(host(props),
port(props), props, database(props), url);
return newC
} catch (SQLException sqlEx) {
throw sqlEx;
} catch (Exception ex) {
throw SQLError.createSQLException(...);
很简洁的写法，就是新建了一个mysql的connection，host, port, database给它传进入，让它去连接就对了，props里面是些什么东西呢，就是把url拆解一下，什么host，什么数据库名，然后url后面的一股脑的参数，再把用户跟密码也都放进入，反正就是所有的连接数据都放进入了。
在com.mysql.jdbc.Connection的构造方法里面，会先做一些连接的初始化操作，例如创建PreparedStatement的cache，创建日志等等。然后就进入createNewIO()来建立连接了。
从时序图中可以看到，createNewIO()就是新建了一个com.mysql.jdbc.MysqlIO，利用com.mysql.jdbc.StandardSocketFactory来创建一个socket。然后就由这个mySqlIO来与MySql服务器进行握手(doHandshake())，这个doHandshake主要用来初始化与Mysql server的连接，负责登陆服务器和处理连接错误。在其中会分析所连接的mysql server的版本，根据不同的版本以及是否使用SSL加密数据都有不同的处理方式，并把要传输给数据库server的数据都放在一个叫做packet的buffer中，调用send()方法往outputStream中写入要发送的数据。
2、PreparedStatement stmt = conn.prepareStatement(sql);使用得到的connection创建一个Statement。Statement有许多种，我们常用的就是PreparedStatement，用于执行预编译好的SQL语句，CallableStatement用于调用数据库的存储过程。它们的继承关系如下图所示。
一旦有了一个statement，就可以通过执行statement.executeQuery()并通过ResultSet对象读出查询结果（如果查询有返回结果的话）。
创建statement的方法一般都有重载，我们看下面的prepareStatement:
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 SQLE
如果没有指定resultSetType和resultSetConcurrency的话，会给它们默认设置一个值。
ResultSet中的参数常量主要有以下几种：
TYPE_FORWARD_ONLY： ResultSet的游标只能向前移动。
TYPE_SCROLL_INSENSITIVE：ResultSet的游标可以滚动，但对于resultSet下的数据改变不敏感。
TYPE_SCROLL_SENSITIVE：ResultSet的游标可以滚动，但对于resultSet下的数据改变是敏感的。
CONCUR_READ_ONLY：不可以更新的ResultSet的并发模式。
CONCUR_UPDATABLE：可以更新的ResultSet的并发模式。
FETCH_FORWARD：按正向（即从第一个到最后一个）处理结果集中的行。
FETCH_REVERSE：按反向（即从最后一个到第一个）处理结果集中的行处理。
FETCH_UNKNOWN：结果集中的行的处理顺序未知。
CLOSE_CURSORS_AT_COMMIT：调用mit方法时应该关闭 ResultSet 对
HOLD_CURSORS_OVER_COMMIT：调用mit方法时不应关闭ResultSet对象。
prepareStatement的创建如下图所示：
在new ParseInfo中，会对这个sql语句进行分析，例如看看这个sql是什么语句；有没有limit条件语句，还有一个重要的工作，如果使用的是PreparedStatement来准备sql语句的话，会在这里把sql语句进行分解。我们知道PreparedStatement对象在实例化创建时就被设置了一个sql语句，使用PreparedStatement对象执行的sql语句在首次发送到数据库时，sql语句就会被编译，这样当多次执行同一个sql语句时，mysql就不用每次都去编译sql语句了。这个sql语句如果包含参数的话，可以用问号(”?”)来为参数进行占位，而不需要立即为参数赋值，而在语句执行之前，必须通过适当的set***()来为问号处的参数赋值。New ParseInfo()中，包含了参数的sql语句就会被分解为多段，放在staticSql中，以便需要设置参数时定位参数的位置。假如sql语句为“select * from adv where id = ? and name = ?”的话，那么staticSql中的元素就是3个，staticSql[3]={ ”select * from adv where id = ”, ” and name = ” , ””}。注意数组中最后一个元素，在这个例子中是””，因为我的例子里面最后一个就是”?”，如果sql语句是这样的“select * from adv where id = ? and name = ? order by id”的话，staticSql就变成是这样的{ ”select * from adv where id = ”, ” and name = ” , ” order by id”}。
3、stmt.setInt(1, new Integer(1));
设置sql语句中的参数值。
对于参数而言，PreparedStatement中一共有四个变量来储存它们，分别是
a) byte[][] parameterValues：参数转换为byte后的值。
b) InputStream[] parameterStreams：只有在调用存储过程batch（CallableStatement）的时候才会用到它，否则它的数组中的值设置为null。
c) boolean[] isStream：是否为stream的标志，如果调用的是preparedStatement，isStream数组中的值均为false，若调用的是CallableStatement，则均设置为true。
d) boolean[] isNull：标识参数是否为空，设置为false。
这四个变量的一维数组的大小都是一样的，sql语句中有几个待set的参数（几个问号），一维的元素个数就是多大。
4、ResultSet rs = stmt.executeQuery();
一切准备就绪，开始执行查询罗！
a) 检查preparedStatement是否已关闭，如果已关闭，抛出一个SQLError.SQL_STATE_CONNECTION_NOT_OPEN的错误。
b) fillSendPacket：创建数据包，其中包含了要发送到服务器的查询。
这个sendPacket就是mysql驱动要发送给数据库服务器的协议数据。一般来说，协议的数据格式有两种，一种是二进制流的格式，还有一种是文本的格式。文本协议就是基本上人可以直接阅读的协议，一般是用ascii字符集，也有用utf8格式的，优点是便于理解，读起来方便，扩充容易，缺点就是解析的时候比较麻烦，而且占用的空间比较大，冗余的数据比较多。二进制格式话，就需要服务器与客户端协议规定固定的数据结构，哪个位置放什么数据，如果单独看协议内容的话，很难理解数据含义，优点就是数据量小，解析的时候只要根据固定位置的值就能知道具体标识什么意义。
在这里使用的是二进制流的格式，也就是说协议中的数据格式是固定的，而且都要转换成二进制。格式为第一个byte标识操作信号，后面开始就是完整的sql语句的二进制流，请看下面的代码分析。
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. 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. 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);
/*否则的话，就用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 sendP
假如sql语句为“select * from adv where id = ?”的话，这个sendPacket中第一个byte的值就是3(MysqlDefs.QUERY的int值)，后面接着的就是填充了参数值的完整的sql语句字符串(例如：select * from adv where id = 1)转换成的byte格式。
于是，我们看到，好像sql语句在这里就已经不是带”?”的preparedStatement，而是在驱动里面把参数替代到”?”中，再把完整的sql语句发送给mysql server来编译，那么尽管只是参数改变，但对于mysql server来说，每次都是新的sql语句，都要进行编译的。这与我们之前一直理解的PreparedStatement完全不一样。照理来说，应该把带”?”的sql语句发送给数据库server，由mysql server来编译这个带”?”的sql语句，然后用实际的参数来替代”?”，这样才是实现了sql语句只编译一次的效果。sql语句预编译的功能取决于server端，oracle就是支持sql预编译的。
所以说，从mysql驱动的PreparedStatement里面，好像我们并没有看到mysql支持预编译功能的证据。（实际测试也表明，如果server没有预编译功能的话，PreparedStatement和Statement的效率几乎一样，甚至当使用次数不多的时候，PreparedStatement比Statement还要慢一些）。
但是并不是说PreparedStatement除了给我们带来高效率就没有其他作用了，它还有非常好的其他作用：
i. 极大的提高了sql语句的安全性，可以防止sql注入
ii. 代码结构清晰，易于理解，便于维护。
增加（感谢gembler）：其实，在mysql5上的版本是支持预编译sql功能的。我用的驱动是5.0.6的，在com.mysql.jdbc.Connection中有一个参数useServerPreparedStmts，表明是否使用预编译功能，所以如果把useServerPreparedStmts置为true的话，mysql驱动可以通过PreparedStatement的子类ServerPreparedStatement来实现真正的PreparedStatement的功能。在这个类的serverExecute方法里面，就负责告诉server，用现在提供的参数来动态绑定到编译好的sql语句上。所以说，ServerPreparedStatement才是真正实现了所谓prepare statement。
c) 设置当前的数据库名，并把之前的数据库名记录下来，在查询完成之后还要恢复原状。
d) 检查一下之前是否有缓存的数据，如果不久之前执行过这个查询，并且缓存了数据的话，就直接从缓存中取出。
e) 如果sql查询没有限制条件的话，为其设置默认的返回行数，若preparedStatement中已经设置了maxRows的话，就使用它。
f) executeInternal：执行查询。
i. 设置当前数据库连接，并调用connection的execSQL来执行查询.然后继续把要发送的查询包，就是之间组装完毕的sendPacket传递进入MysqlIO的sqlQueryDirect()。
ii. 接下来就要往server端发送我们的查询指令啦(sendCommand)，说到发送数据，不禁要问，如果这个待发送的数据包超级大，难道每次都是一次性的发送吗？当然不是，如果数据包超过规定的最大值的话，就会把它分割一下，分成几个不超过最大值的数据包来发送。
所以可以肯定，在分割的过程中，除了最后一个数据包，其他数据包的大小都是一样的。那就这样的数据包直接切割了进行发送的话，假如现在被分成了三个数据包，发送给mysql server，服务器怎么知道那个包是第一个呢，它读数据该从什么地方开始读呢，这都是问题，所以，我们要给每个数据包的前面加上一点属性标志，这个标志一共占了4个byte。从代码①处开始就是头标识位的设置。第一位表示数据包的开始位置，就是数据存放的起始位置，一般都设置为0，就是从第一个位置开始。第二和第三个字节标识了这个数据包的大小，注意的是，这个大小是出去标识的4个字节的大小，对于非最后一个数据包来说，这个大小都是一样的，就是splitSize，也就是maxThreeBytes，它的值是255 * 255 * 255。
最后一个字节中存放的就是数据包的编号了，从0开始递增。
在标识位设置完毕之后，就可以把255 * 255 * 255大小的数据从我们准备好的待发送数据包中copy出来了，注意，前4位已经是标识位了，所以应该从第五个位置开始copy数据。
在数据包都装配完毕之后，就可以往socket的outputSteam中发送数据了。接下来的事情，就是由mysql服务器接收数据并解析，执行查询了。
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();
Buffer packetToS
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 += splitS
len -= splitS
iii. 通过readAllResults方法读取查询结果。这个读取的过程与发送过程相反，如果接收到的数据包有多个的话，通过IO不断读取，并根据第packet第4个位置上的序号来组装这些packet。然后把读到的数据组装成resultSet中的rowData，这个结果就是我们要的查询结果了。
结合下面的executeQuery的时序图再理一下思路就更清楚了。
至此，把resultSet一步步的返回给dao，接下来的过程，就是从resultSet中取出rowData，组合成我们自己需要的对象数据了。
总结一下，经过这次对mysql驱动的探索，我发现了更多关于mysql的底层细节，对于以后分析问题解决问题有很大帮助，当然，这里面还有很多细节文中没有写。另外一个就是对于PreparedStatement有了重新的认识，有些东西往往都是想当然得出来的结论，真相还是要靠实践来发现。
论坛回复 /
(52 / 36232)
whaosoft 写道看来lz要好好学习了哦!~
恭喜您，您获得了javaeye2009年度1-6月份"水王"荣誉称号，您常年活跃于各大板块，坚持灌水为主，讨论为辅，始终保持0分的纯洁和神圣，希望您能将这种精神持之以恒的保持，即使每天一份Javaeye小测验也不动摇自己的信念。
那哥们以后能不能说句有用的话，在这浪费je的数据库空间。
你的类图很漂亮啊，用什么画的
好像是EA吧
/**
*作者:annegu
*日期:
*/
Mysql是一个中小型关系型数据库管理系统，目前使用的也比较广泛。为了对开发中间dao层的问题能有更深的理解，在遇到问题的时候能够有更多的思路，于是研究了一下mysql驱动的使用，并且在这过程中也发现了一直以来关于PreparedStatement常识理解上的错误，与大家分享。
下面是个最简单的使用jdbc取得数据的应用。在例子之后我将分成4步，分别是①取得连接，②创建PreparedStatement，③设置参数，④执行查询，来分步分析这个过程。除了设置参数那一步之外，其他的我都画了时序图，如果不想看文字的话，可以对着时序图 。文中的第4步是组装mysql协议并发送数据包的关键，而且在这部分的(b)环节，我对于PreparedStatement的应用有详细的代码注释分析，建议大家关注一下。
public class DBHelper {
public static Connection getConnection() {
Connection conn =
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();
/*dao中的方法*/
public List&Adv& getAllAdvs() {
Connection conn =
ResultSet rs =
PreparedStatement stmt =
String sql = "select * from adv where id = ?";
List&Adv& advs = new ArrayList&Adv&();
conn = DBHelper.getConnection();
if (conn != null) {
stmt = conn.prepareStatement(sql);
stmt.setInt(1, new Integer(1));
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 {
stmt.close();
conn.close();
} catch (SQLException e) {
e.printStackTrace();
1、首先我们看到要的到一个数据库连接，得到数据库连接这部分放在DBHelper类中的getConnection方法中实现。Class.forName("com.mysql.jdbc.Driver");用来加载mysql的jdbc驱动。
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
public Driver() throws SQLException {
Mysql的Driver类实现了java.sql.Driver接口，任何数据库提供商的驱动类都必须实现这个接口。在DriverManager类中使用的都是接口Driver类型的驱动，也就是说驱动的使用不依赖于具体的实现，这无疑给我们的使用带来很大的方便。如果需要换用其他的数据库的话，只需要把Class.forName()中的参数换掉就可以了，可以说是非常方便的。
在com.mysql.jdbc.Driver类中，除了构造方法，就是一个static的方法体，它调用了DriverManager的registerDriver()方法，这个方法会加载所有系统提供的驱动，并把它们都假如到具体的驱动类中，当然现在就是mysql的Driver。在这里我们第一次看到了DriverManager类，这个类中提供了jdbc连接的主要操作，创建连接就是在这里完成的，可以说这是一个管理驱动的工具类。
public static synchronized void registerDriver(java.sql.Driver driver)
throws SQLException {
if (!initialized) {
initialize();
DriverInfo di = new DriverInfo();
/*把driver的信息封装一下，组成一个DriverInfo对象*/
di.driver =
di.driverClass = driver.getClass();
di.driverClassName = di.driverClass.getName();
writeDrivers.addElement(di);
println("registerDriver: " + di);
readDrivers = (java.util.Vector) writeDrivers.clone();
注册驱动首先就是初始化，然后把驱动的信息封装一下放进一个叫做DriverInfo的驱动信息类中，最后放入一个驱动的集合中。初始化工作主要是完成所有驱动的加载。
至于驱动的集合writeDrivers和readDrivers，很有趣的是，无论是registerDriver还是deregisterDriver，都是先对writeDrivers中的数据进行添加或者删除，然后再把writeDrivers中的驱动都拷贝到readDrivers中，但每次取出driver却从来不从writeDrivers中取，都是通过readDrivers来获得。我认为可以这样理解，writeDrivers只负责注册driver与注销driver，而readDrivers只负责提供可用的driver，只有当writeDrivers中准备好了驱动，这些驱动才是可以使用的，所以才能被copy至readDrivers中以备使用。这样一来，对内的注册注销与对外的提供使用就分开来了。
第二步就要根据url和用户名，密码来获得数据库的连接了。url一般都是这样的格式：jdbc:protocol://host_name:port/db_name?parameter_name=param_value。开头部分的protocal是对应于不同的数据库提供商的协议，例如mysql的就是mysql。
DriverManager中有重载了四个getConnection()，因为我们有用户名和密码，就把用户和密码存放在Properties中，最后进入终极getConnection()，如下：
private static Connection getConnection(
String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {
java.util.Vector drivers =
if (!initialized) {
initialize();
/*取得连接使用的driver从readDrivers中取*/
synchronized (DriverManager.class){
drivers = readD
SQLException reason =
for (int i = 0; i & drivers.size(); i++) {
DriverInfo di = (DriverInfo)drivers.elementAt(i);
if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {
/*找到可供使用的驱动，连接数据库server*/
Connection result = di.driver.connect(url, info);
if (result != null) {
return (result);
} catch (SQLException ex) {
if (reason == null) {
if (reason != null)
println("getConnection failed: " + reason);
throw new SQLException("No suitable driver found for "+ url, "08001");
Initialize()简直无所不在，DriverManager中只要使用driver之前，就要检查一下有没有初始化，非常小心。然后开始遍历所有驱动，直到找到一个可用的驱动，用这个驱动来取得一个数据库连接，最后返回这个连接。当然，这是正常的情况，从上面我们可以看到，程序中对异常的处理很仔细。如果连接失败，会记录抛出的第一个异常信息，如果没有找到合适的驱动，就抛出一个08001的错误。
现在重点就是假如一切正常，就应该从driver.connect()返回一个数据库连接，所以我们来看看如何通过url提供的数据库。
public java.sql.Connection connect(String url, Properties info)
throws SQLException {
Properties props =
if ((props = parseURL(url, info)) == null) {
Connection newConn = new com.mysql.jdbc.Connection(host(props),
port(props), props, database(props), url);
return newC
} catch (SQLException sqlEx) {
throw sqlEx;
} catch (Exception ex) {
throw SQLError.createSQLException(...);
很简洁的写法，就是新建了一个mysql的connection，host, port, database给它传进入，让它去连接就对了，props里面是些什么东西呢，就是把url拆解一下，什么host，什么数据库名，然后url后面的一股脑的参数，再把用户跟密码也都放进入，反正就是所有的连接数据都放进入了。
在com.mysql.jdbc.Connection的构造方法里面，会先做一些连接的初始化操作，例如创建PreparedStatement的cache，创建日志等等。然后就进入createNewIO()来建立连接了。
从时序图中可以看到，createNewIO()就是新建了一个com.mysql.jdbc.MysqlIO，利用com.mysql.jdbc.StandardSocketFactory来创建一个socket。然后就由这个mySqlIO来与MySql服务器进行握手(doHandshake())，这个doHandshake主要用来初始化与Mysql server的连接，负责登陆服务器和处理连接错误。在其中会分析所连接的mysql server的版本，根据不同的版本以及是否使用SSL加密数据都有不同的处理方式，并把要传输给数据库server的数据都放在一个叫做packet的buffer中，调用send()方法往outputStream中写入要发送的数据。
2、PreparedStatement stmt = conn.prepareStatement(sql);使用得到的connection创建一个Statement。Statement有许多种，我们常用的就是PreparedStatement，用于执行预编译好的SQL语句，CallableStatement用于调用数据库的存储过程。它们的继承关系如下图所示。
一旦有了一个statement，就可以通过执行statement.executeQuery()并通过ResultSet对象读出查询结果（如果查询有返回结果的话）。
创建statement的方法一般都有重载，我们看下面的prepareStatement:
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 SQLE
如果没有指定resultSetType和resultSetConcurrency的话，会给它们默认设置一个值。
ResultSet中的参数常量主要有以下几种：
TYPE_FORWARD_ONLY： ResultSet的游标只能向前移动。
TYPE_SCROLL_INSENSITIVE：ResultSet的游标可以滚动，但对于resultSet下的数据改变不敏感。
TYPE_SCROLL_SENSITIVE：ResultSet的游标可以滚动，但对于resultSet下的数据改变是敏感的。
CONCUR_READ_ONLY：不可以更新的ResultSet的并发模式。
CONCUR_UPDATABLE：可以更新的ResultSet的并发模式。
FETCH_FORWARD：按正向（即从第一个到最后一个）处理结果集中的行。
FETCH_REVERSE：按反向（即从最后一个到第一个）处理结果集中的行处理。
FETCH_UNKNOWN：结果集中的行的处理顺序未知。
CLOSE_CURSORS_AT_COMMIT：调用mit方法时应该关闭 ResultSet 对
HOLD_CURSORS_OVER_COMMIT：调用mit方法时不应关闭ResultSet对象。
prepareStatement的创建如下图所示：
在new ParseInfo中，会对这个sql语句进行分析，例如看看这个sql是什么语句；有没有limit条件语句，还有一个重要的工作，如果使用的是PreparedStatement来准备sql语句的话，会在这里把sql语句进行分解。我们知道PreparedStatement对象在实例化创建时就被设置了一个sql语句，使用PreparedStatement对象执行的sql语句在首次发送到数据库时，sql语句就会被编译，这样当多次执行同一个sql语句时，mysql就不用每次都去编译sql语句了。这个sql语句如果包含参数的话，可以用问号(”?”)来为参数进行占位，而不需要立即为参数赋值，而在语句执行之前，必须通过适当的set***()来为问号处的参数赋值。New ParseInfo()中，包含了参数的sql语句就会被分解为多段，放在staticSql中，以便需要设置参数时定位参数的位置。假如sql语句为“select * from adv where id = ? and name = ?”的话，那么staticSql中的元素就是3个，staticSql[3]={ ”select * from adv where id = ”, ” and name = ” , ””}。注意数组中最后一个元素，在这个例子中是””，因为我的例子里面最后一个就是”?”，如果sql语句是这样的“select * from adv where id = ? and name = ? order by id”的话，staticSql就变成是这样的{ ”select * from adv where id = ”, ” and name = ” , ” order by id”}。
3、stmt.setInt(1, new Integer(1));
设置sql语句中的参数值。
对于参数而言，PreparedStatement中一共有四个变量来储存它们，分别是
a) byte[][] parameterValues：参数转换为byte后的值。
b) InputStream[] parameterStreams：只有在调用存储过程batch（CallableStatement）的时候才会用到它，否则它的数组中的值设置为null。
c) boolean[] isStream：是否为stream的标志，如果调用的是preparedStatement，isStream数组中的值均为false，若调用的是CallableStatement，则均设置为true。
d) boolean[] isNull：标识参数是否为空，设置为false。
这四个变量的一维数组的大小都是一样的，sql语句中有几个待set的参数（几个问号），一维的元素个数就是多大。
4、ResultSet rs = stmt.executeQuery();
一切准备就绪，开始执行查询罗！
a) 检查preparedStatement是否已关闭，如果已关闭，抛出一个SQLError.SQL_STATE_CONNECTION_NOT_OPEN的错误。
b) fillSendPacket：创建数据包，其中包含了要发送到服务器的查询。
这个sendPacket就是mysql驱动要发送给数据库服务器的协议数据。一般来说，协议的数据格式有两种，一种是二进制流的格式，还有一种是文本的格式。文本协议就是基本上人可以直接阅读的协议，一般是用ascii字符集，也有用utf8格式的，优点是便于理解，读起来方便，扩充容易，缺点就是解析的时候比较麻烦，而且占用的空间比较大，冗余的数据比较多。二进制格式话，就需要服务器与客户端协议规定固定的数据结构，哪个位置放什么数据，如果单独看协议内容的话，很难理解数据含义，优点就是数据量小，解析的时候只要根据固定位置的值就能知道具体标识什么意义。
在这里使用的是二进制流的格式，也就是说协议中的数据格式是固定的，而且都要转换成二进制。格式为第一个byte标识操作信号，后面开始就是完整的sql语句的二进制流，请看下面的代码分析。
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. 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. 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);
/*否则的话，就用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 sendP
假如sql语句为“select * from adv where id = ?”的话，这个sendPacket中第一个byte的值就是3(MysqlDefs.QUERY的int值)，后面接着的就是填充了参数值的完整的sql语句字符串(例如：select * from adv where id = 1)转换成的byte格式。
于是，我们看到，好像sql语句在这里就已经不是带”?”的preparedStatement，而是在驱动里面把参数替代到”?”中，再把完整的sql语句发送给mysql server来编译，那么尽管只是参数改变，但对于mysql server来说，每次都是新的sql语句，都要进行编译的。这与我们之前一直理解的PreparedStatement完全不一样。照理来说，应该把带”?”的sql语句发送给数据库server，由mysql server来编译这个带”?”的sql语句，然后用实际的参数来替代”?”，这样才是实现了sql语句只编译一次的效果。sql语句预编译的功能取决于server端，oracle就是支持sql预编译的。
所以说，从mysql驱动的PreparedStatement里面，好像我们并没有看到mysql支持预编译功能的证据。（实际测试也表明，如果server没有预编译功能的话，PreparedStatement和Statement的效率几乎一样，甚至当使用次数不多的时候，PreparedStatement比Statement还要慢一些）。
但是并不是说PreparedStatement除了给我们带来高效率就没有其他作用了，它还有非常好的其他作用：
i. 极大的提高了sql语句的安全性，可以防止sql注入
ii. 代码结构清晰，易于理解，便于维护。
增加（感谢gembler）：其实，在mysql5上的版本是支持预编译sql功能的。我用的驱动是5.0.6的，在com.mysql.jdbc.Connection中有一个参数useServerPreparedStmts，表明是否使用预编译功能，所以如果把useServerPreparedStmts置为true的话，mysql驱动可以通过PreparedStatement的子类ServerPreparedStatement来实现真正的PreparedStatement的功能。在这个类的serverExecute方法里面，就负责告诉server，用现在提供的参数来动态绑定到编译好的sql语句上。所以说，ServerPreparedStatement才是真正实现了所谓prepare statement。
c) 设置当前的数据库名，并把之前的数据库名记录下来，在查询完成之后还要恢复原状。
d) 检查一下之前是否有缓存的数据，如果不久之前执行过这个查询，并且缓存了数据的话，就直接从缓存中取出。
e) 如果sql查询没有限制条件的话，为其设置默认的返回行数，若preparedStatement中已经设置了maxRows的话，就使用它。
f) executeInternal：执行查询。
i. 设置当前数据库连接，并调用connection的execSQL来执行查询.然后继续把要发送的查询包，就是之间组装完毕的sendPacket传递进入MysqlIO的sqlQueryDirect()。
ii. 接下来就要往server端发送我们的查询指令啦(sendCommand)，说到发送数据，不禁要问，如果这个待发送的数据包超级大，难道每次都是一次性的发送吗？当然不是，如果数据包超过规定的最大值的话，就会把它分割一下，分成几个不超过最大值的数据包来发送。
所以可以肯定，在分割的过程中，除了最后一个数据包，其他数据包的大小都是一样的。那就这样的数据包直接切割了进行发送的话，假如现在被分成了三个数据包，发送给mysql server，服务器怎么知道那个包是第一个呢，它读数据该从什么地方开始读呢，这都是问题，所以，我们要给每个数据包的前面加上一点属性标志，这个标志一共占了4个byte。从代码①处开始就是头标识位的设置。第一位表示数据包的开始位置，就是数据存放的起始位置，一般都设置为0，就是从第一个位置开始。第二和第三个字节标识了这个数据包的大小，注意的是，这个大小是出去标识的4个字节的大小，对于非最后一个数据包来说，这个大小都是一样的，就是splitSize，也就是maxThreeBytes，它的值是255 * 255 * 255。
最后一个字节中存放的就是数据包的编号了，从0开始递增。
在标识位设置完毕之后，就可以把255 * 255 * 255大小的数据从我们准备好的待发送数据包中copy出来了，注意，前4位已经是标识位了，所以应该从第五个位置开始copy数据。
在数据包都装配完毕之后，就可以往socket的outputSteam中发送数据了。接下来的事情，就是由mysql服务器接收数据并解析，执行查询了。
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();
Buffer packetToS
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 += splitS
len -= splitS
iii. 通过readAllResults方法读取查询结果。这个读取的过程与发送过程相反，如果接收到的数据包有多个的话，通过IO不断读取，并根据第packet第4个位置上的序号来组装这些packet。然后把读到的数据组装成resultSet中的rowData，这个结果就是我们要的查询结果了。
结合下面的executeQuery的时序图再理一下思路就更清楚了。
至此，把resultSet一步步的返回给dao，接下来的过程，就是从resultSet中取出rowData，组合成我们自己需要的对象数据了。
总结一下，经过这次对mysql驱动的探索，我发现了更多关于mysql的底层细节，对于以后分析问题解决问题有很大帮助，当然，这里面还有很多细节文中没有写。另外一个就是对于PreparedStatement有了重新的认识，有些东西往往都是想当然得出来的结论，真相还是要靠实践来发现。
mikewang 写道
1, 数据库是否必须支持事务:
这个你不要扣概念了。在中国还有百万富翁之称呢，你到津巴布韦去自称亿万富翁，笑死你。
mikewang 写道
2, MyISAM是支持事务的&====& MyISAM 只是一个数据文件的格式， 和事物没有任何关系
你怎么前边不搭后边。人们都称MyISAM存储引擎，你却在这里只说人家是数据文件格式
mikewang 写道
3, 你不会认为事务是由文件格式或者文件系统提供的吧？
看来你对MySQL事物的ACDI很了解啊，那就说说MySQL+MyISAM的文件级别的锁怎么实现 我不了解得ACDI吧。
再贴一点
引用
By "transactional table type" I mean either InnoDB or BDB (but the latter is only included in -max versions). There are also some non-MySQL AB storage engines in the wild that might do the trick. And possibly there might be even more in the future.
MyISAM does not support transactions and probably never will.
But we are working on a feature that can rollback commands that were active when the MySQL server crashed. It will also be possible to explicitly rollback everything from the point of a LOCK TABLES as long as no UNLOCK TABLES has been done so far.
Please do not think of it as transactional. The way MyISAM stores data does not guarantee you anything when the machine (or better the operating system) crashes. You won't be able to undo nor redo MyISAM tables to a clean state.
Ingo Strüwing, Senior Software Developer - Storage Engines
MySQL AB,
人家自己都说不支持，你还非得给别人脸上贴金，还有我想等会你干脆根据你的理论说,基于MyISAM存储引擎的MySQL is not 数据库。。。
ok 你说的是对的， 确实我对MySQL 不是能了解， 站在数据库的角度说， Mysql 确实有不小的差距，有很多人认为MySQL 是dabatase，& 但你也说了，津巴布韦也有亿万富翁。
1, 数据库是否必须支持事务:
这个你不要扣概念了。在中国还有百万富翁之称呢，你到津巴布韦去自称亿万富翁，笑死你。
mikewang 写道
2, MyISAM是支持事务的&====& MyISAM 只是一个数据文件的格式， 和事物没有任何关系
你怎么前边不搭后边。人们都称MyISAM存储引擎，你却在这里只说人家是数据文件格式
mikewang 写道
3, 你不会认为事务是由文件格式或者文件系统提供的吧？
看来你对MySQL事物的ACDI很了解啊，那就说说MySQL+MyISAM的文件级别的锁怎么实现 我不了解得ACDI吧。
再贴一点
引用
By "transactional table type" I mean either InnoDB or BDB (but the latter is only included in -max versions). There are also some non-MySQL AB storage engines in the wild that might do the trick. And possibly there might be even more in the future.
MyISAM does not support transactions and probably never will.
But we are working on a feature that can rollback commands that were active when the MySQL server crashed. It will also be possible to explicitly rollback everything from the point of a LOCK TABLES as long as no UNLOCK TABLES has been done so far.
Please do not think of it as transactional. The way MyISAM stores data does not guarantee you anything when the machine (or better the operating system) crashes. You won't be able to undo nor redo MyISAM tables to a clean state.
Ingo Strüwing, Senior Software Developer - Storage Engines
MySQL AB,
人家自己都说不支持，你还非得给别人脸上贴金，还有我想等会你干脆根据你的理论说,基于MyISAM存储引擎的MySQL is not 数据库。。。
MyISAM真的支持事务吗?
/doc/refman/5.4/en/myisam-storage-engine.html
这上面Transactions写的是NO呀。
你不会认为事务是由文件格式或者文件系统提供的吧？
MyISAM 只是一个数据文件的格式， 和事物没有任何关系， 所谓的MyISAM支持本地事物是指可以使用posix文件锁在MyISAM数据文件上提供表级别的锁，MyISAM中一个表就是一个文件， 文件锁就是表锁，并发性可想而知了。 正是如此， 所以这个功能才不被建议使用！在后续的某个版本提供的行锁（排他性的）使用的posix记录锁实现的， 效果也很差。
mysql 提供lock 语句， 你去看看lock的文档，上面应该说的很清楚的。
顺便说一句， 我没用过mysql。mysql的文档我也没读过。我以前为postgresql捐献过代码， 在pgsql开发组中混的几天，所以听那帮大牛说过不少次mysql的优缺点和问题。 所以才对mysql 略微有一些了解。
kaipingk 写道
不要太概念了，概念的东西都是理论的东西，具体实现和概念是有差距的。&& 数据库必须支持事务吗？完全可以做一个不支持事物的数据库啊（MYSQL MyISAM引擎）！ 而且完全可以实现一个不抛异常的api事务操作实现啊（自己实现一个事务接口不给你抛任何异常）！&&&&& 总得把每个函数的作用搞搞清楚吧---应该是吧没有具体实现搞清楚嘛（我又没反对不该搞清楚）。我的意思就是很多东西就那么回事，没有什么大不了的！
1, 数据库是否必须支持事务， 去查查关于数据库的文献， 有很多，而且都是大部头的。 再去了解一下什么是ACDI，顺便搞清楚数据库和文件系统的区别。
2 MyISAM是支持事务的， 而且支持的就是我说的本地事务。 其实现方式用的是文件锁，（后续的某个版本提供了记录锁的支持）， 但是MyISAM的文档上确实说过， 不建议使用事务方式， 同时文档中也说明了理由， 原因是并发太差，而且错误太多。（给你个建议， 我觉得你对MyISAM的了解还是少了些， 最好在去看看文档，补习补习。）
3 你当然可以自己去实现一套api， j2ee 中间有个叫做jca的东西， 如果有兴趣的你可以摆弄一下，搞个不出异常的东西出来，别忘记把 jts 也重新实现一下， 否则还是要抛出异常的！ 但是我这里要说的是，我们讨论的jdbc API， 不是你的个人作品。
MyISAM真的支持事务吗?
/doc/refman/5.4/en/myisam-storage-engine.html
这上面Transactions写的是NO呀。
看来lz要好好学习了哦!~
恭喜您，您获得了javaeye2009年度1-6月份"水王"荣誉称号，您常年活跃于各大板块，坚持灌水为主，讨论为辅，始终保持0分的纯洁和神圣，希望您能将这种精神持之以恒的保持，即使每天一份Javaeye小测验也不动摇自己的信念。
gembler 写道annegu 写道PS：javaeye说严禁讨论与技术无关的问题。
哪里说？
昨天才做了论坛测试题，请看置顶帖子：JavaEye积分规则,博客和论坛使用规则
四、严禁无聊灌水性帖子
JavaEye的论坛不是用来灌水的，是用来交流技术的，即使是海阔天空版面，也不意味着你可以随意灌水，凡是言之无物的无聊灌水贴，将被删除，并扣除发贴者积分30分。纯灌水贴请到“JavaEye水源”圈子。请记住JavaEye的论坛是一个严肃的技术交流场所，在这里制造垃圾信息将受到惩罚。
版主，我不是灌水，是回答问题，并普及论坛规则！
这回robbin高兴死了
annegu 写道PS：javaeye说严禁讨论与技术无关的问题。
哪里说？
昨天才做了论坛测试题，请看置顶帖子：JavaEye积分规则,博客和论坛使用规则
四、严禁无聊灌水性帖子
JavaEye的论坛不是用来灌水的，是用来交流技术的，即使是海阔天空版面，也不意味着你可以随意灌水，凡是言之无物的无聊灌水贴，将被删除，并扣除发贴者积分30分。纯灌水贴请到“JavaEye水源”圈子。请记住JavaEye的论坛是一个严肃的技术交流场所，在这里制造垃圾信息将受到惩罚。
版主，我不是灌水，是回答问题，并普及论坛规则！
& 上一页 1
浏览: 80189 次
来自: 杭州
棒棒的。写得很好！
不过对下面所述的问题有一些不同的看法， 仅为个人观 ...
随便说说:发现几个问题，中国的程序员果然如传闻中的那样会随意指 ...
我想咨询你一个关于JMX的问题。
就是启动一个程序。
配置 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'}