JDBC的典型用法：
JDBC4.2常用接口和类简介：
DriverManager：用于管理JDBC驱动的服务类，程序中使用该类的主要功能是获取Connection对象，该类包含如下方法：
public static synchronized Connection getConnection(String url, String user, String pass) throws SQLException:该方法获得url对应数据库的连接
Connection：代表数据库连接对象，每个Connection代表一个物理连接会话。想要访问数据库，必须先获得数据库连接，该接口的常用方法如下：
1.Statement createStatement() throws SQLException：该方法返回一个Statement对象。
2.PreparedStatement prepareStatement(String sql) throws SQLException：该方法返回预编译的Statement对象，即将SQL语句提交到数据库进行预编译。
3.CallableStatement prepareCall(String sql) throws SQLException：该方法返回CallableStatement对象，该对象用于调用存储过程
上面三个方法都返回用于执行SQL语句的Statement对象，PreparedStatement、CallableStatement是Statement的子类，只有获得了Statement之后才可执行SQL语句。
除此之外，Connection还有如下几个用于控制事务的方法：
1.Savepoint setSavepoint()：创建一个保存点
2.Savepoint setSavepoint(String name)：以指定名字创建一个保存点
3.void setTransactionIsolation(int level)：设置事务的隔离级别
4.void rollback()：回滚事务
5.void rollback(Savepoint savepoint)：将事务回滚到指定的保存点
6.void setAutoCommit(boolean autoCommit)：关闭自动提交、打开事务
7.void commit()：提交事务
Java7 为Connection新增了
setSchema(String schema)、getSchema()两个方法：用于控制该Connection访问的数据库Schema
setNetworkTimeout(Executor executor, int milliseconds)、getNetworkTimeout()两个方法：用于控制数据库连接超时行为。
Statement：用于执行SQL语句的工具接口，常用方法如下：
1.ResultSet executeQuery(String sql) throws SQLException：该方法用于执行查询语句，并返回查询结果对应的ResultSet对象。该方法只能用于执行查询语句
2.int executeUpdate(String sql) throws SQLException：该方法用于执行DML（数据操作语言）语句，并返回受影响的行数；该方法也可用于执行DDL（数据定义
语言）语句执行DDL语句将返回0
3.boolean execute(String sql) throws SQLException：该方法可执行任何SQL语句。若执行后第一个结果为ResultSet对象，则返回true；若执行后第一个结果为受影
响的行数或没有任何结果，则返回false。
Java7为Statement新增了closeOnCompletion()方法：若Statement执行了该方法，则当所有依赖于该Statement的ResultSet关闭时，该Statement会自动关闭。
Java7还为Statement提供了isCloseOnCompletion()方法：用于判断该Statement是否打开了“closeOnCompletion”.
Java8为Statement新增了多个重载的executeLargeUpdate()方法：这些方法相当于增强版的executeUpdate()方法，返回值类型为long，即当DML语句影响的记录条数超过
Integer.MAX_VALUE时，就应该使用executeLargeUpdate()方法。
PreparedStatement：预编译的Statement对象。PreparedStatement是Statement的子接口，它允许数据库预编译SQL语句（这些SQL语句通常带有参数），以后每次只
改变SQL命令的参数，避免数据库每次都需要编译SQL语句，因此性能更好。相对于Statement而言，使用PreparedStatement执行SQL语句时，无需再传入SQL语句，只
要为预编译的SQL语句传入参数数值即可。所以它比Statement多了如下方法：
1.void setXxx(int parameterIndex, Xxx value)：该方法根据传入参数值的类型不同，需要使用不同的方法。传入的值根据索引传给SQL语句中指定位置的参数。
ResultSet：结果集对象。该对象包含访问查询结果的方法，ResultSet可以通过列索引或列名获得列数据。它包含了如下常用方法来移动记录指针：
1.void close()：释放ResultSet对象。
2.boolean absolute(int row)：将结果集的记录指针移动到第row行，若row是负数，则移动到倒数第row行。若移动后的记录指针指向一条有效记录，则该方法返回true
3.void beforeFirst()：将ResultSet的记录指针定位到首行之前，这是ResultSet结果集记录指针的初始状态——记录指针的起始位置位于第一行之前
4.boolean first()：将ResultSet的记录指针定位到首行。若移动后的记录指针指向一条有效记录，则该方法返回true。
5.boolean previous()：将ResultSet的记录指针定位到上一行。若移动后的记录指针指向一条有效记录，则该方法返回true。
6.boolean next()：将ResultSet的记录指针定位到下一行，若移动后的记录指针指向一条有效记录，则该方法返回true。
7.boolean last()：将ResultSet的记录指针定位到最后一行，若移动后的记录指针指向一条有效记录，则该方法返回true。
8.void afterLast()：将ResultSet的记录指针定位到最后一行之后。
JDBC编程步骤：
1.加载数据库驱动：
通常使用Class类的forName()静态方法来加载驱动：
Class.forName(driverClass);//driverClass就是数据库驱动类所对应的字符串。如：加载MySQL的驱动代码
Class.forName("com.mysql.jdbc.Driver");
2.通过DriverManager获取数据库连接：
//获取数据库连接
DriverManager.getConnection(String url, String user, String pass);//数据库URL、登录数据库的用户名和密码。
数据库URL通常遵循如下写法：
jdbc:subprotocol:other stuff
jdbc是固定的写法，subprotocol指定连接到特定数据库的驱动，other stuff也不是固定的（由数据库定）
MySQL数据库的URL写法如下：
jdbc:mysql://hostname:port/databasename
3.通过Connection对象创建Statement对象。有如下三个方法：
1.createStatement()：创建基本的Statement对象
2.prepareStatement(String sql)：根据传入的SQL语句创建预编译的Statement对象
3.prepateCall(String sql)：根据传入的SQL语句创建CllableStatement对象
4.使用Statement执行SQL语句。有如下三个方法：
1.execute()：可执行任何SQL语句，但比较麻烦
2.executeUpdate()：主要用于执行DML和DDL语句。执行DML语句返回受SQL语句影响的行数，执行DDL语句返回0
3.executeQuery()：只能执行查询语句，执行后返回代表查询结果的ResultSet对象
5.操作结果集：
若执行SQL语句是查询语句，则执行结果将返回一个ResultSet对象，该对象里保存了SQL语句查询的结果。程序可通过操作该ResultSet对象来取出查询结果：
1.next()、previous()、first()、last()、beforeFirst()、afterLast()、absolute()等移动记录指针的方法
2.getXxx()方法获取记录指针指向行、特定列的值。该方法既可使用列索引作为参数，也可使用列名作为参数。使用列索引作为参数性能更好，使用列名作为参数可
读性更好
6.回收数据库资源：
包括关闭ResultSet、Statement和Connection等资源。
下面程序简单示范了JDBC编程，并通过ResultSet获得结果集的过程：
drop database if exists select_test;
create database select_test;
use select_test;
# 为了保证从表参照的主表存在，通常应该先建主表。
create table teacher_table
(
# auto_increment:实际上代表所有数据库的自动编号策略，通常用作数据表的逻辑主键。
teacher_id int auto_increment,
teacher_name varchar(255),
primary key(teacher_id)
);
create table student_table
(
# 为本表建立主键约束
student_id int auto_increment primary key,
student_name varchar(255),
# 指定java_teacher参照到teacher_table的teacher_id列
java_teacher int,
foreign key(java_teacher) references teacher_table(teacher_id)
);
insert into teacher_table
values
(null , 'Yeeku');
insert into teacher_table
values
(null , 'Leegang');
insert into teacher_table
values
(null , 'Martine');
insert into student_table
values
(null , '张三' , 1);
insert into student_table
values
(null , '张三' , 1);
insert into student_table
values
(null , '李四' , 1);
insert into student_table
values
(null , '王五' , 2);
insert into student_table
values
(null , '_王五' , 2); insert into student_table
values
(null , null , 2);
insert into student_table
values
(null , '赵六' , null);
数据库建表语句
将驱动（mysql-connector-java-5.1.30-bin.jar）放到java目录的下的jre/lib/ext/目录下面。或者将驱动的路径添加到classpath环境变量后面。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet; public class ConnMySql{
public static void main(String[] args) throws Exception{
//1.加载驱动，使用反射知识，现在记住这么写
Class.forName("com.mysql.jdbc.Driver");
try(
//2.使用DriverManager获取数据库连接
//其中返回的Connection就代表了Java程序和数据库的连接
//不同数据库的URL写法需要查询驱动文档，用户名、密码由DBA分配
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/select_test", "root", "123456");
//3.使用Connection来创建一个Statement对象
Statement stmt = conn.createStatement();
//4.执行SQL语句
/*
Statement有三种执行SQL语句的方法：
1.execute()可执行任何SQL语句-返回一个boolean值，若执行后第一个结果是ResultSet，则返回true，否则返回false
2.executeQuery()执行select语句-返回查询到的结果集
3.executeUpdate()用于执行DML语句-返回一个整数，代表被SQL语句影响的记录条数
*/
ResultSet rs = stmt.executeQuery("select s.*, teacher_name"
+ " from student_table s , teacher_table t"
+ " where t.teacher_id = s.java_teacher")){
//ResultSet有一系列的getXxx(列索引 | 列名)方法，用于获取记录指针
//指向行、特定列的值，不断地使用next()将记录指针下移一行
//若移动之后记录指针依然指向有效行，则next()方法返回true
while(rs.next()){
System.out.println(rs.getInt(1) + "\t"
+ rs.getString(2) + "\t"
+ rs.getString(3) + "\t"
+ rs.getString(4));
}
}
}
}
执行SQL语句的方式：
使用Java8新增的executeLargeUpdate()方法执行DDL和DML语句：
使用statement执行DDL和DML语句的步骤与执行普通查询语句的步骤基本相似，区别在于执行了DDL语句后返回值为0，执行了DML语句后返回值为受到影响的记录条数。
MySQL暂不支持executeLargeUpdate()方法。所以我们使用executeUpdate()方法。
下面的程序并没有直接把数据库连接信息写在代码中，而是使用一个mysql.ini文件（就是properties文件）来保存数据库连接信息，这是比较成熟的做法——当需要把应用程
序从开发环境移植到生产环境时，无需修改源代码，只需要修改mysql.ini配置文件即可：
mysql.ini文件内容：
mysql.ini和ExecuteDDL.java文件所放位置：
import java.io.FileInputStream;
import java.util.Properties;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement; public class ExecuteDDL{
private String driver;
private String url;
private String user;
private String pass;
public void initParam(String paramFile) throws Exception{
//使用Properties类来加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
} public void createTable(String sql) throws Exception{
//加载驱动
Class.forName(driver);
try(
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, pass);
//使用Connection来创建一个Statement对象
Statement stmt = conn.createStatement()){
//执行DDL语句，创建数据表
stmt.executeUpdate(sql);
}
} public static void main(String[] args) throws Exception{
ExecuteDDL ed = new ExecuteDDL();
ed.initParam("mysql.ini");
ed.createTable("create table jdbc_test "
+ "( jdbc_id int auto_increment primary key, "
+ "jdbc_name varchar(255), "
+ "jdbc_desc text);");
System.out.println("------建表成功------");
}
}
使用executeUpdate()方法执行DML语句：
和上面程序的步骤是一样的，只不过程序代码需要修改：
import java.io.FileInputStream;
import java.util.Properties;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement; public class ExecuteDML{
private String driver;
private String url;
private String user;
private String pass; public void initParam(String paramFile) throws Exception{
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
} public int insertData(String sql) throws Exception{
//加载驱动
Class.forName(driver);
try(
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, pass);
//使用Connection来创建一个Statement对象
Statement stmt = conn.createStatement()){
//执行SQL语句，返回受影响的记录条数
return stmt.executeUpdate(sql);
}
} public static void main(String[] args) throws Exception{
ExecuteDML ed = new ExecuteDML();
ed.initParam("mysql.ini");
int result = ed.insertData("insert into jdbc_test(jdbc_name,jdbc_desc)"
+ "select s.student_name , t.teacher_name "
+ "from student_table s , teacher_table t "
+ "where s.java_teacher = t.teacher_id;");
System.out.println("------系统中一共有" + result + "条记录受影响------");
}
}
使用execute()方法执行SQL语句：
Statement的execute()方法几乎可以执行任何SQL语句，但它执行SQL语句比较麻烦，通常没有必要使用execute()方法来执行SQL语句。
使用execute()方法执行SQL语句的返回值只是boolean值，它表明执行该SQL语句是否返回了ResultSet对象，Statement提供了如下两个方法来获取执行结果：
1.getResultSet()：获取该Statement执行查询语句所返回的ResultSet对象
2.getUpdateCount()：获取该Statement执行DML语句所影响的记录行数。
下面程序示范了使用Statement的execute()方法来执行任意的SQL语句：
import java.util.Properties;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData; public class ExecuteSQL{
private String driver;
private String url;
private String user;
private String pass; public void initParam(String paramFile) throws Exception{
//使用Properties类来加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
} public void executeSql(String sql) throws Exception{
//加载数据库驱动
Class.forName(driver);
try(
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, pass);
//通过Connection创建一个Statement
Statement stmt = conn.createStatement()){
//执行SQL语句，返回boolean值表示是否包含ResultSet
boolean hasResultSet = stmt.execute(sql);
//若执行后有ResultSet结果集
if(hasResultSet){
try(
//获取结果集
ResultSet rs = stmt.getResultSet()){
//ResultSetMetaData是用于分析结果集的元数据接口
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount();
//迭代输出ResultSet对象
while(rs.next()){
//依次输出每列的值
for(int i = 0; i < columnCount; i++){
System.out.print(rs.getString(i + 1) + "\t");
}
System.out.print("\n");
}
}
}else{
System.out.println("该SQL语句影响的记录有" + stmt.getUpdateCount() + "条");
}
}
} public static void main(String[] args) throws Exception{
ExecuteSQL es = new ExecuteSQL();
es.initParam("mysql.ini");
System.out.println("------执行删除表的DDL语句------");
es.executeSql("drop table if exists my_test");
System.out.print("------执行建表的DDL语句------");
es.executeSql("create table my_test"
+ "(test_id int auto_increment primary key, "
+ "test_name varchar(255))");
System.out.println("------执行插入数据的DML语句------");
es.executeSql("insert into my_test(test_name) "
+ "select student_name from student_table");
System.out.println("------执行查询数据的查询语句------");
es.executeSql("select * from my_test");
}
}
从结果看，执行DDL语句显示受影响记录条数；执行DML显示插入、修改、删除的记录条数；执行查询语句可以输出查询结果。
上面程序获得的SQL执行结果是没有根据各列的数据类型调用相应的getXxx()方法，而是直接使用getString()方法来取得值，这是可以的。
ResultSet的getString()方法几乎可以获取除了Blob之外的任意类型列的值，因为所有的数据类型都可以自动转换成字符串类型。
使用PreparedStatement执行SQL语句：
若经常要反复执行一条结构相似的SQL语句，如下两条：
insert into student_table values(null, '张三', 1);
insert into student_table values(null, '李四', 2);
对于这两条语句，它们结构相似，只是执行插入时插入的值不同而已。对于这种情况，可以使用占位符（？）参数的SQL语句来代替它：
insert into student_table values(null, ?, ?);
JDBC提供了PreparedStatement接口，它是Statement的子接口。它可以进行预编译SQL语句，预编译后的SQL语句被存储在PreparedStatement对象中，然后可以使用该
对象多次高效地执行该语句。使用PreparedStatement比使用Statement的效率要高。
创建PreparedStatement对象使用Connection的prepareStatement()方法，该方法需要传入一个SQL字符串，该SQL字符串可以包括占位符参数，如下：
//创建一个PreparedStatement对象
pstmt = conn.prepareStatement("insert into student_table values(null,?,1)");
PreparedStatement也提供了execute()、executeUpdate()、executeQuery()三个方法来执行SQL语句，不过这三个方法无需参数，因为PreparedStatement已经存储了预
编译的SQL语句。
使用PreparedStatement预编译SQL语句时，该SQL语句可以带占位符参数，因此在执行SQL语句之前必须为这些参数传入参数值，PreparedStatement提供了一系列
的setXxx(int index, Xxx value)方法来传入参数值。
下面程序示范了使用Statement和PreparedStatement分别插入100条记录的对比。：
import java.io.FileInputStream;
import java.util.Properties;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.Statement; public class PreparedStatementTest{
private String driver;
private String url;
private String user;
private String pass; public void initParam(String paramFile) throws Exception{
//使用Properties类加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
//加载驱动
Class.forName(driver);
} public void insertUseStatement() throws Exception{
long start = System.currentTimeMillis();
try(
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, pass);
//使用Connection来创建一个Statement对象
Statement stmt = conn.createStatement())
{
//需要使用100条SQL语句来插入100条记录
for(int i = 0; i < 100; i++){
stmt.executeUpdate("insert into student_table values("
+ "null,'姓名" + i + "', 1)");
}
System.out.println("使用Statement费时："
+ (System.currentTimeMillis() - start));
}
} public void insertUsePrepare() throws Exception{
long start = System.currentTimeMillis();
try(
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, pass);
//使用Connection来创建一个PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement("insert into student_table values(null,?,1)"))
{
//100次为PreparedStatement的参数设值，就可以插入100条记录
for(int i = 0; i < 100; i++){
pstmt.setString(1, "姓名" + i);
pstmt.executeUpdate();
}
System.out.println("使用PreparedStatement费时：" + (System.currentTimeMillis() - start));
}
} public static void main(String[] args) throws Exception{
PreparedStatementTest pt = new PreparedStatementTest();
pt.initParam("mysql.ini");
pt.insertUseStatement();
pt.insertUsePrepare();
}
}
从上面的结果看，PreparedStatement耗时少于Statement。
使用PreparedStatement还有一个很好的作用——用于防止SQL注入。
下面以一个简单的登录窗口为例来介绍这种SQL注入的结果：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import java.util.Properties;
import java.io.FileInputStream;
import java.awt.*;
import javax.swing.*; public class LoginFrame{
private final String PROP_FILE = "mysql.ini";
private String driver;
//url是数据库的服务地址
private String url;
private String user;
private String pass;
//登录界面的GUI组件
private JFrame jf = new JFrame("登录");
private JTextField userField = new JTextField(20);
private JTextField passField = new JTextField(20);
private JButton loginButton = new JButton("登录"); public void init() throws Exception{
Properties connProp = new Properties();
connProp.load(new FileInputStream(PROP_FILE));
driver = connProp.getProperty("driver");
url = connProp.getProperty("url");
user = connProp.getProperty("user");
pass = connProp.getProperty("pass");
//加载驱动
Class.forName(driver);
//为登录按钮添加事件监听器
loginButton.addActionListener(e -> {
//登录成功则显示“登录成功”
if(validate(userField.getText(), passField.getText())){
JOptionPane.showMessageDialog(jf, "登录成功");
}else{
//否则显示“登录失败”
JOptionPane.showMessageDialog(jf, "登录失败");
}
});
jf.add(userField, BorderLayout.NORTH);
jf.add(passField);
jf.add(loginButton, BorderLayout.SOUTH);
jf.pack();
jf.setVisible(true);
} private boolean validate(String userName, String userPass){
//执行查询的SQL语句
String sql = "select * from jdbc_test "
+ "where jdbc_name='" + userName
+ "' and jdbc_desc='" + userPass + "';";
System.out.println(sql);
try(
Connection conn = DriverManager.getConnection(url, user, pass);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql))
{
//若查询的ResultSet里有超过一条的记录，则登录成功
if(rs.next()){
return true;
}
}catch(Exception e){
e.printStackTrace();
} return false;
} public static void main(String[] args) throws Exception{
new LoginFrame().init();
}
}
登录界面：
登录成功界面：
去数据库中查询是否存在用户和密码，执行的SQL语句。从上面的结果可以看出，我们在登录用户名中输入‘ or true or ’时，竟然也登录成功了。原因就出在执行的SQL语句上。
只要密码和用户为空，但是where后的条件永远为真，这就告诉软件，数据库中存在该用户，可以登录。
把上面的validate()方法换成使用PreparedStatement来执行验证，而不是直接使用Statement：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;
import java.io.FileInputStream;
import java.awt.*;
import javax.swing.*; public class LoginFrame{
private final String PROP_FILE = "mysql.ini";
private String driver;
//url是数据库的服务地址
private String url;
private String user;
private String pass;
//登录界面的GUI组件
private JFrame jf = new JFrame("登录");
private JTextField userField = new JTextField(20);
private JTextField passField = new JTextField(20);
private JButton loginButton = new JButton("登录"); public void init() throws Exception{
Properties connProp = new Properties();
connProp.load(new FileInputStream(PROP_FILE));
driver = connProp.getProperty("driver");
url = connProp.getProperty("url");
user = connProp.getProperty("user");
pass = connProp.getProperty("pass");
//加载驱动
Class.forName(driver);
//为登录按钮添加事件监听器
loginButton.addActionListener(e -> {
//登录成功则显示“登录成功”
if(validate(userField.getText(), passField.getText())){
JOptionPane.showMessageDialog(jf, "登录成功");
}else{
//否则显示“登录失败”
JOptionPane.showMessageDialog(jf, "登录失败");
}
});
jf.add(userField, BorderLayout.NORTH);
jf.add(passField);
jf.add(loginButton, BorderLayout.SOUTH);
jf.pack();
jf.setVisible(true);
} private boolean validate(String userName, String userPass){
//执行查询的SQL语句
String sql = "select * from jdbc_test "
+ "where jdbc_name='" + userName
+ "' and jdbc_desc='" + userPass + "';";
System.out.println(sql);
try(
Connection conn = DriverManager.getConnection(url, user, pass);
PreparedStatement pstmt = conn.prepareStatement("select * from jdbc_test where jdbc_name=? and jdbc_desc=?;"))
{
pstmt.setString(1, userName);
pstmt.setString(2, userPass);
try(
ResultSet rs = pstmt.executeQuery())
{
//若查询的ResultSet里有超过一条的记录，则登录成功
if(rs.next()){
return true;
}
}
}catch(Exception e){
e.printStackTrace();
} return false;
} public static void main(String[] args) throws Exception{
new LoginFrame().init();
}
}
登录界面：
登录失败界面：
从结果中可以看到，把用户中的' or true or '添加到了jdbc_name的后面，避免的SQL注入。
使用PreparedStatement比使用Statement多了如下三个好处：
1.PreparedStatement预编译SQL语句，性能更好
2.PreparedStatement无需“拼接”SQL语句，编程更简单
3.PreparedStatement可以防止SQL注入，安全性更好
基于上面三点，通常推荐避免使用Statement来执行SQL语句，改为使用PreparedStatement执行SQL语句。
使用PreparedStatement执行带占位符参数的SQL语句时，SQL语句中的占位符参数只能代替普通值，不能代替表名、列名等数据库对象，也不能代替的insert、select等关键字
使用CallableStatement调用存储过程：
进入一个数据库中，执行上面的命令。delimiter //将MySQL的语句结束符改为双斜线（\\），这样就可以在创建存储过程中使用分号作为分隔符（MySQL默认使用分号作为语
句结束符）。记得执行完上面命令再将结束符改为分号。上面命令创建了名为add_pro的存储过程，该存储过程包含三个参数：a b是传入参数，sum使用out修饰，是传出
参数
调用存储过程使用CallableStatement，可通过Connection的prepareCall()方法来创建CallableStatement对象，创建该对象时需要传入调用存储过程的SQL语句。
调用存储过程的SQL语句格式：{call 过程名(?, ?, ..., ?)}若下所示：
//使用Connection来创建一个CallableStatement对象
cstmt = conn.prepareCall("{call add_pro(?, ?, ?)"});
存储过程有传入参数，也有传出参数。Java程序必须为这些参数传入值，可通过CallableStatement的setXxx()方法为传入参数设置值；传出参数就是Java程序可以通过该参数
获取存储过程里的值，CallableStatement需要调用registerOutParameter()方法来注册该参数。如下所示：
//注册CallableStatement的第三个参数是int类型
cstmt.registerOutParameter(3, Types.INTEGER);
经过上面步骤，就可以调用CallableStatement的execute()方法来执行存储过程了，执行结束后通过CallableStatement对象的getXxx(int index)方法来获取指定传出参数的值。
import java.util.Properties;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.CallableStatement;
import java.sql.Types; public class CallableStatementTest{
private String driver;
private String url;
private String user;
private String pass; public void initParam(String paramFile) throws Exception{
//使用Properties类来加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
} public void callProcedure()throws Exception{
//加载驱动
Class.forName(driver);
try(
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, pass);
//使用Connection来创建一个CallableStatement对象
CallableStatement cstmt = conn.prepareCall("{call add_pro(?,?,?)}")
){
cstmt.setInt(1, 4);
cstmt.setInt(2, 5);
//注册CallableStatement的第三个参数时int类型
cstmt.registerOutParameter(3, Types.INTEGER);
//执行存储过程
cstmt.execute();
//获取并输出存储过程传出的参数的值
System.out.println("执行结果是：" + cstmt.getInt(3));
}
} public static void main(String[] args) throws Exception{
CallableStatementTest ct = new CallableStatementTest();
ct.initParam("mysql.ini");
ct.callProcedure();
}
}
管理结果集：
JDBC使用ResultSet来封装执行查询得到的查询结果，后通过移动ResultSet的记录指针来取出结果集内容。除此之外，JDBC还允许ResultSet来更新记录，并提供
ResultSetMetaData来获取ResultSet对象的相关信息
可滚动、可更新的结果集：
使用absolute()、previous()、afterLast()等方法自由移动记录指针的ResultSet被称为可滚动的结果集。
以默认方式打开的ResultSet是不可更新的，若希望创建可更新的ResultSet，则必须在创建Statement或PreparedStatement时传入额外的参数。
Connection在创建Statement或PreparedStatement时可额外传入如下两个参数：
1.resultSetType：控制ResultSet的类型，该参数可以取如下三个值：
1.ResultSet.TYPE_FORWARD_ONLY：该常量控制记录指针只能向前移动。
2.ResultSet.TYPE_SCROLL_INSENSITIVE：该常量控制记录指针可以自由移动（可滚动结果集），但底层数据的改变不会影响ResultSet的内容
3.ResultSet.TYPE_SCROLL_SENSITIVE：该常量控制记录指针可自由移动（可滚动结果集），而且底层数据的改变会影响ResultSet的内容
TYPE_SCROLL_INSENSITIVE、TYPE_SCROLL_SENSITIVE两个常量的作用需要底层数据库驱动的支持，对于有些数据库驱动来说，这两个并没有太大的区别
2.resultSetConcurrency：控制ResultSet并发类型，该参数可以接收如下两个值：
1.ResultSet.CONCUR_READ_ONLY：该常量指示ResultSet是只读的并发模式（默认）。
2.ResultSet.CONCUR_UPDATABLE：该常量指示ResultSet是可更新的并发模式。
下面代码通过这两个参数创建了一个PreparedStatement对象，由该对象生成的ResultSet对象将是可滚动、可更新的结果集：
//使用Connection创建一个PreparedStatement对象
//传入控制结果集可滚动、可更新的参数：
pstmt = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
需要指出的是，可更新的结果集还需要满足如下两个条件：
1.所有数据都应该来自一个表
2.选出的数据集必须包含主键列
可调用ResultSet的updateXxx(intcolumnIndex, Xxx value)方法来修改记录指针所指记录、特定列的值，最后调用ResultSet的updateRow()方法来提交修改。
下面程序示范了这种创建可滚动、可更新的结果集的方法：
import java.util.Properties;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet; public class ResultSetTest{
private String driver;
private String url;
private String user;
private String pass;
public void initParam(String paramFile) throws Exception{
//使用Properties类加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
} public void query(String sql) throws Exception{
//加载驱动
Class.forName(driver);
try(
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, pass);
//使用Connection来创建一个PreparedStatement对象
//传入控制结果集可滚动、可更新的参数
PreparedStatement pstmt = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = pstmt.executeQuery()
){
rs.last();
int rowCount = rs.getRow();
for(int i = rowCount; i > 0; i--){
rs.absolute(i);
System.out.println(rs.getString(1) + "\t"
+ rs.getString(2) + "\t" + rs.getString(3));
//修改记录指针所指记录、第2列的值
rs.updateString(2, "学生名" + i);
//提交修改
rs.updateRow();
}
}
} public static void main(String[] args) throws Exception{
ResultSetTest rt = new ResultSetTest();
rt.initParam("mysql.ini");
rt.query("select * from student_table");
}
}
student_table表中记录被倒序输出，且当程序运行结束后，student_table表中所有记录的student_name列的值都被修改。
若要创建可更新的结果集，则使用查询语句查询的数据通常只能来自于一个数据表，而且查询结果集中的数据列必须包含主键列，否则会引起更新失败。
处理Blob类型数据：
Blob（Binary Long Object）：是二进制长对象，Blob列常用于存储大文件，典型的Blob内容是一张图片或一个声音文件，由于它们的特殊性，必须使用特殊的方式来存储
使用Blob列可以把图片、声音等文件的二进制数据保存在数据库中，并可以从数据库中恢复指定文件。
若需要将图片插入数据库，显然不能直接通过普通的SQL语句来完成，因为有一个关键问题——Blob常量无法表示。所以将Blob数据插入数据库需要使用
PreparedStatement，该对象有一个方法：setBinaryStream(int parameterIndex, InputStream x),该方法可以为指定参数传入二进制输入流，从而可以实现将Blob数据保存
到数据库的功能。
需要从ResultSet里取出Blob数据时，可以调用ResultSet的getBlob(int columnIndex)方法，该方法将返回一个Blob对象，Blob对象提供了getBinaryStream()方法来获取该
Blob数据的输入流，也可以使用Blob对象提供的getBytes()方法直接取出该Blob对象封装的二进制数据。
为了把图片放入数据库，使用如下SQL语句建立一个数据表：
img_data mediumblob;创建一个mediumblob类型的数据列，用于保存图片数据
mediumblob类型可存储16M内容，blob类型可存储64KB内容。
下面程序可以实现图片“上传”——实际上就是将图片保存到数据库，并在右边的列表框中显示图片的名字，当用户双击列表框中的图片名时，左边窗口将显示该图片——实质就是根据选中的ID从数据库里查找图片，并将其显示出来：
import java.sql.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Properties;
import java.util.ArrayList;
import java.io.*;
import javax.swing.filechooser.FileFilter; public class BlobTest
{
JFrame jf = new JFrame("图片管理程序");
private static Connection conn;
private static PreparedStatement insert;
private static PreparedStatement query;
private static PreparedStatement queryAll;
// 定义一个DefaultListModel对象
private DefaultListModel<ImageHolder> imageModel
= new DefaultListModel<>();
private JList<ImageHolder> imageList = new JList<>(imageModel);
private JTextField filePath = new JTextField(26);
private JButton browserBn = new JButton("...");
private JButton uploadBn = new JButton("上传");
private JLabel imageLabel = new JLabel();
// 以当前路径创建文件选择器
JFileChooser chooser = new JFileChooser(".");
// 创建文件过滤器
ExtensionFileFilter filter = new ExtensionFileFilter();
static
{
try
{
Properties props = new Properties();
props.load(new FileInputStream("mysql.ini"));
String driver = props.getProperty("driver");
String url = props.getProperty("url");
String user = props.getProperty("user");
String pass = props.getProperty("pass");
Class.forName(driver);
// 获取数据库连接
conn = DriverManager.getConnection(url , user , pass);
// 创建执行插入的PreparedStatement对象，
// 该对象执行插入后可以返回自动生成的主键
insert = conn.prepareStatement("insert into img_table"
+ " values(null,?,?)" , Statement.RETURN_GENERATED_KEYS);
// 创建两个PreparedStatement对象，用于查询指定图片，查询所有图片
query = conn.prepareStatement("select img_data from img_table"
+ " where img_id=?");
queryAll = conn.prepareStatement("select img_id, "
+ " img_name from img_table");
}
catch (Exception e)
{
e.printStackTrace();
}
}
public void init()throws SQLException
{
// -------初始化文件选择器--------
filter.addExtension("jpg");
filter.addExtension("jpeg");
filter.addExtension("gif");
filter.addExtension("png");
filter.setDescription("图片文件(*.jpg,*.jpeg,*.gif,*.png)");
chooser.addChoosableFileFilter(filter);
// 禁止“文件类型”下拉列表中显示“所有文件”选项。
chooser.setAcceptAllFileFilterUsed(false);
// ---------初始化程序界面---------
fillListModel();
filePath.setEditable(false);
// 只能单选
imageList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
JPanel jp = new JPanel();
jp.add(filePath);
jp.add(browserBn);
browserBn.addActionListener(event -> {
// 显示文件对话框
int result = chooser.showDialog(jf , "浏览图片文件上传");
// 如果用户选择了APPROVE（赞同）按钮，即打开，保存等效按钮
if(result == JFileChooser.APPROVE_OPTION)
{
filePath.setText(chooser.getSelectedFile().getPath());
}
});
jp.add(uploadBn);
uploadBn.addActionListener(avt -> {
// 如果上传文件的文本框有内容
if (filePath.getText().trim().length() > 0)
{
// 将指定文件保存到数据库
upload(filePath.getText());
// 清空文本框内容
filePath.setText("");
}
});
JPanel left = new JPanel();
left.setLayout(new BorderLayout());
left.add(new JScrollPane(imageLabel) , BorderLayout.CENTER);
left.add(jp , BorderLayout.SOUTH);
jf.add(left);
imageList.setFixedCellWidth(160);
jf.add(new JScrollPane(imageList) , BorderLayout.EAST);
imageList.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
// 如果鼠标双击
if (e.getClickCount() >= 2)
{
// 取出选中的List项
ImageHolder cur = (ImageHolder)imageList.
getSelectedValue();
try
{
// 显示选中项对应的Image
showImage(cur.getId());
}
catch (SQLException sqle)
{
sqle.printStackTrace();
}
}
}
});
jf.setSize(620, 400);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
}
// ----------查找img_table填充ListModel----------
public void fillListModel()throws SQLException
{ try(
// 执行查询
ResultSet rs = queryAll.executeQuery())
{
// 先清除所有元素
imageModel.clear();
// 把查询的全部记录添加到ListModel中
while (rs.next())
{
imageModel.addElement(new ImageHolder(rs.getInt(1)
,rs.getString(2)));
}
}
}
// ---------将指定图片放入数据库---------
public void upload(String fileName)
{
// 截取文件名
String imageName = fileName.substring(fileName.lastIndexOf('\\')
+ 1 , fileName.lastIndexOf('.'));
File f = new File(fileName);
try(
InputStream is = new FileInputStream(f))
{
// 设置图片名参数
insert.setString(1, imageName);
// 设置二进制流参数
insert.setBinaryStream(2, is , (int)f.length());
int affect = insert.executeUpdate();
if (affect == 1)
{
// 重新更新ListModel，将会让JList显示最新的图片列表
fillListModel();
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
// ---------根据图片ID来显示图片----------
public void showImage(int id)throws SQLException
{
// 设置参数
query.setInt(1, id);
try(
// 执行查询
ResultSet rs = query.executeQuery())
{
if (rs.next())
{
// 取出Blob列
Blob imgBlob = rs.getBlob(1);
// 取出Blob列里的数据
ImageIcon icon=new ImageIcon(imgBlob.getBytes(1L
,(int)imgBlob.length()));
imageLabel.setIcon(icon);
}
}
}
public static void main(String[] args)throws SQLException
{
new BlobTest().init();
}
}
// 创建FileFilter的子类，用以实现文件过滤功能
class ExtensionFileFilter extends FileFilter
{
private String description = "";
private ArrayList<String> extensions = new ArrayList<>();
// 自定义方法，用于添加文件扩展名
public void addExtension(String extension)
{
if (!extension.startsWith("."))
{
extension = "." + extension;
extensions.add(extension.toLowerCase());
}
}
// 用于设置该文件过滤器的描述文本
public void setDescription(String aDescription)
{
description = aDescription;
}
// 继承FileFilter类必须实现的抽象方法，返回该文件过滤器的描述文本
public String getDescription()
{
return description;
}
// 继承FileFilter类必须实现的抽象方法，判断该文件过滤器是否接受该文件
public boolean accept(File f)
{
// 如果该文件是路径，接受该文件
if (f.isDirectory()) return true;
// 将文件名转为小写（全部转为小写后比较，用于忽略文件名大小写）
String name = f.getName().toLowerCase();
// 遍历所有可接受的扩展名，如果扩展名相同，该文件就可接受。
for (String extension : extensions)
{
if (name.endsWith(extension))
{
return true;
}
}
return false;
}
}
// 创建一个ImageHolder类，用于封装图片名、图片ID
class ImageHolder
{
// 封装图片的ID
private int id;
// 封装图片的图片名字
private String name;
public ImageHolder(){}
public ImageHolder(int id , String name)
{
this.id = id;
this.name = name;
}
// id的setter和getter方法
public void setId(int id)
{
this.id = id;
}
public int getId()
{
return this.id;
}
// name的setter和getter方法
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return this.name;
}
// 重写toString方法，返回图片名
public String toString()
{
return name;
}
}
使用ResultSetMetaData分析结果集：
当执行SQL查询后可以通过移动记录指针来遍历ResultSet的每条记录，但程序可能不清楚该ResultSet里包含哪些数据列，以及每个数据列的数据类型，那么可以通
过ResultSetMetaData来获取关于ResultSet的描述信息：
MetaData的意思是元数据，即描述其他数据的数据，因此ResultSetMetaData封装了描述ResultSet对象的数据；后面还要介绍的DatabaseMetaData则封装了描述
Database的数据。
ResultSet中包含了一个getMetaData()方法，该方法可以返回该ResultSet对应的ResultSetMetaData对象。一旦获得了ResultSetMetaData对象就可以通过
ResultSetMetaData提供的大量方法来返回ResultSet的描述信息。常用方法有如下三个：
1.int getColumnCount()：返回该ResultSet的列数量
2.String getColumnName(int Column)：返回指定索引的列名
3.int getColumnType(int column)：返回指定索引的列类型
下面是一个简单的查询器，当用户在文本框内输入合法的查询语句并执行成功后，下面表格将会显示查询结果：
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.util.*;
import java.io.*;
import java.sql.*; public class QueryExecutor
{
JFrame jf = new JFrame("查询执行器");
private JScrollPane scrollPane;
private JButton execBn = new JButton("查询");
// 用于输入查询语句的文本框
private JTextField sqlField = new JTextField(45);
private static Connection conn;
private static Statement stmt;
// 采用静态初始化块来初始化Connection、Statement对象
static
{
try
{
Properties props = new Properties();
props.load(new FileInputStream("mysql.ini"));
String drivers = props.getProperty("driver");
String url = props.getProperty("url");
String username = props.getProperty("user");
String password = props.getProperty("pass");
// 加载数据库驱动
Class.forName(drivers);
// 取得数据库连接
conn = DriverManager.getConnection(url, username, password);
stmt = conn.createStatement();
}
catch (Exception e)
{
e.printStackTrace();
}
}
// --------初始化界面的方法---------
public void init()
{
JPanel top = new JPanel();
top.add(new JLabel("输入查询语句："));
top.add(sqlField);
top.add(execBn);
// 为执行按钮、单行文本框添加事件监听器
execBn.addActionListener(new ExceListener());
sqlField.addActionListener(new ExceListener());
jf.add(top , BorderLayout.NORTH);
jf.setSize(680, 480);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
}
// 定义监听器
class ExceListener implements ActionListener
{
public void actionPerformed(ActionEvent evt)
{
// 删除原来的JTable(JTable使用scrollPane来包装)
if (scrollPane != null)
{
jf.remove(scrollPane);
}
try(
// 根据用户输入的SQL执行查询
ResultSet rs = stmt.executeQuery(sqlField.getText()))
{
// 取出ResultSet的MetaData
ResultSetMetaData rsmd = rs.getMetaData();
Vector<String> columnNames = new Vector<>();
Vector<Vector<String>> data = new Vector<>();
// 把ResultSet的所有列名添加到Vector里
for (int i = 0 ; i < rsmd.getColumnCount(); i++ )
{
columnNames.add(rsmd.getColumnName(i + 1));
}
// 把ResultSet的所有记录添加到Vector里
while (rs.next())
{
Vector<String> v = new Vector<>();
for (int i = 0 ; i < rsmd.getColumnCount(); i++ )
{
v.add(rs.getString(i + 1));
}
data.add(v);
}
// 创建新的JTable
JTable table = new JTable(data , columnNames);
scrollPane = new JScrollPane(table);
// 添加新的Table
jf.add(scrollPane);
// 更新主窗口
jf.validate();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
new QueryExecutor().init();
}
}
虽然ResultSetMetaData可以准确的分析出ResultSet里包含多少列，以及每列的列名、数据类型等，但使用ResultSetMetaData需要一定的系统开销，因此若在编程过程中
已经知道ResultSet里包含多少列，以及每列的列名、类型等信息，就没有必要使用ResultSetMetaData来分析该ResultSet对象了。
Java7的RowSet1.1：
RowSet接口继承了ResultSet接口，RowSet接口下包含JdbcRowSet、CachedRowSet、FilteredRowSet、JoinRowSet和WebRowSet常用子接口。除了JdbcRowSet需要保
持与数据库连接之外，其余4个子接口都是离线的RowSet，无需保持与数据库的连接。
与ResultSet相比，RowSet默认是可滚动、可更新、可序列化的结果集，而且作为JavaBean使用，因此能方便地在网络上传输，用于同步两端的数据。对于离线RowSet而
言，程序在创建RowSet时已经把数据从底层数据库读取到内存，因此可以充分利用计算机内存，从而降低数据库服务器的负载，提高程序性能。
Java7新增的RowSetFactory与RowSet：
Java7新增了RowSetProvider类和RowSetFactory接口，其中RowSetProvider负责创建RowSetFactory，而RowSetFactory则提供了如下方法来创建RowSet实例：
1.CachedRowSet createCachedRowSet()：创建一个默认的CachedRowSet。
2.FilteredRowSet createFilteredRowSet()：创建一个默认的FilteredRowSet。
3.JdbcRowSet createJdbcRowSet()：创建一个默认的JdbcRowSet。
4.JoinRowSet createJoinRowSet()：创建一个默认的JoinRowSet。
5.WebRowSet createWebRowSet()：创建一个默认的WebRowSet。
通过使用RowSetFactory，就可以把应用程序与RowSet实现类分离开，有利于后期的升级、扩展。
下面使用RowSetFactory来创建JdbcRowSet实例：
import java.util.*;
import java.io.*;
import java.sql.*;
import javax.sql.rowset.*; public class RowSetFactoryTest
{
private String driver;
private String url;
private String user;
private String pass;
public void initParam(String paramFile)throws Exception
{
// 使用Properties类来加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
} public void update(String sql)throws Exception
{
// 加载驱动
Class.forName(driver);
// 使用RowSetProvider创建RowSetFactory
RowSetFactory factory = RowSetProvider.newFactory();
try(
// 使用RowSetFactory创建默认的JdbcRowSet实例
JdbcRowSet jdbcRs = factory.createJdbcRowSet())
{
// 设置必要的连接信息
jdbcRs.setUrl(url);
jdbcRs.setUsername(user);
jdbcRs.setPassword(pass);
// 设置SQL查询语句
jdbcRs.setCommand(sql);
// 执行查询
jdbcRs.execute();
jdbcRs.afterLast();
// 向前滚动结果集
while (jdbcRs.previous())
{
System.out.println(jdbcRs.getString(1)
+ "\t" + jdbcRs.getString(2)
+ "\t" + jdbcRs.getString(3));
if (jdbcRs.getInt("student_id") == 3)
{
// 修改指定记录行
jdbcRs.updateString("student_name", "孙悟空");
jdbcRs.updateRow();
}
}
}
}
public static void main(String[] args)throws Exception
{
RowSetFactoryTest jt = new RowSetFactoryTest();
jt.initParam("mysql.ini");
jt.update("select * from student_table");
}
}
上面程序使用RowSetFactory来创建JdbcRowSet对象。由于通过这种方式创建的JdbcRowSet还没有传入Connection参数，因此程序还需调用setUrl()、setUsername()、setPassword()等方法来设置数据库连接信息。
离线RowSet：
在使用ResultSet的时代，程序查询得到ResultSet之后必须立即读取或处理它对应的记录，否则一旦关闭Connection，再通过ResultSet读取记录就会引发异常。
离线RowSet会直接将底层数据读入内存中，封装成RowSet对象，而RowSet对象则完全可以当成JavaBean来使用，因此不仅安全，且编程十分简单。CachedRowSet是
所有离线RowSet的父接口。
下面以CachedRowSet为例进行介绍：
import java.util.*;
import java.io.*;
import java.sql.*;
import javax.sql.*;
import javax.sql.rowset.*; public class CachedRowSetTest
{
private static String driver;
private static String url;
private static String user;
private static String pass;
public void initParam(String paramFile)throws Exception
{
// 使用Properties类来加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
} public CachedRowSet query(String sql)throws Exception
{
// 加载驱动
Class.forName(driver);
// 获取数据库连接
Connection conn = DriverManager.getConnection(url , user , pass);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
// 使用RowSetProvider创建RowSetFactory
RowSetFactory factory = RowSetProvider.newFactory();
// 创建默认的CachedRowSet实例
CachedRowSet cachedRs = factory.createCachedRowSet();
// 使用ResultSet装填RowSet
cachedRs.populate(rs); // ①
// 关闭资源
rs.close();
stmt.close();
conn.close();
return cachedRs;
}
public static void main(String[] args)throws Exception
{
CachedRowSetTest ct = new CachedRowSetTest();
ct.initParam("mysql.ini");
CachedRowSet rs = ct.query("select * from student_table");
rs.afterLast();
// 向前滚动结果集
while (rs.previous())
{
System.out.println(rs.getString(1)
+ "\t" + rs.getString(2)
+ "\t" + rs.getString(3));
if (rs.getInt("student_id") == 3)
{
// 修改指定记录行
rs.updateString("student_name", "孙悟空");
rs.updateRow();
}
}
// 重新获取数据库连接
Connection conn = DriverManager.getConnection(url
, user , pass);
conn.setAutoCommit(false);
// 把对RowSet所做的修改同步到底层数据库
rs.acceptChanges(conn);
}
}
从上面程序可以看到在Connection关闭的情况下，程序依然可以读取、修改RowSet里的记录。为了将程序对离线RowSet所做的修改同步到底层数据库，程序在调用RowSet的
acceptChanges()方法时，必须传入Connection。
离线RowSet的查询分页：
由于CachedRowSet会将数据记录直接装载到内存中，若SQL查询返回的记录过大，CachedRowSet将会占用大量内存，在某些极端情况下，将会导致内存溢出。
未解决上述问题，CachedRowSet提供了分页功能。即一次只装载ResultSet里的某几条记录，这样就避免了CachedRowSet占用内存过大的问题。
CachedRowSet提供了如下方法控制分页：
1.populate(ResultSet rs, int startRow)：使用给定的ResultSet装填RowSet，从ResultSet的第startRow条记录开始装填
2.setPageSize(int pageSize)：设置CachedRowSet每次返回多少条记录
3.previousPage()：在底层ResultSet可用的情况下，让CachedRowSet读取上一页记录。
4.nextPage()：在底层ResultSet可用的情况下，让CachedRowSet读取下一页记录
下面程序示范了CachedRowSet的分页支持：
import java.util.*;
import java.io.*;
import java.sql.*;
import javax.sql.*;
import javax.sql.rowset.*; public class CachedRowSetPage
{
private String driver;
private String url;
private String user;
private String pass;
public void initParam(String paramFile)throws Exception
{
// 使用Properties类来加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
} public CachedRowSet query(String sql , int pageSize
, int page)throws Exception
{
// 加载驱动
Class.forName(driver);
try(
// 获取数据库连接
Connection conn = DriverManager.getConnection(url , user , pass);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql))
{
// 使用RowSetProvider创建RowSetFactory
RowSetFactory factory = RowSetProvider.newFactory();
// 创建默认的CachedRowSet实例
CachedRowSet cachedRs = factory.createCachedRowSet();
// 设置每页显示pageSize条记录
cachedRs.setPageSize(pageSize);
// 使用ResultSet装填RowSet，设置从第几条记录开始
cachedRs.populate(rs , (page - 1) * pageSize + 1);
return cachedRs;
}
}
public static void main(String[] args)throws Exception
{
CachedRowSetPage cp = new CachedRowSetPage();
cp.initParam("mysql.ini");
CachedRowSet rs = cp.query("select * from student_table" , 3 , 2); // ①
// 向后滚动结果集
while (rs.next())
{
System.out.println(rs.getString(1)
+ "\t" + rs.getString(2)
+ "\t" + rs.getString(3));
}
}
}
程序中要查询第2页的记录，每页显示3条记录。
事务处理：
事物的概念和MySQL事务支持：
事务是由一步或几步数据库操作序列组成的逻辑执行单元，这系列操作要么全部执行，要么全部放弃执行。
事务具备四个特性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持续性（Durability）。简称ACID特性。
JDBC的事务支持：
JDBC连接的事务支持有Connection提供，Connection默认打开自动提交，即关闭事务。这种情况下，每一条SQL语句一旦执行，便会立即提交到数据库，永久生效，无法
对其进行回滚操作。
可调用Connection的setAutoCommit()方法来关闭自动提交，开启事务：
//conn.setAutoCommit(false);
等到所有SQL语句都被执行，程序可以调用Connection的commit()方法来提交事务：
//conn.commit();
若任意一条SQL语句执行失败，则应该用Connection的rollback()方法来回滚事务：
//conn.rollback();
实际上，当Connection遇到一个未处理的SQLException异常时，系统将会非正常退出，事务也会自动回滚。但若程序捕获了该异常，则需要在异常处理块中显式地回滚
事务
import java.sql.*;
import java.io.*;
import java.util.*; public class TransactionTest
{
private String driver;
private String url;
private String user;
private String pass;
public void initParam(String paramFile)throws Exception
{
// 使用Properties类来加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
}
public void insertInTransaction(String[] sqls) throws Exception
{
// 加载驱动
Class.forName(driver);
try(
Connection conn = DriverManager.getConnection(url , user , pass))
{
// 关闭自动提交，开启事务
conn.setAutoCommit(false);
try(
// 使用Connection来创建一个Statment对象
Statement stmt = conn.createStatement())
{
// 循环多次执行SQL语句
for (String sql : sqls)
{
stmt.executeUpdate(sql);
}
}
// 提交事务
conn.commit();
}
}
public static void main(String[] args) throws Exception
{
TransactionTest tt = new TransactionTest();
tt.initParam("mysql.ini");
String[] sqls = new String[]{
"insert into student_table values(null , 'aaa' ,1)",
"insert into student_table values(null , 'bbb' ,1)",
"insert into student_table values(null , 'ccc' ,1)",
// 下面这条SQL语句将会违反外键约束，
// 因为teacher_table中没有ID为5的记录。
"insert into student_table values(null , 'ccc' ,5)" //①
};
tt.insertInTransaction(sqls);
}
}
上面代码报错会因为插入语句第四条有错。正是因为这条语句出错，导致产生异常，且该异常没有得到处理，引起程序非正常结束，所以事务自动回滚，上面3条插入语句无效。
Connection也提供了设置中间点的方法：
1.Savepoint setSavepoint()：在当前事务中创建一个未命名的中间点，并返回代表该中间点的Savepoint对象
2.Savepoint setSavepoint(String name)：在当前事务中创建一个具有指定名称的中间点，并返回代表该中间点的SavepointSavepoint对象。
通常来说设置中间点时，没有必要指定名称，因为Connection回滚到指定中间点时，并不是根据名字回滚的，而是根据中间点对象回滚的，Connection提供了
rollback(Savepoint savepoint)方法回滚到指定中间点。
Java8增强的批量更新：
JDBC还提供了一个批量更新的功能，批量更新时，多条SQL语句将被作为一批操作被同时收集，并同时提交。
批量更新必须得到底层数据库的支持，可以通过调用DatabaseMetaData的supportsBatchUpdates()方法来查看底层数据库是否支持批量更新。
使用批量更新需要先创建一个Statement对象，然后利用该对象的addBatch()方法将多条SQL语句同时收集，最后调用Java8位Statement对象新增的executeLargeBatch()或
原有的executeBatch()方法同时执行这些SQL语句。只要批量操作中任何一条SQL语句影响的记录条数可能超过Integer.MAX_VALUE，就应该使用executeLargeBatch()方
法。如下：
Statement stmt = conn.createStatement();
//使用Statement同时收集多条SQL语句
stmt.addBatch(sql1);
stmt.addBatch(sql2);
stmt.addBatch(sql3);
...
//同时执行所有的SQL语句
stmt.executeLargeBatch();
若在批量更新的addBatch()方法中添加了select查询语句，程序将会直接出现错误。为了让批量操作可以正确的处理错误，必须把批量执行的操作视为单个事务，若批量更
新在执行过程中失败，则让事务回滚到批量操作开始之前的状态。为达到这种效果，程序应该在开始批量操作之前先关闭自动提交，然后开始收集更新语句，当批量操作
执行结束后，提交事务，并恢复之前的自动提交模式，如下：
//保存当前的自动的提交模式
boolean autoCommit = conn.getAutoCommit();
//关闭自动提交
conn.setAutoCommit(false);
Statement stmt = conn.createStatement();
//使用Statement同时收集多条SQL语句
stmt.addBatch(sql1);
stmt.addBatch(sql2);
stmt.addBatch(sql3);
...
//同时执行所有的SQL语句
stmt.executeLargeBatch();
//提交修改
conn.commit();
//恢复原有的紫东提交模式
conn.setAutocommit(autoCommit);
MySQL的最新驱动依然不支持executeLargeBatch()方法，对于数据库驱动不支持executeLargeBatch()的情形，则只能依然使用传统的executeBatch()方法。
分析数据库信息：
使用DatabaseMetaData分析数据库信息：
JDBC提供了DatabaseMetaData来封装数据库连接对应数据库的信息，通过Connection提供的getMetaData()方法就可以获取数据库对应的DatabaseMetaData对象
DatabaseMetaData接口通常由驱动程序供应商提供实现，其目的是让用户了解底层数据库的相关信息。使用该接口的目的是发现如何处理底层数据库，尤其是对于试图与
多个数据库一起使用的应用程序——因为应用程序需要在多个数据库之间切换，所以必须利用该接口来找出底层数据库的功能，如：调用supportsCorrelatedSubqueries
()方法查看是否可以使用关联子查询，或者调用supportsBatchUpdates()方法查看是否可以使用批量更新。
许多DatabaseMetaData方法以ResultSet对象的形式返回查询信息，然后使用ResultSet的常规方法（如：getString()和getInt()）即可从这些ResultSet对象中获取数据。若
查询的信息不可用，则将返回一个空ResultSet对象。
DatabaseMetaData的很多方法都需要传入一个XXXPattern模式字符串，这里的XXXPattern不是正则表达式，而是SQL里的模式字符串，即用%代表任意多个字符，使用下
划线代表一个字符。在通常情况下，若把该模式字符串的参数值设置为null，即表明该参数不作为过滤条件。
下面程序通过DatabaseMetaData分析了当前Connection连接对应数据库的一些基本信息，包括当前数据库包含多少数据表，存储过程，student_table表的数据列、主键、
外键等信息：
import java.sql.*;
import java.util.*;
import java.io.*; public class DatabaseMetaDataTest
{
private String driver;
private String url;
private String user;
private String pass;
public void initParam(String paramFile)throws Exception
{
// 使用Properties类来加载属性文件
Properties props = new Properties();
props.load(new FileInputStream(paramFile));
driver = props.getProperty("driver");
url = props.getProperty("url");
user = props.getProperty("user");
pass = props.getProperty("pass");
}
public void info() throws Exception
{
// 加载驱动
Class.forName(driver);
try(
// 获取数据库连接
Connection conn = DriverManager.getConnection(url
, user , pass))
{
// 获取的DatabaseMetaData对象
DatabaseMetaData dbmd = conn.getMetaData();
// 获取MySQL支持的所有表类型
ResultSet rs = dbmd.getTableTypes();
System.out.println("--MySQL支持的表类型信息--");
printResultSet(rs);
// 获取当前数据库的全部数据表
rs = dbmd.getTables(null,null, "%" , new String[]{"TABLE"});
System.out.println("--当前数据库里的数据表信息--");
printResultSet(rs);
// 获取student_table表的主键
rs = dbmd.getPrimaryKeys(null , null, "student_table");
System.out.println("--student_table表的主键信息--");
printResultSet(rs);
// 获取当前数据库的全部存储过程
rs = dbmd.getProcedures(null , null, "%");
System.out.println("--当前数据库里的存储过程信息--");
printResultSet(rs);
// 获取teacher_table表和student_table之间的外键约束
rs = dbmd.getCrossReference(null,null, "teacher_table"
, null, null, "student_table");
System.out.println("--teacher_table表和student_table之间"
+ "的外键约束--");
printResultSet(rs);
// 获取student_table表的全部数据列
rs = dbmd.getColumns(null, null, "student_table", "%");
System.out.println("--student_table表的全部数据列--");
printResultSet(rs);
}
}
public void printResultSet(ResultSet rs)throws SQLException
{
ResultSetMetaData rsmd = rs.getMetaData();
// 打印ResultSet的所有列标题
for (int i = 0 ; i < rsmd.getColumnCount() ; i++ )
{
System.out.print(rsmd.getColumnName(i + 1) + "\t");
}
System.out.print("\n");
// 打印ResultSet里的全部数据
while (rs.next())
{
for (int i = 0; i < rsmd.getColumnCount() ; i++ )
{
System.out.print(rs.getString(i + 1) + "\t");
}
System.out.print("\n");
}
rs.close();
}
public static void main(String[] args)
throws Exception
{
DatabaseMetaDataTest dt = new DatabaseMetaDataTest();
dt.initParam("mysql.ini");
dt.info();
}
}
结果太多，只截取一部分。
使用系统表分析数据库信息：
除了DatabaseMetaData来分析底层数据库信息之外，若已经确定应用程序所以用的数据库系统，则可以通过数据库的系统来分析数据库信息。
系统表又称为数据字典，数据字典的数据通常由数据库系统负责维护，用户通常只能查询数据字典，而不能修改数据字典的内容。
MySQL数据库使用information_schema数据库来保存系统表，在数据库里包含了大量系统表，常用系统表的简单介绍如下：
1.tables：存放数据库里所有数据表信息
2.schemata：存放数据库里所有数据库的信息
3.views：存放数据库里所有视图的信息
4.columns：存放数据库里所有列的信息
5.triggers：存放数据库里所有触发器的信息
6.routines：存放数据库里所有存储过程和函数的信息
7.key_column_usage：存放数据库里所有具有约束的键信息
8.table_constraints：存放数据库里全部约束表的信息
9.statistics：存放数据库里全部索引的信息
使用连接池管理连接：
数据库连接的建立和关闭是极耗费系统资源的操作，数据库连接池的解决方案是：当应用程序启动时，系统主动建立足够的数据库连接，并将这些连接组成一个连接池。每次应
用程序请求数据库连接是，无需重新打开连接，而是从连接池中取出已有的连接使用，使用完后不再关闭数据库连接，而是直接将连接归还给连接池。
对于共享资源的情况，有一个通用的设计模式：资源池（Resource Pool），用于解决资源的频繁请求、释放所造成的性能下降。
数据库连接池是Connection对象的工厂，数据库连接池的常用参数如下：
1.数据库的初始连接数
2.连接池的最大连接数
3.连接池的最小连接数
4.连接池每次增加的容量
JDBC的数据库连接池使用 javax.sql.DataSource来表示，DataSource只是一个接口，该接口通常由商用服务器提供实现，也有一些开源组织提供实现（如DBCP和C3P0）。
DBCP数据源：
DBCP是Apache软件基金组织下的开源连接实现，该连接池依赖该组织下的另一个开源系统：common-pool。若需要使用该连接池实现，则应在系统中增加两个jar 文件：
1.commons-dbcp.jar：连接池的实现
2.commons-pool.jar：连接池实现的依赖库
Tomcat的连接池正是采用该连接池实现的。数据库连接池既可以与应用服务器整合使用，也可以由应用程序独立使用。
下面代码片段示范了使用DBCP来获得数据库连接方式：
//创建连接池实例
BasicDataSource ds = new BasicDataSourc();
//设置连接池所需驱动
ds.setDriverClassName("com.mysql.jdbc.Driver");
//设置连接数据库的URL
ds.setUrl("jdbc:mysql://localhost:3306/javaee");
//设置连接数据库的用户名
ds.setUsername("root");
//设置连接数据库的密码
ds.setPassword("pass");
//设置连接池的初始连接数
ds.setInitialSize(5);
//设置连接池最多可有多少个活动连接数
ds.setMaxActive(20);
//设置连接池中最少有2个空闲的连接
ds.setMinIdle(2);
数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。即：一个应用，上面代码只需要执行一次即可。
建议把上面程序中的ds设置成static成员变量，并且在应用开始时立即初始化数据源对象，程序中所有需要获取数据库连接的地方直接访问该ds对象，并获取数据库连接即
可。
//通过数据源获取数据库连接
Connection conn = ds.getConnection();
当数据库访问结束后，程序还是像以前一样关闭数据库连接：
//释放数据库连接
conn.close();
C3P0数据源：
C3P0数据源性能更胜一筹，Hibernate就推荐使用该连接池。C3P0连接池不仅可以自动清理不在使用的Connection，还可以自动清理ResultSet和Statement。
若需要使用C3P0连接池，则应在系统中增加如下JAR文件
1.c3p0-0.9.1.2.jar：C3P0连接池的实现
下面代码通过C3P0连接池获得数据库连接：
//创建连接池实例
ComboPooledDataSource ds = new ComboPooledDataSource();
//设置连接池所需驱动
ds.setDriverClass("com.mysql.jdbc.Driver");
//设置连接数据库的URL
ds.setJdbcUrl("jdbc:mysql://localhost:3306/javaee");
//设置连接数据库的用户名
ds.setUser("root");
//设置连接数据库的密码
ds.setPassword("pass");
//设置连接池的最大连接数
ds.setMaxPoolSize(40);
//设置连接池的最小连接数
ds.setMinPoolSIze(2);
//设置连接池的初始连接数
ds.setInitialPoolSize(10);
//设置连接池的缓存Statement的最大数
ds.setMaxStatements(180);
通过如下代码获取数据库连接：
Connection conn = ds.getConnection();