`
winneryj
  • 浏览: 129643 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

泛型DAO接口的设计

DAOiBATISMySQLOracleSpring 
阅读更多

1、泛型DAO接口定义

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实现：

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> extends
        SqlMapClientDaoSupport implements GenericDao<T, PK> {

    // sqlmap.xml定义文件中对应的sqlid
    public 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 block
            e.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接口：

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

 4、某实体的DAO实现： 

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

 

分享到：
| iBatis调用存储过程的方法
评论
5 楼 wjhu 2011-07-14  
xml
wolfarmy 写道
sqlmap中的每个类的xml文件也展示一下呗？

+1
4 楼 gaifo 2010-12-07  
DynamicSqlParameter 这个类在那里?怎么没办法导入包啊?
3 楼 askyuan 2010-03-20   
public interface UserDao extends GenericDao<User,Integer> {   
//通用方法从GenericDao继承   
//这里可以定义针对此类的特定方法   
}  


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

这个写完整的呀，UserDao 不能覆盖GenericDao方法，不知道是什么意思
2 楼 heshaoqin 2009-02-03  
xml 配置呢!!!
1 楼 wolfarmy 2009-01-29  
sqlmap中的每个类的xml文件也展示一下呗？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    泛型dao 泛型dao 泛型dao

    泛型dao接口 ：GenericDao, ID extends Serializable&gt; 泛型作为DAO的通用接口 CRUD方法 dao接口 : PersonDAO extends GenericDao, Integer&gt; 可以不写代码,方法已经在父类泛型dao里了,这里为了说明:可扩展添加 ...

    经典泛型dao层代码，非常好用简易

    泛型DAO层通过利用Java的泛型机制，提供了一种类型安全且高度可复用的数据访问接口。相比传统的DAO设计，泛型DAO层具有以下显著优势： 1. **类型安全性**：泛型允许开发者在编译时检查类型，避免了运行时的...

    Hibernate泛型DAO接口，大部分通用都已包括

    本篇将详细介绍"Hibernate泛型DAO接口，大部分通用都已包括"这一主题。 首先，让我们看看DAO的概念。DAO是软件设计模式中的一种，它的主要职责是封装对数据源的访问，以提供业务逻辑层与数据存储层之间的解耦。通过...

    一个很好的通用泛型dao（含源码）

    而泛型DAO是一个类型安全的，代码精简的设计模式（相对于传统DAO），尤其在DAO组件数量庞大的时候，代码量的减少更加明显。 泛型DAO的核心是定义一个GenericDao接口，声明基本的CRUD操作： 用hibernate作为持久化...

    大家看看我设计的泛型DAO（使用Spring的Anotation和Hibernate）

    接着，`GenericDao.java`是泛型DAO接口，它定义了对所有类型实体进行操作的方法。这些方法利用了Java的泛型特性，使得DAO可以处理任何继承自特定基类或实现特定接口的实体。例如，`GenericDao&lt;T&gt;`可能包含以下方法：...

    Hibernate泛型DAO（结合spring模板支持）

    首先，我们需要创建一个泛型DAO接口，如`GenericDao&lt;T&gt;`，其中`T`代表任意实体类类型。接口中包含增删改查等基本操作： ```java public interface GenericDao&lt;T&gt; { void save(T entity); void update(T entity); ...

    泛型dao

    下面是一个简单的泛型DAO接口示例： ```java public interface GenericDAO, ID&gt; { T save(T entity); T update(T entity); void delete(ID id); T findById(ID id); List&lt;T&gt; findAll(); } ``` 在这个例子中，...

    JdbcTemplate通用泛型Dao实现

    `JdbcTemplate`的泛型Dao实现是一种设计模式，目的是提高代码的可重用性和可维护性。通过定义一个泛型接口，我们可以创建一个通用的数据访问对象（DAO），这个DAO可以处理任何类型的实体类，只要它们遵循一定的规则...

    泛型DAO模型设计课堂笔记

    【泛型DAO模型设计】是Java开发中一种高效且可复用的数据访问对象（DAO）设计方式，结合了泛型和反射技术。泛型在Java中引入，旨在提高代码的安全性和可读性，减少类型转换的繁琐过程。DAO设计模式主要用于数据库...

    泛型DAO，注释详细

    2. **代码复用**：一个泛型DAO接口可以为多个实体类提供服务，减少了重复代码。 3. **简化编程**：开发人员无需关心具体的实体类型，只需要关注业务逻辑，提高了开发效率。 在实际项目中，我们通常会根据需求进一步...

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

    例如，一个基本的泛型DAO接口可能包含`save(T entity)`, `delete(T entity)`, `findAll()`, `findById(ID id)`等方法，其中`T`代表任何数据实体类型，`ID`代表主键类型。 在工作过程中，泛型DAO的实现类会利用反射...

    S2SH整合例子 注解配置 JSON 泛型Dao

    6. **泛型Dao**：在Java开发中，泛型Dao（Generic Dao）是一种设计模式，用于减少重复的数据库操作代码。通过定义一个通用的Dao接口，可以实现对不同类型的实体对象进行CRUD操作，提高了代码的复用性和可维护性。...

    spring hibernate 泛型DAO

    下面是一个简单的泛型DAO接口示例： ```java public interface GenericDao, ID extends Serializable&gt; { T save(T entity); void delete(ID id); T findById(ID id); List&lt;T&gt; findAll(); } ``` 在Hibernate中...

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

    下面是一个简单的泛型DAO接口示例： ```java public interface GenericDAO, ID extends Serializable&gt; { void save(T entity); void update(T entity); void delete(ID id); T findById(ID id); List&lt;T&gt; find...

    Hibernate泛型DAO及使用方法.doc

    首先，我们来看一下泛型DAO接口的定义。在`com.th.huz`包下，定义了一个名为`GenericDao`的接口，它有两个泛型参数：`T`代表要操作的实体类，`PK`代表该实体类的主键类型，都必须继承自`Serializable`接口。这个接口...

    SSH 泛型DAO分页

    4. **泛型DAO**: 在SSH框架中，泛型DAO是一种常见的设计模式，用于封装对数据库的基本操作，如增删查改。通过泛型，我们可以创建一个通用的DAO接口和实现，减少代码重复，提高代码复用。例如，我们可以创建一个`...

    基于hibernate的泛型Dao框架

    `GenericDao.txt`可能包含的是关于泛型Dao框架的设计文档或者代码示例，详细解释了如何使用泛型Dao进行数据库操作，可能包括如何定义泛型接口，以及如何创建和使用它的实现类。 `bin`目录通常是编译后生成的Java...

    ssh通用泛型DAO

    总的来说，"ssh通用泛型DAO"是一种设计模式，旨在简化SSH框架下的数据访问层开发，提高代码复用性，减少重复工作，同时通过泛型提供类型安全的保障。理解和熟练运用这一模式，能够有效地提升Java Web应用的开发效率...

Magicbox
Global site tag (gtag.js) - Google Analytics