`

mybatis泛型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. }  

 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. }  

 3、某实体的DAO接口:

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

 4、某实体的DAO实现:

Java代码  收藏代码
  1. public class UserDaoImpl extends GenericIbatisDao<User,Integer> implements UserDao {  
  2. }  

 

分享到:
评论
2 楼 goahead2010 2013-10-22  
projecttian 写道
可以使用拦截器的方式来处理这个范型dao,这样可以省去UserDaoImpl 这个继承类。
这样才是mybaits的Mapper模式的思想。

我是在不用mapper方式下对应sql语句,这样可以定制化我的pojo,也方便配置spring以及分布式部署。哎,一下也没考虑周全
1 楼 projecttian 2013-10-17  
可以使用拦截器的方式来处理这个范型dao,这样可以省去UserDaoImpl 这个继承类。
这样才是mybaits的Mapper模式的思想。

相关推荐

    基于spring MVC 和 MyBatis 泛型的代码生成模板,可以根据自己的需求修改

    总的来说,这个基于Spring MVC和MyBatis的泛型代码生成模板是一个提高开发效率的实用工具。它利用Java的泛型特性实现了通用的DAO层,结合Spring MVC和MyBatis的灵活性,帮助开发者快速构建Web应用的后台逻辑。对于...

    泛型dao

    【泛型DAO】是一种在Java开发中常见的设计模式,它利用了Java泛型特性来提高代码的可重用性和类型安全性。在Java中,DAO(Data Access Object)模式是用来封装对数据库的操作,将业务逻辑与数据访问逻辑分离,使得...

    泛型DAO,注释详细

    接下来,我们可以使用Hibernate或MyBatis等持久层框架实现这个泛型DAO。以Hibernate为例,一个简单的实现可能如下: ```java public class HibernateGenericDAO, ID extends Serializable&gt; implements GenericDAO, ...

    Java Web程序运用中泛型DAO的作用.pdf

    1. **提高运算性能**:由于泛型DAO减少了代码重复,使得程序运行时的内存开销减小,提高了程序的运行效率。 2. **提升安全性**:泛型提供了编译时类型检查,可以避免因类型转换错误导致的运行时异常,提高了程序的...

    Mybatis通用DAO设计封装(mybatis)

    通过以上设计,我们可以构建出一个高效、灵活且易于维护的Mybatis通用DAO层。这种设计封装了数据库操作的细节,使得业务逻辑层可以更专注于业务本身,提升了开发效率。在实际项目中,可以根据具体需求进行适当的扩展...

    ssh整合下的通用泛型DAO+分页

    在这个特定的讨论中,我们聚焦于SSH1中的一个关键概念:通用泛型DAO(Data Access Object)以及分页功能的实现。DAO层是模型层和数据访问层之间的桥梁,它的主要职责是处理数据库操作,为业务层提供无状态的数据访问...

    mybatis 通用DAO 简单实现

    MyBatis 通用DAO(Data Access Object)是一种设计模式,旨在提供一种标准的方式来访问数据库,减少重复代码,提高开发效率。在Java Web开发中,MyBatis作为一个优秀的持久层框架,它支持定制化SQL、存储过程以及...

    基于MAVEN的SpringMVC+Mybatis整合及dao、service强封装

    二、在封装上针对Mybatis进行Dao、service层封装,里面提供两种实现机制:一种采用注解泛型动态实现cud操作,目前查询还是有缺陷;另一种机制采用xml文件形式实现dao、service、controller层封装,具体业务类只需...

    泛型通用DAO,可以很简化DAO层的代码

    1. 代码重用:一个泛型DAO接口或抽象类可以应用于所有数据实体,减少了大量重复代码。 2. 类型安全:编译时类型检查确保了操作的正确性,避免了强制类型转换错误。 3. 易于扩展:如果需要添加新的数据库操作,只需在...

    ssh通用基于泛型的dao

    1. `GenericDAO.java`:泛型DAO接口,定义了基本的CRUD方法。 2. `HibernateGenericDAO.java`:实现了`GenericDAO`接口的具体类,使用Hibernate作为底层的数据访问技术。 3. `BaseDAO.java`:可能是一个抽象类,包含...

    dao.rar_dao

    在实际应用中,我们可以为JXVA框架提供一个泛型DAO的实现,如`HibernateGenericDAO`或`MyBatisGenericDAO`,利用ORM(对象关系映射)工具如Hibernate或MyBatis进行数据库操作。这些实现类将处理与具体数据库系统的...

    ssh2 + dao泛型

    在SSH2框架中,我们可以利用Spring的JdbcTemplate或MyBatis等工具来实现DAO层的泛型化。这些工具提供了强大的SQL执行能力,与泛型结合可以大大减少代码量,避免了重复的模板代码。例如,我们可以定义一个泛型方法`...

    SSH泛型代码实例

    - `DAO(1).rar`可能包含使用泛型的DAO设计模式示例,展示了如何创建泛型DAO以处理不同类型的数据对象。 综上所述,SSH框架结合泛型能够提升Java应用的开发效率和代码质量。通过学习和理解这些示例,开发者可以更好...

    通用DAO

    1. **创建泛型DAO接口**:定义一个泛型接口,如`GenericDAO&lt;T&gt;`,其中T代表数据库实体类型。 2. **实现DAO接口**:在实现类中,使用反射获取实体类的字段信息,构造SQL语句。 3. **执行SQL操作**:使用JDBC或其他ORM...

    iBatis和MyBatis对比

    MyBatis不仅继承了iBatis的优点,还引入了更多的增强功能,如泛型和注解的支持,使得框架更加现代化和易于使用。MyBatis的出现意味着iBatis的升级,它不再仅仅是SQL映射框架,而是发展成一个更全面的ORM解决方案。 ...

    MyBatis中英文文档.tar.gz

    前者是MyBatis的官方中文用户指南,详细介绍了MyBatis的安装、配置、映射文件的编写、事务管理等内容,是学习和使用MyBatis的重要参考资料。后者则是iBatis的英文教程,对于理解iBatis的工作原理和对比MyBatis的新...

    Java反射泛型,实现数据库的动态增删改查等功能

    在动态数据库操作中,泛型可以用来创建通用的DAO(数据访问对象)接口和实现,以处理不同类型的实体对象。例如,我们可以定义一个`GenericDAO&lt;T&gt;`接口,其中`T`代表任何数据模型类。这个接口可以包含`insert(T ...

    mybatis 通用mapper

    MyBatis通用Mapper是一个基于MyBatis框架的扩展工具,它极大地简化了针对单一表的操作,使得开发人员无需编写繁琐的XML映射文件和接口定义就能实现数据层的增删改查等基本功能。其优势在于简化了开发流程,降低了...

Global site tag (gtag.js) - Google Analytics