JDBC简介

JDBC简介：

JDBC代表Java数据库连接(Java Database Connectivity)，它是用于Java编程语言和数据库之间的数据库无关连接的标准Java API，换句话说：JDBC是用于在Java语言编程中与数据库连接的API。

JDBC库包括通常与数据库使用相关，如下面提到的每个任务的API -

连接到数据库
创建SQL或MySQL语句
在数据库中执行SQL或MySQL查询
查看和修改结果记录

从根本上说，JDBC是一个规范，它提供了一整套接口，允许以一种可移植的访问底层数据库API。 Java可以用它来编写不同类型的可执行文件，如 -

Java应用程序
Java Applet
Java Servlets
Java ServerPages(JSP)
企业级JavaBeans(EJB)

所有这些不同的可执行文件都能够使用JDBC驱动程序来访问数据库，并用于存储数据到数据库中。

JDBC提供与ODBC相同的功能，允许Java程序包含与数据库无关的代码(同样的代码，只需要指定使用的数据库类型，不需要重修改数据库查询或操作代码)。

JDBC架构：

JDBC API支持用于数据库访问的两层和三层处理模型，但通常，JDBC体系结构由两层组成：

JDBC API：提供应用程序到JDBC管理器连接。
JDBC驱动程序API：支持JDBC管理器到驱动程序连接。

JDBC API使用驱动程序管理器并指定数据库的驱动程序来提供与异构数据库的透明连接。

JDBC驱动程序管理器确保使用正确的驱动程序来访问每个数据源。驱动程序管理器能够支持连接到多个异构数据库的多个并发驱动程序。

以下是架构图，它显示了驱动程序管理器相对于JDBC驱动程序和Java应用程序的位置 -

JDBC架构

图：JDBC架构图

常见的JDBC组件：

JDBC API提供以下接口和类：

DriverManager：此类管理数据库驱动程序列表。使用通信子协议将来自java应用程序的连接请求与适当的数据库驱动程序进行匹配。在JDBC下识别某个子协议的第一个驱动程序将用于建立数据库连接。
Driver：此接口处理与数据库服务器的通信。我们很少会直接与Driver对象进行交互。但会使用DriverManager对象来管理这种类型的对象。它还提取与使用Driver对象相关的信息。
Connection：此接口具有用于联系数据库的所有方法。连接(Connection)对象表示通信上下文，即，与数据库的所有通信仅通过连接对象。
Statement：使用从此接口创建的对象将SQL语句提交到数据库。除了执行存储过程之外，一些派生接口还接受参数。
ResultSet：在使用Statement对象执行SQL查询后，这些对象保存从数据库检索的数据。它作为一个迭代器并可移动ResultSet对象查询的数据。
SQLException：此类处理数据库应用程序中发生的任何错误。

在编程前需要下载来连接数据库的库：Connector/J。

它里面包含了上面的这些类。

JDBC驱动程序类型：

JDBC驱动程序是什么？

JDBC驱动程序在JDBC API中实现定义的接口，用于与数据库服务器进行交互。

例如，使用JDBC驱动程序，可以通过发送SQL或数据库命令，然后使用Java接收结果来打开数据库连接并与数据库进行交互。

JDK附带的Java.sql包包含各种类，其类的行为被定义，实现在第三方驱动程序中完成。第三方供应商在其数据库驱动程序中实现java.sql.Driver接口。

JDBC驱动程序类型：

JDBC驱动程序实现因Java运行的各种操作系统和硬件平台而异。 Sun将实现类型分为四种类型，分别为1,2,3和4类型，如下所述：

类型1：JDBC-ODBC桥驱动程序

在类型1驱动程序中，JDBC桥接器用于访问安装在每台客户机上的ODBC驱动程序。使用ODBC需要在系统上配置表示目标数据库的数据源名称(DSN)。

当Java第一次出现时，这是一个驱动程序，因为大多数数据库仅支持ODBC访问，但现在这种类型的驱动程序仅推荐用于实验性使用或没有其他替代方案时使用。

类型1

图：类型1 架构图

类型2：JDBC本地API

在类型2驱动程序中，JDBC API调用将转换为本地C/C++ API调用，这是数据库唯一的。这些驱动程序通常由数据库供应商提供，并以与JDBC-ODBC桥接相同的方式使用。必须在每个客户机上安装供应商特定的驱动程序。

如果要更改数据库，则必须更改原生API，因为它特定于数据库，并且现在大部分已经过时，但是使用类型2驱动程序实现了一些扩展功能的开发，它消除了ODBC的开销。

类型2

图:Oracle调用接口(OCI)驱动程序是类型2驱动程序的示例。

类型3：JDBC-Net纯Java

在类型3驱动程序中，使用三层方法访问数据库。 JDBC客户端使用标准网络套接字与中间件应用程序服务器进行通信。套接字信息随后由中间件应用服务器转换成DBMS所需的调用格式，并转发到数据库服务器。

这种驱动程序是非常灵活的，因为它不需要在客户端上安装代码，一个驱动程序实际上可以提供多个数据库的访问。

类型3

图：类型3 架构

可以将应用程序服务器视为JDBC“代理”，它会调用客户端应用程序。因此，我们需要了解应用程序服务器的配置，才能有效地使用此驱动程序类型。

应用程序服务器可能会使用类型1,2或4驱动程序与数据库通信，了解细微差别对理解JDBC是有帮助的。

类型4：100％纯Java

在类型4驱动程序中，基于纯Java的驱动程序通过套接字连接与供应商的数据库直接通信。这是数据库可用的最高性能驱动程序，通常由供应商自己提供。

这种驱动是非常灵活的，不需要在客户端或服务器上安装特殊的软件。此外，这些驱动程序可以动态下载。

类型4

图：类型4 架构

MySQL Connector/J驱动程序是类型4驱动程序。由于其网络协议的专有性质，数据库供应商通常提供类型4驱动程序。

怎么选择驱动程序：

如果在访问一种类型的数据库，例如Oracle，Sybase或IBM DB2，则首选驱动程序类型为类型4。
如果Java应用程序同时访问多种类型的数据库，则类型3是首选驱动程序。
类型2驱动程序在数据库不可用的类型3或类型4驱动程序的情况下使用。
类型1驱动程序不被视为部署级驱动程序，通常仅用于开发和测试目的。

JDBC编程

JDBC SQL语法：

有关MySQL的语法：可以参考MySQL学习笔记。

创建JDBC应用程序的一般步骤：

构建JDBC应用程序涉及以下六个步骤 -

导入包：需要包含包含数据库编程所需的JDBC类的包。大多数情况下，使用import java.sql.*就足够了。
注册JDBC驱动程序：需要初始化驱动程序，以便可以打开与数据库的通信通道。
打开一个连接：需要使用DriverManager.getConnection()方法创建一个Connection对象，它表示与数据库的物理连接。
执行查询：需要使用类型为Statement的对象来构建和提交SQL语句到数据库。
从结果集中提取数据：需要使用相应的ResultSet.getXXX()方法从结果集中检索数据。
清理环境：需要明确地关闭所有数据库资源，而不依赖于JVM的垃圾收集。

JDBC数据库连接：

建立JDBC连接所涉及的编程相当简单。以下是基本的四个步骤 -

导入JDBC包：使用Java语言的import语句在Java代码开头位置导入所需的类。
注册JDBC驱动程序：使JVM将所需的驱动程序实现加载到内存中，从而可以满足JDBC请求。
数据库URL配置：创建一个正确格式化的地址，指向要连接到的数据库(如：MySQL,Oracle和MSSQL等等)。
创建连接对象：最后，调用DriverManager对象的getConnection()方法来建立实际的数据库连接。

注册驱动程序的方法：

方法1：Class.forName()

注册驱动程序最常见的方法是使用Java的Class.forName()方法，将驱动程序的类文件动态加载到内存中，并将其自动注册。这个方法是推荐使用的方法，因为它使驱动程序注册可配置和便携。

以下示例使用Class.forName()注册Oracle驱动程序 -

try {
  Class.forName("oracle.jdbc.driver.OracleDriver");
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
}

使用JDBC驱动程序连接MySQL数据库的示例代码片段 -

Class.forName("com.mysql.jdbc.Driver");
Connection conn = null;
conn = DriverManager.getConnection("jdbc:mysql://hostname:port/db_name","db_username", "db_password");
conn.close();

使用getInstance()方法来解决不合规的JVM，但是必须编写两个额外的异常，如下所示：

try {   
  Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
catch(IllegalAccessException ex) {
   System.out.println("Error: access problem while loading!");
   System.exit(2);
catch(InstantiationException ex) {
   System.out.println("Error: unable to instantiate driver!");
   System.exit(3);
}

方法2 - DriverManager.registerDriver()

第二种方法是使用静态DriverManager.registerDriver()方法来注册驱动程序。

如果使用的是非JDK兼容的JVM(如Microsoft提供的)，则应使用registerDriver()方法。

以下示例使用registerDriver()注册Oracle驱动程序 -

try {
   Driver myDriver = new oracle.jdbc.driver.OracleDriver();
   DriverManager.registerDriver( myDriver );
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
}

数据库URL配置：

加载驱动程序后，可以使用DriverManager.getConnection()方法建立连接。为了方便参考，这里列出三个重载的DriverManager.getConnection()方法 -

getConnection(String url)
getConnection(String url, Properties prop)
getConnection(String url, String user, String password)

这里每个格式都需要一个数据库URL。数据库URL是指向数据库的地址。

制定数据库URL是建立连接相关联的大多数错误问题发生的地方。

下表列出了常用的JDBC驱动程序名称和数据库URL。

RDBMS	JDBC驱动程序名称	URL格式
MySQL	`com.mysql.jdbc.Driver`	`jdbc:mysql://hostname/databaseName`
ORACLE	`oracle.jdbc.driver.OracleDriver`	`jdbc:oracle:thin:@hostname:portNumber:databaseName`
PostgreSQL	`org.postgresql.Driver`	`jdbc:postgresql://hostname:port/dbname`
DB2	`com.ibm.db2.jdbc.net.DB2Driver`	`jdbc:db2:hostname:port Number/databaseName`
Sybase	`com.sybase.jdbc.SybDriver`	`jdbc:sybase:Tds:hostname: portNumber/databaseName`

URL格式的所有突出部分都是静态的，只需要根据数据库设置更改对应的部分。

JDBC Statements类：

当获得了与数据库的连接后，就可以与数据库进行交互了。 JDBC Statement，CallableStatement和PreparedStatement接口定义了可用于发送SQL或PL/SQL命令，并从数据库接收数据的方法和属性。

它们还定义了有助于在Java和SQL数据类型的数据类型差异转换的方法。
下表提供了每个接口定义，以及使用这些接口的目的的总结。

接口	推荐使用
`Statement`	用于对数据库进行通用访问，在运行时使用静态SQL语句时很有用。 `Statement`接口不能接受参数。
`PreparedStatement`	当计划要多次使用SQL语句时使用。`PreparedStatement`接口在运行时接受输入参数。
`CallableStatement`	当想要访问数据库存储过程时使用。`CallableStatement`接口也可以接受运行时输入参数。

Statement对象

1. 创建Statement对象

在使用Statement对象执行SQL语句之前，需要使用Connection对象的createStatement()方法创建一个Statement对象，如以下示例所示：

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

在创建Statement对象后，可以使用它来执行一个SQL语句，它有三个执行方法可以执行。它们分别是 -

boolean execute (String SQL) ：如果可以检索到ResultSet对象，则返回一个布尔值true; 否则返回false。使用此方法执行SQLDDL语句或需要使用真正的动态SQL，可使用于执行创建数据库，创建表的SQL语句等等。
int executeUpdate (String SQL): 返回受SQL语句执行影响的行数。使用此方法执行预期会影响多行的SQL语句，例如:INSERT，UPDATE或DELETE语句。
ResultSet executeQuery(String SQL)：返回一个ResultSet对象。当您希望获得结果集时，请使用此方法，就像使用SELECT语句一样。

2.关闭Statement对象

就像关闭一个Connection对象一样，以保存数据库资源一样，由于同样的原因，还应该关闭Statement对象。

一个简单的调用close()方法将执行该作业(工作)。如果先关闭Connection对象，它也会关闭Statement对象。但是，应该始终显式关闭Statement对象，以确保正确的清理顺序。

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   stmt.close();
}

PreparedStatement对象

PreparedStatement接口扩展了Statement接口，它添加了比Statement对象更好一些优点的功能。

此语句可以动态地提供/接受参数。

2.1 创建PreparedStatement对象

PreparedStatement pstmt = null;
try {
   String SQL = "Update Employees SET age = ? WHERE id = ?";
   pstmt = conn.prepareStatement(SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

JDBC中的所有参数都由 ? 符号作为占位符，这被称为参数标记。 在执行SQL语句之前，必须为每个参数(占位符)提供值。

setXXX()方法将值绑定到参数，其中XXX表示要绑定到输入参数的值的Java数据类型。如果忘记提供绑定值，则将会抛出一个SQLException。

每个参数标记是它其顺序位置引用。第一个标记表示位置1，下一个位置2等等。该方法与Java数组索引不同(它不从0开始)。

所有Statement对象与数据库交互的方法(a)execute()，(b)executeQuery()和(c)executeUpdate()也可以用于PreparedStatement对象。但是，这些方法被修改为可以使用输入参数的SQL语句。

2.关闭PreparedStatement对象

就像关闭Statement对象一样，由于同样的原因(节省数据库系统资源)，也应该关闭PreparedStatement对象。

简单的调用close()方法将执行关闭。如果先关闭Connection对象，它也会关闭PreparedStatement对象。但是，应该始终显式关闭PreparedStatement对象，以确保以正确顺序清理资源。

PreparedStatement pstmt = null;
try {
   String SQL = "Update Employees SET age = ? WHERE id = ?";
   pstmt = conn.prepareStatement(SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   pstmt.close();
}

CallableStatement对象

类似Connection对象创建Statement和PreparedStatement对象一样，它还可以使用同样的方式创建CallableStatement对象，该对象将用于执行对数据库存储过程的调用。

3.1. 创建CallableStatement对象

假设需要执行以下Oracle存储过程 -

CREATE OR REPLACE PROCEDURE getEmpName 
   (EMP_ID IN NUMBER, EMP_FIRST OUT VARCHAR) AS
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END;

注意：上面的存储过程是针对Oracle编写的，但是如果您使用MySQL数据库，可使用以下方式来编写MySQL相同的存储过程，如下在EMP数据库中创建它 -

DELIMITER $$

DROP PROCEDURE IF EXISTS `EMP`.`getEmpName` $$
CREATE PROCEDURE `EMP`.`getEmpName` 
   (IN EMP_ID INT, OUT EMP_FIRST VARCHAR(255))
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END $$

DELIMITER ;

存在三种类型的参数：IN，OUT和INOUT。 PreparedStatement对象只使用IN参数。CallableStatement对象可以使用上面三个参数类型。

以下是上面三种类型参数的定义 -

参数	描述
IN	创建SQL语句时其参数值是未知的。使用`setXXX()`方法将值绑定到`IN`参数。
OUT	由SQL语句返回的参数值。可以使用`getXXX()`方法从OUT参数中检索值。
INOUT	提供输入和输出值的参数。使用`setXXX()`方法绑定变量并使用`getXXX()`方法检索值。

以下代码片段显示了如何使用Connection.prepareCall()方法根据上述存储过程来实例化一个CallableStatement对象 -

CallableStatement cstmt = null;
try {
   String strSQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

String变量strSQL表示存储过程，带有两个参数占位符。

使用CallableStatement对象就像使用PreparedStatement对象一样。在执行语句之前，必须将值绑定到所有参数，否则将抛出一个SQLException异常。

如果有IN参数，只需遵循适用于PreparedStatement对象的相同规则和技术; 使用与绑定的Java数据类型相对应的setXXX()方法。

使用OUT和INOUT参数时，必须使用一个额外的CallableStatement对象方法registerOutParameter()。 registerOutParameter()方法将JDBC数据类型绑定到存储过程并返回预期数据类型。

当调用存储过程，可以使用适当的getXXX()方法从OUT参数中检索该值。此方法将检索到的SQL类型的值转换为对应的Java数据类型。

关闭CallableStatement对象

就像关闭其他Statement对象一样，由于同样的原因(节省数据库系统资源)，还应该关闭CallableStatement对象。

简单的调用close()方法将执行关闭CallableStatement对象。如果先关闭Connection对象，它也会关闭CallableStatement对象。但是，应该始终显式关闭CallableStatement对象，以确保按正确顺序的清理资源。

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   cstmt.close();
}

JDBC结果集：

SQL语句执行后从数据库查询读取数据，返回的数据放在结果集中。 SELECT语句用于从数据库中选择行并在结果集中查看它们的标准方法。 java.sql.ResultSet接口表示数据库查询的结果集。

ResultSet对象维护指向结果集中当前行的游标。术语“结果集”是指包含在ResultSet对象中的行和列数据。

ResultSet接口的方法可以分为三类：

浏览方法：用于移动光标。
获取方法：用于查看光标指向的当前行的列中的数据。
更新方法：用于更新当前行的列中的数据。然后在基础数据库中更新数据。

光标可以基于ResultSet的属性移动。当创建生成ResultSet的相应Statement时，将指定这些属性。

JDBC提供以下连接方法来创建具有所需ResultSet的语句 -

createStatement(int RSType, int RSConcurrency);
prepareStatement(String SQL, int RSType, int RSConcurrency);
prepareCall(String sql, int RSType, int RSConcurrency);

第一个参数表示ResultSet对象的类型，第二个参数是两个ResultSet常量之一，用于指定结果集是只读还是可更新。

浏览结果集

ResultSet接口中有几种涉及移动光标的方法，包括 -

编号	方法	描述
1	`public void beforeFirst() throws SQLException`	将光标移动到第一行之前
2	`public void afterLast() throws SQLException`	将光标移动到最后一行之后。
3	`public boolean first() throws SQLException`	将光标移动到第一行。
4	`public void last() throws SQLException`	将光标移动到最后一行。
5	`public boolean absolute(int row) throws SQLException`	将光标移动到指定的行。
6	`public boolean relative(int row) throws SQLException`	从当前指向的位置，将光标向前或向后移动给定行数。
7	`public boolean previous() throws SQLException`	将光标移动到上一行。如果上一行关闭结果集，此方法返回`false`。
8	`public boolean next() throws SQLException`	将光标移动到下一行。如果结果集中没有更多行，则此方法返回`false`。
9	`public int getRow() throws SQLException`	返回光标指向的行号。
10	`public void moveToInsertRow() throws SQLException`	将光标移动到结果集中的特殊行，该行可用于将新行插入数据库。当前光标位置被记住。
11	`public void moveToCurrentRow() throws SQLException`	如果光标当前位于插入行，则将光标移回当前行; 否则，此方法什么也不做

JDBC事务：

如果JDBC连接处于自动提交模式，默认情况下，则每个SQL语句在完成后都会提交到数据库。

对于简单的应用程序可能没有问题，但是有三个原因需要考虑是否关闭自动提交并管理自己的事务 -

提高性能
保持业务流程的完整性
使用分布式事务

事务能够控制何时更改提交并应用于数据库。它将单个SQL语句或一组SQL语句视为一个逻辑单元，如果任何语句失败，整个事务将失败。

要启用手动事务支持，而不是使用JDBC驱动程序默认使用的自动提交模式，请调用Connection对象的setAutoCommit()方法。如果将布尔的false传递给setAutoCommit()，则关闭自动提交。也可以传递一个布尔值true来重新打开它。

例如，如果有一个名为conn的Connection对象，请将以下代码关闭自动提交 -

1	conn.setAutoCommit(false);

提交和回滚

完成更改后，若要提交更改，那么可在连接对象上调用commit()方法，如下所示：

1	conn.commit( );

否则，要使用连接名为conn的数据库回滚更新，请使用以下代码 -

1	conn.rollback( );

使用保存点

新的JDBC 3.0新添加了Savepoint接口提供了额外的事务控制能力。大多数现代DBMS支持其环境中的保存点，如Oracle的PL/SQL。

设置保存点(Savepoint)时，可以在事务中定义逻辑回滚点。如果通过保存点(Savepoint)发生错误时，则可以使用回滚方法来撤消所有更改或仅保存保存点之后所做的更改。

Connection对象有两种新的方法可用来管理保存点 -

setSavepoint(String savepointName): - 定义新的保存点，它还返回一个Savepoint对象。
releaseSavepoint(Savepoint savepointName): - 删除保存点。要注意，它需要一个Savepoint对象作为参数。该对象通常是由setSavepoint()方法生成的保存点。

有一个rollback (String savepointName)方法，它将使用事务回滚到指定的保存点。

JDBC异常：

异常处理允许我们以受控的方式处理异常情况，而不是直接退出程序，例如程序定义的错误。

发生异常时可以抛出异常。术语“异常”表示当前的程序执行停止，并且被重定向到最近的适用的catch子句。如果没有适用的catch子句存在，则程序的执行结束。

JDBC异常处理与Java异常处理非常相似，但对于JDBC，要处理的最常见异常是java.sql.SQLException。

SQLException方法

驱动程序和数据库中都会发生SQLException。发生这种异常时，SQLException类型的对象将被传递给catch子句。

传递的SQLException对象具有以下可用于检索有关异常信息的方法 -

方法	描述
`getErrorCode( )`	获取与异常关联的错误代码。
`getMessage( )`	获取驱动程序处理的错误的JDBC驱动程序的错误消息，或获取数据库错误的Oracle错误代码和消息。
`getSQLState( )`	获取XOPEN SQLstate字符串。对于JDBC驱动程序错误，不会从此方法返回有用的信息。对于数据库错误，返回五位数的XOPEN SQLstate代码。此方法可以返回`null`。
`getNextException( )`	获取异常链中的下一个`Exception`对象。
`printStackTrace( )`	打印当前异常或可抛出的异常，并将其追溯到标准错误流。
`printStackTrace(PrintStream s)`	将此`throwable`及其回溯打印到指定的打印流。
`printStackTrace(PrintWriter w)`	打印这个`throwable`，它是回溯到指定的打印器(`PrintWriter`)。

JDBC批处理：

批量处理允许将相关的SQL语句分组到批处理中，并通过对数据库的一次调用来提交它们，一次执行完成与数据库之间的交互。

一次向数据库发送多个SQL语句时，可以减少通信开销，从而提高性能。

不需要JDBC驱动程序来支持此功能。应该使用DatabaseMetaData.supportsBatchUpdates()方法来确定目标数据库是否支持批量更新处理。如果JDBC驱动程序支持此功能，该方法将返回true。
Statement，PreparedStatement和CallableStatement的addBatch()方法用于将单个语句添加到批处理。 executeBatch()用于执行组成批量的所有语句。
executeBatch()返回一个整数数组，数组的每个元素表示相应更新语句的更新计数。
就像将批处理语句添加到处理中一样，可以使用clearBatch()方法删除它们。此方法将删除所有使用addBatch()方法添加的语句。但是，无法指定选择某个要删除的语句。

使用Statement对象进行批处理

以下是使用Statement对象的批处理的典型步骤序列 -

使用createStatement()方法创建Statement对象。
使用setAutoCommit()将自动提交设置为false。
使用addBatch()方法在创建的Statement对象上添加SQL语句到批处理中。
在创建的Statement对象上使用executeBatch()方法执行所有SQL语句。
最后，使用commit()方法提交所有更改。

使用PrepareStatement对象进行批处理

以下是使用PrepareStatement对象进行批处理的典型步骤顺序 -

使用占位符创建SQL语句。
使用prepareStatement()方法创建PrepareStatement对象。
使用setAutoCommit()将自动提交设置为false。
使用addBatch()方法在创建的Statement对象上添加SQL语句到批处理中。
在创建的Statement对象上使用executeBatch()方法执行所有SQL语句。
最后，使用commit()方法提交所有更改。

JDBC编程示例

查询数据：

在实验前，事先建立好了两张表，tbl_user,和tbl_address。通过JDBC变量是查询下面两张表的数据。

mysql> show tables;
+------------------+
| Tables_in_jsp_db |
+------------------+
| tbl_address      |
| tbl_user         |
+------------------+
2 rows in set (0.00 sec)

mysql> select * from tbl_user;
+----+-----------+----------+----------------------+
| id | name      | password | email                |
+----+-----------+----------+----------------------+
|  1 | xiaoming  | 123456   | xiaoming@gmeail.com  |
|  2 | xiaozhang | 123456   | xiaozhang@gmeail.com |
+----+-----------+----------+----------------------+
2 rows in set (0.00 sec)

mysql> select * from tbl_address;
+----+----------+---------+---------+
| id | city     | country | user_id |
+----+----------+---------+---------+
|  1 | beijing  | china   |       1 |
|  2 | tianjing | china   |       2 |
+----+----------+---------+---------+
2 rows in set (0.00 sec)

配置dbconfig.properties:

driver=com.mysql.jdbc.Driver
dburl=jdbc:mysql://localhost:3306/jsp_db?useSSL=false
user=root
password=123456

连接实体：

package JDBC.util;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;

public class ConnectionFactory {

	private static String driver;
	private static String dburl;
	private static String user;
	private static String password;
	
	private static final ConnectionFactory factory = new ConnectionFactory();
	private Connection conn;
	
	static {
		Properties prop = new Properties();
		try {
			InputStream in = ConnectionFactory.class.getClassLoader().
						getResourceAsStream("dbconfig.properties");
			prop.load(in);
		} catch (Exception e) {
			System.out.println("========配置文件读取错误========");
		}
		
		
		driver = prop.getProperty("driver");
		dburl = prop.getProperty("dburl");
		user = prop.getProperty("user");
		password = prop.getProperty("password");
		
	}
	
	private ConnectionFactory() {
	}
	
	public static ConnectionFactory getInstance() {
		return factory;
	}
	
	public Connection makeConnection() {
		try {
			Class.forName(driver);
			conn = DriverManager.getConnection(dburl, user, password);
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		return conn;
	}
}

JDBC.entity：

package JDBC.entity;

public abstract class IdEntity {

	protected int id;
	
	public int getId() {
		return id;
	}
	
	public int setId(int id) {
		return this.id = id;
	}
}

package JDBC.entity;

public class User extends IdEntity {

	private String name;
	private String password;
	private String emial;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getEmial() {
		return emial;
	}
	public void setEmial(String emial) {
		this.emial = emial;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", password=" + password + ", "
				+ "emial=" + emial + ", id=" + id + "]";
	}
}

package JDBC.entity;

public class Address extends IdEntity{

	private String city;
	private String country;
	private int userId;
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getCountry() {
		return country;
	}
	public void setCountry(String country) {
		this.country = country;
	}
	public int getUserId() {
		return userId;
	}
	public void setUserId(int i) {
		this.userId = i;
	}

	@Override
	public String toString() {
		return "Address [city=" + city + ", country=" + country + ", "
				+ "userId=" + userId + ", id=" + id + "]";
	}

}

JDBC.test:

package JDBC;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import JDBC.entity.Address;
import JDBC.entity.User;
import JDBC.util.ConnectionFactory;

public class JDBCtest {

	public static void main(String[] args) throws SQLException {
		
		
		ConnectionFactory cf = ConnectionFactory.getInstance();
		Connection conn = cf.makeConnection();
		String sql_user = "SELECT * FROM tbl_user";
		Statement stat = conn.createStatement();
		PreparedStatement ps = null;
		Address address = new Address();
		User user = new User();
		
		try {
			
			stat.executeQuery(sql_user);
			ResultSet re_user = stat.getResultSet();
			String sql_address = "SELECT * FROM tbl_address WhERE user_id = ?";

			while(re_user.next()){
				user.setPassword(re_user.getString("password"));
				user.setId(re_user.getInt("id"));
				user.setName(re_user.getString("name"));
				user.setEmial(re_user.getString("email"));
				System.out.println(user.toString());
				
			    ps = conn.prepareStatement(sql_address);
			    ps.setInt(1, user.getId());
			    ps.execute();
			    ResultSet re_address = ps.getResultSet();
			    
			    if(re_address.next()) {
			    	address.setId(re_address.getInt("id"));
			    	address.setCity(re_address.getString("city"));
			    	address.setCountry(re_address.getString("country"));
			    	address.setUserId(re_address.getInt("user_id"));
			    	System.out.println(address.toString());
			    }
			}
		
				
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}

程序运行结果：

1
2
3

Address [city=beijing, country=china, userId=1, id=1]
User [name=xiaozhang, password=123456, emial=xiaozhang@gmeail.com, id=2]
Address [city=tianjing, country=china, userId=2, id=2]

记录一些学习资料

Java学习笔记（5）JDBC

JDBC简介

JDBC简介：

JDBC架构：

常见的JDBC组件：

JDBC驱动程序类型：

JDBC驱动程序是什么？

JDBC驱动程序类型：

怎么选择驱动程序：

JDBC编程

JDBC SQL语法：

创建JDBC应用程序的一般步骤：

JDBC数据库连接：

注册驱动程序的方法：

数据库URL配置：

JDBC Statements类：

Statement对象

PreparedStatement对象

2.1 创建PreparedStatement对象

CallableStatement对象

3.1. 创建CallableStatement对象

JDBC结果集：

JDBC事务：

JDBC异常：

JDBC批处理：

JDBC编程示例

查询数据：