第十三章.MySQL数据库与JDBC编程（下）

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) + "	"
                            + rs.getString(2) + "	"
                            + rs.getString(3) + "	"
                            + 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) + "	");
                                }
                                System.out.print("
");
                            }
                        }
                }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) + "	"
                    + rs.getString(2) + "	" + 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)
                    + "	" + jdbcRs.getString(2)
                    + "	" + 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)
                + "	" + rs.getString(2)
                + "	" + 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)
                + "	" + rs.getString(2)
                + "	" + 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) + "	");
        }
        System.out.print("
");
        // 打印ResultSet里的全部数据
        while (rs.next())
        {
            for (int i = 0; i < rsmd.getColumnCount() ; i++ )
            {
                System.out.print(rs.getString(i + 1) + "	");
            }
            System.out.print("
");
        }
        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();