PreparedStatement的使用

原文链接

Statement的子类PreparedStatement.

PreparedStatement(预处理执行语句)相比其父类Statement主要有以下几个优点.

1. 可以防止SQL注入.
2. 在特定的驱动数据库下相对效率要高(不绝对)
3. 不需要频繁编译.因为已经预加载了

这里2和3的优点就不具体分析.这里主要讲解下防止SQL注入这一用途.

什么叫SQL注入可以阅读下WIKI.这里还是使用上一节总结的DBUtils来讲解.

DBUtils辅助类

package com.test.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
 * @author Administrator
 * 模板类DBUtils
 */
public final class DBUtils {
    // 参数定义
    private static String url = "jdbc:mysql://localhost:3306/mytest"; // 数据库地址
    private static String username = "root"; // 数据库用户名
    private static String password = "root"; // 数据库密码

    private DBUtils() {

    }
    // 加载驱动
    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            System.out.println("驱动加载出错!");
        }
    }

    // 获得连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    // 释放连接
    public static void free(ResultSet rs, Statement st, Connection conn) {
        try {
            if (rs != null) {
                rs.close(); // 关闭结果集
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (st != null) {
                    st.close(); // 关闭Statement
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (conn != null) {
                        conn.close(); // 关闭连接
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }

            }

        }

    }

}

在写sql注入演示类之前看下数据库结构:

上边就是简单的users表.然后看下SQL注入演示类

SQLInner

package com.test.jdbc;

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

public class SqlInner {
    public static void main(String[] args) {
        //Read("zhangsan"); // 如果普通查询可以
        Read("' or 1 or'");
    }
    public static void Read(String name) {
        Statement st = null;
        ResultSet rs = null;
        Connection conn = null;
        try {
            conn = DBUtils.getConnection();
            st = conn.createStatement();
            String sql = "select * from users where lastname = '" + name + "'"; // 主要注入发生地
            System.out.println("sql: " + sql); // 打印SQL语句
            rs = st.executeQuery(sql); 
            System.out.println("age\tlastname\tfirstname\tid");
            while (rs.next()) {
                System.out.println(rs.getInt(1) + "\t" + rs.getString(2)
                        + "\t\t" + rs.getString(3) + "\t\t" + rs.getString(4));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtils.free(rs, st, conn);
        }
    }
}

见注释.如果用普通的键zhangsan来查询.会打印

age lastname firstname id 23 zhangsan lisi 3

结果正常.但使用下面的’ or 1 or’结果为

age lastname firstname id 22 啡 咖 1 25 434
ni 2 23 zhangsan lisi 3

把所有结果都打印出来了.打印了一下生成后的SQL语句如下:

sql: select * from users where lastname = ” or 1 or”

分析下不难看出.主要问题是用了两个单引号 分别把前后的两个”给封闭了 变成两个空 然后通过or 1即or true就是符合所有条件了.

这就是SQL注入的一种.为了避免这种情况可以使用特殊符号替换 但只是亡羊补牢. 下面就引出了PreparedStatement

package com.test.jdbc;

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

public class SqlInner {
    public static void main(String[] args) {
        Read("' or 1 or'");
    }
    public static void Read(String name) {
        PreparedStatement st = null;
        ResultSet rs = null;
        Connection conn = null;
        try {
            conn = DBUtils.getConnection();
            String sql = "select * from users where lastname = ?"; // 这里用问号        
            st = conn.prepareStatement(sql);
            st.setString(1,name); // 这里将问号赋值
            rs = st.executeQuery(); 
            System.out.println("age\tlastname\tfirstname\tid");
            while (rs.next()) {
                System.out.println(rs.getInt(1) + "\t" + rs.getString(2)
                        + "\t\t" + rs.getString(3) + "\t\t" + rs.getString(4));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtils.free(rs, st, conn);
        }
    }
}

见注释.PreparedStatement用?代替变量.然后加载后setString给赋值.由于PreparedStatement内置了字符过滤

那么就相当于 where name = ’ or 1 or ‘显然没有对应记录.所以数据结果为空.这就体现了PreparedStatement的防注入功能

所以提倡大家只要是动态参数就是用PreparedStatement去代替Statement.况且效率也不错.优化的很好.

PreparedStatement尽最大可能提高性能.

每一种数据库都会尽最大努力对预编译语句提供最大的性能优化.因为预编译语句有可能被重复调用.所以语句在被DB的编译器编译后的执行代码被缓存下来,那么下次调用时只要是相同的预编译语句就不需要编译,只要将参数直接传入编译过的语句执行代码中(相当于一个涵数)就会得到执行.这并不是说只有一个 Connection中多次执行的预编译语句被缓存,而是对于整个DB中,只要预编译的语句语法和缓存中匹配.那么在任何时候就可以不需要再次编译而可以直接执行.而statement的语句中,即使是相同一操作,而由于每次操作的数据不同所以使整个语句相匹配的机会极小,几乎不太可能匹配.比如:
insert into tb_name (col1,col2) values (‘11’,’22’);
insert into tb_name (col1,col2) values (‘11’,’23’);
即使是相同操作但因为数据内容不一样,所以整个个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存.

当然并不是所以预编译语句都一定会被缓存,数据库本身会用一种策略,比如使用频度等因素来决定什么时候不再缓存已有的预编译结果.以保存有更多的空间存储新的预编译语句.