这种情况下的接口该如何设计

[ilstar]

假如我的数据库里有两张表,Person和Car
在对他们进行操作时,有如下两个情况
1:
VO类 DAO类 抽象类
Person PersonDAO AbstractPersonDAO
Car CarDAO AbstractCarDAO
这是第一种情况,也就是为每一个dao都设计一个抽象类(这里,先不区分抽象类和接口的区别,只讨论他们作为父类的使用情况)
我见到的有很多人都是这么用的,但是我不太明白,这个时候抽象类有什么用?用来扩展吗,每个抽象类只有自己的一个dao,怎么扩展?
2:
VO类 DAO类 抽象类
Person PersonDAO AbstractDAO
Car CarDAO AbstractDAO(和上面的是同一个)
这个情况,就是一个抽象的dao,引用着所有实现它方法的子类,如果新加一个物体,比如说Dog,就可以让AbstractDAO指向DogDAO了,我个人是比较偏向于这样的写法的,但是看到大家都在用上面的那个情况

哪位高手愿意花费点时间给解释一下这两个情况的区别以及优缺点啊
一直听人说写一个抽象类(或接口)这样比较容易扩展,将来添加新业务的时候不用修改以前的代码,能举个小例子说明一下吗,先谢谢各位了

[lisl2003]

睡前顶帖

[hbwhwang]

一般用泛型来实现第二种。我的设计：

[hbwhwang]

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);
}

[hbwhwang]

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);	
	}
}

[hbwhwang]

3、某实体的DAO接口：

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

[hbwhwang]

4、某实体的DAO实现：

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

[hbwhwang]

这样做的好处是，根本不用写某具体类的实现代码（UserDao自身基本是空的，因为它的基本功能已经在祖先类中定义了）
需要扩充的就只有特性具体类的代码了

[ilstar]

我对2楼的回答思考了很多遍,有不少收获,这里的95分就送你了,剩下的5分送给1楼给顶贴的,呵呵

明天晚上结贴,如果在有能给一些建议的高手,我还会加一些分数的,谢谢了

[ilstar]

楼上的回答感觉很好,非常感谢,不过有点高深了,呵呵
您的意思我有点了解了,还希望有人给回答一下

[chenzhao]

kankan o