该用户从未签到
|
PreparedStatement是用来执行SQL查询语句的API之一,java提供了 Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句,其中 Statement 用于通用查询, PreparedStatement 用于执行参数化查询,而 CallableStatement则是用于存储过程。同时PreparedStatement还经常会在Java面试被提及,譬如:Statement与PreparedStatement的区别以及如何避免SQL注入式攻击?这篇教程中我们会讨论为什么要用PreparedStatement?使用PreparedStatement有什么样的优势?PreparedStatement又是如何避免SQL注入攻击的?
" e0 ]: j5 A5 m4 h
2 [1 h Q8 @4 D! N: Y/ nPreparedStatement是什么?8 O" D' Y3 p% p
6 r( |) ^: P9 M, j
PreparedStatement是java.sql包下面的一个接口,用来执行SQL语句查询,通过调用connection.preparedStatement(sql)方法可以获得PreparedStatment对象。数据库系统会对sql语句进行预编译处理(如果JDBC驱动支持的话),预处理语句将被预先编译好,这条预编译的sql查询语句能在将来的查询中重用,这样一来,它比Statement对象生成的查询速度更快。下面是一个例子:8 o6 z! j- K" L, v1 ~
2 K* X- B* x7 H X/ R2 i
% D# j, w- r0 W! T* Npublic class PreparedStmtExample {
2 g3 b* @8 k8 l" v+ j/ K, T9 T$ M B3 G$ o d6 H0 d5 T
public static void main(String args[]) throws SQLException {, ?( ?+ j" q9 S x
Connection conn = DriverManager.getConnection("mysql:\\localhost:1520", "root", "root");
/ b4 N+ Y: m9 y% W! Z PreparedStatement preStatement = conn.prepareStatement("select distinct loan_type from loan where bank=?");
7 s1 c! o* m1 h" \$ @5 N( Y preStatement.setString(1, "Citibank");% }! W0 s/ G1 V% S
5 n+ D8 N- o* x. e
ResultSet result = preStatement.executeQuery();
. a- S3 P1 f* V
# W6 n6 b+ j. J4 R: ~; R& o$ q3 i while(result.next()){4 P) H7 U: |( F+ F5 l8 o6 v7 g
System.out.println("Loan Type: " + result.getString("loan_type"));
; q, S: H2 T$ H+ B/ l5 O }
/ H) H6 c! @/ Z4 j _6 D9 {/ n }
' d' g) [! `+ Y& Q3 w}
: ?; E# k/ @6 M+ t8 D I' E% \Output:1 o5 K) ?" D' S
Loan Type: Personal Loan5 R7 h# f* p2 d0 Z7 y. j" c
Loan Type: Auto Loan d4 S! X3 c0 @) F2 T! p2 I, t
Loan Type: Home Loan
) O" b# u% R' d3 cLoan Type: Gold Loan
0 }% k. Q2 ~* l) m' o8 g这个例子中,如果还是用 PreparedStatement 做同样的查询,哪怕参数值不一样,比如:”Standard Chated” 或者”HSBC”作为参数值,数据库系统还是会去调用之前编译器编译好的执行语句(系统库系统初次会对查询语句做最大的性能优化)。默认会返回”TYPE_FORWARD_ONLY”类型的结果集( ResultSet ),当然你也可以使用preparedstatment()的重载方法返回不同类型的结果集。
' D( N( r: u" ^
) F& g- t6 G [0 x9 n预处理语句的优势
2 E* e' W- V6 L4 Z$ `& \1 B
# z, _ j+ h/ M1 Q! wPreparedStatement提供了诸多好处,企业级应用开发中强烈推荐使用PreparedStatement来做SQL查询,下面列出PreparedStatement的几点优势。
0 L; Y/ N6 ?* p8 {6 ]4 [4 \5 R! w; S, U9 {# W% m' K0 L
PreparedStatement可以写动态参数化的查询4 ~ M7 `' `/ I* X3 ]) H/ ~1 A6 r
用PreparedStatement你可以写带参数的sql查询语句,通过使用相同的sql语句和不同的参数值来做查询比创建一个不同的查询语句要好,下面是一个参数化查询:
4 ^" w* ?: t9 L S. }% w. g+ \1$ s% i" v* S) F5 `/ J3 R
SELECT interest_rate FROM loan WHERE loan_type=?
3 Z- v8 z: T# k1 [! T" a& Y% c0 x8 ~现在你可以使用任何一种loan类型如:”personal loan”,”home loan” 或者”gold loan”来查询,这个例子叫做参数化查询,因为它可以用不同的参数调用它,这里的”?”就是参数的占位符。
3 O' B# s" l$ v$ I0 R
5 ?7 U/ \* \$ @+ _PreparedStatement比 Statement 更快
4 n7 E+ F o, N- F使用 PreparedStatement 最重要的一点好处是它拥有更佳的性能优势,SQL语句会预编译在数据库系统中。执行计划同样会被缓存起来,它允许数据库做参数化查询。使用预处理语句比普通的查询更快,因为它做的工作更少(数据库对SQL语句的分析,编译,优化已经在第一次查询前完成了)。为了减少数据库的负载,生产环境中德JDBC代码你应该总是使用PreparedStatement 。值得注意的一点是:为了获得性能上的优势,应该使用参数化sql查询而不是字符串追加的方式。下面两个SELECT 查询,第一个SELECT查询就没有任何性能优势。
( b1 p5 E# ^" G: c5 I4 `# ^" b3 t& ISQL Query 1:字符串追加形式的PreparedStatement
, _0 S/ v; T/ r3 s1
8 ^6 g3 b1 ^6 B8 w2' q$ Q8 W; v, l+ k8 [5 |
String loanType = getLoanType();
- z, P( a; S: Q7 i/ JPreparedStatement prestmt = conn.prepareStatement("select banks from loan where loan_type=" + loanType);6 z4 o+ C% t- w; G) X# H+ j ?" N
SQL Query 2:使用参数化查询的PreparedStatement
9 V% B$ t; F+ n, A# k: E1 @8 h) k9 b6 t. X" z* R- l% J* r
1; c0 ^' g$ O4 q# g
2% ^8 K. d8 c Z# Y( O% q
PreparedStatement prestmt = conn.prepareStatement("select banks from loan where loan_type=?");
9 i9 b1 b8 s$ x2 h% S9 fprestmt.setString(1,loanType);
* X8 X3 G$ f- R* I第二个查询就是正确使用PreparedStatement的查询,它比SQL1能获得更好的性能。) n4 T5 J$ o$ {& w
. ~, [& O! e8 Q
PreparedStatement可以防止SQL注入式攻击
3 \1 ]$ s( Z, k, W如果你是做Java web应用开发的,那么必须熟悉那声名狼藉的SQL注入式攻击。去年Sony就遭受了SQL注入攻击,被盗用了一些Sony play station(PS机)用户的数据。在SQL注入攻击里,恶意用户通过SQL元数据绑定输入,比如:某个网站的登录验证SQL查询代码为:
, i8 Q( P6 U; QstrSQL = "SELECT * FROM users WHERE name = '" + userName + "' and pw = '"+ passWord +"';"( I# K0 C- p; v2 W" x9 R0 h/ i7 r
恶意填入:
$ {9 l, ?% y J/ Q7 ]/ [/ u
1 @6 J x( ~( I7 J- NuserName = "1' OR '1'='1";4 ~' g: x- {* {2 j& f& D
passWord = "1' OR '1'='1";
& l* w9 h5 ?4 i' s' b那么最终SQL语句变成了:
5 l8 S2 X, y! u, A, B: z, p
3 A; K9 Y" Z3 l$ z- t2 @2 dstrSQL = "SELECT * FROM users WHERE name = '1' OR '1'='1' and pw = '1' OR '1'='1';"
; |! Q- f! ?6 \9 Z2 ^0 \因为WHERE条件恒为真,这就相当于执行:
8 E5 t( X) F8 V/ j4 u; @0 z: r9 [
strSQL = "SELECT * FROM users;"6 V+ F" M; K. k/ ?1 e
因此可以达到无账号密码亦可登录网站。如果恶意用户要是更坏一点,用户填入:$ d* j: p! G- j: b! F
; j o* n9 k/ ~, N2 z& S- }# @strSQL = "SELECT * FROM users;"
7 q$ Y8 k# S9 D9 f, j- d' [SQL语句变成了: m9 }/ X# Y, S5 c6 G
S6 N. |6 c u$ CstrSQL = "SELECT * FROM users WHERE name = 'any_value' and pw = ''; DROP TABLE users"
8 @3 {9 |1 s2 @6 V# Z3 g这样一来,虽然没有登录,但是数据表都被删除了。
" p1 m* c% ]9 h" S8 T$ G& E- Y0 H& Z% b4 m5 B7 M; W
然而使用PreparedStatement的参数化的查询可以阻止大部分的SQL注入。在使用参数化查询的情况下,数据库系统(eg:MySQL)不会将参数的内容视为SQL指令的一部分来处理,而是在数据库完成SQL指令的编译后,才套用参数运行,因此就算参数中含有破坏性的指令,也不会被数据库所运行。4 Y+ F( H' F5 O* V* h$ Q' O
补充:避免SQL注入的第二种方式:
" G: ^' H* g' H6 m P在组合SQL字符串的时候,先对所传入的参数做字符取代(将单引号字符取代为连续2个单引号字符,因为连续2个单引号字符在SQL数据库中会视为字符中的一个单引号字符,譬如:" p! c; I/ q* N% q6 D) X& y
+ Y9 t: Y0 O6 G- ZstrSQL = "SELECT * FROM users WHERE name = '" + userName + "';"! C0 E5 \& j1 p
传入字符串:/ Z' @- p5 e! d+ y( ?* p
9 O; z5 _6 F3 E2 ?. ~# E
userName = " 1' OR 1=1 "
2 ]. {+ ~: }* w& i1 q把userName做字符替换后变成:
H1 ]6 j$ G! W; r$ q- H& R$ ?7 _7 e' C4 q2 g1 z" f
userName = " 1'' OR 1=1"! O5 T* P0 ]9 A
最后生成的SQL查询语句为:
: Y& w+ [6 D4 e. b8 Q+ n2 X. I4 x
strSQL = "SELECT * FROM users WHERE name = '1'' OR 1=1': ^' ?1 d) L2 x) ]. X4 g! z, a' a
这样数据库就会去系统查找name为“1′ ‘ OR 1=1”的记录,而避免了SQL注入。
0 t. p3 u" E% E5 \. b: i, k/ A* d, o; A8 `. j' l" a
比起凌乱的字符串追加似的查询,PreparedStatement查询可读性更好、更安全。# O H6 Y4 ]4 a; ^' y
PreparedStatement的局限性, i! G D/ X7 d- Y: ]
. g2 }5 e6 J3 N4 g8 U尽管PreparedStatement非常实用,但是它仍有一定的限制。
$ E8 A5 X# N8 Q- d1. 为了防止SQL注入攻击,PreparedStatement不允许一个占位符(?)有多个值,在执行有**IN**子句查询的时候这个问题变得棘手起来。下面这个SQL查询使用PreparedStatement就不会返回任何结果
- u/ P1 |) j5 \+ q1 Y' m5 N, G, n) r1 a. F
SELECT * FROM loan WHERE loan_type IN (?)/ f" r6 T+ l {
preparedSatement.setString(1, "'personal loan', 'home loan', 'gold loan'");) @* u( c/ s2 W& {6 L3 o9 Q4 [6 m
那如何解决这个问题呢?请你继续关注本博客,下期告诉你答案。% S* d# F; R9 D
% V2 I1 Z* Z0 Z }不算总结的总结8 ^6 _" P8 O( w! r* M
. R& k) | Y, T2 {
关于PreparedStatement接口,需要重点记住的是:# @3 Q& Y; x* j2 J4 x9 n$ ]
1. PreparedStatement可以写参数化查询,比Statement能获得更好的性能。
* `& Z* d# b$ P* @ w+ {( w2. 对于PreparedStatement来说,数据库可以使用已经编译过及定义好的执行计划,这种预处理语句查询比普通的查询运行速度更快。
j+ A; E/ W8 J7 x3. PreparedStatement可以阻止常见的SQL注入式攻击。2 o0 o0 V- }. T: u8 W5 {8 x! Y4 d
4. PreparedStatement可以写动态查询语句2 j- F# ^( Q% f r, K4 q
5. PreparedStatement与java.sql.Connection对象是关联的,一旦你关闭了connection,PreparedStatement也没法使用了。
7 m/ z: _9 G% N a4 j8 ?6 X6. “?” 叫做占位符。% W6 O" W% Z" p6 M2 ~. K3 |
7. PreparedStatement查询默认返回FORWARD_ONLY的ResultSet,你只能往一个方向移动结果集的游标。当然你还可以设定为其他类型的值如:”CONCUR_READ_ONLY”。5 h$ U- i6 D9 d: S0 m+ Z$ j
8. 不支持预编译SQL查询的JDBC驱动,在调用connection.prepareStatement(sql)的时候,它不会把SQL查询语句发送给数据库做预处理,而是等到执行查询动作的时候(调用executeQuery()方法时)才把查询语句发送个数据库,这种情况和使用Statement是一样的。 h8 C- S1 I% Z
9. 占位符的索引位置从1开始而不是0,如果填入0会导致*java.sql.SQLException invalid column index*异常。所以如果PreparedStatement有两个占位符,那么第一个参数的索引时1,第二个参数的索引是2., ?7 A3 f) A& ^# ] D0 g
8 D5 |$ F1 C1 I7 V以上就是为什么要使用PreparedStatement的全部理由,不过你仍然可以使用Statement对象用来做做测试。但是在生产环境下你一定要考虑使用 PreparedStatement 。
% M: E1 `6 L5 I3 O4 g |
|