jdbc知识点（连接mysql）

jdbc连接mysql

 

1.JDBC简介

JDBC：

　　指 Java 数据库连接，是一种标准Java应用编程接口（ JAVA API），用来连接 Java 编程语言和广泛的数据库。从根本上来说，JDBC 是一种规范，它提供了一套完整的接口，允许便携式访问到底层数据库

 

常见的 JDBC 组件：

　JDBC 的 API 提供了以下接口和类：

　　DriverManager ：这个类管理一系列数据库驱动程序。匹配连接使用通信子协议从 JAVA 应用程序中请求合适的数据库驱动程序。识别 JDBC 下某个子协议的第一驱动程序将被用于建立数据库连接。

　　Driver : 这个接口处理与数据库服务器的通信。你将很少直接与驱动程序互动。相反，你使用 DriverManager 中的对象，它管理此类型的对象。它也抽象与驱动程序对象工作相关的详细信息。

　　Connection : 此接口具有接触数据库的所有方法。该连接对象表示通信上下文，即，所有与数据库的通信仅通过这个连接对象进行。

　　Statement : 使用创建于这个接口的对象将 SQL 语句提交到数据库。除了执行存储过程以外，一些派生的接口也接受参数。

　　ResultSet : 在你使用语句对象执行 SQL 查询后，这些对象保存从数据获得的数据。它作为一个迭代器，让您可以通过它的数据来移动。

　　SQLException : 这个类处理发生在数据库应用程序的任何错误。

 

JDBC 4.0 软件包：

　　JDBC 4.0 主要包含 java.sql 包和 javax.sql 包，提供的主要类与数据源进行交互。

 

2.JDBC SQL语法

SQL语法:

　　结构化查询语言（SQL）是一种标准化的语言，可以让你对数据库进行curd操作，如创建项目，读取内容，更新内容和删除项目。SQL 支持你可能会使用到的任何数据库，它可以让你编写独立于底层数据库的数据库代码

 

创建数据库语法：create database 数据库名；
如：create database hejh;
删除数据库语法：drop database 数据库名;
如：drop database hejh;

注意：1.创建或删除数据库，必须有数据库服务器的管理员权限；

　　　2.删除数据库会把存储在该数据库中的数据一并删除。

创建表语法：
　　create table 表名（
   　　 字段名1 字段类型1，
　　　　 字段名2 字段类型2，
　　　　......
　　）；
建表示例：
　　create table hejh(
　　　　id int not null,
　　　　age int not null,
　　　　frist varchar(20),
　　　　last varchar(20),
　　　　primary key(id)
　　);
删除表语法：drop table 表名;
如：drop table hejh;
insert语法：insert into 表名 values(字段值1，字段值2，...);  --(这种方式默认插入所有字段的值)　
如：insert into hejh values(1,22,'19990405','20190505');

 

select语法：select 字段1，字段2，... from 表名  where 查询限制条件；
　　如：select * from hejh where id=1;

注意：WHERE 子句可以使用 =，!=，<，>，<=，>=，BETWEEN 和 LIKE 这些比较操作符。
update语法：updata 表名 set 字段=字段新值 where 条件；
如：update hejh set age=33 where id=1;
注意：where子句可以使用=，!=，<，>，<=，>=，between和 like 这些比较操作符。
delete语法：delete from 表名 where 条件；
如：delete from hejh where id=1;
注意：where子句可以使用=，!=，<，>，<=，>=，between 和 like 这些比较操作符

 3.设置JDBC使用环境

 

 在开始使用 JDBC 之前，必须设置 JDBC 环境。（以mysql、windows系统为例）

　　1.安装jdk，配置环境变量；

　　2.安装mysql数据库；

　　3.安装eclipse；

 

4.JDBC简单示例

创建数据库：hejh；

　　create database hejh;

　　

创建用户表：user表

create table user(
    id int(5) not null,
    username varchar(20) not null,
    gender varchar(4),
    primary key(id)
);

　

初始化数据：

 

创建JDBC应用程序

构建一个 JDBC 应用程序包括以下六个步骤：

  • 导入数据包：导入含有需要进行数据库编程的 JDBC 类的包。大多数情况下，使用 import java.sql.就足够了。

  • 注册 JDBC 驱动器：需要你初始化一个驱动器，以便于你打开一个与数据库的通信通道。

  • 打开连接：需要使用 DriverManager.getConnection() 方法创建一个 Connection 对象，它代表与数据库的物理连接。

  • 执行查询：需要使用类型声明的对象建立并提交一个 SQL 语句到数据库。

  • 提取结果数据：要求使用适当的 ResultSet.getXXX() 方法从结果集中检索数据。

  • 清理环境：依靠 JVM 的垃圾收集来关闭所有需要明确关闭的数据库资源。

 

查看数据库hejh中user表的数据有3条：

 java源码如下：

package com.hejh.day0506;

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

import org.junit.Test;

public class JdbcTest1 {
    
    static final String driver = "com.mysql.jdbc.Driver";
    static final String url = "jdbc:mysql://localhost/hejh";
    static final String user = "root";
    static final String password = "root";
    
    //开启junit局部测试
    @Test
    public void run() {
        
        ResultSet rs=null;
        Statement st = null;
        Connection conn =null;
        
       try {
            //注册驱动
            Class.forName(driver);
            
            //获取连接
            conn = DriverManager.getConnection(url, user, password);
            
            //获取sql执行对象
            st =  conn.createStatement();
            
            //编写sql语句
            String sql = "select * from user";
            
            //执行sql语句,返回一个结果集
            rs =  st.executeQuery(sql);
            
          //处理结果集
            while(rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("username");
                String gender = rs.getString("gender");
                System.out.println("["+id+","+name+","+gender+"]");
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
　　　　　　　//关闭资源，后开启的先关闭
            try {
                if(rs!=null) {
                    rs.close();
                }else {
                        rs=null;
                    }    
            } catch (SQLException e) {
                e.printStackTrace();
            }
            if(st!=null) {
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }else {
                st=null;
            }
            if(conn!=null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }else {
                conn=null;
            }
        }        
        
    }
        
}

junit局部测试结果如下：

第一个jdbc案例完成。

 

4.JDBC 驱动类型

什么是 JDBC 驱动程序？

　　JDBC 驱动实现了 JDBC API 中定义的接口，该接口用于与数据库服务器进行交互。例如，使用 JDBC 驱动程序可以让你打开数据库连接，并通过发送 SQL 或数据库命令，然后通过 Java 接收结果。java.sql 包中附带的 JDK，包含了定义各种类与他们的行为和实际实现，这些类都在第三方驱动程序中完成。第三方供应商在他们的数据库驱动程序中都实现了 java.sql.Driver 接口。

 

JDBC驱动程序类型：

　　JDBC 驱动程序的实现，因为各种各样的操作系统和 Java 运行在硬件平台的不同而不同。Sun 公司将实现类型分为四类：

　　　　1.JDBC-ODBC桥驱动程序

　　　 2.JDBC-Native API

　　　 3.JDBC-Net纯Java

　　　 4.100%纯Java

具体参见资料：https://www.w3cschool.cn/jdbc/j3xk1myd.html

　　

该使用哪种驱动程序？

　　如果你正在访问一个数据库，如 Oracle，Sybase 或 IBM，首选的驱动程序是类型4。

　　如果你的 Java 应用程序同时访问多个数据库类型，类型3是首选的驱动程序。

　　类型2驱动程序是在你的数据库没有提供类型3或类型4驱动程序时使用的。

　　类型1驱动程序不被认为是部署级的驱动程序，它存在的目的通常仅用于开发和测试。

 

 5.JDBC连接数据库

 

编写建立一个 JDBC 连接的程序是相当简单的，下面是简单的四个步骤：

  • 导入 JDBC 包：在你的 Java 代码中，用 import 语句添加你所需的类。

  • 注册 JDBC 驱动程序：这一步会导致 JVM 加载所需的驱动程序到内存中执行，因此它可以实现你的 JDBC 请求。

  • 数据库 URL 制定：这是用来创建格式正确的地址指向你想要连接的数据库。

  • 创建连接对象：最后，代码调用 DriverManager 对象的 getConnection() 方法来建立实际的数据库连接。

 

1.导入jar包

　　import 语句告诉 Java 编译器在哪里可以找到你在代码中引用的类，这些引用放置在你的源代码起始位置。使用标准的 JDBC 包，它允许你选择，插入，更新和删除 SQL 表中的数据，添加以下引用到您的源代码中。

import java.sql.*;
import javax.sql.*;

2.注册JDBC驱动程序　　

　　方法1 - Class.forName()

 　　注册一个驱动程序中最常用的方法是使用 Java 的Class.forName() 方法来动态加载驱动程序的类文件到内存中，它会自动将其注册。这种方法更优越一些，因为它允许你对驱动程序的注册信息进行配置，便于移植。

//注册驱动
Class.forName(“com.mysql.jdbc.Driver”);//会报异常

　　方法2 - DriverManager.registerDriver()　

　　你注册一个驱动程序的第二种方法是使用静态 staticDriverManager.registerDriver() 方法。如果你使用的是不兼容 JVM 的非 JDK，比如微软提供的，你必须使用 registerDriver() 方法

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);
}

 3.数据库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。

RDBMSJDBC 驱动程序名称URL 格式
MySQL com.mysql.jdbc.Driver jdbc:mysql://hostname/ databaseName
ORACLE oracle.jdbc.driver.OracleDriver jdbc:oracle:thin:@hostname:port Number:databaseName
DB2 COM.ibm.db2.jdbc.net.DB2Driver jdbc:db2:hostname:port Number/databaseName
Sybase com.sybase.jdbc.SybDriver jdbc:sybase:Tds:hostname: port Number/databaseName

 URL 格式所有加粗的部分都是静态的，你需要将剩余部分按照你的数据库实际情况进行设置。

 

4.创建连接对象 

 调用适当的用户名和密码以及 getConnection() 方法来获得一个 Connection 对象

static final String url = "jdbc:mysql://localhost/hejh";
static final String user = "root";
static final String password = "root";

Connection conn = DriverManager.getConnection(url, user, password);

使用数据库 URL 和 Properties 对象：

　　第三种 DriverManager.getConnection() 方法调用需要数据库 URL 和 Properties 对象-

DriverManager.getConnection(String url, Properties info);

　　Properties 对象保存了一组关键数值。它通过调用 getConnection() 方法，将驱动程序属性传递给驱动程序。使用下面的代码可以建立与上述示例相同的连接：

import java.util.*;

String URL = "jdbc:mysql://localhost/hejh";
Properties info = new Properties( );
info.put( "user", "username" );
info.put( "password", "password" );

Connection conn = DriverManager.getConnection(URL, info);

5.关闭 JDBC 连接

　　在 JDBC 程序的末尾，必须明确关闭所有连接到数据库的连接，以结束每个数据库会话。但是，如果忘了，Java 垃圾收集器也会关闭连接，它会完全清除过期的对象。依托垃圾收集器，特别是在数据库编程，是非常差的编程习惯。你应该养成用 close()方法关闭连接对象的习惯。为了确保连接被关闭，你可以在代码中的 'finally' 程序块中执行。 无论异常是否发生，finally 程序是肯定会被执行的。要关闭上面打开的连接，应该调用 close()方法，如下所示：

finally {
            try {
                if(rs!=null) {
                    rs.close();
                }else {
                        rs=null;
                    }    
            } catch (SQLException e) {
                e.printStackTrace();
            }
            if(st!=null) {
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }else {
                st=null;
            }
            if(conn!=null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }else {
                conn=null;
            }
        }

6.JDBC Statement 对象

 

1.Statement 对象

　　获得了数据库的连接，就可以和数据库进行交互了。JDBC 的 Statement，CallableStatement 和 PreparedStatement 接口定义的方法和属性，可以发送 SQL 命令或 PL/SQL 命令到数据库，并从数据库接收数据。在数据库中，它们还定义了帮助 Java 和 SQL 数据类型之间转换数据差异的方法。下表提供了每个接口的用途概要，根据实际目的决定使用哪个接口。

接口推荐使用
Statement 可以正常访问数据库，适用于运行静态 SQL 语句。 Statement 接口不接受参数。
PreparedStatement 计划多次使用 SQL 语句， PreparedStatement 接口运行时接受输入的参数。
CallableStatement 适用于当你要访问数据库存储过程的时候， CallableStatement 接口运行时也接受输入的参数。

 

创建 Statement 对象：

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

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

当创建了一个 Statement 对象之后，可以用它的三个执行方法的任一方法来执行 SQL 语句：

  • boolean execute(String SQL) : 如果 ResultSet 对象可以被检索，则返回的布尔值为 true ，否则返回 false 。当你需要使用真正的动态 SQL 时，可以使用这个方法来执行 SQL DDL 语句。

  • int executeUpdate(String SQL) : 返回执行 SQL 语句影响的行的数目。使用该方法来执行 SQL 语句，是希望得到一些受影响的行的数目，例如，INSERT，UPDATE 或 DELETE 语句。

  • ResultSet executeQuery(String SQL) : 返回一个 ResultSet 对象。当你希望得到一个结果集时使用该方法，就像你使用一个 SELECT 语句。

 

关闭 Statement 对象：

　　正如关闭一个 Connection 对象来节约数据库资源，出于同样的原因你也应该关闭 Statement 对象。简单的调用 close() 方法就可以完成这项工作。如果关闭了 Connection 对象，那么它也会关闭 Statement 对象。然而，你应该始终明确关闭 Statement 对象，以确保真正的清除。

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   stmt.close();//会报异常
}

PreparedStatement 对象:

　　PreparedStatement 接口扩展了 Statement 接口，它让你用一个常用的 Statement 对象增加几个高级功能。这个 statement 对象可以提供灵活多变的动态参数。创建 PreparedStatement 对象:

PreparedStatement pstmt = null;
try {
   String SQL = "update user set age = ? where id = ?";
   pstmt = conn.prepareStatement(SQL);
　　psmt.setInt(1,22);
　　psmt.setInt(2,1);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

　　JDBC 中所有的参数都被用 ? 符号表示，这是已知的参数标记。在执行 SQL 语句之前，你必须赋予每一个参数确切的数值。setXXX() 方法将值绑定到参数，其中 XXX 表示你希望绑定到输入参数的 Java 数据类型。如果你忘了赋予值，你将收到一个 SQLException。每个参数标记映射它的序号位置。第一标记表示位置 1 ，下一个位置为 2 等等。这种方法不同于 Java 数组索引是从 0 开始的。所有的 Statement对象 的方法都与数据库交互，(a) execute()，(b) executeQuery()，及 (c) executeUpdate() 也能被 PreparedStatement 对象引用。然而，这些方法被 SQL 语句修改后是可以输入参数的。

关闭 PreparedStatement 对象

　　关闭 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 对象。

 在 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 SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

 7.结果集

 结果集：

　　SQL 语句从数据库查询中获取数据，并将数据返回到结果集中。SELECT 语句是一种标准的方法，它从一个数据库中选择行记录，并显示在一个结果集中。 java.sql.ResultSet 接口表示一个数据库查询的结果集。一个 ResultSet 对象控制一个光标指向当前行的结果集。术语“结果集”是指包含在 ResultSet 对象中的行和列的数据。

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

  • 导航方法：用于移动光标。
  • 获取方法：用于查看当前行被光标所指向的列中的数据。
  • 更新方法：用于更新当前行的列中的数据。这些更新也会更新数据库中的数据。

　　光标的移动基于 ResultSet 的属性。用相应的语句生成 ResultSet 对象时，同时生成 ResultSet 的属性。JDBC 提供了连接方法通过下列创建语句来生成你所需的 ResultSet 对象：

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

第一个参数表示 ResultSet 对象的类型，第二个参数是两个 ResultSet 常量之一，该常量用于判断该结果集是只读的还是可修改的

 

ResultSet的类型：

　　可能的 RSType 如下所示。如果你不指定 ResultSet 类型，将自动获得的值是 TYPE_FORWARD_ONLY。

类型描述
ResultSet.TYPE_FORWARD_ONLY 光标只能在结果集中向前移动。
ResultSet.TYPE_SCROLL_INSENSITIVE 光标可以向前和向后移动。当结果集创建后，其他人对数据库的操作不会影响结果集的数据。
ResultSet.TYPE_SCROLL_SENSITIVE. 光标可以向前和向后移动。当结果集创建后，其他人对数据库的操作会影响结果集的数据。

 

ResultSet的并发性：

　　RSConcurrency 的值如下所示，如果你不指定并发类型，将自动获得的值是 CONCUR_READ_ONLY。

并发性描述
ResultSet.CONCUR_READ_ONLY 创建一个只读结果集，这是默认的值。
ResultSet.CONCUR_UPDATABLE 创建一个可修改的结果集。

示例可以如下所示，初始化一个 Statement 对象，来创建一个只能前进而且只读的 ResultSet 对象：

try {
   Statement stmt = conn.createStatement( ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
}
catch(Exception ex) {
   ....
}
finally {
   ....
}

导航结果集：

　　在 ResultSet 接口中包括如下几种方法涉及移动光标-

S.N.方法 & 描述
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

将光标移动到指定的第 row 行。
6 public boolean relative(int row) throws SQLException

将光标移动到当前指向的位置往前或往后第 row 行的位置。
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

如果光标处于插入行，则将光标返回到当前行，其他情况下，这个方法不执行任何操作。

 

查看结果集：

ResultSet接口中含有几十种从当前行获取数据的方法。每个可能的数据类型都有一个 get 方法，并且每个 get 方法有两个版本-

  • 一个需要列名。
  • 一个需要列的索引。

例如，如果你想查看的列包含一个 int 类型，你需要在 ResultSet 中调用 getInt()方法-

S.N.方法 & 描述
1 public int getInt(String columnName) throws SQLException

返回当前行中名为 columnName 的列的 int 值。
2 public int getInt(int columnIndex) throws SQLException

返回当前行中指定列的索引的 int 值。列索引从 1 开始，意味着行中的第一列是 1 ，第二列是 2 ，以此类推。

同样的，在 ResultSet 接口中还有获取八个 Java 原始类型的 get 方法，以及常见的类型，比如 java.lang.String，java.lang.Object 和java.net.URL。

也有用于获取 SQL 数据类型 java.sql.Date， java.sql.Time， java.sql.Timestamp， java.sql.Clob，java.sql.Blob 中的方法。查看文档可以了解使用这些 SQL 数据类型的更多的信息。

 

更新的结果集：

ResultSet 接口包含了一系列的更新方法，该方法用于更新结果集中的数据。用 get 方法可以有两个更新方法来更新任一数据类型：

  • 一个需要列名。
  • 一个需要列的索引。

例如，要更新一个结果集的当前行的 String 列，你可以使用任一如下所示的 updateString()方法-

S.N.方法 & 描述
1 public void updateString(int columnIndex, String s) throws SQLException

将指定列的字符串的值改为 s。
2 public void updateString(String columnName, String s) throws SQLException

类似于前面的方法，不同之处在于指定的列是用名字来指定的，而不是它的索引。

八个原始数据类型都有其更新方法，比如 String，Object，URL，和在 java.sql 包中的 SQL 数据类型。

更新结果集中的行将改变当前行的列中的 ResultSet 对象，而不是基础数据库中的数据。要更新数据库中一行的数据，你需要调用以下的任一方法：

S.N.方法 & 描述
1 public void updateRow()

通过更新数据库中相对应的行来更新当前行。
2 public void deleteRow()

从数据库中删除当前行。
3 public void refreshRow()

在结果集中刷新数据，以反映数据库中最新的数据变化。
4 public void cancelRowUpdates()

取消对当前行的任何修改。
5 public void insertRow()

在数据库中插入一行。本方法只有在光标指向插入行的时候才能被调用。

 

8.JDBC数据类型

 

　　JDBC 驱动程序在将 Java 数据类型数据发送到数据库之前，会将其转换为相应的 JDBC 类型数据，对于大多数数据类型都采用了默认的映射关系。例如，一个 Java int 数据类型转换为 SQL INTEGER。通过默认的映射关系来提供驱动程序之间的一致性。当你调用 PreparedStatement 中的 setXXX()方法或 CallableStatement 对象或 ResultSet.updateXXX()方法时， Java 数据类型会转换为默认的 JDBC 数据类型，如下表概述。

SQLJDBC/JavasetXXXupdateXXX
VARCHAR java.lang.String setString updateString
CHAR java.lang.String setString updateString
LONGVARCHAR java.lang.String setString updateString
BIT boolean setBoolean updateBoolean
NUMERIC java.math.BigDecimal setBigDecimal updateBigDecimal
TINYINT byte setByte updateByte
SMALLINT short setShort updateShort
INTEGER int setInt updateInt
BIGINT long setLong updateLong
REAL float setFloat updateFloat
FLOAT float setFloat updateFloat
DOUBLE double setDouble updateDouble
VARBINARY byte[ ] setBytes updateBytes
BINARY byte[ ] setBytes updateBytes
DATE java.sql.Date setDate updateDate
TIME java.sql.Time setTime updateTime
TIMESTAMP java.sql.Timestamp setTimestamp updateTimestamp
CLOB java.sql.Clob setClob updateClob
BLOB java.sql.Blob setBlob updateBlob
ARRAY java.sql.Array setARRAY updateARRAY
REF java.sql.Ref SetRef updateRef
STRUCT java.sql.Struct SetStruct updateStruct


　　JDBC 3.0 增强了对 BLOB，CLOB，ARRAY 和 REF 数据类型的支持。 ResultSet 对象现在有 UPDATEBLOB()，updateCLOB()， updateArray()，和 updateRef()方法，通过这些方法你可以直接操作服务器上的相应数据。

你能用 setXXX()方法和 updateXXX()方法将 Java 类型转换为特定的 JDBC 数据类型。你能用 setObject()方法和 updateObject()方法将绝大部分的 Java 类型映射到 JDBC 数据类型。

　　ResultSet 对象为任一数据类型提供相应的 getXXX()方法，该方法可以获取任一数据类型的列值。上述任一方法的使用需要列名或它的顺序位置。

SQLJDBC/JavasetXXXgetXXX
VARCHAR java.lang.String setString getString
CHAR java.lang.String setString getString
LONGVARCHAR java.lang.String setString getString
BIT boolean setBoolean getBoolean
NUMERIC java.math.BigDecimal setBigDecimal getBigDecimal
TINYINT byte setByte getByte
SMALLINT short setShort getShort
INTEGER int setInt getInt
BIGINT long setLong getLong
REAL float setFloat getFloat
FLOAT float setFloat getFloat
DOUBLE double setDouble getDouble
VARBINARY byte[ ] setBytes getBytes
BINARY byte[ ] setBytes getBytes
DATE java.sql.Date setDate getDate
TIME java.sql.Time setTime getTime
TIMESTAMP java.sql.Timestamp setTimestamp getTimestamp
CLOB java.sql.Clob setClob getClob
BLOB java.sql.Blob setBlob getBlob
ARRAY java.sql.Array setARRAY getARRAY
REF java.sql.Ref SetRef getRef
STRUCT java.sql.Struct SetStruct getStruct

 

日期和时间数据类型：

　　java.sql.Date 类映射 SQL DATE 类型，java.sql.Time 类和 java.sql.Timestamp 类也分别映射 SQL TIME 数据类型和 SQL TIMESTAMP 数据类型。以下示例显示了日期和时间类如何转换成标准的 Java 日期和时间值，并匹配成 SQL 数据类型所要求的格式。

package com.hejh.day0507;
import java.util.Date;

public class TimeTest {
    public static void main(String[] args) {
        
        //java util 打印当前具体时间
        Date utilDate = new Date();
        long utilTime = utilDate.getTime();
        System.out.println("java util date:"+utilDate.toString());//java util date:Tue May 07 17:14:53 CST 2019
        
        //sql 打印当前时间（某年-某月-某日）
        java.sql.Date sqlDate  = new java.sql.Date(utilTime);
        System.out.println("java sql date:"+sqlDate.toString());//java sql date:2019-05-07
        
        //sql  打印当前时间（时：分：秒）
        java.sql.Time sqlTime  = new java.sql.Time(utilTime);
        System.out.println("java sql time:"+sqlTime.toString());//java sql time:17:34:33
        
        //sql 打印当前具体时间（某年-某月-某日 时：分：秒）
        java.sql.Timestamp sqlTimeStamp  = new java.sql.Timestamp(utilTime);
        System.out.println("java sql Timestamp:"+sqlTimeStamp.toString());//java sql Timestamp:2019-05-07 17:36:44.176    
    }
}

处理 NULL 值：

SQL 使用 NULL 值和 Java 使用 null 是不同的概念。那么，你可以使用三种策略来处理 Java 中的 SQL NULL 值：

  • 避免使用返回原始数据类型的 getXXX()方法。
  • 使用包装类的基本数据类型，并使用 ResultSet 对象的 wasNull()方法来测试收到 getXXX()方法返回的值是否为 null，如果是 null，该包装类变量则被设置为 null。
  • 使用原始数据类型和 ResultSet 对象的 wasNull()方法来测试通过 getXXX()方法返回的值，如果是 null，则原始变量应设置为可接受的值来代表 NULL。

下面是一个处理 NULL 值的示例：

Statement stmt = conn.createStatement( );
String sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

int id = rs.getInt(1);
if( rs.wasNull( ) ) {
   id = 0;
}

 9.JDBC事务

事务：　

　　如果 JDBC 连接是处于自动提交模式下，该模式为默认模式，那么每句 SQL 语句都是在其完成时提交到数据库。对简单的应用程序来说这种模式相当好，但有三个原因你可能想关闭自动提交模式，并管理你自己的事务：

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

你可以通过事务在任意时间来控制以及更改应用到数据库。它把单个 SQL 语句或一组 SQL 语句作为一个逻辑单元，如果其中任一语句失败，则整个事务失败。

　　若要启用手动事务模式来代替 JDBC 驱动程序默认使用的自动提交模式的话，使用 Connection 对象的的 setAutoCommit()方法。如果传递一个布尔值 false 到 setAutoCommit()方法，你就关闭自动提交模式。你也可以传递一个布尔值 true 将其再次打开。例如，如果有一个名为 conn 的 Connection 对象，以下的代码将关闭自动提交模式：

conn.setAutoCommit(false);//关闭自动提交模式

 提交和回滚：

 　　当完成修改，并且要提交修改，可以在 connection 对象里调用 commit（）方法，如下所示：

conn.commit( );

　　

在默认情况下，事务自动提交，源码和数据库数据如下：

package com.hejh.day0508;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import org.junit.Test;

public class AffairTest {
    
    static final String driver = "com.mysql.jdbc.Driver";
    static String url = "jdbc:mysql://localhost/hejh";
    static final String username = "root";
    static final String password = "root";
    
    @Test
    public void run() {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, username, password);
            String sql = "update user set username = ?  where id = ? ";
            
            ps = conn.prepareStatement(sql);
            ps.setString(1,"hejh11");
            ps.setInt(2, 1);
            int i = ps.executeUpdate();
            System.out.println("影响了:"+i+"行");        //影响了:1行
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(ps!=null) {
                    ps.close();
                }else {
                    ps=null;
                }        
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                if(conn!=null) {
                    conn.close();
               }else {
                        conn=null;
                    }
            } catch (SQLException e) {
                        e.printStackTrace();
                    }
                
        }//finally
    }
}

设置为手动提交，运行下面的源码（替换try-catch部分代码），数据库数据刷新结果如下：

try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, username, password);
            String sql = "update user set username = ?  where id = ? ";
            //在执行sql之前，设置事务为手动提交
            conn.setAutoCommit(false);//手动提交事务,数据不会发生变化
            ps = conn.prepareStatement(sql);
            ps.setString(1,"hejh111");
            ps.setInt(2, 1);
            int i = ps.executeUpdate();
            System.out.println("影响了:"+i+"行");        //影响了:1行
        } catch (Exception e) {
            e.printStackTrace();
        }

 设置为手动提交，并且在sql执行后，手动提交一下事务，运行下面的源码（替换try-catch部分代码），数据库数据刷新结果如下：

try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, username, password);
            String sql = "update user set username = ?  where id = ? ";
            //在执行sql之前，设置事务为手动提交
            conn.setAutoCommit(false);//手动提交事务,数据不会发生变化
            ps = conn.prepareStatement(sql);
            ps.setString(1,"hejh111");
            ps.setInt(2, 1);
            int i = ps.executeUpdate();
            //sql语句执行后，手动提交事务，使sql生效
            conn.commit();
            System.out.println("影响了:"+i+"行");        //影响了:1行
        } catch (Exception e) {
            e.printStackTrace();
        }

 另外，用名为 conn 的连接回滚数据到数据库，

conn.rollback( );//可以放在catch块中

还原点：

　　新的 JDBC 3.0 还原点接口提供了额外的事务控制。大部分现代的数据库管理系统的环境都支持设定还原点，例如 Oracle 的 PL/SQL。当你在事务中设置一个还原点来定义一个逻辑回滚点。如果在一个还原点之后发生错误，那么可以使用 rollback 方法来撤消该还原点之后所做的修改。

Connection 对象有两个新的方法来管理还原点：

  • setSavepoint(String savepointName): 定义了一个新的还原点，返回一个 Savepoint 对象。

  • releaseSavepoint(Savepoint savepointName): 删除一个还原点。请注意，参数是一个 Savepoint 对象，这个对象通常是由 setSavepoint() 方法生成的一个还原点。

有一个 rollback (String savepointName) 方法，该方法可以回滚到指定的还原点。下面的例子说明了如何使用 Savepoint 对象：

package com.hejh.day0508;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Savepoint;

import org.junit.Test;

public class SavePointTest {
	
	@Test
	public void save() throws SQLException {
		Connection conn = null;
		 PreparedStatement ps =null;
		 Savepoint beforeInsert = null;
		try {
			Class.forName("com.mysql.jdbc.Driver");
			//prepareStatement插入的中文参数有可能会出现问号，可以在这里指定一下字符编码为utf-8
			conn  = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8",
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 "root", "root");
			
			//设置一个还原点
			beforeInsert =  conn.setSavepoint();
			
			String sql = "insert into user values(?,?,?)";
			 ps = conn.prepareStatement(sql);
			 ps.setInt(1,4);
			 ps.setString(2, "hejh222");
			 ps.setString(3, "男");
			int i =  ps.executeUpdate();
			System.out.println("插入了："+i+"行数据");
		} catch (Exception e) {
			//回滚到还原点BeforeInsert处
			conn.rollback(beforeInsert);
			e.printStackTrace();
		}finally {
			try {
				if(ps!=null) {
					ps.close();
				}else {
					ps = null;
				}				
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(beforeInsert!=null) {
					conn.releaseSavepoint(beforeInsert);
				}else {
					beforeInsert=null;
				}
				
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null) {
					conn.close();
				}else {
					conn=null;
				}
				
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}		 
	}	
}

　　

 10.JDBC异常

 异常：

　　异常处理可以允许你处理一个异常情况，例如可控方式的程序定义错误。当异常情况发生时，将抛出一个异常。抛出这个词意味着当前执行的程序停止，控制器被重定向到最近的适用的 catch 子句。如果没有适用的 catch 子句存在，那么程序执行被终止。JDBC 的异常处理是非常类似于 Java 的异常处理，但对于 JDBC，最常见的异常是 java.sql.SQLException。

SQLException：

　　SQLException 异常在驱动程序和数据库中都可能出现。当出现这个异常时，SQLException 类型的对象将被传递到 catch 子句。传递的 SQLException 对象具有以下的方法，以下的方法可用于检索该异常的额外信息：

方法描述
getErrorCode( ) 获取与异常关联的错误号。
getMessage( ) 获取 JDBC 驱动程序的错误信息，该错误是由驱动程序处理的，或者在数据库错误中获取 Oracl 错误号和错误信息。
getSQLState( ) 获取 XOPEN SQLstate 字符串。对于 JDBC 驱动程序错误，使用该方法不能返回有用的信息。对于数据库错误，返回第五位的 XOPEN SQLstate 代码。该方法可以返回 null。
getNextException( ) 获取异常链的下一个 Exception 对象。
printStackTrace( ) 打印当前异常或者抛出，其回溯到标准的流错误。
printStackTrace(PrintStream s) 打印该抛出，其回溯到你指定的打印流。
printStackTrace(PrintWriter w) 打印该抛出，其回溯到你指定的打印写入。

通过利用可从 Exception 对象提供的信息，你可以捕获异常并继续运行程序。这是一个 try 块的一般格式：

try {
   // 可能出现异常的代码
}
catch(Exception ex) {
   //异常的捕捉和处理
}
finally {// 必须执行的操作，想数据库的资源关闭，
}
package com.hejh.day0508;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Savepoint;

import org.junit.Test;

public class ExceptionTest {
    
    @Test
    public void save() throws SQLException {
        Connection conn = null;
         PreparedStatement ps =null;
         Savepoint beforeInsert = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            //1.数据库用户名和密码不符（root,hejh）,实际用户名密码为（root，root）
            conn  = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8", "root", "hejh");
            
            String sql = "insert into user values(?,?,?)";
             ps = conn.prepareStatement(sql);
             ps.setInt(1,4);
             ps.setString(2, "hejh200");
             ps.setString(3, "男");
            int i =  ps.executeUpdate();
            System.out.println("插入了："+i+"行数据");
        } catch (Exception e) {
            //2.在这里捕获异常，并将异常信息打印到控制台
            e.printStackTrace();
        }finally {
            try {
                if(ps!=null) {
                    ps.close();
                }else {
                    ps = null;
                }                
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if(beforeInsert!=null) {
                    conn.releaseSavepoint(beforeInsert);
                }else {
                    beforeInsert=null;
                }
                
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if(conn!=null) {
                    conn.close();
                }else {
                    conn=null;
                }
                
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }         
    }    
    
}

出现以下异常：

java.sql.SQLException: Access denied for user 'root'@'localhost' (using password: YES)
......

 11.JDBC批处理

 批处理：

　　批处理是指你将关联的 SQL 语句组合成一个批处理，并将他们当成一个调用提交给数据库。当你一次发送多个 SQL 语句到数据库时，可以减少通信的资源消耗，从而提高了性能。

  • JDBC 驱动程序不一定支持该功能。你可以使用 DatabaseMetaData.supportsBatchUpdates() 方法来确定目标数据库是否支持批处理更新。如果你的JDBC驱动程序支持此功能，则该方法返回值为 true。

  • Statement，PreparedStatement 和 CallableStatement 的 addBatch() 方法用于添加单个语句到批处理。

  • executeBatch() 方法用于启动执行所有组合在一起的语句。

  • executeBatch() 方法返回一个整数数组，数组中的每个元素代表了各自的更新语句的更新数目。

  • 正如你可以添加语句到批处理中，你也可以用 clearBatch() 方法删除它们。此方法删除所有用 addBatch() 方法添加的语句。但是，你不能有选择性地选择要删除的语句。

Statement 对象执行批处理：

使用 Statement 对象来使用批处理所需要的典型步骤如下所示-

  • 使用 createStatement() 方法创建一个 Statement 对象。
  • 使用 setAutoCommit() 方法将自动提交设为 false。
  • 被创建的 Statement 对象可以使用 addBatch() 方法来添加你想要的所有SQL语句。
  • 被创建的 Statement 对象可以用 executeBatch() 将所有的 SQL 语句执行。
  • 最后，使用 commit() 方法提交所有的更改。

批量执行3条insert语句，示例如下：

package com.hejh.day0508;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

import org.junit.Test;
import org.omg.Messaging.SyncScopeHelper;

//批处理
public class Batching {
    
    @Test
    public void test() {
        Connection conn = null;
        Statement st = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            
            //获取链接
            conn = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8", "root", "root");
            
            //设置为：手动提交事务
            conn.setAutoCommit(false);
            
            //编写3个insert sql语句
            String sql1 = "insert into user values(4,'sss','女')";
          String sql2 = "insert into user values(5,'www','男')";
          String sql3 = "insert into user values(6,'yyy','女')";
            
            //获取statement对象
            st = conn.createStatement();
            
            //添加sql语句到批处理
            st.addBatch(sql1);
            st.addBatch(sql2);
            st.addBatch(sql3);
            
            //执行批处理，返回一个整数数组，数组中的每个元素代表了各自的更新语句的更新数目
            int[] arr = st.executeBatch();
            
            //事务提交,使sql语句生效
            conn.commit();
            
            //处理数组
            System.out.print("影响行数为：");
            for(int i=0;i<arr.length;i++) {
                System.out.print(arr[i]+"  ");//影响行数为：1  1  1  
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(st!=null) {
                    st.close();
                }else {
                    st = null;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if(conn!=null) {
                    conn.close();
                }else {
                    conn = null;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        
        
    }
    
}

批处理和 PrepareStatement 对象：

使用 prepareStatement 对象来使用批处理需要的典型步骤如下所示：

  • 使用占位符创建 SQL 语句。
  • 使用任一 prepareStatement() 方法创建 prepareStatement 对象。
  • 使用 setAutoCommit() 方法将自动提交设为 false。
  • 被创建的 Statement 对象可以使用 addBatch() 方法来添加你想要的所有 SQL 语句。
  • 被创建的 Statement 对象可以用 executeBatch() 将所有的 SQL 语句执行。
  • 最后，使用 commit() 方法提交所有的更改。

 示例如下：

package com.hejh.day0508;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import org.junit.Test;

public class PrepareStatementBatching {
    
    @Test
    public void test() {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            
            //获取链接
            conn = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8", "root", "root");
            
            //设置为：手动提交事务
            conn.setAutoCommit(false);
            
            //编写sql语句
            String sql = "update user set username=? where id=?";
                        
            //获取statement对象
            ps = conn.prepareStatement(sql);
            
            //添加第一个sql语句到批处理
            ps.setString(1, "s");
            ps.setInt(2, 4);
            ps.addBatch();
            //添加第二个sql语句到批处理
            ps.setString(1, "w");
            ps.setInt(2, 5);
            ps.addBatch();
            //添加第三个sql语句到批处理
            ps.setString(1, "y");
            ps.setInt(2, 6);
            ps.addBatch();
            
            //执行批处理，返回一个整数数组，数组中的每个元素代表了各自的更新语句的更新数目
            int []arr  = ps.executeBatch();
            
            //提交事务,使sql语句生效
            conn.commit();
            
            //处理数组 
           System.out.print("分别影响了：");
        for(int i=0;i<arr.length;i++) {
            System.out.print(arr[i]+"  ");  //分别影响了：1行   1行   1行 
        }
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(ps!=null) {
                    ps.close();
                }else {
                    ps = null;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if(conn!=null) {
                    conn.close();
                }else {
                    conn = null;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }        
    }    
}

12.JDBC流数据

流数据：

　　　　PreparedStatement 对象必须具备使用输入和输出流来提供参数数据的能力。这使你能够将整个文件存储到数据库列中，这样数据库就能存储大型数据，例如 CLOB 和 BLOB 数据类型。

用于流数据有下列几种方法：

  • setAsciiStream(): 该方法是用来提供较大的 ASCII 值。
  • setCharacterStream(): 该方法是用来提供较大的 UNICODE 值。
  • setBinaryStream(): 该方法是用来提供较大的二进制值。

setXXXStream()方法需要一个额外的参数，该参数是除了参数占位符的文件大小。这个参数通知驱动程序通过使用流有多少数据被发送到数据库中。

假如我们到要上传一个名为 hejh.xml 的 XML 文件到数据库的表中。下面是该 XML 文件的内容

<?xml version="1.0"?>
<hejh>
    <id>1</id>
    <username>hjh</username>
    <gender>男</gender>
</hejh>

将该 xml_data.xml文件和要运行的示例保存在相同的目录的。这个示例将创建一个数据库表 xml_data ，然后 xml_data.xml 将被上传到该表中。

将下面的示例拷贝并粘帖到 JDBCStreamingDate.java 中，编译并运行它，如下所示:

package com.hejh.day0509;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCStreamingDate {
    public static void main(String[] args)throws SQLException, IOException {
        Connection conn = null;
        Statement st  = null;
        PreparedStatement pps = null;
        ResultSet rs = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");            
            //获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8", "root", "root");            
            //获取 Statement 对象，来创建一张xml_data表
            st = conn.createStatement();
            createXMLTable(st);            
            //将xml_data.xml文件读取进来
            File file = new File("src/xml_data.xml");
            long fileLength  = file.length();
            FileInputStream fis = new FileInputStream(file);            
            //获取  对象，给表插入数据,并执行sql
            String sql = "insert into xml_data values(?,?)";
            pps = conn.prepareStatement(sql);
            pps.setInt(1, 100);
            pps.setAsciiStream(2, fis,(int)fileLength );
            pps.execute();            
            //关闭输入流
            fis.close();                
            String selectSql = "select data from xml_data where id =100";
            rs = st.executeQuery(selectSql);
            InputStream is = null;
            ByteArrayOutputStream bos = null;
            if(rs.next()) {
                is = rs.getAsciiStream(1);    
                int c ;
                //获取输出流，将带数据的hejh.xml文件输出
                bos = new ByteArrayOutputStream();
                while((c=is.read())!=-1) {
                    bos.write(c);
                }
            }            
            System.out.println(bos.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {//关闭资源
            if(rs!=null) {
                rs.close();
            }else {
                rs = null;
            }
            if(pps!=null) {
                pps.close();
            }else {
                pps = null;
            }
            if(st!=null) {
                st.close();
            }else {
                st = null;
            }
            if(conn!=null) {
                conn.close();
            }else {
                conn = null;
            }        
        }    
    }

    //创建一张表，表名xml_data
    public static void createXMLTable(Statement st) throws SQLException {
        //sql语句，创建一张表xml_data
        
        String createTable = "create table xml_data(id int,data long)";
        //删除表xml_data
        String dropTable  = "drop table xml_data";    
        //在建表前，应该先删除表，如果存在相同的表名的话
        try {
            st.execute(dropTable);
        } catch (SQLException e) {
            e.printStackTrace();
        }    
        //创建表
        st.executeUpdate(createTable);        
    }    
}

console输出为：

<?xml version="1.0" encoding="UTF-8"?>
<hejh>
    <id>1</id>
    <username>hjh</username>
    <gender>男</gender>
</hejh>

数据库表现为：

本博文参考w3cschool网JDBC指南一文，附上网址：https://www.w3cschool.cn/jdbc/bgqu1my6.html

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/hejh/p/10811847.html