Java JDBC下执行SQL的不同方式、参数化预编译防御

相关学习资料

http://zh.wikipedia.org/wiki/Java数据库连接
http://lavasoft.blog.51cto.com/62575/20588
http://blog.csdn.net/cxwen78/article/details/6863696
http://www.ibm.com/developerworks/cn/java/jdbc-objects/index.html?ca=drs
http://www.moon-soft.com/doc/37897.htm

目录

. Java JDBC简介
. Java JDBC下执行SQL的不同方式
. Java JDBC编程实践

1. Java JDBC简介

数据库驱动程序是JDBC程序和数据库之间的转换层，数据库驱动程序负责将JDBC调用映射成特定的数据库调用，类似PHP中的"数据库抽象层"

http://www.php.net/manual/zh/refs.database.vendors.php

使用Java JDBC API进行编程，可以为多种关系数据库提供统一访问，为我们带来跨平台、跨数据库系统的好处

总的来说，JDBC驱动通常有如下4种类型

. JDBC-ODPC桥:
它将JDBC API映射到ODPC API。再让JDBC-ODPC调用数据库本地驱动代码(也就是数据库厂商提供的数据库操作二进制代码库，例如Oracle中的oci.dll)
. 本地API驱动
直接将JDBC API映射成数据库特定的客户端API，即通过客户端加载数据库厂商提供的本地代码库(C／C++等)
. 网络协议驱动
这种类型的驱动给客户端提供了一个网络API，客户端上的JDBC驱动程序使用套接字（Socket）来调用服务器上的中间件程序，后者在将其请求转化为所需的具体API调用。
. 本地协议驱动
这种类型的驱动使用Socket，直接在客户端和数据库间通信。它是一种直接与数据库实例交互的JDBC
这种驱动是智能的，它知道数据库使用的底层协议，也是目前最主流使用的JDBC驱动，我们本章的重点就是它

JDBC编程(连接数据库)步骤

) 加载数据库驱动
通常我们使用Class类的forName()静态方法来加载驱动(由各个数据库厂商自己实现)
Class.forName("com.mysql.jdbc.Driver");
Class.forName("oracle.jdbc.driver.OracleDriver");
"com.mysql.jdbc.Driver"、"oracle.jdbc.driver.OracleDriver"代表了数据库驱动类对应的字符串
) 通过DriverManager获取数据库连接
DriverManager.getConnection(String url, String user, String pass);
    2.1) url: 数据库连接字符串
        2.1.) Mysql
        jdbc:mysql://hostname:port/databasename
        2.1.) Oracle
        jdbc:oracle:thin:@hostname:port:databasename
    2.2) user: 数据库的系统用户名
    2.3) pass: 数据库的系统密码
) 通过Connection对象创建Statement对象，Connection创建Statement对象的方法有如下3个
    3.1) createStatement(String sql):创建基本的Statement对象
    3.2) prepareStatement(String sql): 根据传入的SQL语句创建预编译的Statement对象
    3.3) prepareCall(String sql): 根据传入的SQL语句创建CallableStatement对象
) 使用Statement执行SQL语句
所有的Statement都有如下3个方法来执行SQL语句
    4.1) execute(): 可以执行任何SQL语句，但比较麻烦
    4.2) executeUpdate(): 主要用于执行DML和DDL语句。执行DML语句返回受SQL影响的行数，执行DDL语句返回0
    4.3) executeQuery(): 只能执行查询语句，执行后返回代表查询结果的ResultSet对象
) 操作结果集
如果执行的SQL语句是查询语句，则执行结果将返回一个ResultSet对象，该对象里保存了SQL语句查询的结果。程序可以通过操作该ResultSet对象来取出查询结果。ResultSet对象主要提供了如
下方法
    5.1) 移动记录指针的方法
        5.1.) next()
        5.1.) previous()
        5.1.) first()
        5.1.) last()
        5.1.) beforeFirst()
        5.1.) afterLast()
        5.1.) absolute()
    5.2) 获取指针指向的某行的"特定的列值"
        5.2.) getInt()
　　　　 5.2.) getString()
　　　　 ...
        该方法既可以使用列索引作为参数，也可以使用列名作为参数
) 回收数据库资源
包括关闭ResultSet、Statement、Connection等资源

2. Java JDBC下执行SQL的不同方式

JDBC是一个相对比较底层的API接口，它只提供给我们一个执行原生SQL语句的输入接口。所以和JDBC的API接口都定义在

java.sql
javax.sql

我们知道，Java JDBC编程中有3种方法进行DDL、DML语句的执行

. createStatement
返回Statement
    ) execute()
    ) executeUpdate()
    ) executeQuery()
. prepareStatement
返回PrepareStatement
    ) execute()
    ) executeUpdate()
    ) executeQuery()
. prepareCall
返回CallableStatement

我们来逐一学习

0x1: 基本的Statement对象

Statement提供了3个方法来执行SQL语句，它们都可以用于执行DDL(执行后返回值为0)、DML(执行后返回受影响行数)语句

使用execute执行DDL、DML语句

Statement的execute()方法几乎可以执行任何原生SQL语句，但它执行SQL语句时比较麻烦(它无法直接返回一个ResultSet，而是需要我们手工再次获取)，通常情况下，使用executeQuery()、或executeUpdate()方法更加简单。但如果程序员不清楚SQL语句的类型，则只能使用execute()方法来执行该SQL语句了。

注意，使用execute()方法执行SQL语句的返回值"只是"boolean值，它表明了执行该SQL语句是否返回了ResultSet对象，而我们要得到具体的ResultSet对象还需要额外的方法

. getResult(): 获取该Statement执行查询语句所返回的ResultSet对象
. getUpdateCount(): 获取该Statement执行DML语句所影响的记录行数

code:

import java.util.*;
import java.io.*;
import java.sql.*;

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 =  ; i < columnCount ; i++ )
                        {
                            System.out.print(rs.getString(i + ) + "\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.println("------执行建表的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");
    }
}

使用executeUpdate执行DDL、DML语句

import java.util.*;
import java.io.*;
import java.sql.*;

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来创建一个Statment对象
        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("-----建表成功-----");
    }
}

从代码中我们可以看到，我们并没有把数据库连接信息写在程序里，而是使用一个mysql.ini文件来保存数据库连接信息，这样当需要把程序从开发环境移植到生产环境时，无须修改源代码，只需要修改mysql.ini配置文件即可

mysql.ini:

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/select_test
user=root
pass=

使用executeQuery执行DDL、DML语句

import java.sql.*;

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/company"
                , "root" , "");
            // 3.使用Connection来创建一个Statment对象
            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 *"
                + " from p8_ad_user"))
        {
            // ResultSet有系列的getXxx(列索引 | 列名)，用于获取记录指针
            // 指向行、特定列的值，不断地使用next()将记录指针下移一行，
            // 如果移动之后记录指针依然指向有效行，则next()方法返回true。
            while(rs.next())
            {
                System.out.println(rs.getInt() + "\t"
                    + rs.getString() + "\t"
                    + rs.getString() + "\t"
                    + rs.getString());
            }
        }
    }
}

0x2: prepareStatement预编译对象

JDBC中的这个类对于安全人员、和黑客都需要重点关注，它不仅可以提供SQL执行性能，同时还有防御SQL注入的功能。

当我们的业务层中和数据库相关的代码经常要执行一些相似度很高的SQL语句，它们的结果基本相似，只是插入时插入的值不同而已

insert into student_table values(null, "LittleHann", );
insert into student_table values(null, "LittleHann", );

在这种情况下，我们可以使用带占位符(?)参数的SQL语句来代替它

insert into student_table values(null, ?, ?);

为了满足这种功能，JDBC提供了prepareStatement接口，它是Statement接口的子接口，它可以预编译SQL语句，预编译后的SQL语句被存储在prepareStatement对象中，然后可以使用该对象多次高效地执行该语句。prepareStatement同样也使用execute()、executeUpdate()、executeQuery()来执行SQL语句，但这三个方法无须参数，因为prepareStatement在创建的时候已经存储了预编译的SQL语句，在执行SQL语句的时候只要传入参数值即可(setXxx)

Statement和prepareStatement的性能对比

import java.util.*;
import java.io.*;
import java.sql.*;

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来创建一个Statment对象
            Statement stmt = conn.createStatement())
        {
            // 需要使用100条SQL语句来插入100条记录
            for (int i = ; i <  ; 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 = ; i <  ; i++ )
            {
                pstmt.setString( , "姓名" + 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();
    }
}

mysql.ini:

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/select_test
user=root
pass=

result:

使用Statement费时:
使用PreparedStatement费时:

除了性能上的优势，prepareStatement还有另一个优势: 无须在SQL语句中"拼接"SQL参数，从安全的角度来看，这就从很大程序上避免了"SQL注入"的发生。使用prepareStatement时，所有的参数都变成了"问号占位符"，也就避免了数据和代码的混淆(这是造成注入的根本原因)

关于使用参数化预编译防御SQL注入，这里要注意几点：

. 参数化预编译之所以能防御住SQL注入，只要是基于以下2点:
    ) setString(): WEB程序接收字符串的场景
    将用户输入的参数全部强制转换为字符串，并进行适当的转义，防止了闭合的产生
    ) setInt(): WEB程序接收整型的场景
    将用户输入的非整型参数强制转换为整型，并去除潜在的"非整型注入字符"，类似与PHP中的intVal()防御思路
. 并不是说使用了参数化预编译方法执行SQL，就不会有注入的发生了，当WEB系统和DataBase系统的字符集配置不当，可能会导致宽字节注入的发生

0x3: prepareCall存储过程对象

调用存储过程可以使用CallableStatement，程序员通过Connection的prepareCall()方法创建CallableStatement对象

创建存储过程

delimiter //
create procedure add_pro(a int, b int, out sum int)
begin
set sum = a + b
end;
//

通过Connection的prepareCall()方法创建CallableStatement对象时需要传入"调用存储过程的SQL命令语句":

cstmt = conn.prepareCall("{call add_pro(?, ?, ?)}");

存储过程的参数既有:

. 传入参数
java程序必须为这些参数传入值，可以通过CallableStatement的setXxx()方法为"传入参数"设置值
. 传出参数
java程序可以通过该参数获取存储过程里的值，CallableStatement需要调用registerOutParameter()方法来注册该参数，执行结束后调用CallableStatement对象的getXxx(int index)
方法来获取指定传出参数的值

code:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import java.io.*;
import java.sql.*;

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来创建一个CallableStatment对象
            CallableStatement cstmt = conn.prepareCall(
                "{call add_pro(?,?,?)}"))
        {
            cstmt.setInt(, );
            cstmt.setInt(, );
            // 注册CallableStatement的第三个参数是int类型
            cstmt.registerOutParameter(, Types.INTEGER);
            // 执行存储过程
            cstmt.execute();
            // 获取，并输出存储过程传出参数的值。
            System.out.println("执行结果是: " + cstmt.getInt());
        }
    }
    public static void main(String[] args) throws Exception
    {
        CallableStatementTest ct = new CallableStatementTest();
        ct.initParam("mysql.ini");
        ct.callProcedure();
    }
}

3. Java JDBC编程实践

0x1: 下载MySQL支持JDBC的驱动程序

我们前面说过，Java JDBC现在主流的做法是"本地协议驱动"，为此，Java需要借助不同厂商提供的数据库驱动(本质上是一个JAR包)来和数据库进行连接，我们这里以Mysql为例，

前往MySQL官网(http://www.mysql.com/products/connector/ )下载驱动程序,，MySQL针对不同的平台提供了不同的连接器，我们需要的是JDBC Driver for MySQL (Connector/J)

aaarticlea/png;base64,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" alt="" />

0x2: 在MyEclips中创建工程项目，并添加驱动JAR包

import java.sql.*;

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/company"
                , "root" , "");
            // 3.使用Connection来创建一个Statment对象
            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 *"
                + " from p8_ad_user where u_id=1"))
        {
            // ResultSet有系列的getXxx(列索引 | 列名)，用于获取记录指针
            // 指向行、特定列的值，不断地使用next()将记录指针下移一行，
            // 如果移动之后记录指针依然指向有效行，则next()方法返回true。
            while(rs.next())
            {
                System.out.println(rs.getInt() + "\t"
                    + rs.getString() + "\t"
                    + rs.getString() + "\t"
                    + rs.getString());
            }
        }
    }
}

aaarticlea/png;base64,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" alt="" />

将mysql数据库连接驱动添加到当前项目的CLASSPATH中

aaarticlea/png;base64,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" alt="" />

0x3: 编译、运行Java代码

aaarticlea/png;base64,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" alt="" />

Copyright (c) 2014 LittleHann All rights reserved