zoukankan      html  css  js  c++  java

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

    该问题，我百度了下，根本没发现什么有价值的文章；还是看源代码（详见最后附录）中的注释，最有效了！
    insert，返回值是：新插入行的主键（primary key）；需要包含<selectKey>语句，才会返回主键，否则返回值为null。
    update/delete，返回值是：更新或删除的行数；无需指明resultClass；但如果有约束异常而删除失败，只能去捕捉异常。
    queryForObject，返回的是：一个实例对象或null；需要包含<select>语句，并且指明resultMap；
    queryForList，返回的是：实例对象的列表；需要包含<select>语句，并且指明resultMap；

    我的配置文件如下（desktop_common_sqlMap.xml）：

    [html] view plain copy
     print?
    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源码如下：
    [java] view plain copy
     print?
    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的接口，参见其源码（comibatissqlmapclientSqlMapExecutor.java）:

    [java] view plain copy
     print?
    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       The property to be used as the value in the Map. 
    317.    * @return A Map keyed by keyProp with values of valueProp. 
    318.    * @throws java.sql.SQLException If an error occurs. 
    319.    */  
    320.   Map queryForMap(String id, Object parameterObject, String keyProp, String valueProp) throws SQLException;  
    321.   
    322.   /** 
    323.    * Starts a batch in which update statements will be cached before being sent to 
    324.    * the database all at once. This can improve overall performance of updates update 
    325.    * when dealing with numerous updates (e.g. inserting 1:M related data). 
    326.    * 
    327.    * @throws java.sql.SQLException If the batch could not be started. 
    328.    */  
    329.   void startBatch() throws SQLException;  
    330.   
    331.   /** 
    332.    * Executes (flushes) all statements currently batched. 
    333.    * 
    334.    * @return the number of rows updated in the batch 
    335.    * @throws java.sql.SQLException If the batch could not be executed or if any of the statements 
    336.    *                               fails. 
    337.    */  
    338.   int executeBatch() throws SQLException;  
    339.   
    340.   /** 
    341.    * Executes (flushes) all statements currently batched. 
    342.    * 
    343.    * @return a List of BatchResult objects.  There will be one element in the 
    344.    *  list for each sub-batch executed.  A sub-batch is created by adding a statement 
    345.    *  to the batch that does not equal the prior statement.  
    346.    * @throws SQLException if a database access error occurs, or the drive 
    347.    *   does not support batch statements 
    348.    * @throws BatchException if the driver throws BatchUpdateException 
    349.    * @see com.ibatis.sqlmap.engine.execution.BatchException 
    350.    */  
    351.   List executeBatchDetailed() throws SQLException, BatchException;  
    352. }  




查看全文
  • 相关阅读:
    进入全屏 nodejs+express+mysql实现restful风格的增删改查示例
    WebAPI 实现前后端分离
    android 集成支付宝app支付(原生态)-包括android前端与java后台
    Windows 64 位系统下 Python 环境的搭建
    Es6主要特征详解
    js上传图片
    Python socket
    设置windows开机自启某个软件
    oracle导入导出数据
    mysql触发器，答题记录表同步教学跟踪（用户列表）
  • 原文地址：https://www.cnblogs.com/jpfss/p/8918328.html
    • Copyright © 2011-2022 走看看