Mybatis/Ibatis，数据库操作的返回值

copy

1. <typeAlias alias="UnlockTagInfo" type="com.desktop.common.bean.UnlockTagInfo" />  
2. <resultMap class="UnlockTagInfo" id="UnlockTagInfoResult">  
3.     <result column="id" property="id" jdbcType="INTEGER" />  
4.     <result column="name" property="name" jdbcType="VARCHAR" />  
5.     <result column="description" property="description" jdbcType="VARCHAR" />  
6.     <result column="priority" property="priority" jdbcType="INTEGER" />  
7. </resultMap>  
8. <insert id="insertUnlockTagInfo" parameterClass="map">  
9.     <selectKey resultClass="int" keyProperty="id">  
10.         select  
11.         nextval(‘desktop_unlock_tag_id_seq‘) as id  
12.     </selectKey>  
13.     insert into  
14.     desktop_unlock_tag(id,name,description,priority)  
15.     values(#id:INTEGER#,#name:VARCHAR#,#description:VARCHAR#,#priority:INTEGER#)  
16. </insert>  
17. <update id="updateUnlockTagInfo" parameterClass="map">  
18.     update  
19.     desktop_unlock_tag  
20.     set modify_time=now(),priority=#priority:INTEGER#,  
21.     name=#name:VARCHAR#,description=#description:VARCHAR#  
22.     where  
23.     id=#id:INTEGER#  
24. </update>  
25. <delete id="deleteUnlockTagInfo" parameterClass="int">  
26.     delete from  
27.     desktop_unlock_tag  
28.     where id=#value:INTEGER#  
29. </delete>  
30. <select id="countUnlockTagInfo" resultClass="int">  
31.     select count(*)  
32.     from  
33.     desktop_unlock_tag  
34. </select>  
35. <sql id="selectUnlockTagInfo">  
36.     select  
37.     id,name,description,priority  
38.     from  
39.     desktop_unlock_tag  
40. </sql>  
41. <select id="findUnlockTagInfoById" parameterClass="int"  
42.     resultMap="UnlockTagInfoResult">  
43.     <include refid="selectUnlockTagInfo" />  
44.     where id=#id:INTEGER#  
45. </select>  
46. <select id="listUnlockTagInfo" parameterClass="map"  
47.     resultMap="UnlockTagInfoResult">  
48.     <include refid="selectUnlockTagInfo" />  
49.     order by  
50.     modify_time desc limit #size:INTEGER#  
51.     offset #start:INTEGER#  
52. </select>  

我的DAO源码如下：

copy

1. public class UnlockTagDaoImpl extends SqlMapClientDaoSupport implements  
2.         UnlockTagDao {  
3.     @Override  
4.     public Integer addItem(String name, String desc, Integer priority) {  
5.         SqlMapClientTemplate template = this.getSqlMapClientTemplate();  
6.         Map<String, Object> args = new HashMap<String, Object>();  
7.         args.put("name", name);  
8.         args.put("description", desc);  
9.         args.put("priority", priority);  
10.         Object key = template.insert("DesktopCommon.insertUnlockTagInfo", args);  
11.         return (Integer) key;  
12.     }  
13.   
14.     @Override  
15.     public boolean updateItem(Integer id, String name, String description,  
16.             Integer priority) {  
17.         SqlMapClientTemplate template = this.getSqlMapClientTemplate();  
18.         Map<String, Object> args = new HashMap<String, Object>();  
19.         args.put("id", id);  
20.         args.put("name", name);  
21.         args.put("description", description);  
22.         args.put("priority", priority);  
23.         try {  
24.             int c = template.update("DesktopCommon.updateUnlockTagInfo", args);  
25.             if (c > 0) {  
26.                 return true;  
27.             }  
28.             return false;  
29.         } catch (Exception e) {  
30.             return false;  
31.         }  
32.     }  
33.   
34.     @Override  
35.     public boolean deleteItem(Integer id) {  
36.         SqlMapClientTemplate template = this.getSqlMapClientTemplate();  
37.         try {  
38.             int c = template.delete("DesktopCommon.deleteUnlockTagInfo", id);  
39.             if (c > 0) {  
40.                 return true;  
41.             }  
42.             return false;  
43.         } catch (Exception e) {  
44.             return false;  
45.         }  
46.     }  
47.   
48.     @Override  
49.     public UnlockTagInfo findItemById(Integer id) {  
50.         SqlMapClientTemplate template = this.getSqlMapClientTemplate();  
51.         UnlockTagInfo item = (UnlockTagInfo) template.queryForObject(  
52.                 "DesktopCommon.findUnlockTagInfoById", id);  
53.         return item;  
54.     }  
55.   
56.     @Override  
57.     public PagedList<UnlockTagInfo> listAll(Integer nStart, Integer nSize,  
58.             boolean bCountTotal) {  
59.         SqlMapClientTemplate template = this.getSqlMapClientTemplate();  
60.         PagedList<UnlockTagInfo> result = new PagedList<UnlockTagInfo>();  
61.         if (bCountTotal) {  
62.             int total = (Integer) template  
63.                     .queryForObject("DesktopCommon.countUnlockTagInfo");  
64.             result.setTotal(total);  
65.         }  
66.         Map<String, Integer> args = new HashMap<String, Integer>();  
67.         args.put("start", nStart);  
68.         args.put("size", nSize);  
69.         @SuppressWarnings("unchecked")  
70.         List<UnlockTagInfo> items = template.queryForList(  
71.                 "DesktopCommon.listUnlockTagInfo", args);  
72.         result.setData(items);  
73.         return result;  
74.     }  
75. }  

关于ibatis的接口，参见其源码（com\ibatis\sqlmap\client\SqlMapExecutor.java）:

copy

1. /* 
2.  *  Copyright 2004 Clinton Begin 
3.  * 
4.  *  Licensed under the Apache License, Version 2.0 (the "License"); 
5.  *  you may not use this file except in compliance with the License. 
6.  *  You may obtain a copy of the License at 
7.  * 
8.  *      http://www.apache.org/licenses/LICENSE-2.0 
9.  * 
10.  *  Unless required by applicable law or agreed to in writing, software 
11.  *  distributed under the License is distributed on an "AS IS" BASIS, 
12.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
13.  *  See the License for the specific language governing permissions and 
14.  *  limitations under the License. 
15.  */  
16. package com.ibatis.sqlmap.client;  
17.   
18. import com.ibatis.common.util.PaginatedList;  
19. import com.ibatis.sqlmap.client.event.RowHandler;  
20. import com.ibatis.sqlmap.engine.execution.BatchException;  
21.   
22. import java.sql.SQLException;  
23. import java.util.List;  
24. import java.util.Map;  
25.   
26. /** 
27.  * This interface declares all methods involved with executing statements 
28.  * and batches for an SQL Map. 
29.  * 
30.  * @see SqlMapSession 
31.  * @see SqlMapClient 
32.  */  
33. public interface SqlMapExecutor {  
34.   
35.   /** 
36.    * Executes a mapped SQL INSERT statement. 
37.    * Insert is a bit different from other update methods, as it 
38.    * provides facilities for returning the primary key of the 
39.    * newly inserted row (rather than the effected rows).  This 
40.    * functionality is of course optional. 
41.    * <p/> 
42.    * The parameter object is generally used to supply the input 
43.    * data for the INSERT values. 
44.    * 
45.    * @param id              The name of the statement to execute. 
46.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
47.    * @return The primary key of the newly inserted row.  This might be automatically 
48.    *         generated by the RDBMS, or selected from a sequence table or other source. 
49.    * @throws java.sql.SQLException If an error occurs. 
50.    */  
51.   Object insert(String id, Object parameterObject) throws SQLException;  
52.   
53.   /** 
54.    * Executes a mapped SQL INSERT statement. 
55.    * Insert is a bit different from other update methods, as it 
56.    * provides facilities for returning the primary key of the 
57.    * newly inserted row (rather than the effected rows).  This 
58.    * functionality is of course optional. 
59.    * <p/> 
60.    * This overload assumes no parameter is needed. 
61.    * 
62.    * @param id              The name of the statement to execute. 
63.    * @return The primary key of the newly inserted row.  This might be automatically 
64.    *         generated by the RDBMS, or selected from a sequence table or other source. 
65.    * @throws java.sql.SQLException If an error occurs. 
66.    */  
67.   Object insert(String id) throws SQLException;  
68.   
69.   /** 
70.    * Executes a mapped SQL UPDATE statement. 
71.    * Update can also be used for any other update statement type, 
72.    * such as inserts and deletes.  Update returns the number of 
73.    * rows effected. 
74.    * <p/> 
75.    * The parameter object is generally used to supply the input 
76.    * data for the UPDATE values as well as the WHERE clause parameter(s). 
77.    * 
78.    * @param id              The name of the statement to execute. 
79.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
80.    * @return The number of rows effected. 
81.    * @throws java.sql.SQLException If an error occurs. 
82.    */  
83.   int update(String id, Object parameterObject) throws SQLException;  
84.   
85.   /** 
86.    * Executes a mapped SQL UPDATE statement. 
87.    * Update can also be used for any other update statement type, 
88.    * such as inserts and deletes.  Update returns the number of 
89.    * rows effected. 
90.    * <p/> 
91.    * This overload assumes no parameter is needed. 
92.    * 
93.    * @param id              The name of the statement to execute. 
94.    * @return The number of rows effected. 
95.    * @throws java.sql.SQLException If an error occurs. 
96.    */  
97.   int update(String id) throws SQLException;  
98.   
99.   /** 
100.    * Executes a mapped SQL DELETE statement. 
101.    * Delete returns the number of rows effected. 
102.    * <p/> 
103.    * The parameter object is generally used to supply the input 
104.    * data for the WHERE clause parameter(s) of the DELETE statement. 
105.    * 
106.    * @param id              The name of the statement to execute. 
107.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
108.    * @return The number of rows effected. 
109.    * @throws java.sql.SQLException If an error occurs. 
110.    */  
111.   int delete(String id, Object parameterObject) throws SQLException;  
112.   
113.   /** 
114.    * Executes a mapped SQL DELETE statement. 
115.    * Delete returns the number of rows effected. 
116.    * <p/> 
117.    * This overload assumes no parameter is needed. 
118.    * 
119.    * @param id              The name of the statement to execute. 
120.    * @return The number of rows effected. 
121.    * @throws java.sql.SQLException If an error occurs. 
122.    */  
123.   int delete(String id) throws SQLException;  
124.   
125.   /** 
126.    * Executes a mapped SQL SELECT statement that returns data to populate 
127.    * a single object instance. 
128.    * <p/> 
129.    * The parameter object is generally used to supply the input 
130.    * data for the WHERE clause parameter(s) of the SELECT statement. 
131.    * 
132.    * @param id              The name of the statement to execute. 
133.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
134.    * @return The single result object populated with the result set data, 
135.    *         or null if no result was found 
136.    * @throws java.sql.SQLException If more than one result was found, or if any other error occurs. 
137.    */  
138.   Object queryForObject(String id, Object parameterObject) throws SQLException;  
139.   
140.   /** 
141.    * Executes a mapped SQL SELECT statement that returns data to populate 
142.    * a single object instance. 
143.    * <p/> 
144.    * This overload assumes no parameter is needed. 
145.    * 
146.    * @param id              The name of the statement to execute. 
147.    * @return The single result object populated with the result set data, 
148.    *         or null if no result was found 
149.    * @throws java.sql.SQLException If more than one result was found, or if any other error occurs. 
150.    */  
151.   Object queryForObject(String id) throws SQLException;  
152.   
153.   /** 
154.    * Executes a mapped SQL SELECT statement that returns data to populate 
155.    * the supplied result object. 
156.    * <p/> 
157.    * The parameter object is generally used to supply the input 
158.    * data for the WHERE clause parameter(s) of the SELECT statement. 
159.    * 
160.    * @param id              The name of the statement to execute. 
161.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
162.    * @param resultObject    The result object instance that should be populated with result data. 
163.    * @return The single result object as supplied by the resultObject parameter, populated with the result set data, 
164.    *         or null if no result was found 
165.    * @throws java.sql.SQLException If more than one result was found, or if any other error occurs. 
166.    */  
167.   Object queryForObject(String id, Object parameterObject, Object resultObject) throws SQLException;  
168.   
169.   /** 
170.    * Executes a mapped SQL SELECT statement that returns data to populate 
171.    * a number of result objects. 
172.    * <p/> 
173.    * The parameter object is generally used to supply the input 
174.    * data for the WHERE clause parameter(s) of the SELECT statement. 
175.    * 
176.    * @param id              The name of the statement to execute. 
177.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
178.    * @return A List of result objects. 
179.    * @throws java.sql.SQLException If an error occurs. 
180.    */  
181.   List queryForList(String id, Object parameterObject) throws SQLException;  
182.   
183.   /** 
184.    * Executes a mapped SQL SELECT statement that returns data to populate 
185.    * a number of result objects. 
186.    * <p/> 
187.    * This overload assumes no parameter is needed. 
188.    * 
189.    * @param id              The name of the statement to execute. 
190.    * @return A List of result objects. 
191.    * @throws java.sql.SQLException If an error occurs. 
192.    */  
193.   List queryForList(String id) throws SQLException;  
194.   
195.   /** 
196.    * Executes a mapped SQL SELECT statement that returns data to populate 
197.    * a number of result objects within a certain range. 
198.    * <p/> 
199.    * The parameter object is generally used to supply the input 
200.    * data for the WHERE clause parameter(s) of the SELECT statement. 
201.    * 
202.    * @param id              The name of the statement to execute. 
203.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
204.    * @param skip            The number of results to ignore. 
205.    * @param max             The maximum number of results to return. 
206.    * @return A List of result objects. 
207.    * @throws java.sql.SQLException If an error occurs. 
208.    */  
209.   List queryForList(String id, Object parameterObject, int skip, int max) throws SQLException;  
210.   
211.   /** 
212.    * Executes a mapped SQL SELECT statement that returns data to populate 
213.    * a number of result objects within a certain range. 
214.    * <p/> 
215.    * This overload assumes no parameter is needed. 
216.    * 
217.    * @param id              The name of the statement to execute. 
218.    * @param skip            The number of results to ignore. 
219.    * @param max             The maximum number of results to return. 
220.    * @return A List of result objects. 
221.    * @throws java.sql.SQLException If an error occurs. 
222.    */  
223.   List queryForList(String id, int skip, int max) throws SQLException;  
224.     
225.   /** 
226.    * Executes a mapped SQL SELECT statement that returns a number of 
227.    * result objects that will be handled one at a time by a 
228.    * RowHandler. 
229.    * <p/> 
230.    * This is generally a good approach to take when dealing with large sets 
231.    * of records (i.e. hundreds, thousands...) that need to be processed without 
232.    * eating up all of the system resources. 
233.    * <p/> 
234.    * The parameter object is generally used to supply the input 
235.    * data for the WHERE clause parameter(s) of the SELECT statement. 
236.    * 
237.    * @param id              The name of the statement to execute. 
238.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
239.    * @param rowHandler      A RowHandler instance 
240.    * @throws java.sql.SQLException If an error occurs. 
241.    */  
242.   void queryWithRowHandler(String id, Object parameterObject, RowHandler rowHandler) throws SQLException;  
243.   
244.   /** 
245.    * Executes a mapped SQL SELECT statement that returns a number of 
246.    * result objects that will be handled one at a time by a 
247.    * RowHandler. 
248.    * <p/> 
249.    * This is generally a good approach to take when dealing with large sets 
250.    * of records (i.e. hundreds, thousands...) that need to be processed without 
251.    * eating up all of the system resources. 
252.    * <p/> 
253.    * This overload assumes no parameter is needed. 
254.    * 
255.    * @param id              The name of the statement to execute. 
256.    * @param rowHandler      A RowHandler instance 
257.    * @throws java.sql.SQLException If an error occurs. 
258.    */  
259.   void queryWithRowHandler(String id, RowHandler rowHandler) throws SQLException;  
260.   
261.   /** 
262.    * Executes a mapped SQL SELECT statement that returns data to populate 
263.    * a number of result objects a page at a time. 
264.    * <p/> 
265.    * The parameter object is generally used to supply the input 
266.    * data for the WHERE clause parameter(s) of the SELECT statement. 
267.    * 
268.    * @param id              The name of the statement to execute. 
269.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
270.    * @param pageSize        The maximum number of result objects each page can hold. 
271.    * @return A PaginatedList of result objects. 
272.    * @throws java.sql.SQLException If an error occurs. 
273.    * @deprecated All paginated list features have been deprecated 
274.    */  
275.   PaginatedList queryForPaginatedList(String id, Object parameterObject, int pageSize) throws SQLException;  
276.   
277.   /** 
278.    * Executes a mapped SQL SELECT statement that returns data to populate 
279.    * a number of result objects a page at a time. 
280.    * <p/> 
281.    * This overload assumes no parameter is needed. 
282.    * 
283.    * @param id              The name of the statement to execute. 
284.    * @param pageSize        The maximum number of result objects each page can hold. 
285.    * @return A PaginatedList of result objects. 
286.    * @throws java.sql.SQLException If an error occurs. 
287.    * @deprecated All paginated list features have been deprecated 
288.    */  
289.   PaginatedList queryForPaginatedList(String id, int pageSize) throws SQLException;  
290.   
291.   /** 
292.    * Executes a mapped SQL SELECT statement that returns data to populate 
293.    * a number of result objects that will be keyed into a Map. 
294.    * <p/> 
295.    * The parameter object is generally used to supply the input 
296.    * data for the WHERE clause parameter(s) of the SELECT statement. 
297.    * 
298.    * @param id              The name of the statement to execute. 
299.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
300.    * @param keyProp         The property to be used as the key in the Map. 
301.    * @return A Map keyed by keyProp with values being the result object instance. 
302.    * @throws java.sql.SQLException If an error occurs. 
303.    */  
304.   Map queryForMap(String id, Object parameterObject, String keyProp) throws SQLException;  
305.   
306.   /** 
307.    * Executes a mapped SQL SELECT statement that returns data to populate 
308.    * a number of result objects from which one property will be keyed into a Map. 
309.    * <p/> 
310.    * The parameter object is generally used to supply the input 
311.    * data for the WHERE clause parameter(s) of the SELECT statement. 
312.    * 
313.    * @param id              The name of the statement to execute. 
314.    * @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.). 
315.    * @param keyProp         The property to be used as the key in the Map. 
316.    * @param valueProp    &n