Java 数据库编程1---JDBC操作步骤

红太狼 2022-05-21 08:20 249阅读 0赞

## 数据库操作步骤 ##

数据库安装并配置完成后，可按下面的步骤进行数据库的操作：

1.  **加载数据库驱动程序**：每个数据库都会提供JDBC的驱动开发包，直接把JDBC操作所需要的开发包(一般为\*.jar或\*.zip)配置到classpath路径即可。
2.  **连接数据库**：根据各个数据库的不同，连接的地址也不同，这个地址有数据库厂商提供。一般在JDBC连接数据库是都要求用户输入数据库连接的用户名和密码，本专栏中使用的是mysql数据库，设置用户名为`root`,密码也为`root`,用户在取得连接之后才对数据库进行查询或跟新的操作。
3.  **使用SQL语句进行数据库操作**：数据库操作分为更新和查询两种，处理可以使用标准的SQL语句外，对于各个数据库也可以使用它们自己提供的各个命令
4.  **关闭数据库连接**：数据库操作完毕之后需要关闭连接以释放资源。

## 加载驱动 ##

如果要使用`MySQL`数据库进行开发，必须让`java`代码找到`mysql`驱动程序，  
这里有两种方法：  
(1)可以把`mysql`驱动程序包，放到`%JAVA_HOME%\jre\lib\ext`目录下，然后即可在所有的自己所有的`java`代码里使用`jdbc`操作数据库了.  
(2)另一种方法就是在`eclipse`的\*\*`Build Path**`中引入`jdbc`的驱动即可。

### 实例：测试mysql驱动程序加载 ###

public class ConnectionDemo01
    { 
    	// 定义MySQL的数据库驱动程序
    	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
    
    	public static void main(String args[])
    	{ 
    		try
    		{ 
    			//加载数据库驱动
    			Class.forName(DBDRIVER); // 加载驱动程序
    			//打印提示
    			System.out.println("加载驱动成功");
    		} catch (ClassNotFoundException e)
    		{ 
    			e.printStackTrace();
    		}
    	}
    }

运行结果：

加载驱动成功

如果mysql驱动程序包没有位置没有配置正确的话上面的代码会抛出异常：

java.lang.ClassNotFoundException: com.mysql.jdbc.Driver

## 获取数据库连接 ##

### DriverManager类介绍 ###

如果数据库驱动可以正常加载，下面就可以使用`DriverManager`类连接数据库。`DriverManager`类的常用方法如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public static Connection getConnection(String url</code>)</td> 
   <td>通过<code>url</code>链接连接到数据库</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public static Connection getConnection(String url, String user, String password</code>)</td> 
   <td>通过**<code>url</code><strong>链接连接到数据库,同时指定用户登录的</strong>用户名**，和<strong>密码</strong></td> 
  </tr> 
 </tbody> 
</table>

在`DriverManager`类中，提供的主要操作就是得到一个数据库的连接，`getConnection`()方法就是取得连接对象，此方法返回的类型是`Connection`对象，不管使用哪种方式连接，都必须提供一个数据库的链接地址`url`,`Mysql`数据库的链接地址形式如下：

### JDBC的URL形式 ###

`JDBC`虽然提供了与平台无关的数据库操作，但是各个数据库的连接地址是有差异的，`JDBC`的连接地址实际上是由下列3个部分组成。

1.  **`jdbc`协议**：`JDBC URL`中的协议总是`jdbc`
2.  **子协议**：驱动程序名或数据库连接机制的名称(这种机制可以有一个或者多个驱动程序支持)，如`mysql`.
3.  **子名称**：一种标识数据库的方法。必须遵循"//主机名：端口/子协议"的标准URL命名规定，如：`//localhost:3306/usersinfo`

所以完整的URL: `jdbc协议:子协议：子名称` （`jdbc:mysql://localhost:3306/usersinfo`）

#### MySQL数据库的URL详解 ####

jdbc:mysql://IP地址：端口号/数据库名称

现在本机上存在一个`usersinfo`数据库，则此时的地址为

jdbc:mysql://localhost:3306/usersinfo

### Connection接口 ###

下面来看`Connection`接口，以后的数据库操作都是从`Connection`接口开始的。

#### 常用方法 ####

`Connection`接口的常用方法如下表所示：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th></th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>Statement <strong>createStatement</strong>() throws SQLException</td> 
   <td>创建一个 Statement 对象来将 SQL 语句发送到数据库。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>Statement <strong>createStatement</strong>(int resultSetType, int resultSetConcurrency) throws SQLException</td> 
   <td>创建一个 Statement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>PreparedStatement <strong>prepareStatement</strong>(String sql) throws SQLException</td> 
   <td>创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException</td> 
   <td>创建一个 PreparedStatement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>CallableStatement prepareCall(String sql)</td> 
   <td>创建一个 CallableStatement 对象，该对象专门用来调用数据库存储过程。</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException</td> 
   <td>创建一个 CallableStatement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>DatabaseMetaData getMetaData() throws SQLException</td> 
   <td>获取一个 DatabaseMetaData 对象，该对象包含关于此 Connection 对象所连接的<strong>数据库的元数据</strong>。</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>void setAutoCommit(boolean autoCommit) throws SQLException</td> 
   <td>设置数据库的自动提交，与事务相关</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>boolean getAutoCommit() throws SQLException</td> 
   <td>判断数据库是否可以自动提交，与事务相关</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>Savepoint setSavepoint() throws SQLException</td> 
   <td>设置数据的恢复点，与事务相关</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>Savepoint setSavepoint(String name) throws SQLException</td> 
   <td>为数据库的恢复点设置一个名字，与事务相关。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>void rollback() throws SQLException</td> 
   <td>取消在当前事务中进行的所有更改，并释放此 Connection 对象当前持有的所有数据库锁。</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>void rollback(Savepoint savepoint) throws SQLException</td> 
   <td>数据库操作回滚到指定的保存点，与事物有关</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>void commit() throws SQLException</td> 
   <td>使所有上一次提交/回滚后进行的更改成为持久更改，并释放此 Connection 对象当前持有的所有数据库锁。</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td>boolean isClosed() throws SQLException</td> 
   <td>查询此 Connection 对象是否已经被关闭(判断连接是否已经关闭)</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td>void close() throws SQLException</td> 
   <td>立即释放此 Connection 对象的数据库和 JDBC 资源，而不是等待它们被自动释放。关闭数据库</td> 
  </tr> 
 </tbody> 
</table>

上面的方法在JDBC操作中都非常有用，本专栏将部分介绍上述方法的使用。

### 实例：连接数据库 ###

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    public class ConnectionDemo02
    { 
    	// 定义MySQL的数据库驱动程序
    	public static final String driver = "com.mysql.jdbc.Driver";
    	// 定义MySQL数据库的连接地址
    	public static final String url = "jdbc:mysql://localhost:3306";
    	// MySQL数据库的连接用户名
    	public static final String user = "root";
    	// MySQL数据库的连接密码
    	public static final String password = "root";
    
    	public static void main(String args[])
    	{ 
    		Connection conn = null; // 数据库连接
    		try
    		{ 
    			Class.forName(driver); // 加载驱动程序
    			System.out.println("驱动加载成功");
    		} catch (ClassNotFoundException e)
    		{ 
    			e.printStackTrace();
    		}
    		try
    		{ 
    			//连接数据库，url,数据库名，密码
    			conn = DriverManager.getConnection(url, user, password);
    			System.out.println("数据库连接成功");
    		} catch (SQLException e)
    		{ 
    			e.printStackTrace();
    		}
    		System.out.println(conn); // 如果此时可以打印表示连接正常
    		try
    		{ 
    			conn.close(); // 数据库关闭
    		} catch (SQLException e)
    		{ 
    			e.printStackTrace();
    		}
    	}
    }

运行结果：

驱动加载成功
    数据库连接成功
    com.mysql.jdbc.JDBC4Connection@2e0fa5d3

如果出现上述打印，说明此时已经连接上数据库了。

### 注意：数据库打开之后必须关闭 ###

在程序操作中，数据库的资源是非常有限的，这就要求开发者在操作完数据库之后必须将其关闭，如果不关闭，在程序中就会产生无法连接到数据库的异常。

## 执行数据库的更新操作 ##

数据库连接后，下面即可进行数据库的具体操作，如果对数据库进行操作，可以使用`Statement`接口完成，`Statement`接口可以使用`Connection`接口中提供的`createStatement()`方法实例化。

### Statement接口 ###

`Statement`接口中定义了下表所示的常用方法。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>int executeUpdate(String sql) throws SQLException</td> 
   <td>执行给定的SQL语句，这可能是 INSERT ， UPDATE ，或 DELETE语句，或者不返回任何内容，如SQL DDL语句的SQL语句。返回更新的记录数</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>ResultSet executeQuery(String sql) throws SQLException</td> 
   <td>执行数据库查询操作，该语句返回单个 ResultSet对象(结果集对象)。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>void addBatch(String sql) throws SQLException</td> 
   <td>真增加一个待执行的SQL语句</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>int[] executeBatch()</td> 
   <td>批量执行SQL语句</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>void close()</td> 
   <td>关闭Statement操作</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>boolean execute(String sql)</td> 
   <td>执行给定的SQL语句，这可能会返回多个结果。</td> 
  </tr> 
 </tbody> 
</table>

下面使用Statement接口分别完成数据库的插入，修改，删除等操作。

### 实例操作1—执行数据库插入操作 ###

下面直接向student表中添加一条新的记录，编写完整一条SQL语句，并通过Statement执行。  
**实例：向student表中插入数据**  
student表结构：  
![student表结构][student]

package my.insert;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    
    public class InsertDemo01
    { 
    	// 定义MySQL的数据库驱动程序
    	public static final String dirver = "com.mysql.jdbc.Driver";
    	// 定义MySQL数据库的连接地址
    	public static final String url = "jdbc:mysql://localhost:3306/usersinfo?characterEncoding=gbk";
    	// MySQL数据库的连接用户名
    	public static final String user = "root";
    	// MySQL数据库的连接密码
    	public static final String password = "root";
    
    	public static void main(String args[]) throws Exception
    	{  
    		Connection conn = null; // 数据库连接
    		Statement stmt = null; // 数据库操作
    		Class.forName(dirver); // 加载驱动程序
    		String sql = "insert into student(学号,姓名,性别,专业,年级,出生,课程,成绩)"
    				              + " values('H1002','小王','男','软件工程','大三',1996,'高等数学',100);";
    		System.out.println("执行SQL语句："+sql);
    		//获取数据库的连接对象
    		conn = DriverManager.getConnection(url, user, password);
    		// 实例化Statement对象
    		stmt = conn.createStatement(); 
    		// 执行数据库更新操作
    		stmt.executeUpdate(sql);
    		stmt.close(); // 关闭操作
    		conn.close(); // 数据库关闭
    	}
    }

运行结果：  
1.控制台输出:

执行SQL语句：insert into student(学号,姓名,性别,专业,年级,出生,课程,成绩) values('H1002','小王','男','软件工程','大三',1996,'高等数学',100);

2.student表：  
![插入成功][70]  
如果上面执行的SQL语句是一条标准的SQL语句，肯定是可以正常执行的。但是上的SQL语句是固定的，可以将上面的每个内容换成变量，这样灵活性好点。  
也就是换成下吗的形式：

String id="H1003";
    String name="小芳";
    String sex="男";
    String major="嵌入式";
    String grade="大二";
    String birthYear="1997";
    String course="离散数学";
    int score=100;
    //拼接SQL语句
    String sql = "insert into student(学号,姓名,性别,专业,"
    				               + "年级,出生,课程,成绩)"
    		              + " values('"+id+"','"+name+"','"+sex+"','"+major+
    		              "','"+grade+"','"+birthYear+"','"+course+"',"+score+")";

**完整实例：拼接SQL方法**

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    
    public class InsertDemo02
    { 
    	// 定义MySQL的数据库驱动程序
    	public static final String dirver = "com.mysql.jdbc.Driver";
    	// 定义MySQL数据库的连接地址
    	public static final String url = "jdbc:mysql://localhost:3306/usersinfo?characterEncoding=gbk";
    	// MySQL数据库的连接用户名
    	public static final String user = "root";
    	// MySQL数据库的连接密码
    	public static final String password = "root";
    
    	public static void main(String args[]) throws Exception
    	{  
    		Connection conn = null; // 数据库连接
    		Statement stmt = null; // 数据库操作
    		Class.forName(dirver); // 加载驱动程序
    		String id="H1003";
    		String name="小芳";
    		String sex="男";
    		String major="嵌入式";
    		String grade="大二";
    		String birthYear="1997";
    		String course="离散数学";
    		int score=100;
    		//拼接SQL语句
    		String sql = "insert into student(学号,姓名,性别,专业,"
    						               + "年级,出生,课程,成绩)"
    				              + " values('"+id+"','"+name+"','"+sex+"','"+major+
    				              "','"+grade+"','"+birthYear+"','"+course+"',"+score+")";
    		System.out.println("执行SQL语句："+sql);
    		//获取数据库的连接对象
    		conn = DriverManager.getConnection(url, user, password);
    		// 实例化Statement对象
    		stmt = conn.createStatement(); 
    		// 执行数据库更新操作
    		stmt.executeUpdate(sql);
    		stmt.close(); // 关闭操作
    		conn.close(); // 数据库关闭
    	}
    }

运行结果：

*  控制台输出

执行SQL语句：insert into student(学号,姓名,性别,专业,年级,出生,课程,成绩) values('H1003','小芳','男','嵌入式','大二','1997','离散数学',100)

*  student表：  
    ![student表][student 1]

#### 上面的代码中为什么要写两个关闭语句？ ####

以上的代码中分别关闭了Statement和Connection,在开发中只关闭可以吗？

stmt.close(); // 关闭操作
    		conn.close(); // 数据库关闭

**答：可只关闭一次**  
在数据库操作中都存在关闭方法，连接有关闭方法，操作也有关闭方法，一般来说**连接只要已关闭，则其他所有的数据库操作都会关闭**。但是在**开发`JDBC`代码一般习惯分贝按照顺序关闭，即先打开的后关闭**。所以在此处**先关闭`Statement`操作，再关闭`Connection`操作**。

### 实例2----执行数据库修改 ###

要想执行数据库修改操作，只需要将`SQL`语句改成`update`即可。  
**实例：数据库修改操作**

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    
    public class UpdataDemo01
    {
    	// 定义MySQL的数据库驱动程序
    	public static final String dirver = "com.mysql.jdbc.Driver";
    	// 定义MySQL数据库的连接地址
    	public static final String url = "jdbc:mysql://localhost:3306/usersinfo?characterEncoding=gbk";
    	// MySQL数据库的连接用户名
    	public static final String user = "root";
    	// MySQL数据库的连接密码
    	public static final String password = "root";
    
    	public static void main(String args[]) throws Exception
    	{ 
    		Connection conn = null; // 数据库连接
    		Statement stmt = null; // 数据库操作
    		Class.forName(dirver); // 加载驱动程序
    		String id="H1003";
    		String name="张三";
    		String sex="男";
    		String major="软件工程";
    		String grade="大一";
    		String birthYear="1999";
    		String course="Java语言程序设计";
    		int score=100;
    		//拼接SQL语句
    //		String sql = "insert into student(学号,姓名,性别,专业,"
    //						               + "年级,出生,课程,成绩)"
    //				              + " values('"+id+"','"+name+"','"+sex+"','"+major+
    //				              "','"+grade+"','"+birthYear+"','"+course+"',"+score+")";
    		String sql="update student set 姓名='"+name+"',性别='"+sex+"',专业='"+major
    				+"',年级='"+grade+"',出生='"+birthYear+"',课程='"+course+"',成绩="+score+
    				" where 学号='"+id+"'";
    		
    		System.out.println("执行SQL语句："+sql);
    		//获取数据库的连接对象
    		conn = DriverManager.getConnection(url, user, password);
    		// 实例化Statement对象
    		stmt = conn.createStatement(); 
    		// 执行数据库更新操作
    		stmt.executeUpdate(sql);
    		stmt.close(); // 关闭操作
    		conn.close(); // 数据库关闭
    	}
    }

运行结果：

*  控制台输出：

执行SQL语句：update student set 姓名='张三',性别='男',专业='软件工程',年级='大一',出生='1999',课程='Java语言程序设计',成绩=100 where 学号='H1003'

*  更新前的student表：  
    ![student表][student 1]
 *  更新后的student表：  
    ![更新后的学生表][70 1]

### 实例3----执行数据库删除操作 ###

和之前的更新操作差不多，直接执行delete的SQL语句即可完成记录的删除操作。  
**实例：按`学号`删除一条记录**

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    
    public class DeleteDemo
    {
    	// 定义MySQL的数据库驱动程序
    	public static final String dirver = "com.mysql.jdbc.Driver";
    	// 定义MySQL数据库的连接地址
    	public static final String url = "jdbc:mysql://localhost:3306/usersinfo?characterEncoding=gbk";
    	// MySQL数据库的连接用户名
    	public static final String user = "root";
    	// MySQL数据库的连接密码
    	public static final String password = "root";
    
    	public static void main(String args[]) throws Exception
    	{ 
    		Connection conn = null; // 数据库连接
    		Statement stmt = null; // 数据库操作
    		Class.forName(dirver); // 加载驱动程序
    		String id="H1003";
    //		String name="张三";
    //		String sex="男";
    //		String major="软件工程";
    //		String grade="大一";
    //		String birthYear="1999";
    //		String course="Java语言程序设计";
    //		int score=100;
    		//拼接SQL语句
    //		String sql = "insert into student(学号,姓名,性别,专业,"
    //						               + "年级,出生,课程,成绩)"
    //				              + " values('"+id+"','"+name+"','"+sex+"','"+major+
    //				              "','"+grade+"','"+birthYear+"','"+course+"',"+score+")";
    //		String sql="update student set 姓名='"+name+"',性别='"+sex+"',专业='"+major
    //				+"',年级='"+grade+"',出生='"+birthYear+"',课程='"+course+"',成绩="+score+
    //				" where 学号='"+id+"'";
    		String sql="delete from student where 学号='"+id+"'";
    		System.out.println("执行SQL语句："+sql);
    		//获取数据库的连接对象
    		conn = DriverManager.getConnection(url, user, password);
    		// 实例化Statement对象
    		stmt = conn.createStatement(); 
    		// 执行数据库更新操作
    		stmt.executeUpdate(sql);
    		stmt.close(); // 关闭操作
    		conn.close(); // 数据库关闭
    	}
    }

运行结果：

*  控制台输出：

执行SQL语句：delete from student where 学号='H1003'

*  删除之前的student表：  
    ![更新后的学生表][70 1]
 *  删除之后的student表：  
    ![删除后的student表][student 2]

[student]: /images/20220521/a9712ae016974515b43fe555ff4ee7a6.png
[70]: /images/20220521/df632d474068430cad33c6018373274f.png
[student 1]: /images/20220521/02ed760e741942f19dbe7f8e6a52a975.png
[70 1]: /images/20220521/7a71f0627d7d4645a3992aaef2c8db47.png
[student 2]: /images/20220521/15b3617d0b754212b424684e551df1e2.png