JDBC连接数据库经验技巧

下面罗列了各种 数据库使用JDBC连接的方式，可以作为一个手册使用。

　　1、Oracle8/8i/9i 数据库（thin模式）

　　Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
　　String url="jdbc:oracle:thin:@localhost:1521:orcl"; //orcl为 数据库的SID
　　String user="test";
　　String password="test";
　　Connection conn= DriverManager.getConnection(url,user,password);

　　2、DB2 数据库

　　Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
　　String url="jdbc:db2://localhost:5000/sample"; //sample为你的 数据库名
　　String user="admin";
　　String password="";
　　Connection conn= DriverManager.getConnection(url,user,password);

　　3、Sql Server7.0/2000 数据库

　　Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
　　String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb";
　　//mydb为 数据库
　　String user="sa";
　　String password="";
　　Connection conn= DriverManager.getConnection(url,user,password);

　　4、Sybase 数据库

　　Class.forName("com.sybase.jdbc.SybDriver").newInstance();
　　String url =" jdbc:sybase:Tds:localhost:5007/myDB";//myDB为你的 数据库名
　　Properties sysProps = System.getProperties();
　　SysProps.put("user","userid");
　　SysProps.put("password","user_password");
　　Connection conn= DriverManager.getConnection(url, SysProps);

　　5、Informix 数据库

　　Class.forName("com.informix.jdbc.IfxDriver").newInstance();
　　String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver;
　　user=testuser;password=testpassword"; //myDB为 数据库名
　　Connection conn= DriverManager.getConnection(url);

　　6、MySQL 数据库

　　Class.forName("org.gjt.mm.mysql.Driver").newInstance();
　　String url ="jdbc:mysql://localhost/myDB?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
　　//myDB为 数据库名
　　Connection conn= DriverManager.getConnection(url);

　　7、PostgreSQL 数据库

　　Class.forName("org.postgresql.Driver").newInstance();
　　String url ="jdbc:postgresql://localhost/myDB" //myDB为 数据库名
　　String user="myuser";
　　String password="mypassword";
　　Connection conn= DriverManager.getConnection(url,user,password);

　　8、access 数据库直连用ODBC的

　　Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ;
　　String url="jdbc:odbc:Driver={MicroSoft Access Driver (*.mdb)};DBQ="+application.getRealPath("/Data/ReportDemo.mdb");
　　Connection conn = DriverManager.getConnection(url,"","");
　　Statement stmtNew=conn.createStatement() ;

　　 二、JDBC连接MySql方式

　　下面是使用JDBC连接MySql的一个小的教程

　　1、查找驱动 程序

　　MySQL目前提供的 java驱动 程序为Connection/J，可以从MySQL官方网站下载，并找到mysql-connector- java-3.0.15-ga-bin.jar文件，此驱动 程序为纯 java驱动 程序，不需做其他配置。

　　2、动态指定classpath

　　如果需要执行时动态指定classpath，就在执行时采用－cp方式。否则将上面的.jar文件加入到classpath环境变量中。

　　3、加载驱动 程序

　　try{
　　Class.forName(com.mysql.jdbc.Driver);
　　System.out.println(Success loading Mysql Driver!);
　　}catch(Exception e)
　　{
　　System.out.println(Error loading Mysql Driver!);
　　e.printStackTrace();
　　}

　　4、设置连接的url

　　jdbc：mysql：//localhost/databasename[?pa=va][＆pa=va]

　　 三、以下列出了在使用JDBC来连接Oracle数据库时可以使用的一些技巧

　　1、在客户端 软件 开发中使用Thin驱动 程序

　　在 开发 Java 软件方面，Oracle的 数据库提供了四种类型的驱动 程序，二种用于应用 软件、applets、servlets等客户端 软件，另外二种用于 数据库中的 Java存储过程等服务器端 软件。在客户机端 软件的 开发中，我们可以选择OCI驱动 程序或Thin驱动 程序。OCI驱动 程序利用 Java本地化接口（JNI），通过Oracle客户端 软件与 数据库进行通讯。Thin驱动 程序是纯 Java驱动 程序，它直接与 数据库进行通讯。为了获得最高的性能，Oracle建议在客户端 软件的 开发中使用OCI驱动 程序，这似乎是正确的。但我建议使用Thin驱动 程序，因为通过多次测试发现，在通常情况下，Thin驱动 程序的性能都超过了OCI驱动 程序。

　　2、关闭自动提交功能，提高 系统性能

　　在第一次建立与 数据库的连接时，在缺省情况下，连接是在自动提交模式下的。为了获得更好的性能，可以通过调用带布尔值false参数的Connection类的setAutoCommit()方法关闭自动提交功能，如下所示：

　　conn.setAutoCommit(false);

　　值得注意的是，一旦关闭了自动提交功能，我们就需要通过调用Connection类的commit()和rollback()方法来人工的方式对事务进行 管理。

　　3、在动态SQL或有时间限制的命令中使用Statement对象

　　在执行SQL命令时，我们有二种选择：可以使用PreparedStatement对象，也可以使用Statement对象。无论多少次地使用同一个SQL命令，PreparedStatement都只对它解析和编译一次。当使用Statement对象时，每次执行一个SQL命令时，都会对它进行解析和编译。这可能会使你认为，使用PreparedStatement对象比使用Statement对象的速度更快。然而，我进行的测试表明，在客户端 软件中，情况并非如此。因此，在有时间限制的SQL操作中，除非成批地处理SQL命令，我们应当考虑使用Statement对象。

　　此外，使用Statement对象也使得编写动态SQL命令更加简单，因为我们可以将字符串连接在一起，建立一个有效的SQL命令。因此，我认为，Statement对象可以使动态SQL命令的创建和执行变得更加简单。

　　4、利用helper函数对动态SQL命令进行格式化

　　在创建使用Statement对象执行的动态SQL命令时，我们需要处理一些格式化方面的问题。例如，如果我们想创建一个将名字O'Reilly插入表中的SQL命令，则必须使用二个相连的“''”号替换O'Reilly中的“'”号。完成这些工作的最好的方法是创建一个完成替换操作的helper方法，然后在连接字符串心服用公式表达一个SQL命令时，使用创建的helper方法。与此类似的是，我们可以让helper方法接受一个Date型的值，然后让它输出基于Oracle的to_date()函数的字符串表达式。

　　5、利用PreparedStatement对象提高 数据库的总体效率

　　在使用PreparedStatement对象执行SQL命令时，命令被 数据库进行解析和编译，然后被放到命令缓冲区。然后，每当执行同一个PreparedStatement对象时，它就会被再解析一次，但不会被再次编译。在缓冲区中可以发现预编译的命令，并且可以重新使用。在有大量用户的企业级应用 软件中，经常会重复执行相同的SQL命令，使用PreparedStatement对象带来的编译次数的减少能够提高 数据库的总体性能。如果不是在客户端创建、预备、执行PreparedStatement任务需要的时间长于Statement任务，我会建议在除动态SQL命令之外的所有情况下使用PreparedStatement对象。

　　6、在成批处理重复的插入或更新操作中使用PreparedStatement对象

　　如果成批地处理插入和更新操作，就能够显著地减少它们所需要的时间。Oracle提供的Statement和 CallableStatement并不真正地支持批处理，只有PreparedStatement对象才真正地支持批处理。我们可以使用addBatch()和executeBatch()方法选择标准的JDBC批处理，或者通过利用PreparedStatement对象的setExecuteBatch()方法和标准的executeUpdate()方法选择速度更快的Oracle专有的方法。要使用Oracle专有的批处理机制，可以以如下所示的方式调用setExecuteBatch()：

　　PreparedStatement pstmt3D null;
　　try {
　　((OraclePreparedStatement)pstmt).setExecuteBatch(30);
　　...
　　pstmt.executeUpdate();
　　}

　　调用setExecuteBatch()时指定的值是一个上限，当达到该值时，就会自动地引发SQL命令执行，标准的executeUpdate()方法就会被作为批处理送到 数据库中。我们可以通过调用PreparedStatement类的sendBatch()方法随时传输批处理任务。

　　7、使用Oracle locator方法插入、更新大对象（LOB）

　　Oracle的PreparedStatement类不完全支持BLOB和CLOB等大对象的处理，尤其是Thin驱动 程序不支持利用PreparedStatement对象的setObject()和setBinaryStream()方法设置BLOB的值，也不支持利用setCharacterStream()方法设置CLOB的值。只有locator本身中的方法才能够从 数据库中获取LOB类型的值。可以使用PreparedStatement对象插入或更新LOB，但需要使用locator才能获取LOB的值。由于存在这二个问题，因此，我建议使用locator的方法来插入、更新或获取LOB的值。

　　8、使用SQL92语法调用存储过程

　　在调用存储过程时，我们可以使用SQL92或Oracle PL/SQL，由于使用Oracle PL/SQL并没有什么实际的好处，而且会给以后维护你的应用 程序的 开发人员带来麻烦，因此，我建议在调用存储过程时使用SQL92。

　　9、使用Object SQL将对象模式转移到 数据库中

　　既然可以将Oracle的 数据库作为一种面向对象的 数据库来使用，就可以考虑将应用 程序中的面向对象模式转到 数据库中。目前的方法是创建 Java bean作为伪装的 数据库对象，将它们的属性映射到关系表中，然后在这些bean中添加方法。尽管这样作在 Java中没有什么问题，但由于操作都是在 数据库之外进行的，因此其他访问 数据库的应用 软件无法利用对象模式。如果利用Oracle的面向对象的 技术，可以通过创建一个新的 数据库对象类型在 数据库中模仿其数据和操作，然后使用JPublisher等工具生成自己的 Java bean类。如果使用这种方式，不但 Java应用 程序可以使用应用 软件的对象模式，其他需要共享你的应用中的数据和操作的应用 软件也可以使用应用 软件中的对象模式。

　　10、利用SQL完成 数据库内的操作

　　我要向大家介绍的最重要的经验是充分利用SQL的面向集合的方法来解决 数据库处理需求，而不是使用 Java等过程化的编程语言。

　　如果编程人员要在一个表中查找许多行，结果中的每个行都会查找其他表中的数据，最后，编程人员创建了独立的UPDATE命令来成批地更新第一个表中的数据。与此类似的任务可以通过在set子句中使用多列子查询而在一个UPDATE命令中完成。当能够在单一的SQL命令中完成任务，何必要让数据在网上流来流去的？我建议用户认真学习如何最大限度地发挥SQL的功能。
　　　　　　　　　　　

CNBIE BLOG

JDBC连接数据库经验技巧集萃

原文： JDBC连接数据库经验技巧集萃

Java数据库连接（JDBC）由一组用 Java 编程语言编写的类和接口组成。JDBC 为工具/数据库开发人员提供了一个标准的 API，使他们能够用纯Java API 来编写数据库应用程序。然而各个开发商的接口并不完全相同，所以开发环境的变化会带来一定的配置变化。本文主要集合了不同数据库的连接方式。 　　一、连接各种数据库方式速查表 　　下面罗列了各种数据库使用JDBC连接的方式，可以作为一个手册使用。 　　1、Oracle8/8i/9i数据库（thin模式） Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); String url="jdbc:oracle:thin:@localhost:1521:orcl"; //orcl为数据库的SID String user="test"; String password="test"; Connection conn= DriverManager.getConnection(url,user,password); 　　2、DB2数据库 Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance(); String url="jdbc:db2://localhost:5000/sample"; //sample为你的数据库名 String user="admin"; String password=""; Connection conn= DriverManager.getConnection(url,user,password); 　　3、Sql Server7.0/2000数据库 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance(); String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb"; //mydb为数据库 String user="sa"; String password=""; Connection conn= DriverManager.getConnection(url,user,password); 　　4、Sybase数据库 Class.forName("com.sybase.jdbc.SybDriver").newInstance(); String url =" jdbc:sybase:Tds:localhost:5007/myDB";//myDB为你的数据库名 Properties sysProps = System.getProperties(); SysProps.put("user","userid"); SysProps.put("password","user_password"); Connection conn= DriverManager.getConnection(url, SysProps); 　　5、Informix数据库 Class.forName("com.informix.jdbc.IfxDriver").newInstance(); String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver; user=testuser;password=testpassword"; //myDB为数据库名 Connection conn= DriverManager.getConnection(url); 　　6、MySQL数据库 Class.forName("org.gjt.mm.mysql.Driver").newInstance(); String url ="jdbc:mysql://localhost/myDB?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1" //myDB为数据库名 Connection conn= DriverManager.getConnection(url); 　　7、PostgreSQL数据库 Class.forName("org.postgresql.Driver").newInstance(); String url ="jdbc:postgresql://localhost/myDB" //myDB为数据库名 String user="myuser"; String password="mypassword"; Connection conn= DriverManager.getConnection(url,user,password); 　　8、access数据库直连用ODBC的 Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ; String url="jdbc:odbc:Driver={MicroSoft Access Driver (*.mdb)};DBQ="+application.getRealPath("/Data/ReportDemo.mdb"); Connection conn = DriverManager.getConnection(url,"",""); Statement stmtNew=conn.createStatement() ; 　　二、JDBC连接MySql方式 　　下面是使用JDBC连接MySql的一个小的教程 　　1、查找驱动程序 　　MySQL目前提供的java驱动程序为Connection/J，可以从MySQL官方网站下载，并找到mysql-connector-java-3.0.15-ga-bin.jar文件，此驱动程序为纯java驱动程序，不需做其他配置。 　　2、动态指定classpath 　　如果需要执行时动态指定classpath，就在执行时采用－cp方式。否则将上面的.jar文件加入到classpath环境变量中。 　　3、加载驱动程序 try{ 　Class.forName(com.mysql.jdbc.Driver); 　System.out.println(Success loading Mysql Driver!); }catch(Exception e) { 　System.out.println(Error loading Mysql Driver!); 　e.printStackTrace(); } 　　4、设置连接的url jdbc：mysql：//localhost/databasename[?pa=va][＆pa=va] 　　三、以下列出了在使用JDBC来连接Oracle数据库时可以使用的一些技巧 　　1、在客户端软件开发中使用Thin驱动程序 　　在开发Java软件方面，Oracle的数据库提供了四种类型的驱动程序，二种用于应用软件、applets、servlets等客户端软件，另外二种用于数据库中的Java存储过程等服务器端软件。在客户机端软件的开发中，我们可以选择OCI驱动程序或Thin驱动程序。OCI驱动程序利用Java本地化接口（JNI），通过Oracle客户端软件与数据库进行通讯。Thin驱动程序是纯Java驱动程序，它直接与数据库进行通讯。为了获得最高的性能，Oracle建议在客户端软件的开发中使用OCI驱动程序，这似乎是正确的。但我建议使用Thin驱动程序，因为通过多次测试发现，在通常情况下，Thin驱动程序的性能都超过了OCI驱动程序。 　　2、关闭自动提交功能，提高系统性能 　　在第一次建立与数据库的连接时，在缺省情况下，连接是在自动提交模式下的。为了获得更好的性能，可以通过调用带布尔值false参数的Connection类的setAutoCommit()方法关闭自动提交功能，如下所示： 　　conn.setAutoCommit(false); 　　值得注意的是，一旦关闭了自动提交功能，我们就需要通过调用Connection类的commit()和rollback()方法来人工的方式对事务进行管理。 　　3、在动态SQL或有时间限制的命令中使用Statement对象 　　在执行SQL命令时，我们有二种选择：可以使用PreparedStatement对象，也可以使用Statement对象。无论多少次地使用同一个SQL命令，PreparedStatement都只对它解析和编译一次。当使用Statement对象时，每次执行一个SQL命令时，都会对它进行解析和编译。这可能会使你认为，使用PreparedStatement对象比使用Statement对象的速度更快。然而，我进行的测试表明，在客户端软件中，情况并非如此。因此，在有时间限制的SQL操作中，除非成批地处理SQL命令，我们应当考虑使用Statement对象。 　　此外，使用Statement对象也使得编写动态SQL命令更加简单，因为我们可以将字符串连接在一起，建立一个有效的SQL命令。因此，我认为，Statement对象可以使动态SQL命令的创建和执行变得更加简单。 　　4、利用helper函数对动态SQL命令进行格式化 　　在创建使用Statement对象执行的动态SQL命令时，我们需要处理一些格式化方面的问题。例如，如果我们想创建一个将名字O'Reilly插入表中的SQL命令，则必须使用二个相连的“''”号替换O'Reilly中的“'”号。完成这些工作的最好的方法是创建一个完成替换操作的helper方法，然后在连接字符串心服用公式表达一个SQL命令时，使用创建的helper方法。与此类似的是，我们可以让helper方法接受一个Date型的值，然后让它输出基于Oracle的to_date()函数的字符串表达式。 　　5、利用PreparedStatement对象提高数据库的总体效率 　　在使用PreparedStatement对象执行SQL命令时，命令被数据库进行解析和编译，然后被放到命令缓冲区。然后，每当执行同一个PreparedStatement对象时，它就会被再解析一次，但不会被再次编译。在缓冲区中可以发现预编译的命令，并且可以重新使用。在有大量用户的企业级应用软件中，经常会重复执行相同的SQL命令，使用PreparedStatement对象带来的编译次数的减少能够提高数据库的总体性能。如果不是在客户端创建、预备、执行PreparedStatement任务需要的时间长于Statement任务，我会建议在除动态SQL命令之外的所有情况下使用PreparedStatement对象。 　　6、在成批处理重复的插入或更新操作中使用PreparedStatement对象 　　如果成批地处理插入和更新操作，就能够显著地减少它们所需要的时间。Oracle提供的Statement和 CallableStatement并不真正地支持批处理，只有PreparedStatement对象才真正地支持批处理。我们可以使用addBatch()和executeBatch()方法选择标准的JDBC批处理，或者通过利用PreparedStatement对象的setExecuteBatch()方法和标准的executeUpdate()方法选择速度更快的Oracle专有的方法。要使用Oracle专有的批处理机制，可以以如下所示的方式调用setExecuteBatch()： PreparedStatement pstmt3D null; try { 　((OraclePreparedStatement)pstmt).setExecuteBatch(30); 　... 　pstmt.executeUpdate(); } 　　调用setExecuteBatch()时指定的值是一个上限，当达到该值时，就会自动地引发SQL命令执行，标准的executeUpdate()方法就会被作为批处理送到数据库中。我们可以通过调用PreparedStatement类的sendBatch()方法随时传输批处理任务。 　　7、使用Oracle locator方法插入、更新大对象（LOB） 　　Oracle的PreparedStatement类不完全支持BLOB和CLOB等大对象的处理，尤其是Thin驱动程序不支持利用PreparedStatement对象的setObject()和setBinaryStream()方法设置BLOB的值，也不支持利用setCharacterStream()方法设置CLOB的值。只有locator本身中的方法才能够从数据库中获取LOB类型的值。可以使用PreparedStatement对象插入或更新LOB，但需要使用locator才能获取LOB的值。由于存在这二个问题，因此，我建议使用locator的方法来插入、更新或获取LOB的值。 　　8、使用SQL92语法调用存储过程 　　在调用存储过程时，我们可以使用SQL92或Oracle PL/SQL，由于使用Oracle PL/SQL并没有什么实际的好处，而且会给以后维护你的应用程序的开发人员带来麻烦，因此，我建议在调用存储过程时使用SQL92。 　　9、使用Object SQL将对象模式转移到数据库中 　　既然可以将Oracle的数据库作为一种面向对象的数据库来使用，就可以考虑将应用程序中的面向对象模式转到数据库中。目前的方法是创建Java bean作为伪装的数据库对象，将它们的属性映射到关系表中，然后在这些bean中添加方法。尽管这样作在Java中没有什么问题，但由于操作都是在数据库之外进行的，因此其他访问数据库的应用软件无法利用对象模式。如果利用Oracle的面向对象的技术，可以通过创建一个新的数据库对象类型在数据库中模仿其数据和操作，然后使用JPublisher等工具生成自己的Java bean类。如果使用这种方式，不但Java应用程序可以使用应用软件的对象模式，其他需要共享你的应用中的数据和操作的应用软件也可以使用应用软件中的对象模式。 　　10、利用SQL完成数据库内的操作 　　我要向大家介绍的最重要的经验是充分利用SQL的面向集合的方法来解决数据库处理需求，而不是使用Java等过程化的编程语言。 　　如果编程人员要在一个表中查找许多行，结果中的每个行都会查找其他表中的数据，最后，编程人员创建了独立的UPDATE命令来成批地更新第一个表中的数据。与此类似的任务可以通过在set子句中使用多列子查询而在一个UPDATE命令中完成。当能够在单一的SQL命令中完成任务，何必要让数据在网上流来流去的？我建议用户认真学习如何最大限度地发挥SQL的功能。

CNBIE BLOG

JDBC链接sqlserver数据库遇到的问题和解决方法

原文： JDBC链接sqlserver数据库遇到的问题和解决方法

两天的时间全都耗在这里了,其实这并不是很复杂的事情但还是把我搞了半天. 首先是下载jdbc sql server 驱动. 然后是将mssqlserver.jar,msbase.jar,msutil.jar考到tomcat/common/lib 下 这里出现了问题.因为使用JCreater.没有把这三个文件设置到JCreater调用的类库里所以在使用是就没有了提示. 这次耗费时间的主要原因是没有考虑到系统的问题.我的SQL Server是老早的一个版本了.所以安装好后一直有问题.最后打上了sp3的布丁.总于搞定了.由此也得出一些结论,加上在这里问题种收集的一些资料最后汇集起来: 1当出现“Error establishing socket“首先要确认sqlserver是否安装了sp3的布丁 2检查SQL SERVER 是否允许远程访问.具体步骤: 1)打开"企业管理器",打开控制台根目录>SQL Server 组>数据库 2)在相应"数据库"上单击右键,选择"属性" 3)选择"连接"选项卡,检查"远程服务器连接"下,RPC服务是否选择. 3使用telnet IP地址 1433,系统是否提示连接出错,如系统提示出错 检查是否防火墙屏蔽了SQL SERVER 或 java IDE 的网络访问端口 如果是,关闭防火墙,重新启动SQL SERVER和java IDE,进行测试, 如果系统仍提示上述错误,尝试下列步骤 4检查SQL SERVER 端口号及是否启用了TCP/IP协议,具体步骤: 1)打开"企业管理器",打开控制台根目录>SQL Server 组>数据库 2)在相应"数据库"上单击右键,选择"属性" 3)选择"常规"选项卡,点击"网络配置",如启用的协议中无"TCP/IP协议"将其加入 4)选择"TCP/IP协议",点击"属性",检查其端口号是否为1433 5)如端口号为1433将其修改为其它端口号,修改jdbc连接语句,将端口号同样改为新启用的端口号,如jdbc:microsoft:sqlserver://server_name:1400(假设新端口号为 1400)

CNBIE BLOG

JDBC入门

原文： JDBC入门

JDBC 入门 -- 建立联接 教程：JDBC 入门 作者：Maydene Fisher 翻译：comer 　　你需要做的第一事情是你与想要使用的 DBMS 建立一个连接。这包含 2 个步骤：装载驱动程序并建立连接。 装载驱动程序 　　装载驱动程序只需要非常简单的一行代码。例如，你想要使用 JDBC-ODBC 桥驱动程序, 可以用下列代码装载它： 　　　　Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 　　你的驱动程序文档将告诉你应该使用的类名。例如， 如果类名是 jdbc.DriverXYZ ，你将用代码以下的代码装载驱动程序： 　　　　Class.forName("jdbc.DriverXYZ"); 　　你不需要创建一个驱动程序类的实例并且用 DriverManager 登记它，因为调用 Class.forName 将自动将加载驱动程序类。如果你曾自己创建实例，你将创建一个不必要的副本，但它不会带来什么坏处。 　　加载 Driver 类后，它们即可用来与数据库建立连接。 建立连接 　　第二步就是用适当的驱动程序类与 DBMS 建立一个连接。下列代码是一般的做法： 　　　　Connection con = DriverManager.getConnection(url, "myLogin", "myPassword"); 　　这个步骤也非常简单，最难的是怎么提供 url。如果你正在使用 JDBC-ODBC 桥， JDBC URL 将以 jdbc:odbc 开始：余下 URL 通常是你的数据源名字或数据库系统。因此，假设你正在使用 ODBC 存取一个叫 "Fred" 的 ODBC 数据源，你的 JDBC URL 是 jdbc:odbc:Fred 。把 "myLogin" 及 "myPassword" 替换为你登陆 DBMS 的用户名及口令。如果你登陆数据库系统的用户名为 "Fernanda" 口令为 "J8"，只需下面的 2 行代码就可以建立一个连接： String url = "jdbc:odbc:Fred"; Connection con = DriverManager.getConnection(url,"Fernanda", "J8"); 　　如果你使用的是第三方开发了的 JDBC驱动程序，文档将告诉你该使用什么 subprotocol， 就是在 JDBC URL 中放在 jdbc 后面的部分。例如, 如果驱动程序开发者注册了 acme 作为 subprotocol， JDBC URL 的第一和第二部分将是 jdbc:acme。驱动程序文档也会告诉你余下 JDBC URL 的格式。JDBC URL 最后一部分提供了定位数据库的信息。 　　如果你装载的驱动程序识别了提供给 DriverManager.getConnection 的 JDBC URL ，那个驱动程序将根据 JDBC URL 建立一个到指定 DBMS 的连接。正如名称所示，DriverManager 类在幕后为你管理建立连接的所有细节。除非你是正在写驱动程序，你可能无需使用此类的其它任何方法，一般程序员需要在此类中直接使用的唯一方法是 DriverManager.getConnection。 　　DriverManager.getConnection 方法返回一个打开的连接，你可以使用此连接创建 JDBC statements 并发送 SQL 语句到数据库。在前面的例子里，con 对象是一个打开的连接，并且我们要在以后的例子里使用它。 JDBC 入门 -- 设置表 创建表 　　首先，我们在我们的示例数据库创建其中一张表 COFFEES，包含在咖啡店所卖咖啡的必要的信息，包括咖啡名字，他们的价格，本星期卖了多少磅及迄今为止卖的数目。关于 COFFEES 表我们以后会详细描述，如下： COF_NAME SUP_ID PRICE SALES TOTAL Colombian 101 7.99 0 0 French_Roast 49 8.99 0 0 Espresso 150 9.99 0 0 Colombian_Decaf 101 8.99 0 0 French_Roast_Decaf 49 9.99 0 0 　　存储咖啡名的列是 COF_NAME，它的 SQL 数据类型是 VARCHAR，最大的长度为 32 个字符。因为我们所卖的每种类型咖啡都使用不同的名字，名字可用于作为唯一识别咖啡的标识，因此可用于作主键。第二个列叫 SUP_ID，用于保存咖啡供应商标识；其 SQL 数据类型为 INTEGER。第 3 列叫 PRICE，因为它需要保存带小数的十进制数，因此它的 SQL 类型为 FLOAT。（注意，通常钱的 SQL 类型为 DECIMAL 或 NUMERIC，但在不同 DBMSs 间存在差异，为了避免于老版本的 JDBC 的不兼容性在本教程我们采用更标准的 FLOAT 类型）SALES 列的 SQL 类型为 INTEGER，其值为本星期所卖咖啡的磅数。最后一列，TOTAL 的 SQL 类型为 INTEGER，保存了迄今为止所卖咖啡的总磅数。 　　数据库里的第二个表 SUPPLIERS，保存了每个供应商的信息： SUP_ID SUP_NAME STREET CITY STATE ZIP 101 Acme, Inc. 99 Market Street Groundsville CA 95199 49 Superior Coffee 1 Party Place Mendocino CA 95460 150 The High Ground 100 Coffee Lane Meadows CA 93966 　　COFFEES 跟 SUPPLIERS 都包含列 SUP_ID，它意味着可以用 SELECT 语句从这两张表中取得有关信息。列 SUP_ID 是 SUPPLIERS 表的主键，用于唯一识别每个咖啡供应商。在 COFFEES 表中，SUP_ID 列被称外键。注意每个 SUP_ID 值在 SUPPLIERS 表里只出现一次；这对主键是必须的。在 COFFEES 表里，它作为外键，显然它可以有重复的 SUP_ID 值，因为同一供应商可以提供很多种的咖啡。在本节的最后，你将看见如何在 SELECT 语句中使用主键及外键的一个例子。 　　下面的 SQL 语句用于创建 COFFEES 表。列由列名跟空格跟 SQL 类型组成。列（包括列名及其 SQL 类型）跟下一个之间用逗号分隔。VARCHAR 类型创建定义了最大长度， 因此它需要有一个参数来表示最大长度。参数必须在类型后面的括号内。SQL 语句如下，列 COF_NAME 的长度 被限定为不得超过 32 个字符： CREATE TABLE COFFEES (COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, SALES INTEGER, TOTAL INTEGER) 　　这些代码不带 DBMS 语句结束符， 因为每个 DBMS 都可能不同。例如, Oracle 使用一个分号 (;) 作为语句的结束，而 Sybase 使用 go。你所使用的驱动程序会自动提供合适的语句结束符，因此你无须把它包括在你的 JDBC 代码中。 　　另外，我们应该指出的的是 SQL 语句的格式。在 CREATE TABLE 语句中，关键字采用大写字符，并且每个项目都另起一行。SQL 并没有此要求；仅仅是为了更容易阅读。SQL 标准是不区分关键词的大小写的, 因此，如下例中的 SELECT 语句可以有多种写法。因此下面两个不同写法的语句对 SQL 来说是一样的。 SELECT First_Name, Last_Name FROM Employees WHERE Last_Name LIKE "Washington" select First_Name, Last_Name from Employees where Last_Name like "Washington" 　　然而，引号里的内容是区分大小写的：在名字"Washington" 里 "W" 必须被大写，并且余下的字符必须是小写的。 　　对于标识，不同的 DBMS 有不同的要求，例如, 某些 DBMSs 要求那些列名及表名必须跟创建时的一样，有些则没有此要求。为安全起见，我们全部使用大写标识如 COFFEES、SUPPLIERS，因为我们是那样定义他们的。 　　到止我们写了创建 COFFEES 表的 SQL 语句。现在我们在它外面加上引号（使它成为字符串），并且字符串赋值给变量 createTableCoffees，在以后的 JDBC 代码中我们可以使用此变量。正如看到的，DBMS 并不在意分行，但对 Java 语言来，String 对象分行是通不过编译的。因而，我们可以用加号 (+) 把每一行的串连接。 String createTableCoffees = "CREATE TABLE COFFEES " + "(COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, " + "SALES INTEGER, TOTAL INTEGER)"; 　　我们在 CREATE TABLE 语句中使用的数据类型是通用的 SQL 类型（也称 JDBC 类型）它们在类 java.sql.Types 中定义。DBMSs 通常使用这些标准的类型，因此，当你要尝试一些 JDBC 应用程序时，你可以直接使用 CreateCoffees.java 应用程序，它使用了 CREATE TABLE 语句。如果你的 DBMS 使用了它的自己的本地的类型名字，我们为你供应其它的应用程序，我们将在后面详细解释。 　　在运用任何应用程序前，当然，我们将让你了解 JDBC 的基础。 创建 JDBC Statements 对象 　　Statement 对象用于把 SQL 语句发送到 DBMS 。你只须简单地创建一个 Statement 对象并且然后执行它，使用适当的方法执行你发送的 SQL 语句。对 SELECT 语句来说，可以使用 executeQuery。要创建或修改表的语句，使用的方法是 executeUpdate。 　　需要一个活跃的连接的来创建 Statement 对象的实例。在下面的例子中，我们使用我们的 Connection 对象 con 创建 Statement 对象 stmt： Statement stmt = con.createStatement(); 　　到此 stmt 已经存在了，但它还没有把 SQL 语句传递到 DBMS。我们需要提供 SQL 语句作为参数提供给我们使用的 Statement 的方法。例如，在下面的代码段里，我们使用上面例子中的 SQL 语句作为 executeUpdate 的参数： stmt.executeUpdate("CREATE TABLE COFFEES " + "(COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, " + "SALES INTEGER, TOTAL INTEGER)"); 　　因为我们已经把 SQL 语句赋给了 createTableCoffees 变量，我们可以如下方式书写代码： stmt.executeUpdate(createTableCoffees); 执行语句 　　我们使用 executeUpdate 方法是因为在 createTableCoffees 中的 SQL 语句是 DDL （数据定义语言）语句。创建表，改变表，删除表都是 DDL 语句的例子，要用 executeUpdate 方法来执行。你也可以从它的名字里看出，方法 executeUpdate 也被用于执行更新表 SQL 语句。实际上，相对于创建表来说，executeUpdate 用于更新表的时间更多，因为表只需要创建一次，但经常被更新。 　　被使用最多的执行 SQL 语句的方法是 executeQuery。这个方法被用来执行 SELECT 语句，它几乎是使用最多的 SQL 语句。马上你将看到如何使用这个方法。 在表中输入数据 　　我们已经显示了如何通过指定列名、数据类型来创建表 COFFEES，但是这仅仅建立表的结构。表还没有任何数据。我们将次输入一行数据到表中，提供每列的信息，注意插入的数据显示顺序跟表创建时候是一样的，既缺省顺序。 　　下列代码插入一个行数据，COF_NAME 的值为 Colombian，SUP_ID 为 101，PRICE 为 7.99，SALES 0，TOTAL 0。就象创建 COFFEES 表一样，我们创建一 Statement 对象，并执行 executeUpdate 方法。 　　因为 SQL 语句一行显示不下，因此我们把它分为两行，并用加号 (+) 相连。特别要注意的是，在 COFFEES 和 VALUES 之间要有空格。这个空格必须在引号之内并且要在 COFFEES 跟 VALUES 之间；没有这个空格，SQL 语句将被错误地被读作为 "INSERT INTO COFFEESVALUES ..."，并且 DBMS 将寻找表 COFFEESVALUES。还要注意的是在 coffee name 上我们使用了单引号。 Statement stmt = con.createStatement(); stmt.executeUpdate( "INSERT INTO COFFEES " + "VALUES ('Colombian', 101, 7.99, 0, 0)"); 　　下面的代码把第二行插入到表 COFFEES 中。我们可以在使用 Statement 对象而无须为每次执行创建一个新的。 stmt.executeUpdate("INSERT INTO COFFEES " + "VALUES ('French_Roast', 49, 8.99, 0, 0)"); 　　剩下行的数据如下： stmt.executeUpdate("INSERT INTO COFFEES " + "VALUES ('Espresso', 150, 9.99, 0, 0)"); stmt.executeUpdate("INSERT INTO COFFEES " + "VALUES ('Colombian_Decaf', 101, 8.99, 0, 0)"); stmt.executeUpdate("INSERT INTO COFFEES " + "VALUES ('French_Roast_Decaf', 49, 9.99, 0, 0)"); 从表中取得数据 　　既然表 COFFEES 中已经有数据了，我们就可以写一个 SELECT 语句来取得这些值。下面的 SQL 语句中星号 (*) 表示选择所有的列。因为没有用 WHERE 子句来限制所选的行，因此下面的 SQL 语句选择的是整个表。 SELECT * FROM COFFEES 　　结果是整个表的数据，如下： COF_NAME SUP_ID PRICE SALES TOTAL --------------- ------ ----- ----- ----- Colombian 101 7.99 0 0 French_Roast 49 8.99 0 0 Espresso 150 9.99 0 0 Colombian_Decaf 101 8.99 0 0 French_Roast_Decaf 49 9.99 0 0 　　如果你直接在数据库系统里输入 SQL 查询语句，你将在你的终端上看到如上的结果。当我们通过一个 Java 应用程序存取一个数据库时，正如我们马上要做的一样，我们需要检索结果以便我们能使用他们。你将在下一节看到如何实现。 这是 SELECT 语句的另一个例子，这将得到咖啡及其各自每磅单价的列表。 SELECT COF_NAME, PRICE FROM COFFEES 查询的结果集将具有如下形式： COF_NAME PRICE -------- ---------- ----- Colombian 7.99 French_Roast 8.99 Espresso 9.99 Colombian_Decaf 8.99 French_Roast_Decaf 9.99 上面 SELECT 语句取得了所有咖啡的名字及价格。而下面的 SELECT 语句限制那些每磅价格低于 $9.00 的咖啡才被选择。 SELECT COF_NAME, PRICE FROM COFFEES WHERE PRICE < 9.00 结果集将具有如下形式： COF_NAME PRICE -------- ------- ----- Colombian 7.99 French_Roast 8.99 Colombian Decaf 8.99 JDBC 入门 -- 开始 你需要做的第一事情是你要正确的安装。这包含下列几个步骤： 在你的计算机上安装 Java 和 JDBC 　　Java 数据库连接 (JDBC) 是一个标准 SQL（Structured Query Language，结构化查询语言）数据库访问接口, 可以为多种关系数据库提供统一访问。JDBC（Java DataBase Connection，Java 数据库连接） 也提供一种基准，据此可以构建更高级的工具和接口。 目前的 JDK（Java Development Kit，Java 开发工具包）软件捆绑包括 JDBC 和 JDBC-ODBC（Open DataBase Connection，开放式数据库连接）桥。这些包也可独立得到，以跟 JDK 1.0 一起使用。应该注意的是，本文的示例使用了 JDBC 2.0 接口，需要 JDK 2.0 来运行，不能在 JDK 1.1 下运行。 　　你可以从 http://java.sun.com/products/JDK/CurrentRelease 找到最新版。 安装驱动程序 　　你的驱动程序应该有安装方法。为特定的 DBMSs 写的 JDBC 驱动程序安装时只要拷贝到你的计算机上就可以了。并不需要特殊的配置。 　　如果你下载的是 Solaris 或 Windows JDK1.1 版本，桥作为包 sun.jdbc.odbc 与 JDK 一起自动安装。有关安装和配置 ODBC 的信息，请咨询 ODBC 驱动程序厂商。桥无须特殊配置。有关客户机安装和配置信息，请咨询数据库厂商。 如果需要，安装数据库系统 　　如果你不能确认是否安装了数据库系统，你需要按照供应商的要求安装数据库。大多数用户都已经安装了数据库，可继续使用他们安装好的数据库。 配置数据库 　　我们假设数据库 COFFEEBREAK 已经存在。（创建一个数据库并不困难，但需要一定的权限并通常是由数据库管理员来做）你还需要在此数据库里创建本教程作为例子使用的表。我们有意限制表的大小跟及数目，以便于管理。 　　假设我们的数据库是在一个咖啡馆里使用， 咖啡豆按磅卖，而咖啡则以杯为单位。为了简单起见，还假定经营者只需要 2 张表，分别存放不同种类的咖啡及咖啡供应商的有关信息。 　　首先我们演示怎么打开一个 DBMS 连接， 及 JDBC 是怎么发送 SQL 语句到你的 DBMS。通过这些代码，我们将表明使用 JDBC 传递 SQL 语句到你的 DBMS 并处理返回的结果是非常简单的。 　　所有的代码在主要的几个 DBMS 产品做了测试。然而, 如果你使用 JDBC-ODBC 桥来连接旧版本 ODBC 驱动程序时，可能会遇到一些兼容性问题。

CNBIE BLOG

JDBC入门(三)-设置表

原文： JDBC入门(三)-设置表

作者：axeon 创建表 　　首先，我们在我们的示例数据库创建其中一张表 COFFEES，包含在咖啡店所卖咖啡的必要的信息，包括咖啡名字，他们的价格，本星期卖了多少磅及迄今为止卖的数目。关于 COFFEES 表我们以后会详细描述，如下： COF_NAME SUP_ID PRICE SALES TOTAL Colombian 101 7.99 0 0 French_Roast 49 8.99 0 0 Espresso 150 9.99 0 0 Colombian_Decaf 101 8.99 0 0 French_Roast_Decaf 49 9.99 0 0 　　存储咖啡名的列是 COF_NAME，它的 SQL 数据类型是 VARCHAR，最大的长度为 32 个字符。因为我们所卖的每种类型咖啡都使用不同的名字，名字可用于作为唯一识别咖啡的标识，因此可用于作主键。第二个列叫 SUP_ID，用于保存咖啡供应商标识；其 SQL 数据类型为 INTEGER。第 3 列叫 PRICE，因为它需要保存带小数的十进制数，因此它的 SQL 类型为 FLOAT。（注意，通常钱的 SQL 类型为 DECIMAL 或 NUMERIC，但在不同 DBMSs 间存在差异，为了避免于老版本的 JDBC 的不兼容性在本教程我们采用更标准的 FLOAT 类型）SALES 列的 SQL 类型为 INTEGER，其值为本星期所卖咖啡的磅数。最后一列，TOTAL 的 SQL 类型为 INTEGER，保存了迄今为止所卖咖啡的总磅数。 　　数据库里的第二个表 SUPPLIERS，保存了每个供应商的信息： SUP_ID SUP_NAME STREET CITY STATE ZIP 101 Acme, Inc. 99 Market Street Groundsville CA 95199 49 Superior Coffee 1 Party Place Mendocino CA 95460 150 The High Ground 100 Coffee Lane Meadows CA 93966 　　COFFEES 跟 SUPPLIERS 都包含列 SUP_ID，它意味着可以用 SELECT 语句从这两张表中取得有关信息。列 SUP_ID 是 SUPPLIERS 表的主键，用于唯一识别每个咖啡供应商。在 COFFEES 表中，SUP_ID 列被称外键。注意每个 SUP_ID 值在 SUPPLIERS 表里只出现一次；这对主键是必须的。在 COFFEES 表里，它作为外键，显然它可以有重复的 SUP_ID 值，因为同一供应商可以提供很多种的咖啡。在本节的最后，你将看见如何在 SELECT 语句中使用主键及外键的一个例子。 　　下面的 SQL 语句用于创建 COFFEES 表。列由列名跟空格跟 SQL 类型组成。列（包括列名及其 SQL 类型）跟下一个之间用逗号分隔。VARCHAR 类型创建定义了最大长度， 因此它需要有一个参数来表示最大长度。参数必须在类型后面的括号内。SQL 语句如下，列 COF_NAME 的长度 被限定为不得超过 32 个字符： CREATE TABLE COFFEES (COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, SALES INTEGER, TOTAL INTEGER) 　　这些代码不带 DBMS 语句结束符， 因为每个 DBMS 都可能不同。例如, Oracle 使用一个分号 (;) 作为语句的结束，而 Sybase 使用 go。你所使用的驱动程序会自动提供合适的语句结束符，因此你无须把它包括在你的 JDBC 代码中。 　　另外，我们应该指出的的是 SQL 语句的格式。在 CREATE TABLE 语句中，关键字采用大写字符，并且每个项目都另起一行。SQL 并没有此要求；仅仅是为了更容易阅读。SQL 标准是不区分关键词的大小写的, 因此，如下例中的 SELECT 语句可以有多种写法。因此下面两个不同写法的语句对 SQL 来说是一样的。 SELECT First_Name, Last_Name FROM Employees WHERE Last_Name LIKE "Washington" select First_Name, Last_Name from Employees where Last_Name like "Washington" 　　然而，引号里的内容是区分大小写的：在名字"Washington" 里 "W" 必须被大写，并且余下的字符必须是小写的。 　　对于标识，不同的 DBMS 有不同的要求，例如, 某些 DBMSs 要求那些列名及表名必须跟创建时的一样，有些则没有此要求。为安全起见，我们全部使用大写标识如 COFFEES、SUPPLIERS，因为我们是那样定义他们的。 　　到止我们写了创建 COFFEES 表的 SQL 语句。现在我们在它外面加上引号（使它成为字符串），并且字符串赋值给变量 createTableCoffees，在以后的 JDBC 代码中我们可以使用此变量。正如看到的，DBMS 并不在意分行，但对 Java 语言来，String 对象分行是通不过编译的。因而，我们可以用加号 (+) 把每一行的串连接。 String createTableCoffees = "CREATE TABLE COFFEES " + "(COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, " + "SALES INTEGER, TOTAL INTEGER)"; 　　我们在 CREATE TABLE 语句中使用的数据类型是通用的 SQL 类型（也称 JDBC 类型）它们在类 java.sql.Types 中定义。DBMSs 通常使用这些标准的类型，因此，当你要尝试一些 JDBC 应用程序时，你可以直接使用 CreateCoffees.java 应用程序，它使用了 CREATE TABLE 语句。如果你的 DBMS 使用了它的自己的本地的类型名字，我们为你供应其它的应用程序，我们将在后面详细解释。 　　在运用任何应用程序前，当然，我们将让你了解 JDBC 的基础。 创建 JDBC Statements 对象 　　Statement 对象用于把 SQL 语句发送到 DBMS 。你只须简单地创建一个 Statement 对象并且然后执行它，使用适当的方法执行你发送的 SQL 语句。对 SELECT 语句来说，可以使用 executeQuery。要创建或修改表的语句，使用的方法是 executeUpdate。 　　需要一个活跃的连接的来创建 Statement 对象的实例。在下面的例子中，我们使用我们的 Connection 对象 con 创建 Statement 对象 stmt： Statement stmt = con.createStatement(); 　　到此 stmt 已经存在了，但它还没有把 SQL 语句传递到 DBMS。我们需要提供 SQL 语句作为参数提供给我们使用的 Statement 的方法。例如，在下面的代码段里，我们使用上面例子中的 SQL 语句作为 executeUpdate 的参数： stmt.executeUpdate("CREATE TABLE COFFEES " + "(COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, " + "SALES INTEGER, TOTAL INTEGER)"); 　　因为我们已经把 SQL 语句赋给了 createTableCoffees 变量，我们可以如下方式书写代码： stmt.executeUpdate(createTableCoffees); 执行语句 　　我们使用 executeUpdate 方法是因为在 createTableCoffees 中的 SQL 语句是 DDL （数据定义语言）语句。创建表，改变表，删除表都是 DDL 语句的例子，要用 executeUpdate 方法来执行。你也可以从它的名字里看出，方法 executeUpdate 也被用于执行更新表 SQL 语句。实际上，相对于创建表来说，executeUpdate 用于更新表的时间更多，因为表只需要创建一次，但经常被更新。 　　被使用最多的执行 SQL 语句的方法是 executeQuery。这个方法被用来执行 SELECT 语句，它几乎是使用最多的 SQL 语句。马上你将看到如何使用这个方法。 在表中输入数据 　　我们已经显示了如何通过指定列名、数据类型来创建表 COFFEES，但是这仅仅建立表的结构。表还没有任何数据。我们将次输入一行数据到表中，提供每列的信息，注意插入的数据显示顺序跟表创建时候是一样的，既缺省顺序。 　　下列代码插入一个行数据，COF_NAME 的值为 Colombian，SUP_ID 为 101，PRICE 为 7.99，SALES 0，TOTAL 0。就象创建 COFFEES 表一样，我们创建一 Statement 对象，并执行 executeUpdate 方法。 　　因为 SQL 语句一行显示不下，因此我们把它分为两行，并用加号 (+) 相连。特别要注意的是，在 COFFEES 和 VALUES 之间要有空格。这个空格必须在引号之内并且要在 COFFEES 跟 VALUES 之间；没有这个空格，SQL 语句将被错误地被读作为 "INSERT INTO COFFEESVALUES ..."，并且 DBMS 将寻找表 COFFEESVALUES。还要注意的是在 coffee name 上我们使用了单引号。 Statement stmt = con.createStatement(); stmt.executeUpdate( "INSERT INTO COFFEES " + "VALUES ('Colombian', 101, 7.99, 0, 0)"); 　　下面的代码把第二行插入到表 COFFEES 中。我们可以在使用 Statement 对象而无须为每次执行创建一个新的。 stmt.executeUpdate("INSERT INTO COFFEES " + "VALUES ('French_Roast', 49, 8.99, 0, 0)"); 　　剩下行的数据如下： stmt.executeUpdate("INSERT INTO COFFEES " + "VALUES ('Espresso', 150, 9.99, 0, 0)"); stmt.executeUpdate("INSERT INTO COFFEES " + "VALUES ('Colombian_Decaf', 101, 8.99, 0, 0)"); stmt.executeUpdate("INSERT INTO COFFEES " + "VALUES ('French_Roast_Decaf', 49, 9.99, 0, 0)"); 从表中取得数据 　　既然表 COFFEES 中已经有数据了，我们就可以写一个 SELECT 语句来取得这些值。下面的 SQL 语句中星号 (*) 表示选择所有的列。因为没有用 WHERE 子句来限制所选的行，因此下面的 SQL 语句选择的是整个表。 SELECT * FROM COFFEES 　　结果是整个表的数据，如下： COF_NAME SUP_ID PRICE SALES TOTAL --------------- ------ ----- ----- ----- Colombian 101 7.99 0 0 French_Roast 49 8.99 0 0 Espresso 150 9.99 0 0 Colombian_Decaf 101 8.99 0 0 French_Roast_Decaf 49 9.99 0 0 　　如果你直接在数据库系统里输入 SQL 查询语句，你将在你的终端上看到如上的结果。当我们通过一个 Java 应用程序存取一个数据库时，正如我们马上要做的一样，我们需要检索结果以便我们能使用他们。你将在下一节看到如何实现。 这是 SELECT 语句的另一个例子，这将得到咖啡及其各自每磅单价的列表。 SELECT COF_NAME, PRICE FROM COFFEES 查询的结果集将具有如下形式： COF_NAME PRICE -------- ---------- ----- Colombian 7.99 French_Roast 8.99 Espresso 9.99 Colombian_Decaf 8.99 French_Roast_Decaf 9.99 上面 SELECT 语句取得了所有咖啡的名字及价格。而下面的 SELECT 语句限制那些每磅价格低于 $9.00 的咖啡才被选择。 SELECT COF_NAME, PRICE FROM COFFEES WHERE PRICE < 9.00 结果集将具有如下形式： COF_NAME PRICE -------- ------- ----- Colombian 7.99 French_Roast 8.99 Colombian Decaf 8.99

CNBIE BLOG

JDBC入门系列专题讲座

原文： JDBC入门系列专题讲座

　　5. 安全性考虑

　　作为 网络上的语言 JAVA必须十分注安全性的考虑。基于上面的讨论，JDBC的两种主要使用场合里面，我们必须考虑安全性问题：

　　* 在 Java applications的场合里面 Java代码是本地的，所以也是"trusted"

　　* 没有验证的 Java applet代码不可以存取本地的以及其他 网络的数据。

　　5. 1. JDBC 和未验证的applet

　　JDBC首先必须符合 JAVA的一般安全规则。另外：

　　* JDBC 必须认为没有验证的applets是不可靠的。

　　* JDBC 不可以让不可靠的applets存取本地 数据库。

　　* 一个已经向JDBC DriverManager注册的是JDBC Driver只能存取它所来的数据源。

　　* 一个applet也只能向它所Download来的来存取数据。

　　如果JDBC驱动层如果完全确信对一个 数据库打开连接不会引起认证或者权限问题（可能由网上随机主机上运行的 程序引起），那么它就允许applet打开这样的连接。

　　 数据库不通过IP地址来限制存取是相当少的，主要是为了举例。（当心，这一段话我可能翻译反了！！！大家看看原文。）这些限制是相当烦琐的。不过他们与对一般applet的限制是一致的我们没有必要放开这些限制。

　　5. 2. JDBC 和 Java应用 程序

　　对于一个普通的 Java应用 程序（例如全部用 Java代码而不是不可靠的applet ）JDBC将从本地的类路径里面获得驱动，并且允许应用 程序自由存取文件，远程等等。

　　但是和applet一样，如果由于某些原因一个没有验证的sun.sql.Driver类从远程的来源里面获得，那么这个驱动只能和相同地方来的代码配合。

　　5. 3. Driver的安全责任

　　JDBC driver可能在各种情况下使用，所以驱动的编制者遵循一定的简单的安全规则，从而避免applet做非法的 数据库连接。

　　如果所有的驱动都象applet一样从网上 下载，那么这些原则将是不必要的，因为普通的安全规则已经对它做了限制。

　　但是驱动的编写者必须记住一旦他们的驱动获得成功，用户将在本地磁盘安装这些驱动，那么驱动将成为 Java环境中一个被信任的部分，所以必须确信它不会被来访的applet所滥用。所以我们鼓励所有的驱动编写者必须遵循一定安全原则。

　　所有这些原则都是在连接打开的时候使用。这正式驱动和虚拟机器检查当前调用者是否真的可以与指定的 数据库连接的时刻。一旦连接建立就不必做更多的检查了。

　　5. 3. 1. 分享TCP/IP连接的时候必须谨慎

　　如果一个JDBC驱动试图打开一个 TCP 连接，那么这个打开会被 Java 安全 管理机制自动检查。这个机构会检查当前调用栈里面有没有applet，如果有那么就限定它可以访问的机器集合。所以一般地JDBC驱动可以把TCP建立检查留给 Java虚拟机。

　　但是如果一个JDBC驱动试图在多个 数据库连接之间共享一个TCP连接，那么驱动就必须自己负责检查每个调用者是否真的被允许与目标 数据库联系。

　　例如如果我们为applet A打开了一个通往机器foobah 的TCP连接，这并不意味着applet B被自动允许来共享这个连接。

　　applet B可能没有任何访问机器foobah的权力。所以在允许某个 程序重用一个现成的TCP连接之前，JDBC 驱动必须通过安全机构来检查当前的的调用者是否可以访问这个连接。通过下面的代码可是实现这个功能。
　　SecurityManager security = System.getSecurityManager();

　　if (security != null)

　　{

　　security.checkConnect(hostName, portNumber);

　　}

　　如果连接是不允许的，那么Security.checkConnect方法将产生一个 java.lang.SecurityException。

　　5. 3. 2. 检查所有的本地文件访问

　　如果一个JDBC取得需要访问本地机器上的数据，那么他必须确信调用者是被允许打开这个文件的。例如：
　　SecurityManager security = System.getSecurityManager();

　　if (security != null)

　　{

　　security.checkRead(fileName);

　　}

　　如果对特定文件的访问是不允许的，那么Security.checkRead方法将产生一个 java.lang.SecurityException。

　　5. 3. 3. 作好最坏的准备

　　一些驱动可能使用本地的方法来桥接底层 数据库 程序。则这些情况里面判断那些本地文件将被底层函数所访问是困难的。

　　在这些环境里面用户必须作好最坏的打算，并且否决所有 下载applet所发出的 数据库存取，除非驱动可能完全确信将要做存取是没有问题的。

　　例如一个JDBC-ODBC桥接器必须检查ODBC数据源的的名称，确保applet只可以访问它的"生源地"。如果对有的名字中不能判断出数据源的主机名，那么只能否决这个访问。

　　为了决定一个当前的调用者是可以信赖的应用还是一个applet，JDBC驱动必须能够检查这个调用者是否可以写一个随机的文件：
　　SecurityManager security = System.getSecurityManager();

　　if (security != null)

　　{

　　security.checkWrite("foobaz");

　　I. }

 

上一页  [1] [2] [3] 

CNBIE BLOG

JDBC数据库访问例子(1)

原文： JDBC数据库访问例子(1)
JDBC数据库访问例子

　　JAVA语言的跨平台的工作能力（Write Once ,Run Anywhere）、优秀的图像处理能力(我相信现在没有那种语言可以超过JAVA在网络上的图形处理能力)、网络通信功能、通过JDBC数据库访问技术等等，让我们谁都不可否认JAVA语言是SUN公司对于计算机界的一个巨大的贡献。笔者可以描述这样一个场景：有一天你上网完全可以不用IE 或者NETSCAPE,上网就像是玩游戏，你可以获得游戏那么精美的图像和互动的感觉，如果你玩过UO,也许你就知道那种感觉了，但是JAVA做成的东西一定会超过UO的，因为不单单是游戏，也不是单单是浏览器，如果你愿意（要你有钱，有时间，有优秀的JAVA人才）你可以把所有的这一切用Java完全集成出来！！！我不是夸大JAVA的功能，大家可以访问一下http://www.simchina.net的那个社区程序，你就能找到一种感觉了：相信我没有说什么假话 。好了，不说废话了，现在我向你介绍JAVA的数据库访问技术----JDBC数据库访问技术（你可千万不要搞成ODBC了哟！）。

　　JDBC技术事实上是一种能通过JAVA语言访问任何结构化数据库的应用程序接口(API)(Sun这样说的，我也不知道是不是真的),而且现在的JDBC 3.0据Sun说也能访问Execel等电子表格程序!

　　JDBC对于数据库的访问有四种方式，我们这里只是介绍两种：

　　第一种是通过ODBC做为“桥”(Bridge)对数据库访问，第二种是直接对数据库访问。

　　我们先来看看第一种JDBC<-->ODBC访问的流程：

　　JDBC Driver Mannager->JDBC<->ODBC桥->ODBC->数据库客户机驱动库->数据库服务器->返回查询结果，在这种访问中值的我们注意的是虽然JAVA是"Write Once ,Run Anywhere"，但是如果通过这种访问的话，需要客户端必须设置ODBC和有相应的数据库客户机的驱动，当你看了下面的另外一个流程的时候或许你会想：明明下一种更方面，为什么还要有这个东西的产生！呵呵，因为，未必所有的数据库服务器提供商都提供下面的JDBC驱动程序（给JDBC访问提供相应的接口），所以就有了JDBC<->ODBC Bridge。

　　接着再让我们来看看第二种访问流程：

　　JDBC Driver Mannager->局部JDBC驱动->客户端数据库->数据库服务器->返回查询结果，这种访问事实上是转换JDBC调用为相应的数据库（Oracle, Sybase, Informix, DB2, 和其他的数据库数据库管理系统）的客户端API调用（这么说，不知道大家能不能懂，说简单点就好像ASP不是通过DSN对数据库访问而是通过OLEDB访问，说道这里我还是不知道大家能不能明白我的意思。哎呀，不要扔鸡蛋嘛!），这种方式的访问需要相应的数据库提供商提供相应的JDBC驱动程序，但是有一种好处，可以独立于odbc用于可以随处可Run的客户端的浏览器中的Applet程序。
我们下面将给大家一个通过JDBC-ODBC桥数据库访问的实例，但是在看下面的事例前我想问大家一次:JDK1.3装了吗？数据库驱动装了吗（我使用的是SQLserver）？你该没有使用Linux吧？虽然java支持Linux，但是老兄我可没有使用Linux哟(这同JAVA的Write Once ,Run Anywhere没有关系)，由于使用了运行于Win下面的ODBC，我建议你看看这篇东西http://www.aspcn.com/showarticle.asp?id=112，否则你要是有了问题，出不了结果那岂不是要怪我（不过欲加之罪，何患无吃... ...），冤枉呀！

CNBIE BLOG

JDBC系列教程（一）---连接

原文： JDBC系列教程（一）---连接

连接
本概述是从《JDBCTM Database Access from JavaTM: A Tutorial and Annotated Reference 》这本书中摘引来的。JavaSoft 目前正在准备这本书。这本书是一本教程，同时也是 JDBC 的重要参考手册，它将作为 Java 系列的组成部份在 1997 年春季由 Addison-Wesley 出版公司出版。


2.1 概述
Connection 对象代表与数据库的连接。连接过程包括所执行的 SQL 语句和在该连接上所返回的结果。一个应用程序可与单个数据库有一个或多个连接，或者可与许多数据库有连接。


2.1.1 打开连接
与数据库建立连接的标准方法是调用 DriverManager.getConnection 方法。该方法接受含有某个 URL 的字符串。DriverManager 类（即所谓的 JDBC 管理层）将尝试找到可与那个 URL 所代表的数据库进行连接的驱动程序。DriverManager 类存有已注册的 Driver 类的清单。当调用方法 getConnection 时，它将检查清单中的每个驱动程序，直到找到可与 URL 中指定的数据库进行连接的驱动程序为止。Driver 的方法 connect 使用这个 URL 来建立实际的连接。

用户可绕过 JDBC 管理层直接调用 Driver 方法。这在以下特殊情况下将很有用：当两个驱动器可同时连接到数据库中，而用户需要明确地选用其中特定的驱动器。但一般情况下，让 DriverManager 类处理打开连接这种事将更为简单。

下述代码显示如何打开一个与位于 URL "jdbc:odbc:wombat" 的数据库的连接。所用的用户标识符为 "oboy" ，口令为 "12Java"：

String url = "jdbc:odbc:wombat";
Connection con = DriverManager.getConnection(url, "oboy", "12Java");

2.1.2 一般用法的 URL
由于 URL 常引起混淆，我们将先对一般 URL 作简单说明，然后再讨论 JDBC URL。

URL（统一资源定位符）提供在 Internet 上定位资源所需的信息。可将它想象为一个地址。

URL 的第一部份指定了访问信息所用的协议，后面总是跟着冒号。常用的协议有 "ftp"（代表“文件传输协议”）和 "http" （代表“超文本传输协议”）。如果协议是 "file"，表示资源是在某个本地文件系统上而非在 Internet 上（下例用于表示我们所描述的部分；它并非 URL 的组成部分）。

ftp://javasoft.com/docs/JDK-1_apidocs.zip
http://java.sun.com/products/jdk/CurrentRelease
file:/home/haroldw/docs/books/tutorial/summary.html

URL 的其余部份（冒号后面的）给出了数据资源所处位置的有关信息。如果协议是 file，则 URL 的其余部份是文件的路径。对于 ftp 和 http 协议，URL 的其余部份标识了主机并可选地给出某个更详尽的地址路径。例如，以下是 JavaSoft 主页的 URL。该 URL 只标识了主机：

http://java.sun.com

从该主页开始浏览，就可以进到许多其它的网页中，其中之一就是 JDBC 主页。JDBC 主页的 URL 更为具体，它看起来类似：

http://java.sun.com/products/jdbc

2.1.3 JDBC URL
JDBC URL 提供了一种标识数据库的方法，可以使相应的驱动程序能识别该数据库并与之建立连接。实际上，驱动程序编程员将决定用什么 JDBC URL 来标识特定的驱动程序。用户不必关心如何来形成 JDBC URL；他们只须使用与所用的驱动程序一起提供的 URL 即可。JDBC 的作用是提供某些约定，驱动程序编程员在构造他们的 JDBC URL 时应该遵循这些约定。

由于 JDBC URL 要与各种不同的驱动程序一起使用，因此这些约定应非常灵活。首先，它们应允许不同的驱动程序使用不同的方案来命名数据库。例如， odbc 子协议允许（但并不是要求） URL 含有属性值。

第二，JDBC URL 应允许驱动程序编程员将一切所需的信息编入其中。这样就可以让要与给定数据库对话的 applet 打开数据库连接，而无须要求用户去做任何系统管理工作。

第三， JDBC URL 应允许某种程度的间接性。也就是说，JDBC URL 可指向逻辑主机或数据库名，而这种逻辑主机或数据库名将由网络命名系统动态地转换为实际的名称。这可以使系统管理员不必将特定主机声明为 JDBC 名称的一部份。网络命名服务（例如 DNS、 NIS 和 DCE ）有多种,而对于使用哪种命名服务并无限制。

JDBC URL 的标准语法如下所示。它由三部分组成，各部分间用冒号分隔：

jdbc::

JDBC URL 的三个部分可分解如下：


jdbc ─ 协议。JDBC URL 中的协议总是 jdbc。


─ 驱动程序名或数据库连接机制（这种机制可由一个或多个驱动程序支持）的名称。子协议名的典型示例是 "odbc"，该名称是为用于指定 ODBC 风格的数据资源名称的 URL 专门保留的。例如，为了通过 JDBC-ODBC 桥来访问某个数据库，可以用如下所示的 URL：
jdbc:odbc:fred

本例中，子协议为 "odbc"，子名称 "fred" 是本地
ODBC 数据资源。

如果要用网络命名服务（这样 JDBC URL 中的数据库名称不必是实际名称），则命名服务可以作为子协议。例如，可用如下所示的 URL ：

jdbc:dcenaming:accounts-payable

本例中，该 URL 指定了本地 DCE 命名服务应该将
数据库名称 "accounts-payable" 解析为更为具体的
可用于连接真实数据库的名称。


─ 一种标识数据库的方法。子名称可以依不同的子协议而变化。它还可以有子名称的子名称（含有驱动程序编程员所选的任何内部语法）。使用子名称的目的是为定位数据库提供足够的信息。前例中，因为 ODBC 将提供其余部份的信息，因此用 "fred" 就已足够。然而，位于远程服务器上的数据库需要更多的信息。例如，如果数据库是通过 Internet 来访问的，则在 JDBC URL 中应将网络地址作为子名称的一部份包括进去，且必须遵循如下所示的标准 URL 命名约定：
//主机名:端口/子协议

假设 "dbnet" 是个用于将某个主机连接到 Internet 上的协议，则 JDBC URL 类似：

jdbc:dbnet://wombat:356/fred

2.1.4 "odbc" 子协议
子协议 odbc 是一种特殊情况。它是为用于指定 ODBC 风格的数据资源名称的 URL 而保留的，并具有下列特性：允许在子名称（数据资源名称）后面指定任意多个属性值。odbc 子协议的完整语法为：


jdbc:odbc:[;=]*

因此，以下都是合法的 jdbc:odbc 名称：

jdbc:odbc:qeor7
jdbc:odbc:wombat
jdbc:odbc:wombat;CacheSize=20;ExtensionCase=LOWER
jdbc:odbc:qeora;UID=kgh;PWD=fooey

2.1.5 注册子协议
驱动程序编程员可保留某个名称以将之用作 JDBC URL 的子协议名。当 DriverManager 类将此名称加到已注册的驱动程序清单中时，为之保留该名称的驱动程序应能识别该名称并与它所标识的数据库建立连接。例如，odbc 是为 JDBC- ODBC 桥而保留的。示例之二，假设有个 Miracle 公司，它可能会将 "miracle" 注册为连接到其 Miracle DBMS 上的 JDBC 驱动程序的子协议，从而使其他人都无法使用这个名称。

JavaSoft 目前作为非正式代理负责注册 JDBC 子协议名称。要注册某个子协议名称，请发送电子邮件到下述地址：

[email protected]

2.1.6 发送 SQL 语句
连接一旦建立，就可用来向它所涉及的数据库传送 SQL 语句。JDBC 对可被发送的 SQL 语句类型不加任何限制。这就提供了很大的灵活性，即允许使用特定的数据库语句或甚至于非 SQL 语句。然而，它要求用户自己负责确保所涉及的数据库可以处理所发送的 SQL 语句，否则将自食其果。例如，如果某个应用程序试图向不支持储存程序的 DBMS 发送储存程序调用，就会失败并将抛出异常。JDBC 要求驱动程序应至少能提供 ANSI SQL-2 Entry Level 功能才可算是符合 JDBC 标准TM 的。这意味着用户至少可信赖这一标准级别的功能。

JDBC 提供了三个类，用于向数据库发送 SQL 语句。Connection 接口中的三个方法可用于创建这些类的实例。下面列出这些类及其创建方法：


Statement ─ 由方法 createStatement 所创建。Statement 对象用于发送简单的 SQL 语句。
PreparedStatement ─ 由方法 prepareStatement 所创建。PreparedStatement 对象用于发送带有一个或多个输入参数（ IN 参数）的 SQL 语句。PreparedStatement 拥有一组方法，用于设置 IN 参数的值。执行语句时，这些 IN 参数将被送到数据库中。PreparedStatement 的实例扩展了 Statement ，因此它们都包括了 Statement 的方法。PreparedStatement 对象有可能比 Statement 对象的效率更高，因为它已被预编译过并存放在那以供将来使用。
CallableStatement ─ 由方法 prepareCall 所创建。CallableStatement 对象用于执行 SQL 储存程序 ─ 一组可通过名称来调用（就象函数的调用那样）的 SQL 语句。CallableStatement 对象从 PreparedStatement 中继承了用于处理 IN 参数的方法，而且还增加了用于处理 OUT 参数和 INOUT 参数的方法。

以下所列提供的方法可以快速决定应用哪个 Connection 方法来创建不同类型的 SQL 语句：


createStatement 方法用于：


简单的 SQL 语句（不带参数）


prepareStatement 方法用于：


带一个或多个 IN 参数的 SQL 语句


经常被执行的简单 SQL 语句


prepareCall 方法用于：


调用已储存过程


2.1.7 事务
事务由一个或多个这样的语句组成：这些语句已被执行、完成并被提交或还原。当调用方法 commit 或 rollback 时，当前事务即告就结束，另一个事务随即开始。

缺省情况下，新连接将处于自动提交模式。也就是说，当执行完语句后，将自动对那个语句调用 commit 方法。这种情况下，由于每个语句都是被单独提交的，因此一个事务只由一个语句组成。如果禁用自动提交模式，事务将要等到 commit 或 rollback 方法被显式调用时才结束，因此它将包括上一次调用 commit 或 rollback 方法以来所有执行过的语句。对于第二种情况，事务中的所有语句将作为组来提交或还原。

方法 commit 使 SQL 语句对数据库所做的任何更改成为永久性的，它还将释放事务持有的全部锁。而方法 rollback 将弃去那些更改。

有时用户在另一个更改生效前不想让此更改生效。这可通过禁用自动提交并将两个更新组合在一个事务中来达到。如果两个更新都是成功的，则调用 commit 方法，从而使两个更新结果成为永久性的；如果其中之一或两个更新都失败了，则调用 rollback 方法，以将值恢复为进行更新之前的值。

大多数 JDBC 驱动程序都支持事务。事实上，符合 JDBC 的驱动程序必须支持事务。DatabaseMetaData 给出的信息描述 DBMS 所提供的事务支持水平。


2.1.8 事务隔离级别
如果 DBMS 支持事务处理，它必须有某种途径来管理两个事务同时对一个数据库进行操作时可能发生的冲突。用户可指定事务隔离级别，以指明 DBMS 应该花多大精力来解决潜在冲突。例如，当事务更改了某个值而第二个事务却在该更改被提交或还原前读取该值时该怎么办？ 假设第一个事务被还原后，第二个事务所读取的更改值将是无效的，那么是否可允许这种冲突？ JDBC 用户可用以下代码来指示 DBMS 允许在值被提交前读取该值（“dirty 读取”），其中 con 是当前连接：

con.setTransactionIsolation(TRANSACTION_READ_UNCOMMITTED);

事务隔离级别越高，为避免冲突所花的精力也就越多。Connection 接口定义了五级，其中最低级别指定了根本就不支持事务，而最高级别则指定当事务在对某个数据库进行操作时，任何其它事务不得对那个事务正在读取的数据进行任何更改。通常，隔离级别越高，应用程序执行的速度也就越慢（由于用于锁定的资源耗费增加了，而用户间的并发操作减少了）。在决定采用什么隔离级别时，开发人员必须在性能需求和数据一致性需求之间进行权衡。当然，实际所能支持的级别取决于所涉及的 DBMS 的功能。

当创建 Connection 对象时，其事务隔离级别取决于驱动程序，但通常是所涉及的数据库的缺省值。用户可通过调用 setIsolationLevel 方法来更改事务隔离级别。新的级别将在该连接过程的剩余时间内生效。要想只改变一个事务的事务隔离级别，必须在该事务开始前进行设置，并在该事务结束后进行复位。我们不提倡在事务的中途对事务隔离级别进行更改，因为这将立即触发 commit 方法的调用，使在此之前所作的任何更改变成永久性的。

CNBIE BLOG

JDBC学习笔记（保持更新）

原文： JDBC学习笔记（保持更新）

一、几种装载JDBC驱动程序的方法 1．    在DriverManager中注册 举例：在DriverManager中注册Oracle JDBC Driver     // 注册Oracle JDBC 驱动器     DriverManager.registerDriver(new oracle.jdbc.OracleDriver()); 2．    直接装载 二、常见问题 在WebLogic 6.x中连接Oracle 9i数据库时，可能会出现类似如下错误： java.sql.SQLException: ORA-00600: 内部错误代码，参数: [ttcgcshnd-1], [0], [], [], [], [], [],[] 示例代码：     // 注册Oracle JDBC 驱动器     DriverManager.registerDriver(new oracle.jdbc.OracleDriver());       // 注意连接url的格式：jdbc:oracle:thin:@ip:port:sid     java/lang/String.java.html" target="_blank">String url = "jdbc:oracle:thin:@192.168.0.1:1521:mydb";     java/lang/String.java.html" target="_blank">String userName = "scott";     java/lang/String.java.html" target="_blank">String password = "tiger";       Connection conn =       DriverManager.getConnection (url, userName, password);       // Create a Statement     Statement stmt = conn.createStatement();       // 从EMP表中查询员工姓名     ResultSet rs = stmt.executeQuery ("select ENAME from EMP");       // 在结果集中取出第一列，即ENAME     while (rs.next ()) {       java/lang/System.java.html" target="_blank">System.out.println (rs.getString (1));     } 原因分析：在WebLogic的核心包weblogic.jar（$WEBLOGIC\lib）中内置了Oracle8i的驱动器，这个错误就是由于使用了Oracle8i的驱动器访问Oracle9i造成的。 解决办法：将Oracle9i的JDBC Driver（如果你安装了Oracle9i的服务器或客户端，在$ORACLE\ora90\jdbc\lib下就包含了classes12.zip或者classes12.jar）加入到你的WebLogic当前域的启动脚本（startWebLogic.cmd）中。特别注意，这个.jar一定要位于weblogic.jar之前！ 版声说明：本文仅授权JavaResearch.org发表，严禁其它网站、媒体转载。

CNBIE BLOG

JDBC学习笔记-----jdbc性能优化[转载]

原文： JDBC学习笔记-----jdbc性能优化[转载]

jdbc程序的性能主要由两个因素决定,一是数据库本身的性质,另一个是与数据库相对独立的jdbc应用程序接口(api)的使用.这里说的是如何正确使用jdbc编程接口,以获得更好的性能.   jdbc主要优化有:      1.选择正确的jdbc驱动程序      2.Connention的优化  使用连接池来管理Connection对象      3.Statement的优化   使用批量更新等      4.Result的优化  正确的从数据库中get数据等            (1)选择正确的jdbc驱动程序:   1 jdbc-odbc 桥             2 本地api-部分 java驱动                 3 jdbc网路协议-纯java驱动                 4 jdbc本地协议                 最好选择 jdbc网路协议-纯java驱动  效率比较高  但需要第三方软件的支持 比如corba  weblogic属于这种类型           (2)优化Connection对象:          1.设置适当的参数  DriverManager.getConnection(String url,Properties props);                  例如:     Properties props=new Properties();       props.put("user","wuwei");       props.put("password","wuwei");             props.put("defaultRowPrefectch","30");                            props.put("dufaultBatchValue","5");                            Connection con=DriverManager.getConnection("jdbcracle:thin:@hostsString",props);              对象可以通过设置setDefaultRowPrefetch(int) 和 setDefaultBatchValue(int) 两个参数类优化连接  2.使用连接池  可以自己写一个连接池 这样程序的灵活性强,便于移植.       apache项目开发了一套非常通用而表现非常稳定的对象池 http://jakarta.apache.org/commons/pool.htm       设计了自己的连接池后 在客户端调用建立对象                            public Object makeObject() throws Exception{     Class.forName("oracle.jdbc.driver.OracalDriver");     return DriverManager.getConnection("url","username","password");       }                   销毁对象时用       public void destroyObject(Object obj) throws Exception{          ((Connection)obj.close());       }         注意几点 对象池里有没有回收机制,对象池里有机有容量限制,对象池里有多少个闲置对象(可以释放)                    3.控制事务的提交  最好手动提交事务,不但可以可以保证数据原子性,而且对新能提高留下余地.                    try{    connection.setAutoCommint(false);                         // 代码 用PreparedStatement  性能比Statementh好.                         connection.commit();                         connection.setAutoCommit(true);      }             catch(SQLException e){                    }                    finally{    //代码    if(connection!=null){       connection.close();      }        }  4.适当的选择事务的隔离级别   TRANSACTION_READ_UNCOMMITED  性能最高                                      TRANSACTION_READ_COMMITED    快                                      TRANSACTION_REFEATABLE_READ  中等             RANSACTION_SERIALIZABLE      慢      (3)Statement 优化       jdbc3个接口用来处理sql的执行,是Statement PreparedStatement CallableStatement           提供适当的Statement接口            批量执行sql           从数据库批量获取数据       PreparedStatement 比Statement性能要好 主要体现在一个sql语句多次重复执行的情况       PreparedStatemnt只编译解析一次而Statement每次编译一次.              批量修改数据库     Statement 提供了方法addBatch(String)和executeBatch()         调用方法为stmt.addBatch("isnert....."); stmt.addBatch("update.....")                   stmt.executeBatch();         也可以用PreparedStatement从而更好的提高性能.                 pstmt=conn.preparedStatement("insert into test_table(......) values(....?)");                 pstmt.setString(1,"aaa");                 pstmt.addBatch();                 pstmt.setString(1,"bbb");                 pstmt.addBatch();                 .....                 pstmt.executeBatch();         批量地从数据库中取数据.           通过setFetchSize()和getFectchSize()方法来设定和查看这个参数.这个参数对体统的性能影响比较大.           这个参数太小会严重地降低程序地性能.    Connection Statement ResultSet都有这个参数,他们对性能地影响顺序是:              ResultSet---------Statement---------Connection   (4)优化ResultSet.      体现在以下几个方面         批量读取数据.合理设置ResultSet的getFetchSize()和setFetchSize()方法中的参数         使用正确的get和set方法              使用整数而不是字段名作为参数性能比较高,              例如 setInt(1,100);                   setString(2,"aaaa");                比 setInt("id","100");                   setString("name","aaaa");                性能好         设置适当的滚动方向.有3个方向FETCH_FORWORD,FETCH_REVERSE FETCH_UNKNOWN              单向滚动性能比较高.   其他方面的性能优化       及时显示的关闭Connection Statement ResultSet           其中Connection可以用Connetion Pool处理.       使用数据库系统的强大查询功能去组织数据.这样程序运行是和数据库服务的交互次数少,数据库返回给       程序的记录条数少的多,所以性能有很大的提高. 作者不清  jinijxta 回复于：2003-08-29 11:56:04 在服务器端能用SQLJ处理的商务逻辑最好不要放在客户端,否则客户端代码维护十分不便  selen 回复于：2003-08-29 20:47:25 我有个应用是WEBLOGCI于PROGRESS连接的但是发现JDBC的接口效率不如原来用JDBC-ODBC的高，而且经常会断开。请大家帮助分析一 下。

java lover