泛型DAO接口的设计

1、泛型DAO接口定义

Java代码

 

1. import java.io.Serializable;   
2. import java.util.List;   
3.   
4. /**  
5.  * GenericDao DAO层泛型接口，定义基本的DAO功能  
6.  * @author wl  
7.  * @since 0.1  
8.  * @param <T>    实体类  
9.  * @param <PK>    主键类，必须实现Serializable接口  
10.  *   
11.  * @see com.thinkon.commons.dao.GenericIbatisDao  
12.  */  
13. public abstract interface GenericDao<T, PK extends Serializable> {   
14.     /**  
15.      * 插入一个实体（在数据库INSERT一条记录）  
16.      * @param entity 实体对象  
17.      */  
18.     public abstract void insert(T entity);   
19.        
20.     /**  
21.      * 修改一个实体对象（UPDATE一条记录）  
22.      * @param entity 实体对象  
23.      * @return 修改的对象个数，正常情况=1  
24.      */  
25.     public abstract int update(T entity);   
26.        
27.     /**  
28.      * 修改符合条件的记录  
29.      * <p>此方法特别适合于一次性把多条记录的某些字段值设置为新值（定值）的情况，比如修改符合条件的记录的状态字段</p>  
30.      * <p>此方法的另一个用途是把一条记录的个别字段的值修改为新值（定值），此时要把条件设置为该记录的主键</p>  
31.      * @param param 用于产生SQL的参数值，包括WHERE条件、目标字段和新值等  
32.      * @return 修改的记录个数，用于判断修改是否成功  
33.      */  
34.     public abstract int update(DynamicSqlParameter param);   
35.        
36.     /**  
37.      * 按主键删除记录  
38.      * @param primaryKey 主键对象  
39.      * @return 删除的对象个数，正常情况=1  
40.      */  
41.     public abstract int delete(PK primaryKey);   
42.   
43.     /**  
44.      * 删除符合条件的记录  
45.      * <p><strong>此方法一定要慎用，如果条件设置不当，可能会删除有用的记录！</strong></p>  
46.      * @param param 用于产生SQL的参数值，包括WHERE条件（其他参数内容不起作用）  
47.      * @return  
48.      */  
49.     public abstract int delete(DynamicSqlParameter param);   
50.        
51.     /**  
52.      * 清空表，比delete具有更高的效率，而且是从数据库中物理删除（delete是逻辑删除，被删除的记录依然占有空间）  
53.      * <p><strong>此方法一定要慎用！</strong></p>  
54.      * @return  
55.      */  
56.     public abstract int truncate();   
57.        
58.     /**  
59.      * 查询整表总记录数  
60.      * @return 整表总记录数  
61.      */  
62.     public abstract int count();   
63.        
64.     /**  
65.      * 查询符合条件的记录数  
66.      * @param param 查询条件参数，包括WHERE条件（其他参数内容不起作用）。此参数设置为null，则相当于count()  
67.      * @return  
68.      */  
69.     public abstract int count(DynamicSqlParameter param);   
70.   
71.     /**  
72.      * 按主键取记录  
73.      * @param primaryKey 主键值  
74.      * @return 记录实体对象，如果没有符合主键条件的记录，则返回null  
75.      */  
76.     public abstract T get(PK primaryKey);   
77.   
78.     /**  
79.      * 按主键取记录  
80.      * @param primaryKey 主键值  
81.      * @return 记录实体对象，如果没有符合主键条件的记录，则 throw DataAccessException  
82.      */  
83.     public abstract T load(PK primaryKey) throws DataAccessException;   
84.   
85.     /**  
86.      * 取全部记录  
87.      * @return 全部记录实体对象的List  
88.      */  
89.     public abstract List<T> select();   
90.        
91.     /**  
92.      * 按条件查询记录  
93.      * @param param 查询条件参数，包括WHERE条件、分页条件、排序条件  
94.      * @return 符合条件记录的实体对象的List  
95.      */  
96.     public abstract List<T> select(DynamicSqlParameter param);   
97.        
98.     /**  
99.      * 按条件查询记录，并处理成分页结果  
100.      * @param param 查询条件参数，包括WHERE条件、分页条件、排序条件  
101.      * @return PaginationResult对象，包括（符合条件的）总记录数、页实体对象List等  
102.      */  
103.     public abstract PaginationResult<T> selectPagination(DynamicSqlParameter param);   
104.        
105.     /**  
106.      * 按条件查询记录，并把有外键关联的字段的关联对象也处理出来  
107.      * <p>此方法是为了避免1+N而设置的</p>  
108.      * @param param 查询条件参数，包括WHERE条件、分页条件、排序条件<strong>（不包括外键关联表条件）</strong>  
109.      * @return 符合条件记录的实体对象的List  
110.      */  
111.     public abstract List<T> selectFk(DynamicSqlParameter param);   
112.        
113.     /**  
114.      * 按条件查询记录，并把有外键关联的字段的关联对象也处理出来，并处理成分页结果  
115.      * <p>此方法是为了避免1+N而设置的</p>  
116.      * @param param 查询条件参数，包括WHERE条件、分页条件、排序条件<strong>（不包括外键关联表条件）</strong>  
117.      * @return PaginationResult对象，包括（符合条件的）总记录数、页实体对象List等  
118.      */  
119.     public abstract PaginationResult<T> selectFkPagination(DynamicSqlParameter param);   
120.        
121.     /**  
122.      * 批量插入  
123.      * @param list  
124.      */  
125.     public abstract void batchInsert(final List<T> list);   
126.        
127.     /**  
128.      * 批量修改  
129.      * @param list  
130.      */  
131.     public abstract void batchUpdate(final List<T> list);   
132.        
133.     /**  
134.      * 批量删除  
135.      * @param list  
136.      */  
137.     public abstract void batchDelete(final List<PK> list);   
138. }  

import java.io.Serializable;import java.util.List;/*** GenericDao DAO层泛型接口，定义基本的DAO功能* @author wl* @since 0.1* @param <T>    实体类* @param <PK>    主键类，必须实现Serializable接口** @see com.thinkon.commons.dao.GenericIbatisDao*/public abstract interface GenericDao<T, PK extends Serializable> {/*** 插入一个实体（在数据库INSERT一条记录）* @param entity 实体对象*/public abstract void insert(T entity);/*** 修改一个实体对象（UPDATE一条记录）* @param entity 实体对象* @return 修改的对象个数，正常情况=1*/public abstract int update(T entity);/*** 修改符合条件的记录* <p>此方法特别适合于一次性把多条记录的某些字段值设置为新值（定值）的情况，比如修改符合条件的记录的状态字段</p>* <p>此方法的另一个用途是把一条记录的个别字段的值修改为新值（定值），此时要把条件设置为该记录的主键</p>* @param param 用于产生SQL的参数值，包括WHERE条件、目标字段和新值等* @return 修改的记录个数，用于判断修改是否成功*/public abstract int update(DynamicSqlParameter param);/*** 按主键删除记录* @param primaryKey 主键对象* @return 删除的对象个数，正常情况=1*/public abstract int delete(PK primaryKey);/*** 删除符合条件的记录* <p><strong>此方法一定要慎用，如果条件设置不当，可能会删除有用的记录！</strong></p>* @param param 用于产生SQL的参数值，包括WHERE条件（其他参数内容不起作用）* @return*/public abstract int delete(DynamicSqlParameter param);/*** 清空表，比delete具有更高的效率，而且是从数据库中物理删除（delete是逻辑删除，被删除的记录依然占有空间）* <p><strong>此方法一定要慎用！</strong></p>* @return*/public abstract int truncate();/*** 查询整表总记录数* @return 整表总记录数*/public abstract int count();/*** 查询符合条件的记录数* @param param 查询条件参数，包括WHERE条件（其他参数内容不起作用）。此参数设置为null，则相当于count()* @return*/public abstract int count(DynamicSqlParameter param);/*** 按主键取记录* @param primaryKey 主键值* @return 记录实体对象，如果没有符合主键条件的记录，则返回null*/public abstract T get(PK primaryKey);/*** 按主键取记录* @param primaryKey 主键值* @return 记录实体对象，如果没有符合主键条件的记录，则 throw DataAccessException*/public abstract T load(PK primaryKey) throws DataAccessException;/*** 取全部记录* @return 全部记录实体对象的List*/public abstract List<T> select();/*** 按条件查询记录* @param param 查询条件参数，包括WHERE条件、分页条件、排序条件* @return 符合条件记录的实体对象的List*/public abstract List<T> select(DynamicSqlParameter param);/*** 按条件查询记录，并处理成分页结果* @param param 查询条件参数，包括WHERE条件、分页条件、排序条件* @return PaginationResult对象，包括（符合条件的）总记录数、页实体对象List等*/public abstract PaginationResult<T> selectPagination(DynamicSqlParameter param);/*** 按条件查询记录，并把有外键关联的字段的关联对象也处理出来* <p>此方法是为了避免1+N而设置的</p>* @param param 查询条件参数，包括WHERE条件、分页条件、排序条件<strong>（不包括外键关联表条件）</strong>* @return 符合条件记录的实体对象的List*/public abstract List<T> selectFk(DynamicSqlParameter param);/*** 按条件查询记录，并把有外键关联的字段的关联对象也处理出来，并处理成分页结果* <p>此方法是为了避免1+N而设置的</p>* @param param 查询条件参数，包括WHERE条件、分页条件、排序条件<strong>（不包括外键关联表条件）</strong>* @return PaginationResult对象，包括（符合条件的）总记录数、页实体对象List等*/public abstract PaginationResult<T> selectFkPagination(DynamicSqlParameter param);/*** 批量插入* @param list*/public abstract void batchInsert(final List<T> list);/*** 批量修改* @param list*/public abstract void batchUpdate(final List<T> list);/*** 批量删除* @param list*/public abstract void batchDelete(final List<PK> list);}

 2、泛型接口的实现类（其他DAO的基类），以iBatis实现：

Java代码

 

1. import java.io.Serializable;   
2. import java.sql.SQLException;   
3. import java.util.List;   
4.   
5. import org.springframework.orm.ibatis.SqlMapClientCallback;   
6. import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;   
7.   
8. import com.ibatis.sqlmap.client.SqlMapExecutor;   
9.   
10. /**  
11.  * iBatis DAO层泛型基类，实现了基本的DAO功能 利用了Spring的DaoSupport功能  
12.  *   
13.  * @author wl  
14.  * @since 0.1  
15.  * @param <T>  
16.  *            实体类  
17.  * @param <PK>  
18.  *            主键类，必须实现Serializable接口  
19.  *   
20.  * @see com.thinkon.commons.dao.GenericDao  
21.  * @see org.springframework.orm.ibatis.support.SqlMapClientDaoSupport  
22.  */  
23. public abstract class GenericIbatisDao<T, PK extends Serializable> extends  
24.         SqlMapClientDaoSupport implements GenericDao<T, PK> {   
25.   
26.     // sqlmap.xml定义文件中对应的sqlid   
27.     public static final String SQLID_INSERT = "insert";   
28.     public static final String SQLID_UPDATE = "update";   
29.     public static final String SQLID_UPDATE_PARAM = "updateParam";   
30.     public static final String SQLID_DELETE = "delete";   
31.     public static final String SQLID_DELETE_PARAM = "deleteParam";   
32.     public static final String SQLID_TRUNCATE = "truncate";   
33.     public static final String SQLID_SELECT = "select";   
34.     public static final String SQLID_SELECT_PK = "selectPk";   
35.     public static final String SQLID_SELECT_PARAM = "selectParam";   
36.     public static final String SQLID_SELECT_FK = "selectFk";   
37.     public static final String SQLID_COUNT = "count";   
38.     public static final String SQLID_COUNT_PARAM = "countParam";   
39.   
40.     private String sqlmapNamespace = "";   
41.   
42.     /**  
43.      * sqlmapNamespace，对应sqlmap.xml中的命名空间  
44.      *   
45.      * @return  
46.      */  
47.     public String getSqlmapNamespace() {   
48.         return sqlmapNamespace;   
49.     }   
50.   
51.     /**  
52.      * sqlmapNamespace的设置方法，可以用于spring注入  
53.      *   
54.      * @param sqlmapNamespace  
55.      */  
56.     public void setSqlmapNamespace(String sqlmapNamespace) {   
57.         this.sqlmapNamespace = sqlmapNamespace;   
58.     }   
59.   
60.     /**  
61.      * 数据库方言，缺省为MYSQL  
62.      */  
63.     private String dbDialect = "MYSQL";   
64.   
65.     /**  
66.      * 数据库方言dbDialect的get方法  
67.      *   
68.      * @return  
69.      */  
70.     public String getDbDialect() {   
71.         return dbDialect;   
72.     }   
73.   
74.     /**  
75.      * 数据库方言dbDialect的set方法  
76.      *   
77.      * @return  
78.      */  
79.     public void setDbDialect(String dbDialect) {   
80.         if (dbDialect == null  
81.                 || (!dbDialect.equals("MYSQL") && !dbDialect.equals("ORACLE")))   
82.             throw new DaoException("错误的数据库方言设置：本系统只支持MYSQL和ORACLE");   
83.         this.dbDialect = dbDialect;   
84.     }   
85.   
86.     public int count() {   
87.         Integer count = (Integer) getSqlMapClientTemplate().queryForObject(   
88.                 sqlmapNamespace + "." + SQLID_COUNT);   
89.         return count.intValue();   
90.     }   
91.   
92.     public int count(DynamicSqlParameter param) {   
93.         Integer count = (Integer) getSqlMapClientTemplate().queryForObject(   
94.                 sqlmapNamespace + "." + SQLID_COUNT_PARAM, param);   
95.         return count.intValue();   
96.     }   
97.   
98.     public int delete(PK primaryKey) {   
99.         int rows = getSqlMapClientTemplate().delete(   
100.                 sqlmapNamespace + "." + SQLID_DELETE, primaryKey);   
101.         try {   
102.             getSqlMapClientTemplate().getSqlMapClient().startBatch();   
103.         } catch (SQLException e) {   
104.             // TODO Auto-generated catch block   
105.             e.printStackTrace();   
106.         }   
107.         return rows;   
108.     }   
109.   
110.     public int delete(DynamicSqlParameter param) {   
111.         int rows = getSqlMapClientTemplate().delete(   
112.                 sqlmapNamespace + "." + SQLID_DELETE_PARAM, param);   
113.         return rows;   
114.     }   
115.   
116.     public int truncate() {   
117.         int rows = getSqlMapClientTemplate().delete(   
118.                 sqlmapNamespace + "." + SQLID_TRUNCATE);   
119.         return rows;   
120.     }   
121.   
122.     public T get(PK primaryKey) {   
123.         return (T) getSqlMapClientTemplate().queryForObject(   
124.                 sqlmapNamespace + "." + SQLID_SELECT_PK, primaryKey);   
125.     }   
126.   
127.     public void insert(T entity) {   
128.         getSqlMapClientTemplate().insert(sqlmapNamespace + "." + SQLID_INSERT,   
129.                 entity);   
130.     }   
131.   
132.     public T load(PK primaryKey) throws DaoException {   
133.         Object o = getSqlMapClientTemplate().queryForObject(   
134.                 sqlmapNamespace + "." + SQLID_SELECT_PK, primaryKey);   
135.         if (o == null)   
136.             throw new DataAccessException("数据查询异常：无法查询出主键数据");   
137.         return (T) o;   
138.     }   
139.   
140.     public List<T> select() {   
141.         return getSqlMapClientTemplate().queryForList(   
142.                 sqlmapNamespace + "." + SQLID_SELECT);   
143.     }   
144.   
145.     public List<T> select(DynamicSqlParameter param) {   
146.         return getSqlMapClientTemplate().queryForList(   
147.                 sqlmapNamespace + "." + SQLID_SELECT_PARAM, param);   
148.     }   
149.   
150.     public PaginationResult<T> selectPagination(DynamicSqlParameter param) {   
151.         if (param != null)   
152.             param.setDbDialect(this.dbDialect);   
153.   
154.         PaginationResult<T> result = new PaginationResult<T>();   
155.         int count = count(param);   
156.         result.setTotalSize(count);   
157.         if (count > 0) {   
158.             List<T> data = getSqlMapClientTemplate().queryForList(   
159.                     sqlmapNamespace + "." + SQLID_SELECT_PARAM, param);   
160.             result.setData(data);   
161.         }   
162.   
163.         return result;   
164.     }   
165.   
166.     public List<T> selectFk(DynamicSqlParameter param) {   
167.         return getSqlMapClientTemplate().queryForList(   
168.                 sqlmapNamespace + "." + SQLID_SELECT_FK, param);   
169.     }   
170.   
171.     public PaginationResult<T> selectFkPagination(DynamicSqlParameter param) {   
172.         if (param != null)   
173.             param.setDbDialect(this.dbDialect);   
174.         PaginationResult<T> result = new PaginationResult<T>();   
175.         int count = count(param);   
176.         result.setTotalSize(count);   
177.         if (count > 0) {   
178.             List<T> data = getSqlMapClientTemplate().queryForList(   
179.                     sqlmapNamespace + "." + SQLID_SELECT_FK, param);   
180.             result.setData(data);   
181.         }   
182.   
183.         return result;   
184.     }   
185.   
186.     public int update(T entity) {   
187.         return getSqlMapClientTemplate().update(   
188.                 sqlmapNamespace + "." + SQLID_UPDATE, entity);   
189.     }   
190.   
191.     public int update(DynamicSqlParameter param) {   
192.         if (param == null || param.getUpdateValueList() == null)   
193.             throw new ParameterException(   
194.                     "参数设置错误:使用带参数的update必须设定update的column！");   
195.   
196.         return getSqlMapClientTemplate().update(   
197.                 sqlmapNamespace + "." + SQLID_UPDATE_PARAM, param);   
198.     }   
199.   
200.     public void batchInsert(final List<T> list){   
201.         SqlMapClientCallback callback = new SqlMapClientCallback() {           
202.             public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {               
203.                 executor.startBatch();               
204.                 for (T member : list) {                   
205.                     executor.insert(sqlmapNamespace + "." + SQLID_INSERT, member);               
206.                 }               
207.                 executor.executeBatch();               
208.                 return null;           
209.             }       
210.         };       
211.         this.getSqlMapClientTemplate().execute(callback);       
212.     }   
213.   
214.     public void batchUpdate(final List<T> list){   
215.         SqlMapClientCallback callback = new SqlMapClientCallback() {           
216.             public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {               
217.                 executor.startBatch();               
218.                 for (T member : list) {                   
219.                     executor.update(sqlmapNamespace + "." + SQLID_UPDATE, member);               
220.                 }               
221.                 executor.executeBatch();               
222.                 return null;           
223.             }       
224.         };       
225.         this.getSqlMapClientTemplate().execute(callback);       
226.     }   
227.   
228.     public void batchDelete(final List<PK> list){   
229.         SqlMapClientCallback callback = new SqlMapClientCallback() {           
230.             public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {               
231.                 executor.startBatch();               
232.                 for (PK member : list) {                   
233.                     executor.delete(sqlmapNamespace + "." + SQLID_DELETE, member);               
234.                 }               
235.                 executor.executeBatch();               
236.                 return null;           
237.             }       
238.         };       
239.         this.getSqlMapClientTemplate().execute(callback);       
240.     }   
241. }  

import java.io.Serializable;import java.sql.SQLException;import java.util.List;import org.springframework.orm.ibatis.SqlMapClientCallback;import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;import com.ibatis.sqlmap.client.SqlMapExecutor;/*** iBatis DAO层泛型基类，实现了基本的DAO功能 利用了Spring的DaoSupport功能** @author wl* @since 0.1* @param <T>*            实体类* @param <PK>*            主键类，必须实现Serializable接口** @see com.thinkon.commons.dao.GenericDao* @see org.springframework.orm.ibatis.support.SqlMapClientDaoSupport*/public abstract class GenericIbatisDao<T, PK extends Serializable> extendsSqlMapClientDaoSupport implements GenericDao<T, PK> {// sqlmap.xml定义文件中对应的sqlidpublic static final String SQLID_INSERT = "insert";public static final String SQLID_UPDATE = "update";public static final String SQLID_UPDATE_PARAM = "updateParam";public static final String SQLID_DELETE = "delete";public static final String SQLID_DELETE_PARAM = "deleteParam";public static final String SQLID_TRUNCATE = "truncate";public static final String SQLID_SELECT = "select";public static final String SQLID_SELECT_PK = "selectPk";public static final String SQLID_SELECT_PARAM = "selectParam";public static final String SQLID_SELECT_FK = "selectFk";public static final String SQLID_COUNT = "count";public static final String SQLID_COUNT_PARAM = "countParam";private String sqlmapNamespace = "";/*** sqlmapNamespace，对应sqlmap.xml中的命名空间** @return*/public String getSqlmapNamespace() {return sqlmapNamespace;}/*** sqlmapNamespace的设置方法，可以用于spring注入** @param sqlmapNamespace*/public void setSqlmapNamespace(String sqlmapNamespace) {this.sqlmapNamespace = sqlmapNamespace;}/*** 数据库方言，缺省为MYSQL*/private String dbDialect = "MYSQL";/*** 数据库方言dbDialect的get方法** @return*/public String getDbDialect() {return dbDialect;}/*** 数据库方言dbDialect的set方法** @return*/public void setDbDialect(String dbDialect) {if (dbDialect == null|| (!dbDialect.equals("MYSQL") && !dbDialect.equals("ORACLE")))throw new DaoException("错误的数据库方言设置：本系统只支持MYSQL和ORACLE");this.dbDialect = dbDialect;}public int count() {Integer count = (Integer) getSqlMapClientTemplate().queryForObject(sqlmapNamespace + "." + SQLID_COUNT);return count.intValue();}public int count(DynamicSqlParameter param) {Integer count = (Integer) getSqlMapClientTemplate().queryForObject(sqlmapNamespace + "." + SQLID_COUNT_PARAM, param);return count.intValue();}public int delete(PK primaryKey) {int rows = getSqlMapClientTemplate().delete(sqlmapNamespace + "." + SQLID_DELETE, primaryKey);try {getSqlMapClientTemplate().getSqlMapClient().startBatch();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}return rows;}public int delete(DynamicSqlParameter param) {int rows = getSqlMapClientTemplate().delete(sqlmapNamespace + "." + SQLID_DELETE_PARAM, param);return rows;}public int truncate() {int rows = getSqlMapClientTemplate().delete(sqlmapNamespace + "." + SQLID_TRUNCATE);return rows;}public T get(PK primaryKey) {return (T) getSqlMapClientTemplate().queryForObject(sqlmapNamespace + "." + SQLID_SELECT_PK, primaryKey);}public void insert(T entity) {getSqlMapClientTemplate().insert(sqlmapNamespace + "." + SQLID_INSERT,entity);}public T load(PK primaryKey) throws DaoException {Object o = getSqlMapClientTemplate().queryForObject(sqlmapNamespace + "." + SQLID_SELECT_PK, primaryKey);if (o == null)throw new DataAccessException("数据查询异常：无法查询出主键数据");return (T) o;}public List<T> select() {return getSqlMapClientTemplate().queryForList(sqlmapNamespace + "." + SQLID_SELECT);}public List<T> select(DynamicSqlParameter param) {return getSqlMapClientTemplate().queryForList(sqlmapNamespace + "." + SQLID_SELECT_PARAM, param);}public PaginationResult<T> selectPagination(DynamicSqlParameter param) {if (param != null)param.setDbDialect(this.dbDialect);PaginationResult<T> result = new PaginationResult<T>();int count = count(param);result.setTotalSize(count);if (count > 0) {List<T> data = getSqlMapClientTemplate().queryForList(sqlmapNamespace + "." + SQLID_SELECT_PARAM, param);result.setData(data);}return result;}public List<T> selectFk(DynamicSqlParameter param) {return getSqlMapClientTemplate().queryForList(sqlmapNamespace + "." + SQLID_SELECT_FK, param);}public PaginationResult<T> selectFkPagination(DynamicSqlParameter param) {if (param != null)param.setDbDialect(this.dbDialect);PaginationResult<T> result = new PaginationResult<T>();int count = count(param);result.setTotalSize(count);if (count > 0) {List<T> data = getSqlMapClientTemplate().queryForList(sqlmapNamespace + "." + SQLID_SELECT_FK, param);result.setData(data);}return result;}public int update(T entity) {return getSqlMapClientTemplate().update(sqlmapNamespace + "." + SQLID_UPDATE, entity);}public int update(DynamicSqlParameter param) {if (param == null || param.getUpdateValueList() == null)throw new ParameterException("参数设置错误:使用带参数的update必须设定update的column！");return getSqlMapClientTemplate().update(sqlmapNamespace + "." + SQLID_UPDATE_PARAM, param);}public void batchInsert(final List<T> list){SqlMapClientCallback callback = new SqlMapClientCallback() {public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {executor.startBatch();for (T member : list) {executor.insert(sqlmapNamespace + "." + SQLID_INSERT, member);}executor.executeBatch();return null;}};this.getSqlMapClientTemplate().execute(callback);}public void batchUpdate(final List<T> list){SqlMapClientCallback callback = new SqlMapClientCallback() {public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {executor.startBatch();for (T member : list) {executor.update(sqlmapNamespace + "." + SQLID_UPDATE, member);}executor.executeBatch();return null;}};this.getSqlMapClientTemplate().execute(callback);}public void batchDelete(final List<PK> list){SqlMapClientCallback callback = new SqlMapClientCallback() {public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {executor.startBatch();for (PK member : list) {executor.delete(sqlmapNamespace + "." + SQLID_DELETE, member);}executor.executeBatch();return null;}};this.getSqlMapClientTemplate().execute(callback);}}

 3、某实体的DAO接口：

Java代码

 

1. public interface UserDao extends GenericDao<User,Integer> {   
2. //通用方法从GenericDao继承   
3. //这里可以定义针对此类的特定方法   
4. }  

public interface UserDao extends GenericDao<User,Integer> {//通用方法从GenericDao继承//这里可以定义针对此类的特定方法}

 4、某实体的DAO实现：

Java代码

 

1. public class UserDaoImpl extends GenericIbatisDao<User,Integer> implements UserDao {   
2. }