iBatis分页

最近在学习iBatis的分页功能，iBatis默认的分页是采用游标滚动的方式来实现的，这种方式在大数据量的情况下便会OOM了，因此一般都采用手写分页SQL语句使用数据库物理分页方式实现，参考了网上很多网友所写的如何实现像hibernate一样使用方言的方式来实现分页功能，基本上千篇一律都是继承com.ibatis.sqlmap.engine.execution.SqlExecutor类然后在spring中进行注入等等，操作复杂编码甚多，方法不可取。

另外还有些是修改iBatis的jar包来实现，本人觉得这种方法更不可取。
基于网友们的思想，自己实现了另一种方法，不用修改源码，不用在spring中做任何配置即可实现物理分页功能：
条件
1、JVM类的加载是通过Class.forName(String cls)来实现，根据这个原理可以自己写一个与com.ibatis.sqlmap.engine.execution.SqlExecutor同名类；
2、java web类的加载顺序是：首先是web容器的相关类与jar包，然后是web工程下面WEB-INF/classes/下的所有类，最后才是WEB-INF/lib下的所有jar包；
有了以上的先决条件就好办了，可以在你的项目src目录下建包com.ibatis.sqlmap.engine.execution，然后在此包下建类SqlExecutor，然后把iBatis包下的这个类的源码复制进来后做小小改动，原来的executeQuery方法改成私有、换名，换成什么名称随便，然后新建一个公有的executeQuery方法，分页功能就在这个方法体内实现；
这样一来，web容器首会找到WEB-INF/classes下的com.ibatis.sqlmap.engine.execution.SqlExecutor这个类，因而会忽略掉在ibatis包中的这个类，即实现了自定义的分页功能，又不用去破坏ibatis的包；
还有一点，也可以将自定义的这个类打成jar包放到lib中去，不过这时就要注意了，jar包的名称一定要在ibatis包的名称之前，也就是说ibatis-2.3.4.726.jar，那么这个jar就可以写成ibatis-2.3.4.725.jar，或者字母在ibatis这几个字母之前，这样才能正确加载自己写的那个类。
贴上代码：
SqlExecutor.java

Java代码

1. /*
2. *Copyright2004ClintonBegin
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
16. packagecom.ibatis.sqlmap.engine.execution;
18. importjava.sql.BatchUpdateException;
19. importjava.sql.CallableStatement;
20. importjava.sql.Connection;
21. importjava.sql.PreparedStatement;
22. importjava.sql.ResultSet;
23. importjava.sql.SQLException;
24. importjava.sql.Statement;
25. importjava.sql.Types;
26. importjava.util.ArrayList;
27. importjava.util.List;
29. importorg.apache.commons.logging.Log;
30. importorg.apache.commons.logging.LogFactory;
32. importcom.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
33. importcom.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
34. importcom.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
35. importcom.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
36. importcom.ibatis.sqlmap.engine.mapping.result.ResultMap;
37. importcom.ibatis.sqlmap.engine.mapping.result.ResultObjectFactoryUtil;
38. importcom.ibatis.sqlmap.engine.mapping.statement.DefaultRowHandler;
39. importcom.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
40. importcom.ibatis.sqlmap.engine.mapping.statement.RowHandlerCallback;
41. importcom.ibatis.sqlmap.engine.scope.ErrorContext;
42. importcom.ibatis.sqlmap.engine.scope.SessionScope;
43. importcom.ibatis.sqlmap.engine.scope.StatementScope;
45. /**
46. *ClassresponsibleforexecutingtheSQL
47. */
48. @SuppressWarnings("unchecked")
49. publicclassSqlExecutor{
51. privatestaticfinalLoglog=LogFactory.getLog(SqlExecutor.class);
52. //
53. //Constants
54. //
55. /**
56. *Constanttoletusknownottoskipanything
57. */
58. publicstaticfinalintNO_SKIPPED_RESULTS=0;
59. /**
60. *Constanttoletusknowtoincludeallrecords
61. */
62. publicstaticfinalintNO_MAXIMUM_RESULTS=-999999;
64. publicSqlExecutor(){
65. log.info("Customclass'SqlExecutor'Initialization");
66. }
68. //
69. //PublicMethods
70. //
72. /**
73. *Executeanupdate
74. *
75. *@paramstatementScope
76. *-therequestscope
77. *@paramconn
78. *-thedatabaseconnection
79. *@paramsql
80. *-thesqlstatementtoexecute
81. *@paramparameters
82. *-theparametersforthesqlstatement
83. *@return-thenumberofrecordschanged
84. *@throwsSQLException
85. *-iftheupdatefails
86. */
87. publicintexecuteUpdate(StatementScopestatementScope,Connectionconn,
88. Stringsql,Object[]parameters)throwsSQLException{
89. ErrorContexterrorContext=statementScope.getErrorContext();
90. errorContext.setActivity("executingupdate");
91. errorContext.setObjectId(sql);
92. PreparedStatementps=null;
93. setupResultObjectFactory(statementScope);
94. introws=0;
95. try{
96. errorContext
97. .setMoreInfo("ChecktheSQLStatement(preparationfailed).");
98. ps=prepareStatement(statementScope.getSession(),conn,sql);
99. setStatementTimeout(statementScope.getStatement(),ps);
100. errorContext
101. .setMoreInfo("Checktheparameters(setparametersfailed).");
102. statementScope.getParameterMap().setParameters(statementScope,ps,
103. parameters);
104. errorContext.setMoreInfo("Checkthestatement(updatefailed).");
105. ps.execute();
106. rows=ps.getUpdateCount();
107. }finally{
108. closeStatement(statementScope.getSession(),ps);
109. }
110. returnrows;
111. }
113. /**
114. *Addsastatementtoabatch
115. *
116. *@paramstatementScope
117. *-therequestscope
118. *@paramconn
119. *-thedatabaseconnection
120. *@paramsql
121. *-thesqlstatement
122. *@paramparameters
123. *-theparametersforthestatement
124. *@throwsSQLException
125. *-ifthestatementfails
126. */
127. publicvoidaddBatch(StatementScopestatementScope,Connectionconn,
128. Stringsql,Object[]parameters)throwsSQLException{
129. Batchbatch=(Batch)statementScope.getSession().getBatch();
130. if(batch==null){
131. batch=newBatch();
132. statementScope.getSession().setBatch(batch);
133. }
134. batch.addBatch(statementScope,conn,sql,parameters);
135. }
137. /**
138. *Executeabatchofstatements
139. *
140. *@paramsessionScope
141. *-thesessionscope
142. *@return-thenumberofrowsimpactedbythebatch
143. *@throwsSQLException
144. *-ifastatementfails
145. */
146. publicintexecuteBatch(SessionScopesessionScope)throwsSQLException{
147. introws=0;
148. Batchbatch=(Batch)sessionScope.getBatch();
149. if(batch!=null){
150. try{
151. rows=batch.executeBatch();
152. }finally{
153. batch.cleanupBatch(sessionScope);
154. }
155. }
156. returnrows;
157. }
159. /**
160. *Executeabatchofstatements
161. *
162. *@paramsessionScope
163. *-thesessionscope
164. *@return-aListofBatchResultobjects(maybenullifnobatchhasbeen
165. *initiated).TherewillbeoneBatchResultobjectinthelistfor
166. *eachsub-batchexecuted
167. *@throwsSQLException
168. *ifadatabaseaccesserroroccurs,orthedrivedoesnot
169. *supportbatchstatements
170. *@throwsBatchException
171. *ifthedriverthrowsBatchUpdateException
172. */
173. publicListexecuteBatchDetailed(SessionScopesessionScope)
174. throwsSQLException,BatchException{
175. Listanswer=null;
176. Batchbatch=(Batch)sessionScope.getBatch();
177. if(batch!=null){
178. try{
179. answer=batch.executeBatchDetailed();
180. }finally{
181. batch.cleanupBatch(sessionScope);
182. }
183. }
184. returnanswer;
185. }
187. /**
188. *Longformofthemethodtoexecuteaquery
189. *
190. *@paramstatementScope
191. *-therequestscope
192. *@paramconn
193. *-thedatabaseconnection
194. *@paramsql
195. *-theSQLstatementtoexecute
196. *@paramparameters
197. *-theparametersforthestatement
198. *@paramskipResults
199. *-thenumberofresultstoskip
200. *@parammaxResults
201. *-themaximumnumberofresultstoreturn
202. *@paramcallback
203. *-therowhandlerforthequery
204. *@throwsSQLException
205. *-ifthequeryfails
206. */
207. //-------------------------------分页代码重写(start)------------------------------------//
208. //重写executeQuery方法，首先判断是否分页查询，分页查询先将分页SQL语句构建，然后执行iBatis默认的查询
209. publicvoidexecuteQuery(StatementScopestatementScope,Connectionconn,
210. Stringsql,Object[]parameters,intskipResults,intmaxResults,
211. RowHandlerCallbackcallback)throwsSQLException{
212. //取数据库产品名称
213. StringdbName=conn.getMetaData().getDatabaseProductName();
215. intlen=sql.length();
217. //判断是否分页
218. if((skipResults!=NO_SKIPPED_RESULTS||maxResults!=NO_MAXIMUM_RESULTS)){
219. //根据数据库产品名称取对应的分页SQL语句
220. sql=Dialect.getLimitString(dbName,sql,skipResults,maxResults);
222. //分页语句是否存在
223. if(sql.length()!=len){
224. skipResults=NO_SKIPPED_RESULTS;
225. maxResults=NO_MAXIMUM_RESULTS;
226. }
227. }
228. iBatisExecuteQuery(statementScope,conn,sql,parameters,skipResults,
229. maxResults,callback);
230. }
232. //iBatis包中默认的executeQuery方法
233. privatevoidiBatisExecuteQuery(StatementScopestatementScope,
234. Connectionconn,Stringsql,Object[]parameters,intskipResults,
235. intmaxResults,RowHandlerCallbackcallback)throwsSQLException{
236. ErrorContexterrorContext=statementScope.getErrorContext();
237. errorContext.setActivity("executingquery");
238. errorContext.setObjectId(sql);
239. PreparedStatementps=null;
240. ResultSetrs=null;
241. setupResultObjectFactory(statementScope);
242. try{
243. errorContext
244. .setMoreInfo("ChecktheSQLStatement(preparationfailed).");
245. IntegerrsType=statementScope.getStatement().getResultSetType();
246. if(rsType!=null){
247. ps=prepareStatement(statementScope.getSession(),conn,sql,
248. rsType);
249. }else{
250. ps=prepareStatement(statementScope.getSession(),conn,sql);
251. }
252. setStatementTimeout(statementScope.getStatement(),ps);
253. IntegerfetchSize=statementScope.getStatement().getFetchSize();
254. if(fetchSize!=null){
255. ps.setFetchSize(fetchSize.intValue());
256. }
257. errorContext
258. .setMoreInfo("Checktheparameters(setparametersfailed).");
259. statementScope.getParameterMap().setParameters(statementScope,ps,
260. parameters);
261. errorContext.setMoreInfo("Checkthestatement(queryfailed).");
262. ps.execute();
263. errorContext
264. .setMoreInfo("Checktheresults(failedtoretrieveresults).");
266. //BeginResultSetHandling
267. rs=handleMultipleResults(ps,statementScope,skipResults,
268. maxResults,callback);
269. //EndResultSetHandling
270. }finally{
271. try{
272. closeResultSet(rs);
273. }finally{
274. closeStatement(statementScope.getSession(),ps);
275. }
276. }
277. }
278. //--------------------分页代码重写(end)-------------------------------------//
279. /**
280. *Executeastoredprocedurethatupdatesdata
281. *
282. *@paramstatementScope
283. *-therequestscope
284. *@paramconn
285. *-thedatabaseconnection
286. *@paramsql
287. *-theSQLtocalltheprocedure
288. *@paramparameters
289. *-theparametersfortheprocedure
290. *@return-therowsimpactedbytheprocedure
291. *@throwsSQLException
292. *-iftheprocedurefails
293. */
294. publicintexecuteUpdateProcedure(StatementScopestatementScope,
295. Connectionconn,Stringsql,Object[]parameters)
296. throwsSQLException{
297. ErrorContexterrorContext=statementScope.getErrorContext();
298. errorContext.setActivity("executingupdateprocedure");
299. errorContext.setObjectId(sql);
300. CallableStatementcs=null;
301. setupResultObjectFactory(statementScope);
302. introws=0;
303. try{
304. errorContext
305. .setMoreInfo("ChecktheSQLStatement(preparationfailed).");
306. cs=prepareCall(statementScope.getSession(),conn,sql);
307. setStatementTimeout(statementScope.getStatement(),cs);
308. ParameterMapparameterMap=statementScope.getParameterMap();
309. ParameterMapping[]mappings=parameterMap.getParameterMappings();
310. errorContext
311. .setMoreInfo("Checktheoutputparameters(registeroutputparametersfailed).");
312. registerOutputParameters(cs,mappings);
313. errorContext
314. .setMoreInfo("Checktheparameters(setparametersfailed).");
315. parameterMap.setParameters(statementScope,cs,parameters);
316. errorContext
317. .setMoreInfo("Checkthestatement(updateprocedurefailed).");
318. cs.execute();
319. rows=cs.getUpdateCount();
320. errorContext
321. .setMoreInfo("Checktheoutputparameters(retrievalofoutputparametersfailed).");
322. retrieveOutputParameters(statementScope,cs,mappings,parameters,
323. null);
324. }finally{
325. closeStatement(statementScope.getSession(),cs);
326. }
327. returnrows;
328. }
330. /**
331. *Executeastoredprocedure
332. *
333. *@paramstatementScope
334. *-therequestscope
335. *@paramconn
336. *-thedatabaseconnection
337. *@paramsql
338. *-thesqltocalltheprocedure
339. *@paramparameters
340. *-theparametersfortheprocedure
341. *@paramskipResults
342. *-thenumberofresultstoskip
343. *@parammaxResults
344. *-themaximumnumberofresultstoreturn
345. *@paramcallback
346. *-arowhandlerforprocessingtheresults
347. *@throwsSQLException
348. *-iftheprocedurefails
349. */
350. publicvoidexecuteQueryProcedure(StatementScopestatementScope,
351. Connectionconn,Stringsql,Object[]parameters,intskipResults,
352. intmaxResults,RowHandlerCallbackcallback)throwsSQLException{
353. ErrorContexterrorContext=statementScope.getErrorContext();
354. errorContext.setActivity("executingqueryprocedure");
355. errorContext.setObjectId(sql);
356. CallableStatementcs=null;
357. ResultSetrs=null;
358. setupResultObjectFactory(statementScope);
359. try{
360. errorContext
361. .setMoreInfo("ChecktheSQLStatement(preparationfailed).");
362. IntegerrsType=statementScope.getStatement().getResultSetType();
363. if(rsType!=null){
364. cs=prepareCall(statementScope.getSession(),conn,sql,rsType);
365. }else{
366. cs=prepareCall(statementScope.getSession(),conn,sql);
367. }
368. setStatementTimeout(statementScope.getStatement(),cs);
369. IntegerfetchSize=statementScope.getStatement().getFetchSize();
370. if(fetchSize!=null){
371. cs.setFetchSize(fetchSize.intValue());
372. }
373. ParameterMapparameterMap=statementScope.getParameterMap();
374. ParameterMapping[]mappings=parameterMap.getParameterMappings();
375. errorContext
376. .setMoreInfo("Checktheoutputparameters(registeroutputparametersfailed).");
377. registerOutputParameters(cs,mappings);
378. errorContext
379. .setMoreInfo("Checktheparameters(setparametersfailed).");
380. parameterMap.setParameters(statementScope,cs,parameters);
381. errorContext
382. .setMoreInfo("Checkthestatement(updateprocedurefailed).");
383. cs.execute();
384. errorContext
385. .setMoreInfo("Checktheresults(failedtoretrieveresults).");
387. //BeginResultSetHandling
388. rs=handleMultipleResults(cs,statementScope,skipResults,
389. maxResults,callback);
390. //EndResultSetHandling
391. errorContext
392. .setMoreInfo("Checktheoutputparameters(retrievalofoutputparametersfailed).");
393. retrieveOutputParameters(statementScope,cs,mappings,parameters,
394. callback);
396. }finally{
397. try{
398. closeResultSet(rs);
399. }finally{
400. closeStatement(statementScope.getSession(),cs);
401. }
402. }
403. }
405. privateResultSethandleMultipleResults(PreparedStatementps,
406. StatementScopestatementScope,intskipResults,intmaxResults,
407. RowHandlerCallbackcallback)throwsSQLException{
408. ResultSetrs;
409. rs=getFirstResultSet(statementScope,ps);
410. if(rs!=null){
411. handleResults(statementScope,rs,skipResults,maxResults,callback);
412. }
414. //MultipleResultSethandling
415. if(callback.getRowHandler()instanceofDefaultRowHandler){
416. MappedStatementstatement=statementScope.getStatement();
417. DefaultRowHandlerdefaultRowHandler=((DefaultRowHandler)callback
418. .getRowHandler());
419. if(statement.hasMultipleResultMaps()){
420. ListmultipleResults=newArrayList();
421. multipleResults.add(defaultRowHandler.getList());
422. ResultMap[]resultMaps=statement.getAdditionalResultMaps();
423. inti=0;
424. while(moveToNextResultsSafely(statementScope,ps)){
425. if(i>=resultMaps.length)
426. break;
427. ResultMaprm=resultMaps[i];
428. statementScope.setResultMap(rm);
429. rs=ps.getResultSet();
430. DefaultRowHandlerrh=newDefaultRowHandler();
431. handleResults(statementScope,rs,skipResults,maxResults,
432. newRowHandlerCallback(rm,null,rh));
433. multipleResults.add(rh.getList());
434. i++;
435. }
436. defaultRowHandler.setList(multipleResults);
437. statementScope.setResultMap(statement.getResultMap());
438. }else{
439. while(moveToNextResultsSafely(statementScope,ps))
440. ;
441. }
442. }
443. //EndadditionalResultSethandling
444. returnrs;
445. }
447. privateResultSetgetFirstResultSet(StatementScopescope,Statementstmt)
448. throwsSQLException{
449. ResultSetrs=null;
450. booleanhasMoreResults=true;
451. while(hasMoreResults){
452. rs=stmt.getResultSet();
453. if(rs!=null){
454. break;
455. }
456. hasMoreResults=moveToNextResultsIfPresent(scope,stmt);
457. }
458. returnrs;
459. }
461. privatebooleanmoveToNextResultsIfPresent(StatementScopescope,
462. Statementstmt)throwsSQLException{
463. booleanmoreResults;
464. //ThisisthemessedupJDBCapproachfordeterminingiftherearemore
465. //results
466. moreResults=!(((moveToNextResultsSafely(scope,stmt)==false)&&(stmt
467. .getUpdateCount()==-1)));
468. returnmoreResults;
469. }
471. privatebooleanmoveToNextResultsSafely(StatementScopescope,Statementstmt)
472. throwsSQLException{
473. if(forceMultipleResultSetSupport(scope)
474. ||stmt.getConnection().getMetaData()
475. .supportsMultipleResultSets()){
476. returnstmt.getMoreResults();
477. }
478. returnfalse;
479. }
481. privatebooleanforceMultipleResultSetSupport(StatementScopescope){
482. return((SqlMapClientImpl)scope.getSession().getSqlMapClient())
483. .getDelegate().isForceMultipleResultSetSupport();
484. }
486. privatevoidhandleResults(StatementScopestatementScope,ResultSetrs,
487. intskipResults,intmaxResults,RowHandlerCallbackcallback)
488. throwsSQLException{
489. try{
490. statementScope.setResultSet(rs);
491. ResultMapresultMap=statementScope.getResultMap();
492. if(resultMap!=null){
493. //SkipResults
494. if(rs.getType()!=ResultSet.TYPE_FORWARD_ONLY){
495. if(skipResults>0){
496. rs.absolute(skipResults);
497. }
498. }else{
499. for(inti=0;i<skipResults;i++){
500. if(!rs.next()){
501. return;
502. }
503. }
504. }
506. //GetResults
507. intresultsFetched=0;
508. while((maxResults==SqlExecutor.NO_MAXIMUM_RESULTS||resultsFetched<maxResults)
509. &&rs.next()){
510. Object[]columnValues=resultMap.resolveSubMap(
511. statementScope,rs).getResults(statementScope,rs);
512. callback.handleResultObject(statementScope,columnValues,
513. rs);
514. resultsFetched++;
515. }
516. }
517. }finally{
518. statementScope.setResultSet(null);
519. }
520. }
522. privatevoidretrieveOutputParameters(StatementScopestatementScope,
523. CallableStatementcs,ParameterMapping[]mappings,
524. Object[]parameters,RowHandlerCallbackcallback)
525. throwsSQLException{
526. for(inti=0;i<mappings.length;i++){
527. ParameterMappingmapping=((ParameterMapping)mappings[i]);
528. if(mapping.isOutputAllowed()){
529. if("java.sql.ResultSet".equalsIgnoreCase(mapping
530. .getJavaTypeName())){
531. ResultSetrs=(ResultSet)cs.getObject(i+1);
532. ResultMapresultMap;
533. if(mapping.getResultMapName()==null){
534. resultMap=statementScope.getResultMap();
535. handleOutputParameterResults(statementScope,resultMap,
536. rs,callback);
537. }else{
538. SqlMapClientImplclient=(SqlMapClientImpl)statementScope
539. .getSession().getSqlMapClient();
540. resultMap=client.getDelegate().getResultMap(
541. mapping.getResultMapName());
542. DefaultRowHandlerrowHandler=newDefaultRowHandler();
543. RowHandlerCallbackhandlerCallback=newRowHandlerCallback(
544. resultMap,null,rowHandler);
545. handleOutputParameterResults(statementScope,resultMap,
546. rs,handlerCallback);
547. parameters[i]=rowHandler.getList();
548. }
549. rs.close();
550. }else{
551. parameters[i]=mapping.getTypeHandler().getResult(cs,
552. i+1);
553. }
554. }
555. }
556. }
558. privatevoidregisterOutputParameters(CallableStatementcs,
559. ParameterMapping[]mappings)throwsSQLException{
560. for(inti=0;i<mappings.length;i++){
561. ParameterMappingmapping=((ParameterMapping)mappings[i]);
562. if(mapping.isOutputAllowed()){
563. if(null!=mapping.getTypeName()
564. &&!mapping.getTypeName().equals("")){//@added
565. cs.registerOutParameter(i+1,mapping.getJdbcType(),
566. mapping.getTypeName());
567. }else{
568. if(mapping.getNumericScale()!=null
569. &&(mapping.getJdbcType()==Types.NUMERIC||mapping
570. .getJdbcType()==Types.DECIMAL)){
571. cs.registerOutParameter(i+1,mapping.getJdbcType(),
572. mapping.getNumericScale().intValue());
573. }else{
574. cs.registerOutParameter(i+1,mapping.getJdbcType());
575. }
576. }
577. }
578. }
579. }
581. privatevoidhandleOutputParameterResults(StatementScopestatementScope,
582. ResultMapresultMap,ResultSetrs,RowHandlerCallbackcallback)
583. throwsSQLException{
584. ResultMaporig=statementScope.getResultMap();
585. try{
586. statementScope.setResultSet(rs);
587. if(resultMap!=null){
588. statementScope.setResultMap(resultMap);
590. //GetResults
591. while(rs.next()){
592. Object[]columnValues=resultMap.resolveSubMap(
593. statementScope,rs).getResults(statementScope,rs);
594. callback.handleResultObject(statementScope,columnValues,
595. rs);
596. }
597. }
598. }finally{
599. statementScope.setResultSet(null);
600. statementScope.setResultMap(orig);
601. }
602. }
604. /**
605. *Cleanupanybatchesonthesession
606. *
607. *@paramsessionScope
608. *-thesessiontocleanup
609. */
610. publicvoidcleanup(SessionScopesessionScope){
611. Batchbatch=(Batch)sessionScope.getBatch();
612. if(batch!=null){
613. batch.cleanupBatch(sessionScope);
614. sessionScope.setBatch(null);
615. }
616. }
618. privatePreparedStatementprepareStatement(SessionScopesessionScope,
619. Connectionconn,Stringsql,IntegerrsType)throwsSQLException{
620. SqlMapExecutorDelegatedelegate=((SqlMapClientImpl)sessionScope
621. .getSqlMapExecutor()).getDelegate();
622. if(sessionScope.hasPreparedStatementFor(sql)){
623. returnsessionScope.getPreparedStatement((sql));
624. }else{
625. PreparedStatementps=conn.prepareStatement(sql,
626. rsType.intValue(),ResultSet.CONCUR_READ_ONLY);
627. sessionScope.putPreparedStatement(delegate,sql,ps);
628. returnps;
629. }
630. }
632. privateCallableStatementprepareCall(SessionScopesessionScope,
633. Connectionconn,Stringsql,IntegerrsType)throwsSQLException{
634. SqlMapExecutorDelegatedelegate=((SqlMapClientImpl)sessionScope
635. .getSqlMapExecutor()).getDelegate();
636. if(sessionScope.hasPreparedStatementFor(sql)){
637. return(CallableStatement)sessionScope.getPreparedStatement((sql));
638. }else{
639. CallableStatementcs=conn.prepareCall(sql,rsType.intValue(),
640. ResultSet.CONCUR_READ_ONLY);
641. sessionScope.putPreparedStatement(delegate,sql,cs);
642. returncs;
643. }
644. }
646. privatestaticPreparedStatementprepareStatement(
647. SessionScopesessionScope,Connectionconn,Stringsql)
648. throwsSQLException{
649. SqlMapExecutorDelegatedelegate=((SqlMapClientImpl)sessionScope
650. .getSqlMapExecutor()).getDelegate();
651. if(sessionScope.hasPreparedStatementFor(sql)){
652. returnsessionScope.getPreparedStatement((sql));
653. }else{
654. PreparedStatementps=conn.prepareStatement(sql);
655. sessionScope.putPreparedStatement(delegate,sql,ps);
656. returnps;
657. }
658. }
660. privateCallableStatementprepareCall(SessionScopesessionScope,
661. Connectionconn,Stringsql)throwsSQLException{
662. SqlMapExecutorDelegatedelegate=((SqlMapClientImpl)sessionScope
663. .getSqlMapExecutor()).getDelegate();
664. if(sessionScope.hasPreparedStatementFor(sql)){
665. return(CallableStatement)sessionScope.getPreparedStatement((sql));
666. }else{
667. CallableStatementcs=conn.prepareCall(sql);
668. sessionScope.putPreparedStatement(delegate,sql,cs);
669. returncs;
670. }
671. }
673. privatestaticvoidcloseStatement(SessionScopesessionScope,
674. PreparedStatementps){
675. if(ps!=null){
676. if(!sessionScope.hasPreparedStatement(ps)){
677. try{
678. ps.close();
679. }catch(SQLExceptione){
680. //ignore
681. }
682. }
683. }
684. }
686. /**
687. *@paramrs
688. */
689. privatestaticvoidcloseResultSet(ResultSetrs){
690. if(rs!=null){
691. try{
692. rs.close();
693. }catch(SQLExceptione){
694. //ignore
695. }
696. }
697. }
699. privatestaticvoidsetStatementTimeout(MappedStatementmappedStatement,
700. Statementstatement)throwsSQLException{
701. if(mappedStatement.getTimeout()!=null){
702. statement.setQueryTimeout(mappedStatement.getTimeout().intValue());
703. }
704. }
706. //
707. //InnerClasses
708. //
710. privatestaticclassBatch{
711. privateStringcurrentSql;
712. privateListstatementList=newArrayList();
713. privateListbatchResultList=newArrayList();
714. privateintsize;
716. /**
717. *Createanewbatch
718. */
719. publicBatch(){
720. this.size=0;
721. }
723. /**
724. *Getterforthebatchsize
725. *
726. *@return-thebatchsize
727. */
728. publicintgetSize(){
729. returnsize;
730. }
732. /**
733. *Addapreparedstatementtothebatch
734. *
735. *@paramstatementScope
736. *-therequestscope
737. *@paramconn
738. *-thedatabaseconnection
739. *@paramsql
740. *-theSQLtoadd
741. *@paramparameters
742. *-theparametersfortheSQL
743. *@throwsSQLException
744. *-ifthepreparefortheSQLfails
745. */
746. publicvoidaddBatch(StatementScopestatementScope,Connectionconn,
747. Stringsql,Object[]parameters)throwsSQLException{
748. PreparedStatementps=null;
749. if(currentSql!=null&&currentSql.equals(sql)){
750. intlast=statementList.size()-1;
751. ps=(PreparedStatement)statementList.get(last);
752. }else{
753. ps=prepareStatement(statementScope.getSession(),conn,sql);
754. setStatementTimeout(statementScope.getStatement(),ps);
755. currentSql=sql;
756. statementList.add(ps);
757. batchResultList.add(newBatchResult(statementScope
758. .getStatement().getId(),sql));
759. }
760. statementScope.getParameterMap().setParameters(statementScope,ps,
761. parameters);
762. ps.addBatch();
763. size++;
764. }
766. /**
767. *TODO(JeffButler)-maybethismethodshouldbedeprecatedinsome
768. *release,andthenremovedinsomeevenlaterrelease.
769. *executeBatchDetailedgivesmuchmorecompleteinformation.<p/>
770. *Executethecurrentsession'sbatch
771. *
772. *@return-thenumberofrowsupdated
773. *@throwsSQLException
774. *-ifthebatchfails
775. */
776. publicintexecuteBatch()throwsSQLException{
777. inttotalRowCount=0;
778. for(inti=0,n=statementList.size();i<n;i++){
779. PreparedStatementps=(PreparedStatement)statementList.get(i);
780. int[]rowCounts=ps.executeBatch();
781. for(intj=0;j<rowCounts.length;j++){
782. if(rowCounts[j]==Statement.SUCCESS_NO_INFO){
783. //donothing
784. }elseif(rowCounts[j]==Statement.EXECUTE_FAILED){
785. thrownewSQLException(
786. "Thebatchedstatementatindex"+j
787. +"failedtoexecute.");
788. }else{
789. totalRowCount+=rowCounts[j];
790. }
791. }
792. }
793. returntotalRowCount;
794. }
796. /**
797. *Batchexecutionmethodthatreturnsalltheinformationthedriver
798. *hastooffer.
799. *
800. *@returnaListofBatchResultobjects
801. *@throwsBatchException
802. *(anSQLExceptionsubclass)ifanynestedbatchfails
803. *@throwsSQLException
804. *ifadatabaseaccesserroroccurs,orthedrivedoesnot
805. *supportbatchstatements
806. *@throwsBatchException
807. *ifthedriverthrowsBatchUpdateException
808. */
809. publicListexecuteBatchDetailed()throwsSQLException,BatchException{
810. Listanswer=newArrayList();
811. for(inti=0,n=statementList.size();i<n;i++){
812. BatchResultbr=(BatchResult)batchResultList.get(i);
813. PreparedStatementps=(PreparedStatement)statementList.get(i);
814. try{
815. br.setUpdateCounts(ps.executeBatch());
816. }catch(BatchUpdateExceptione){
817. StringBuffermessage=newStringBuffer();
818. message.append("Subbatchnumber");
819. message.append(i+1);
820. message.append("failed.");
821. if(i>0){
822. message.append("");
823. message.append(i);
824. message
825. .append("priorsubbatch(s)completedsuccessfully,butwillberolledback.");
826. }
827. thrownewBatchException(message.toString(),e,answer,br
828. .getStatementId(),br.getSql());
829. }
830. answer.add(br);
831. }
832. returnanswer;
833. }
835. /**
836. *Closeallthestatementsinthebatchandclearallthestatements
837. *
838. *@paramsessionScope
839. */
840. publicvoidcleanupBatch(SessionScopesessionScope){
841. for(inti=0,n=statementList.size();i<n;i++){
842. PreparedStatementps=(PreparedStatement)statementList.get(i);
843. closeStatement(sessionScope,ps);
844. }
845. currentSql=null;
846. statementList.clear();
847. batchResultList.clear();
848. size=0;
849. }
850. }
852. privatevoidsetupResultObjectFactory(StatementScopestatementScope){
853. SqlMapClientImplclient=(SqlMapClientImpl)statementScope
854. .getSession().getSqlMapClient();
855. ResultObjectFactoryUtil.setResultObjectFactory(client
856. .getResultObjectFactory());
857. ResultObjectFactoryUtil.setStatementId(statementScope.getStatement()
858. .getId());
859. }
860. }

Dialect.java

Java代码

1. packagecom.ibatis.sqlmap.engine.execution;
3. publicclassDialect{
4. privatestaticfinalStringSQL_END_DELIMITER=";";
6. publicstaticStringgetLimitString(StringdbName,Stringsql,intoffset,
7. intlimit){
8. StringlimitString=sql;
9. if(dbName.toLowerCase().indexOf("mysql")!=-1){
10. limitString=getMysqlLimitString(sql,offset,limit);
11. }
12. if(dbName.toLowerCase().indexOf("microsoftsqlserver")!=-1){
13. limitString=getMssqlLimitString(sql,offset,limit);
14. }
15. if(dbName.toLowerCase().indexOf("oracle")!=-1){
16. limitString=getOracleLimitString(sql,offset,limit);
17. }
18. if(dbName.toLowerCase().indexOf("db2")!=-1){
19. limitString=getDB2LimitString(sql,offset,limit);
20. }
22. returnlimitString;
23. }
25. privatestaticStringgetMysqlLimitString(Stringsql,intoffset,intlimit){
26. sql=trim(sql);
27. StringBuffersb=newStringBuffer(sql.length()+20);
28. sb.append(sql);
29. if(offset>0){
30. sb.append("limit").append(offset).append(',').append(limit);
31. }else{
32. sb.append("limit").append(limit);
33. }
34. returnsb.toString();
35. }
37. privatestaticStringgetOracleLimitString(Stringsql,intoffset,intlimit){
38. sql=trim(sql);
39. StringBuffersb=newStringBuffer(sql.length()+100);
40. if(offset>0){
41. sb.append("select*from(selectrow_.*,rownumrownum_from(")
42. .append(sql).append(")row_whererownum<=").append(
43. offset+limit).append(")whererownum_>")
44. .append(offset);
45. }else{
46. sb.append("select*from(").append(sql).append(
47. ")whererownum<=").append(limit);
48. }
49. returnsb.toString();
50. }
52. privatestaticStringgetMssqlLimitString(Stringsql,intoffset,intlimit){
53. returnnull;
54. }
56. privatestaticStringgetDB2LimitString(Stringsql,intoffset,intlimit){
57. returnnull;
58. }
60. privatestaticStringtrim(Stringsql){
61. sql=sql.trim();
62. if(sql.endsWith(SQL_END_DELIMITER)){
63. sql=sql.substring(0,sql.length()-1
64. -SQL_END_DELIMITER.length());
65. }
66. returnsql;
67. }
68. }