该用户从未签到
|
PreparedStatement是用来执行SQL查询语句的API之一,java提供了 Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句,其中 Statement 用于通用查询, PreparedStatement 用于执行参数化查询,而 CallableStatement则是用于存储过程。同时PreparedStatement还经常会在Java面试被提及,譬如:Statement与PreparedStatement的区别以及如何避免SQL注入式攻击?这篇教程中我们会讨论为什么要用PreparedStatement?使用PreparedStatement有什么样的优势?PreparedStatement又是如何避免SQL注入攻击的?' F4 [: x _3 [3 s7 m& @3 q
8 _/ V0 N% \6 X0 k3 p" \/ [$ P; l) T
PreparedStatement是什么?
$ s3 q2 U7 I$ y/ Y2 j8 `6 ], @
# F0 Z& ]) \# {! v6 L vPreparedStatement是java.sql包下面的一个接口,用来执行SQL语句查询,通过调用connection.preparedStatement(sql)方法可以获得PreparedStatment对象。数据库系统会对sql语句进行预编译处理(如果JDBC驱动支持的话),预处理语句将被预先编译好,这条预编译的sql查询语句能在将来的查询中重用,这样一来,它比Statement对象生成的查询速度更快。下面是一个例子:* n ~/ f; j( `% m. |$ T; u2 _
6 Y/ d, t/ s0 N: g$ q
7 w$ o; S, a5 i& r+ b8 d) Tpublic class PreparedStmtExample {
+ j, v5 K1 V4 J# y p# ]; B6 ]. t% l. j( |+ R( g
public static void main(String args[]) throws SQLException {
( Z5 Z! _; X; Q# ~ Connection conn = DriverManager.getConnection("mysql:\\localhost:1520", "root", "root");1 v* _3 n1 J' b" ~8 j/ `" T
PreparedStatement preStatement = conn.prepareStatement("select distinct loan_type from loan where bank=?");
. B: L, e* S: U* F, }* t preStatement.setString(1, "Citibank");
3 L+ j/ w2 b7 L! X$ C! k k: o/ V1 ?# X' O4 N2 D1 t9 N5 n
ResultSet result = preStatement.executeQuery();3 I+ G9 I; [7 L8 n2 W. t ?: C1 Q
& y4 ]1 u' M8 q/ P# H; M2 d% B while(result.next()){8 b+ T- @# v/ F: J( a( W. a
System.out.println("Loan Type: " + result.getString("loan_type"));
, T6 E' Z9 ~! X/ J } + _( U+ V# j$ |9 K; r/ |
}
9 I8 x1 W- Z* h. o& \9 a y}
/ d* |( [3 M/ cOutput:
9 d* r. S. i" MLoan Type: Personal Loan
. M: @2 C6 z6 ELoan Type: Auto Loan: f. Q* S! f3 g M
Loan Type: Home Loan
. l5 H( `( U& a, U- a L; HLoan Type: Gold Loan- f! |! D" [; i! s" X5 A: [ ]
这个例子中,如果还是用 PreparedStatement 做同样的查询,哪怕参数值不一样,比如:”Standard Chated” 或者”HSBC”作为参数值,数据库系统还是会去调用之前编译器编译好的执行语句(系统库系统初次会对查询语句做最大的性能优化)。默认会返回”TYPE_FORWARD_ONLY”类型的结果集( ResultSet ),当然你也可以使用preparedstatment()的重载方法返回不同类型的结果集。
) u% o8 n( J7 b ?
) n9 w3 g. K$ \0 O" u预处理语句的优势$ u5 z' ~6 p' w0 V
8 h% e7 ]) D1 G# e2 l6 N5 DPreparedStatement提供了诸多好处,企业级应用开发中强烈推荐使用PreparedStatement来做SQL查询,下面列出PreparedStatement的几点优势。! P0 _" h! o; |& `4 X
% p# x0 R8 F9 P) H0 BPreparedStatement可以写动态参数化的查询4 t8 M- l8 v& W- E
用PreparedStatement你可以写带参数的sql查询语句,通过使用相同的sql语句和不同的参数值来做查询比创建一个不同的查询语句要好,下面是一个参数化查询:0 J* S; |9 N! ^8 M9 }
1* h( c) `, z9 P2 E. X5 W( z' ^; v! V
SELECT interest_rate FROM loan WHERE loan_type=?
2 V! C' H# _, B$ B b8 U& c现在你可以使用任何一种loan类型如:”personal loan”,”home loan” 或者”gold loan”来查询,这个例子叫做参数化查询,因为它可以用不同的参数调用它,这里的”?”就是参数的占位符。
; M% ? k, ]$ \5 x. L. C; C6 ~* w( n
PreparedStatement比 Statement 更快. R0 h7 Z/ I ]. h
使用 PreparedStatement 最重要的一点好处是它拥有更佳的性能优势,SQL语句会预编译在数据库系统中。执行计划同样会被缓存起来,它允许数据库做参数化查询。使用预处理语句比普通的查询更快,因为它做的工作更少(数据库对SQL语句的分析,编译,优化已经在第一次查询前完成了)。为了减少数据库的负载,生产环境中德JDBC代码你应该总是使用PreparedStatement 。值得注意的一点是:为了获得性能上的优势,应该使用参数化sql查询而不是字符串追加的方式。下面两个SELECT 查询,第一个SELECT查询就没有任何性能优势。' ?, t& x8 ^, L% N' g) e p& C
SQL Query 1:字符串追加形式的PreparedStatement
4 p& S, u$ T0 A; b4 ~5 ~1* c5 m( C6 F2 G+ _6 T2 E( ?# M8 H5 m
2 }) N" M U# j9 G; l
String loanType = getLoanType();& K( ]# I* s# ^3 f' ?$ I B6 U
PreparedStatement prestmt = conn.prepareStatement("select banks from loan where loan_type=" + loanType);
4 Z# |2 q* E% p9 c+ T* v4 LSQL Query 2:使用参数化查询的PreparedStatement+ V+ C5 T. ]5 x* r, J8 Z1 c# \
) g& i( |4 D" k& U! e
1
# p% j6 Z' p6 }( Y, |$ k6 x, Z2
3 x. ^) b; L2 m3 G# O4 [7 SPreparedStatement prestmt = conn.prepareStatement("select banks from loan where loan_type=?");
C- ]5 P! l& P( ^- H* V5 E" i1 Cprestmt.setString(1,loanType);2 o5 \) Y+ [+ Q- A( R0 K$ y
第二个查询就是正确使用PreparedStatement的查询,它比SQL1能获得更好的性能。
$ |" ^* I; R' f& c: m
5 Z0 y) s' D) GPreparedStatement可以防止SQL注入式攻击
+ p. |+ v+ i; I- t如果你是做Java web应用开发的,那么必须熟悉那声名狼藉的SQL注入式攻击。去年Sony就遭受了SQL注入攻击,被盗用了一些Sony play station(PS机)用户的数据。在SQL注入攻击里,恶意用户通过SQL元数据绑定输入,比如:某个网站的登录验证SQL查询代码为:2 k' i1 Q, { a( a- E8 T0 Y/ v
strSQL = "SELECT * FROM users WHERE name = '" + userName + "' and pw = '"+ passWord +"';"
: P7 U5 ]& Z0 G9 S恶意填入:1 E2 u7 O0 T Q! s. Z& p2 {
3 ]8 R7 a* ]( Q! N8 M1 h. ?6 Y. X
userName = "1' OR '1'='1";
/ D/ Y. B i2 IpassWord = "1' OR '1'='1";
4 H/ s$ k* C' W/ p那么最终SQL语句变成了:
0 P, t H b B. G
3 o( W7 g8 z" t0 y% tstrSQL = "SELECT * FROM users WHERE name = '1' OR '1'='1' and pw = '1' OR '1'='1';". D$ [% L4 D" U% M0 s$ e+ ~- P
因为WHERE条件恒为真,这就相当于执行:
; ~3 T! G$ `1 t5 t6 v
! `1 \ ~# e( C- istrSQL = "SELECT * FROM users;"
) B0 h, k3 I* M0 M因此可以达到无账号密码亦可登录网站。如果恶意用户要是更坏一点,用户填入:
7 U# R0 `5 r5 R
! N/ @" `+ p2 M, Z3 S! nstrSQL = "SELECT * FROM users;"
! h$ M$ W7 m+ v! J0 g; pSQL语句变成了:7 \# f9 U3 U a
( E, V0 l4 G& |% M) W/ lstrSQL = "SELECT * FROM users WHERE name = 'any_value' and pw = ''; DROP TABLE users"
6 G, j7 Z) @5 e" I( F& O这样一来,虽然没有登录,但是数据表都被删除了。
J; n! b) V' z9 B. U+ ]
, e% ~( T D) `* h然而使用PreparedStatement的参数化的查询可以阻止大部分的SQL注入。在使用参数化查询的情况下,数据库系统(eg:MySQL)不会将参数的内容视为SQL指令的一部分来处理,而是在数据库完成SQL指令的编译后,才套用参数运行,因此就算参数中含有破坏性的指令,也不会被数据库所运行。
2 T2 ?' D6 W4 l% x2 H; Q9 ?/ J补充:避免SQL注入的第二种方式:6 Y1 `* p! o9 P) I: I
在组合SQL字符串的时候,先对所传入的参数做字符取代(将单引号字符取代为连续2个单引号字符,因为连续2个单引号字符在SQL数据库中会视为字符中的一个单引号字符,譬如:
`2 D/ g) V* F, J% `% x% }8 U* Y$ D# b. a T c$ g% j0 C
strSQL = "SELECT * FROM users WHERE name = '" + userName + "';"
( @& P# b$ }" Q! j; }" K& [7 w传入字符串:2 N7 z9 d4 ?7 `" C- m D
4 Q Q" m2 G3 quserName = " 1' OR 1=1 ". R8 p+ l5 w$ S4 p, | o! ^
把userName做字符替换后变成:
/ V# Z- i. r9 [9 d' P$ F6 ?% a( ^
6 @9 _! V" P2 [7 ~1 _% }3 f( KuserName = " 1'' OR 1=1". m6 F7 {+ m, i, R$ }9 i
最后生成的SQL查询语句为:3 m+ e: p- w$ T5 r' L
& a. e1 ?! D) z. W, M! w
strSQL = "SELECT * FROM users WHERE name = '1'' OR 1=1'
% e" r1 y2 l" e* }* k2 u1 I) h' }这样数据库就会去系统查找name为“1′ ‘ OR 1=1”的记录,而避免了SQL注入。
/ { T- k9 i* Z" I2 b- d# N
: }) t3 O d2 ^6 ~比起凌乱的字符串追加似的查询,PreparedStatement查询可读性更好、更安全。
' \% x. g. e$ W4 }- q! x' GPreparedStatement的局限性) e3 E3 c6 Q0 o4 h; Y) Y
2 P! T4 n+ b1 l4 k
尽管PreparedStatement非常实用,但是它仍有一定的限制。- t4 f0 k K. ~# ^0 U) g z
1. 为了防止SQL注入攻击,PreparedStatement不允许一个占位符(?)有多个值,在执行有**IN**子句查询的时候这个问题变得棘手起来。下面这个SQL查询使用PreparedStatement就不会返回任何结果
. P- ]1 l1 x1 {/ ~: D/ ?& R+ g* g% V z- ~, P0 h4 i8 V
SELECT * FROM loan WHERE loan_type IN (?)
5 n5 ~' o& |0 C! b* b6 rpreparedSatement.setString(1, "'personal loan', 'home loan', 'gold loan'");
) ]! i' c6 } D4 y- ~/ l那如何解决这个问题呢?请你继续关注本博客,下期告诉你答案。
/ {. N# [$ v- I5 H& C1 f0 k4 j* N# m0 ~1 O' n
不算总结的总结
! P: j; a- H) D% S8 g0 g, r. G& m: c* K" b' v; H
关于PreparedStatement接口,需要重点记住的是:
/ x) r9 E% f H3 W* B1. PreparedStatement可以写参数化查询,比Statement能获得更好的性能。1 [; c& G* w" Y4 h
2. 对于PreparedStatement来说,数据库可以使用已经编译过及定义好的执行计划,这种预处理语句查询比普通的查询运行速度更快。5 c" [+ V8 w: }9 L, _7 D
3. PreparedStatement可以阻止常见的SQL注入式攻击。3 \0 l) I e* O) r' E3 ]0 i3 ^
4. PreparedStatement可以写动态查询语句
' x" S; D( X0 t! Q6 B7 K% q5. PreparedStatement与java.sql.Connection对象是关联的,一旦你关闭了connection,PreparedStatement也没法使用了。9 G: E1 K7 |) b. Q! }' `6 `( V* w
6. “?” 叫做占位符。
, L* N0 ]' J! `$ i/ N# Y+ K7 ]7. PreparedStatement查询默认返回FORWARD_ONLY的ResultSet,你只能往一个方向移动结果集的游标。当然你还可以设定为其他类型的值如:”CONCUR_READ_ONLY”。) C9 T( B+ F" }: d z
8. 不支持预编译SQL查询的JDBC驱动,在调用connection.prepareStatement(sql)的时候,它不会把SQL查询语句发送给数据库做预处理,而是等到执行查询动作的时候(调用executeQuery()方法时)才把查询语句发送个数据库,这种情况和使用Statement是一样的。/ I: w! T5 F' F0 p
9. 占位符的索引位置从1开始而不是0,如果填入0会导致*java.sql.SQLException invalid column index*异常。所以如果PreparedStatement有两个占位符,那么第一个参数的索引时1,第二个参数的索引是2.
# F/ P# l3 v) ?* w* L
" `* h: c' ]3 s9 Y( q. @以上就是为什么要使用PreparedStatement的全部理由,不过你仍然可以使用Statement对象用来做做测试。但是在生产环境下你一定要考虑使用 PreparedStatement 。
8 Q9 y: n) `* Y# j5 e |
|