该用户从未签到
|
PreparedStatement是用来执行SQL查询语句的API之一,java提供了 Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句,其中 Statement 用于通用查询, PreparedStatement 用于执行参数化查询,而 CallableStatement则是用于存储过程。同时PreparedStatement还经常会在Java面试被提及,譬如:Statement与PreparedStatement的区别以及如何避免SQL注入式攻击?这篇教程中我们会讨论为什么要用PreparedStatement?使用PreparedStatement有什么样的优势?PreparedStatement又是如何避免SQL注入攻击的?
) W9 X6 ^ R8 | |9 V8 I' B+ x
) A _! z; Z5 Q, _" X3 bPreparedStatement是什么?
) Y# ^! u9 T& W W8 ]
. f( J1 f" Y2 A. n. Z/ lPreparedStatement是java.sql包下面的一个接口,用来执行SQL语句查询,通过调用connection.preparedStatement(sql)方法可以获得PreparedStatment对象。数据库系统会对sql语句进行预编译处理(如果JDBC驱动支持的话),预处理语句将被预先编译好,这条预编译的sql查询语句能在将来的查询中重用,这样一来,它比Statement对象生成的查询速度更快。下面是一个例子:: R4 |& D6 z' o+ @" A1 X
; @8 @' P7 g% H. G4 X, |- D
. F0 [8 J* b2 ~) hpublic class PreparedStmtExample {9 G: M ~$ l! ~) q. Q
' v' X' m8 f9 u& b- U: @; U public static void main(String args[]) throws SQLException {
( i7 T5 g7 P! J4 C' j5 A, g Connection conn = DriverManager.getConnection("mysql:\\localhost:1520", "root", "root");& I( s1 j6 Q; N/ v. S! w) r U/ a
PreparedStatement preStatement = conn.prepareStatement("select distinct loan_type from loan where bank=?");* _) R3 `: W7 Y5 `8 {
preStatement.setString(1, "Citibank");; N, X2 T& a0 f. `2 h
! V% M5 O$ q' F* u" J1 H ResultSet result = preStatement.executeQuery();
) g* U, ^3 \. z7 K6 g. G4 r; |$ i" W, Y( T1 U/ j3 @* j0 q
while(result.next()){: p6 ?( M. J$ M9 D: W' ]( V) l
System.out.println("Loan Type: " + result.getString("loan_type"));
; F: c0 `) h' o/ p; k. E. c }
. @. _. d5 M0 }/ ^ }5 T) N. Z1 G" A" s& }
} 0 e0 e9 `1 L1 Y6 X o6 n$ s C! o
Output:& K% C5 {1 Q5 `8 U' o* `& N% |
Loan Type: Personal Loan w1 N) ^( h8 a8 d
Loan Type: Auto Loan
+ u& h6 S) w( y8 Q# WLoan Type: Home Loan% t4 E7 ?% K5 F9 ?- E2 U. M
Loan Type: Gold Loan, g% w$ H* b e* O
这个例子中,如果还是用 PreparedStatement 做同样的查询,哪怕参数值不一样,比如:”Standard Chated” 或者”HSBC”作为参数值,数据库系统还是会去调用之前编译器编译好的执行语句(系统库系统初次会对查询语句做最大的性能优化)。默认会返回”TYPE_FORWARD_ONLY”类型的结果集( ResultSet ),当然你也可以使用preparedstatment()的重载方法返回不同类型的结果集。$ B e( h) i( o+ `2 F+ Q. ]8 Z
# U8 P* L4 t( x$ L" K* C- }
预处理语句的优势
& S0 \7 P9 ?+ ?( ^9 t) ~5 a' X7 a4 B# t k8 @+ s4 }) V
PreparedStatement提供了诸多好处,企业级应用开发中强烈推荐使用PreparedStatement来做SQL查询,下面列出PreparedStatement的几点优势。
+ l. i+ W! |, T
" D1 V4 F* a$ q0 vPreparedStatement可以写动态参数化的查询5 l0 X* N% k6 d' f' I4 [
用PreparedStatement你可以写带参数的sql查询语句,通过使用相同的sql语句和不同的参数值来做查询比创建一个不同的查询语句要好,下面是一个参数化查询:
) A9 @+ O# @; L* `- U# Y1 y1 d7 p5 t5 \: L) _% B
SELECT interest_rate FROM loan WHERE loan_type=?8 ~5 r( U% w! V/ c5 p# ?
现在你可以使用任何一种loan类型如:”personal loan”,”home loan” 或者”gold loan”来查询,这个例子叫做参数化查询,因为它可以用不同的参数调用它,这里的”?”就是参数的占位符。
: T4 H$ p& m7 g. |( O1 T% G. Q6 Z+ A# x' a" d |9 E
PreparedStatement比 Statement 更快* S, F9 C2 G0 y* z
使用 PreparedStatement 最重要的一点好处是它拥有更佳的性能优势,SQL语句会预编译在数据库系统中。执行计划同样会被缓存起来,它允许数据库做参数化查询。使用预处理语句比普通的查询更快,因为它做的工作更少(数据库对SQL语句的分析,编译,优化已经在第一次查询前完成了)。为了减少数据库的负载,生产环境中德JDBC代码你应该总是使用PreparedStatement 。值得注意的一点是:为了获得性能上的优势,应该使用参数化sql查询而不是字符串追加的方式。下面两个SELECT 查询,第一个SELECT查询就没有任何性能优势。. K# N) p6 v: x% K: d( @
SQL Query 1:字符串追加形式的PreparedStatement
/ \3 v% ?8 R; ]: l2 z1
1 V$ B! {8 k0 _; V* e% H2
% i' g9 T5 y6 x! r6 x1 m' J5 kString loanType = getLoanType();; R6 H* W9 Q m$ f
PreparedStatement prestmt = conn.prepareStatement("select banks from loan where loan_type=" + loanType);
4 O" w. b9 m' H4 D4 CSQL Query 2:使用参数化查询的PreparedStatement
& x6 V r3 j. N4 ^* \& w3 V8 s1 H0 ?/ h. W$ ]( N
1
) y4 {' @9 y8 u; s" Q: r5 \. Z25 s5 P' o% k" j: C X
PreparedStatement prestmt = conn.prepareStatement("select banks from loan where loan_type=?");& s/ a) W: N! L& V% n5 g% G! X0 Q
prestmt.setString(1,loanType);( S7 V! W, o* F7 q6 y( l. K9 c9 w
第二个查询就是正确使用PreparedStatement的查询,它比SQL1能获得更好的性能。
& V& m% G. o4 [" b2 |7 p! i- J1 |9 ^9 ?0 A" o: B
PreparedStatement可以防止SQL注入式攻击9 r0 r, @) R i
如果你是做Java web应用开发的,那么必须熟悉那声名狼藉的SQL注入式攻击。去年Sony就遭受了SQL注入攻击,被盗用了一些Sony play station(PS机)用户的数据。在SQL注入攻击里,恶意用户通过SQL元数据绑定输入,比如:某个网站的登录验证SQL查询代码为:7 u& h" l; ^1 h
strSQL = "SELECT * FROM users WHERE name = '" + userName + "' and pw = '"+ passWord +"';"6 B; d7 `5 H# u9 k' Y; F9 `
恶意填入:
: k: o4 p# ^' c. U V) o" ~: @* o) A3 x
userName = "1' OR '1'='1";
1 b4 m0 e/ ~6 Y* Q+ ]% MpassWord = "1' OR '1'='1";3 w: a4 O; I8 I) S
那么最终SQL语句变成了:- C+ W6 E0 G, ?4 ~
& W1 p4 T* j9 G1 |strSQL = "SELECT * FROM users WHERE name = '1' OR '1'='1' and pw = '1' OR '1'='1';"
# ^6 }/ m* b) {, T6 F因为WHERE条件恒为真,这就相当于执行:
- s% M2 L; ]. E, E& o& v5 a
, f" J! p7 r4 N7 LstrSQL = "SELECT * FROM users;"% z7 c% R) v2 C& g/ G4 a; n
因此可以达到无账号密码亦可登录网站。如果恶意用户要是更坏一点,用户填入:
1 b' C: Y6 z4 J
2 P5 P N& u: S0 R- ?6 T" V( `strSQL = "SELECT * FROM users;": o0 \ r- E6 F; [/ ?/ b
SQL语句变成了:
- P( w& g4 z2 ^* L+ a+ Y4 S- F0 ^/ ]( J; F! {/ r( a
strSQL = "SELECT * FROM users WHERE name = 'any_value' and pw = ''; DROP TABLE users"/ a; p [9 m3 r. T a; V) L
这样一来,虽然没有登录,但是数据表都被删除了。
7 v7 Z$ H3 e2 s0 D6 P( m+ h3 G0 E3 p. L& X2 _8 ?$ _: M
然而使用PreparedStatement的参数化的查询可以阻止大部分的SQL注入。在使用参数化查询的情况下,数据库系统(eg:MySQL)不会将参数的内容视为SQL指令的一部分来处理,而是在数据库完成SQL指令的编译后,才套用参数运行,因此就算参数中含有破坏性的指令,也不会被数据库所运行。
, Z+ D0 x' O ~$ d& g n补充:避免SQL注入的第二种方式:8 u( ^6 h+ q O. Z
在组合SQL字符串的时候,先对所传入的参数做字符取代(将单引号字符取代为连续2个单引号字符,因为连续2个单引号字符在SQL数据库中会视为字符中的一个单引号字符,譬如:. {& S1 a P* B6 d9 J% ]
5 |: Y4 `' J- W- \( |
strSQL = "SELECT * FROM users WHERE name = '" + userName + "';"2 I0 Z8 V5 @, ?& Q' T: K' K2 H2 o5 k
传入字符串:
- K5 G4 q9 f S& N: y/ S
j8 j* O% a* j% \% ~+ v, |userName = " 1' OR 1=1 "& W2 q! O) p; T+ r6 j9 g- j- k
把userName做字符替换后变成:. X* i4 Q: Y5 u8 U. D" \
* `: C* ]! @ R. J+ E9 a6 q. @) cuserName = " 1'' OR 1=1"
$ J' d) t" O6 J" y最后生成的SQL查询语句为:" q4 e! F/ h( \" p* r) e) c
6 `) d7 F' R" o' j9 _) H1 _
strSQL = "SELECT * FROM users WHERE name = '1'' OR 1=1'
4 K% t7 Z& f4 I0 a# ~这样数据库就会去系统查找name为“1′ ‘ OR 1=1”的记录,而避免了SQL注入。
$ {8 Z, o; P1 J! K5 s, ]* Z( v1 s
比起凌乱的字符串追加似的查询,PreparedStatement查询可读性更好、更安全。
3 o8 |' M5 s) RPreparedStatement的局限性4 u$ T" K3 r( \& ^9 `: j% j
+ T! g! P% U& z6 n尽管PreparedStatement非常实用,但是它仍有一定的限制。. q5 o/ O H* S% y! z8 u
1. 为了防止SQL注入攻击,PreparedStatement不允许一个占位符(?)有多个值,在执行有**IN**子句查询的时候这个问题变得棘手起来。下面这个SQL查询使用PreparedStatement就不会返回任何结果
% L) R! H) q: {8 j) U: Q0 q; P2 z8 v9 I9 D4 n
SELECT * FROM loan WHERE loan_type IN (?)
' Y6 H. a) ]5 t% R) M# ^preparedSatement.setString(1, "'personal loan', 'home loan', 'gold loan'");
6 {6 I2 v, b& ]9 c- r) V7 k* e那如何解决这个问题呢?请你继续关注本博客,下期告诉你答案。. V& K- Z& A$ ?8 M
# ?% \ \4 k. D3 B) a& `; |. P不算总结的总结
! q: }+ m, f$ S/ A& i6 L1 ^8 G$ J( D5 {5 X
关于PreparedStatement接口,需要重点记住的是:
: l! ~1 s4 s6 g' P; e" I1. PreparedStatement可以写参数化查询,比Statement能获得更好的性能。
# k; B3 t% j) W/ R. N& M2. 对于PreparedStatement来说,数据库可以使用已经编译过及定义好的执行计划,这种预处理语句查询比普通的查询运行速度更快。
( k# w$ P# d& @7 G3. PreparedStatement可以阻止常见的SQL注入式攻击。
0 F/ R8 s4 @9 G6 N; c4. PreparedStatement可以写动态查询语句
0 t g/ K! p) b5 |* a0 R8 W. t0 u6 R5. PreparedStatement与java.sql.Connection对象是关联的,一旦你关闭了connection,PreparedStatement也没法使用了。
9 P( [9 r( |4 Q6. “?” 叫做占位符。; J& U. u; v. [( M
7. PreparedStatement查询默认返回FORWARD_ONLY的ResultSet,你只能往一个方向移动结果集的游标。当然你还可以设定为其他类型的值如:”CONCUR_READ_ONLY”。9 H N% ]( {! t' s
8. 不支持预编译SQL查询的JDBC驱动,在调用connection.prepareStatement(sql)的时候,它不会把SQL查询语句发送给数据库做预处理,而是等到执行查询动作的时候(调用executeQuery()方法时)才把查询语句发送个数据库,这种情况和使用Statement是一样的。
8 h) `. L4 i7 o7 @2 o9. 占位符的索引位置从1开始而不是0,如果填入0会导致*java.sql.SQLException invalid column index*异常。所以如果PreparedStatement有两个占位符,那么第一个参数的索引时1,第二个参数的索引是2.
( V" [/ _1 h& X; \* m$ ?3 {& Q+ L/ r
以上就是为什么要使用PreparedStatement的全部理由,不过你仍然可以使用Statement对象用来做做测试。但是在生产环境下你一定要考虑使用 PreparedStatement 。
% E/ u1 G) ?1 v. m" o; R% d |
|