JDBC 学习笔记（六）—— PreparedStatement

1. 引入 PreparedStatement

PreparedStatement 通过 Connection.createPreparedStatement(String sql) 方法创建，主要用来反复执行一条结构相似的 SQL 语句。

例如：

INSERT INTO STUDENT (STUDENT_NAME, STUDENT_PASSWORD) VALUES ('van Nistelrooy', '666666');

INSERT INTO STUDENT (STUDENT_NAME, STUDENT_PASSWORD) VALUES ('van der Sar', '777777');

这两条 SQL 语句，除了插入的值不同，其他的基本语法没有任何区别。

针对这种情况，可以使用占位符？来代替：

INSERT INTO STUDENT (STUDENT_NAME, STUDENT_PASSWORD) VALUES (?, ?);

Statement 是不允许使用？占位符的，而且这个占位符需要获得值之后才能够执行。PreparedStatement 就是针对这种场景才引入进来的。

PreparedStatement 是 Statement 的子接口，它支持以下4种执行 SQL 的方式：

execute()
executeUpdate()
executeQuery()
executeLargeUpdate()

同时，PreparedStatement 提供了一系列的 setXxx(int index, Xxx value) 来支持对于？占位符的替换。Xxx 是占位符的数据类型。

如果不确定数据类型，可以通过 setObject() 方法来传入数据。

2. Demo

这里贴一个自己写的例子：

package com.gerrard.demo;

import com.gerrard.entity.Student;
import com.gerrard.util.Connector;
import com.gerrard.util.DriverLoader;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public final class PreparedStatementDemo {

    public static void main(String[] args) {
        String sql = "INSERT INTO STUDENT (STUDENT_NAME, STUDENT_PASSWORD) VALUES (?, ?)";

        Student student1 = new Student(0, "van Nistelrooy", "666666");
        Student student2 = new Student(0, "van der Sar", "777777");
        List<Student> studentList = new ArrayList<>(Arrays.asList(student1, student2));

        DriverLoader.loadSqliteDriver();
        try (Connection conn = Connector.getSqlConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {


            for (Student student : studentList) {
                pstmt.setString(1, student.getName());
                pstmt.setObject(2, student.getPassword());
                pstmt.executeUpdate();
            }
            System.out.println("Successfully executeUpdate using PreparedStatement.");

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

3. PreparedStatement 的优势

PreparedStatement 的优势主要有以下3点：

通过预编译 SQL 语句的方式（即创建 PreparedStatement 的时候，就将 SQL语句传递进去），大大降低了多次执行相似的 SQL 语句的效率。
需要传递参数的时候，无需拼接 SQL 语句，降低了编程的复杂度。
防止 SQL 注入。

4. SQL 注入

SQL 注入是一个常见的 Cracker 入侵方式，利用 SQL 语句的漏洞来入侵。

那么怎么去理解 PrepareStatement 能够防止 SQL 注入呢？

实际上，这是不使用 SQL 字符串拼接的副产品。

现在假设，有一个 GUI 界面，需要输入用户名和密码来登录。

在后台，我提供了一个登陆服务：

public interface StudentLoginService {

    Student login(String id, String password);
}

那么现在，我用 Statement 去实现这个服务：（有些我自定义的类，会在后续的章节解释，这里就简单地理解成一个简易的 ORM 框架）

package com.gerrard.service;

import com.gerrard.entity.Student;
import com.gerrard.executor.SqlExecutorStatement;
import com.gerrard.orm.FlexibleResultSetAdapter;
import com.gerrard.orm.ResultSetAdapter;

import java.util.List;

public final class StatementLoginService implements StudentLoginService {

    private static final String VALIDATE_SQL = "select * from STUDENT s where s.[STUDENT_ID] = ? and s.[STUDENT_PASSWORD] = ?";

    @Override
    public Student login(String id, String password) {
        ResultSetAdapter<Student> adapter = new FlexibleResultSetAdapter<>(Student.class);
        SqlExecutorStatement<Student> executor = new SqlExecutorStatement<>(adapter);
        String sql = VALIDATE_SQL.replaceFirst("\\?", id).replaceFirst("\\?", "'" + password + "'");
        List<Student> list = executor.executeQuery(sql);
        return list.isEmpty() ? null : list.get(0);
    }
}

这样写代码，看似没有问题，但是实际上有个致命的缺陷。

假设有人猜测到了这个登陆服务是用 Statement 实现的，那么他在密码一栏可以输入：

' or 1=1 or '

这样，整句 SQL 就变成了：

select * from STUDENT s where s.[STUDENT_ID] = 1 and s.[STUDENT_PASSWORD] = '' or 1=1 or ''

显然，所有的 Student 都被查到了，登陆成功。

但是，使用 PreparedStatement 就没有这种问题，Cracker 输入会被拒绝登陆：

package com.gerrard.service;

import com.gerrard.entity.Student;
import com.gerrard.executor.SqlExecutorPreparedStatement;
import com.gerrard.orm.FlexibleResultSetAdapter;
import com.gerrard.orm.ResultSetAdapter;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public final class PreparedStatementLoginService implements StudentLoginService {

    private static final String VALIDATE_SQL = "select * from STUDENT s where s.[STUDENT_ID] = ? and s.[STUDENT_PASSWORD] = ?";

    @Override
    public Student login(String id, String password) {
        List<Object> params = new LinkedList<>(Arrays.asList(id, password));
        ResultSetAdapter<Student> adapter = new FlexibleResultSetAdapter<>(Student.class);
        SqlExecutorPreparedStatement<Student> executor = new SqlExecutorPreparedStatement<>(adapter, params);
        List<Student> list = executor.executeQuery(VALIDATE_SQL);
        return list.isEmpty() ? null : list.get(0);
    }
}

最后贴一下实验代码和输出：

package com.gerrard.demo;

import com.gerrard.entity.Student;
import com.gerrard.service.PreparedStatementLoginService;
import com.gerrard.service.StatementLoginService;
import com.gerrard.service.StudentLoginService;

public final class InjectCase {

    public static void main(String[] args) {

        String id1 = "6";
        String pass1 = "123456";

        String id2 = "6";
        String pass2 = "' or 1=1 or '";

        // case 1, normal login with Statement
        StudentLoginService service1 = new StatementLoginService();
        Student student1 = service1.login(id1, pass1);
        if (student1 == null) {
            System.out.println("Login failure.");
        } else {
            System.out.println("Student [" + student1.getName() + "] login success.");
        }

        // case 2, cracker login with PreparedStatement
        StudentLoginService service2 = new StatementLoginService();
        Student student2 = service2.login(id2, pass2);
        if (student2 == null) {
            System.out.println("Login failure.");
        } else {
            System.out.println("Student [" + student2.getName() + "] login success.");
        }

        // case 3, normal login with Statement
        StudentLoginService service3 = new PreparedStatementLoginService();
        Student student3 = service3.login(id1, pass1);
        if (student3 == null) {
            System.out.println("Login failure.");
        } else {
            System.out.println("Student [" + student3.getName() + "] login success.");
        }

        // case 4, cracker login with PreparedStatement
        StudentLoginService service4 = new PreparedStatementLoginService();
        Student student4 = service4.login(id2, pass2);
        if (student4 == null) {
            System.out.println("Login failure.");
        } else {
            System.out.println("Student [" + student4.getName() + "] login success.");
        }
    }
}

JDBC 学习笔记（六）—— PreparedStatement

猜你喜欢