通過jdbc使用PreparedStatement，提升性能，防止sql注入

為什么要使用PreparedStatement？

一、通過PreparedStatement提升性能

     Statement主要用於執行靜態SQL語句，即內容固定不變的SQL語句。Statement每執行一次都要對傳入的SQL語句編譯一次，效率較差。
     某些情況下，SQL語句只是其中的參數有所不同，其余子句完全相同，適用於PreparedStatement。
PreparedStatement的另外一個好處就是預防sql注入攻擊
     PreparedStatement是接口，繼承自Statement接口。
    使用PreparedStatement時，SQL語句已提前編譯，三種常用方法 execute、 executeQuery 和 executeUpdate 已被更改，以使之不再需要參數。
     PreparedStatement 實例包含已事先編譯的 SQL 語句，SQL 語句可有一個或多個 IN 參數，IN參數的值在 SQL 語句創建時未被指定。該語句為每個 IN 參數保留一個問號（“？”）作為占位符。
     每個問號的值必須在該語句執行之前，通過適當的setInt或者setString 等方法提供。
     由於 PreparedStatement 對象已預編譯過，所以其執行速度要快於 Statement 對象。因此，多次執行的 SQL 語句經常創建為 PreparedStatement 對象，以提高效率。
通常批量處理時使用PreparedStatement。
  

 

//SQL語句已發送給數據庫，並編譯好為執行作好准備
PreparedStatement pstmt = con.prepareStatement(
         "UPDATE  emp   SET job= ? WHERE empno = ?");
//對占位符進行初始化 
pstmt.setLong(1, "Manager");
pstmt.setInt(2,1001);
//執行SQL語句
pstmt.executeUpdate();

 

小案例：分別向數據庫插入1000條記錄。分別記錄執行時間，然后進行比較。

 

新建項目：

 

使用Statement的 執行效率的類INSERT3:

package com.cnblogs.daliu_it;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.Statement;

/**
 * 使用Statement的 執行效率
 * 
 */
public class INSERT3 {

    public static void main(String[] args) {
        Connection conn = null;
        try {
            conn = DBUtility.getConnection();
            Statement state = conn.createStatement();
            long start = System.currentTimeMillis();

            for (int i = 7000; i < 8000; i++) {
                String sql = "INSERT INTO user VALUES" + "(" + i + ","
                        + "'test" + i + "'," + "'12345'," + "5000," + "'test"
                        + i + "@qq.com'" + ")";
                state.executeUpdate(sql);
            }
            System.out.println("插入完畢");
            long end = System.currentTimeMillis();
            System.out.println("耗時:" + (end - start));
        } catch (Exception e) {
            System.out.println("插入數據失敗");
            e.printStackTrace();
        } finally {
            DBUtility.closeConnection(conn);
        }
    }
}

 

測試數據：

 

使用預編譯PreparedStatement SQL提高執行效率的類INSERT2:

package com.cnblogs.daliu_it;

import java.sql.Connection;
import java.sql.PreparedStatement;

/**
 * 使用預編譯PreparedStatement SQL提高執行效率
 * 
 */
public class INSERT2 {
    public static void main(String[] args) {
        Connection conn = null;
        try {
            conn = DBUtility.getConnection();
            // Statement state= conn.createStatement();

            String sql = "INSERT INTO user VALUES(?,?,'123456',?,?)";
            /*
             * 根據給定的預編譯SQL語句創建一個 PreparedStatement
             */
            PreparedStatement ps = conn.prepareStatement(sql);

            long start = System.currentTimeMillis();

            for (int i = 9000; i < 10000; i++) {
                ps.setInt(1, i);
                ps.setString(2, "test" + i);
                ps.setInt(3, 5000);
                ps.setString(4, "test" + i + "@qq.com");
                ps.executeUpdate();
            }
            System.out.println("插入完畢");
            long end = System.currentTimeMillis();
            System.out.println("耗時:" + (end - start));
        } catch (Exception e) {
            System.out.println("插入數據失敗");
            e.printStackTrace();
        } finally {
            DBUtility.closeConnection(conn);
        }
    }
}

 

測試效果：

二、通過PreparedStatement防止SQL Injection

      對JDBC而言，SQL注入攻擊只對Statement有效，對PreparedStatement無效，因為PreparedStatement不允許在插入參數時改變SQL語句的邏輯結構。
      使用預編譯的語句對象時，用戶傳入的任何數據不會和原SQL語句發生匹配關系，無需對輸入的數據做過濾。如果用戶將”or 1 = 1”傳入賦值給占位符，下述SQL語句將無法執行：select * from t where username = ? and password = ?;

      PreparedStatement是Statement的子類，表示預編譯的SQL語句的對象。在使用PreparedStatement對象執行SQL命令時，命令被數據庫編譯和解析，並放入命令緩沖區。緩沖區中的預編譯SQL命令可以重復使用。

 sql = "select * from users where NAME = ? and PWD = ?";
   System.out.println(sql);

  
   con = DBUtility.getConnection();

   //通過Statement 的改為prepareStatement
   stmt = con.prepareStatement(sql);

  
//   rs = stmt.executeQuery(sql);
   
    stmt.setString(1, username);
             stmt.setString(2, password);
             rs = stmt.executeQuery();

 

使用PreparedStatement來執行SQL語句。在SQL語句中有2個問號，在代碼中要給它們分別設置值，規則是：從左到右，對應1，2，...。

對於JDBC而言,SQL注入攻擊只對Statement有效,對PreparedStatement是無效的,這是因為PreparedStatement不允許在插入時改變查詢的邏輯結構。

 

 

 例子：使用PreparedStatement實現用戶名和密碼的驗證功能。

（1） 使用Statement實現用戶名和密碼的驗證功能，並測試用戶名為“Tom”、密碼為“123”以及用戶名為“Tom”、密碼為“a' OR 'b'='b”是否能登錄成功。

（2）使用PreparedStatement實現用戶名和密碼的驗證功能，並測試用戶名為“Tom”、密碼為“a' OR 'b'='b”是否能登錄成功。

 

1.新建一個java項目，配置文件，導入所需要的jar包。如下圖：

 

2.首先創建user表：

     
    create table users(
      id int(4) auto_increment,
      name varchar(50),
      pwd varchar(50),
      phone varchar(50)
    );
    
    desc users;
    
    select * from users;
    
    insert into users(id,username,password)values(1,'Tom','123','110');
    insert into users(id,username,password)values(2,'Jerry','abc','119');
    insert into users(id,username,password)values(3,'Andy','456','112');
    
    
    select * from users;

 

3.連接數據庫類DBUtility：

package com.cnblogs.daliu_it;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import org.apache.commons.dbcp.BasicDataSource;
/**
 * 工具類
 * @author daliu_it
 *
 */
public class DBUtility {
    private static BasicDataSource dataSource = null;

    public DBUtility() {
    }
    public static void init() {

        Properties dbProps = new Properties();
        // 取配置文件可以根據實際的不同修改
        try {
            dbProps.load(DBUtility.class.getClassLoader().getResourceAsStream(
                    "com/cnblogs/daliu_it/db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            String driveClassName = dbProps.getProperty("jdbc.driverClassName");
            String url = dbProps.getProperty("jdbc.url");
            String username = dbProps.getProperty("jdbc.username");
            String password = dbProps.getProperty("jdbc.password");

            String initialSize = dbProps.getProperty("dataSource.initialSize");
            String minIdle = dbProps.getProperty("dataSource.minIdle");
            String maxIdle = dbProps.getProperty("dataSource.maxIdle");
            String maxWait = dbProps.getProperty("dataSource.maxWait");
            String maxActive = dbProps.getProperty("dataSource.maxActive");

            dataSource = new BasicDataSource();
            dataSource.setDriverClassName(driveClassName);
            dataSource.setUrl(url);
            dataSource.setUsername(username);
            dataSource.setPassword(password);

            // 初始化連接數
            if (initialSize != null)
                dataSource.setInitialSize(Integer.parseInt(initialSize));

            // 最小空閑連接
            if (minIdle != null)
                dataSource.setMinIdle(Integer.parseInt(minIdle));

            // 最大空閑連接
            if (maxIdle != null)
                dataSource.setMaxIdle(Integer.parseInt(maxIdle));

            // 超時回收時間(以毫秒為單位)
            if (maxWait != null)
                dataSource.setMaxWait(Long.parseLong(maxWait));

            // 最大連接數
            if (maxActive != null) {
                if (!maxActive.trim().equals("0"))
                    dataSource.setMaxActive(Integer.parseInt(maxActive));
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("創建連接池失敗!請檢查設置!!!");
        }
    }

    /**
     * 數據庫連接
     * @return
     * @throws SQLException
     */
    public static synchronized Connection getConnection() throws SQLException {
        if (dataSource == null) {
            init();
        }
        Connection conn = null;
        if (dataSource != null) {
            conn = dataSource.getConnection();
        }
        return conn;
    }
    
    /**
     * 關閉數據庫
     * @param conn
     */
    public static void closeConnection(Connection conn){
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                System.out.println("關閉資源失敗");
                e.printStackTrace();
            }
        }
    }
    
}

 

4.使用Statement實現驗證用戶名密碼是否存在的方法的類UserDAO：

package com.cnblogs.daliu_it;

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

public class UserDAO {

    /**
     * 使用Statement實現驗證用戶名密碼是否存在的方法
     * 
     * @param username
     * @param password
     */
    public void login(String username, String password) {

        // Statement
        Connection con = null;
        Statement stmt = null;
        ResultSet rs = null;

        // 定義sql語句，用來查詢用戶名和密碼
        String sql = null;

        try {
            sql = "select * from users where NAME = '" + username
                    + "' and PWD= '" + password + "'";

            // 檢查一下sql語句是否拼寫正確
            System.out.println(sql);

            // 獲得數據庫的連接
            con = DBUtility.getConnection();

            stmt = con.createStatement();

            // 執行sql語句
            rs = stmt.executeQuery(sql);

            // 進行結果的遍歷，並給出相應的提示
            if (rs.next()) {
                System.out.println("登錄成功！");
            } else {
                System.out.println("登錄失敗！");
            }

        } catch (SQLException e) {

            System.out.println("數據庫訪問異常!");
            throw new RuntimeException(e);

        } finally {

            // 最后關閉一下資源
            if (con != null) {
                DBUtility.closeConnection(con);
            }
        }
    }
}

 

5.使用PreparedStatement實現驗證用戶名密碼是否存在的方法的類 UserDAO2：

package com.cnblogs.daliu_it;

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

public class UserDAO2 {

    /**
     * 使用PreparedStatement實現驗證用戶名密碼是否存在的方法
     * 
     * @param username
     * @param password
     */
    public void login(String username, String password) {

        Connection con = null;

        // 通過Statement 的改為prepareStatement
        PreparedStatement stmt = null;
        ResultSet rs = null;

        String sql = null;

        try {
            // sql = "select * from users where NAME = '" + username+
            // "' and PWD= '" + password + "'";
            sql = "select * from users where NAME = ? and PWD = ?";
            // 使用PreparedStatement是將 "aa' or '1' = '1"
            // 作為一個字符串賦值給問號“?”，使其作為"用戶名"字段的對應值，這樣來防止SQL注入。

            System.out.println(sql);
            con = DBUtility.getConnection();

            // 對於JDBC而言,SQL注入攻擊只對Statement有效,對PreparedStatement是無效的,這是因為PreparedStatement不允許在插入時改變查詢的邏輯結構。
            stmt = con.prepareStatement(sql);
            // rs = stmt.executeQuery(sql);
            stmt.setString(1, username);
            stmt.setString(2, password);
            rs = stmt.executeQuery();

            // 進行結果的遍歷，並給出相應的提示
            if (rs.next()) {
                System.out.println("登錄成功！");
            } else {
                System.out.println("登錄失敗！");
            }

            System.out.println("執行完畢！");
        } catch (SQLException e) {

            System.out.println("數據庫訪問異常!");
            throw new RuntimeException(e);

        } finally {

            // 最后關閉一下資源
            if (con != null) {
                DBUtility.closeConnection(con);
            }
        }
    }
}

6.配置文件db.properties：

#Oracle
#jdbc.driverClassName=oracle.jdbc.OracleDriver
#jdbc.url=jdbc:oracle:thin:@localhost:1521:orcl
#jdbc.username=root
#jdbc.password=123456

#Mysql
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/csdn
jdbc.username=root
jdbc.password=123456

dataSource.initialSize=10
dataSource.maxIdle=20
dataSource.minIdle=5
dataSource.maxActive=50
dataSource.maxWait=1000

 

7.測試類testCase：

package com.daliu_it.test;

import java.sql.SQLException;

import org.junit.Test;

import com.cnblogs.daliu_it.DBUtility;
import com.cnblogs.daliu_it.UserDAO;
import com.cnblogs.daliu_it.UserDAO2;

public class testCase {

    /**
     * 測試是否連接
     * 
     * @throws SQLException
     */
    @Test
    public void testgetConnection() throws SQLException {
        DBUtility db = new DBUtility();
        System.out.println(db.getConnection());
    }

    /**
     * 測試使用Statement實現驗證用戶名密碼是否存在的方法
     */
    @Test
    public void testStatementLogin() {

        UserDAO dao = new UserDAO();
        // 用戶名不正確
        dao.login("Tom1", "123");
        // 用戶名不正確
        dao.login("Tom", "1234");
        // 正確
        dao.login("Tom", "123");

        /**
         * 這個也能登陸成功，不過這里會存在一個sql注入的問題
         */
        dao.login("Tom", " a' OR 'b'='b  ");

    }

    @Test
    public void testPreparedStatementLogin() {

        UserDAO2 dao = new UserDAO2();
        // 用戶名不正確
        dao.login("Tom1", "123");
        // 用戶名不正確
        dao.login("Tom", "1234");
        // 正確
        dao.login("Tom", "123");
        // 測試是否還存在sql注入問題，不能登陸成功，說明我們已經解決了sql注入問題
        dao.login("Tom", " a' OR 'b'='b  ");
        /**
         * 實現機制不同,注入只對SQL語句的准備(編譯)過程有破壞作用,而PreparedStatement已經准備好了，
         * 執行階段只是把輸入串作為數據處理，不再需要對SQL語句進行解析、准備，因此也就避免了SQL注入問題。
         */

    }

}

 

測試效果：

（1）連接效果：

 

（2）測試使用Statement實現驗證用戶名密碼是否存在的方法

 

（3）測試使用PreparedStatement實現驗證用戶名密碼是否存在的方法

 

 

 

原文作者：daliu_it
博文出處：http://www.cnblogs.com/liuhongfeng/p/4175765.html

本文版權歸作者和博客園共有，但未經作者同意轉載必須保留以上的聲明且在放在文章頁面明顯位置。謝謝合作。