数据库框架设计与实现（一）_本地数据库框架设计

一、设计目标

1. 对上层提供统一、唯一的接口，不仅支持关系型数据库，还要支持非关系型数据库。

2. 以基于ORM思想，泛型为实现的方法进行数据库操作进行封装。

3. 实现数据库可配置，可替换。

二、框架图

框架核心采用了工厂模式+简单工厂模式，本来应该由BaseDao去实现Query来构成工厂模式，但为了最大程度解耦，在创建Query时又采用了简单工厂去关联IQuery接口。UserDao则是客户端调用者，同样采用简单工厂来与IDataBaseDao关联。IPageModel、ITreeModel则分别是为分页、树形结构服务的。（这里一说到简单工厂，实际上是交由spring的IOC来完成的）最终使得任何类都是基于接口实现，从而达到整体框架灵活性。

三、代码实现

1. IDataBaseDao

package com.core.dao;
 
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
 
/**
 * 数据库访问操作对象
 * @author Wang
 * @param <T> 实体类
 * @param <PK> 主键类型
 */
public interface IDataBaseDao<T extends Serializable, PK extends Serializable> {
 
	/**
	 * 设置实体类
	 * @param entityClass 实体类class
	 */
	void setEntityClass(Class<T> entityClass);
 
	/**
	 * 新建一个查询对象
	 * @return
	 */
	IQuery createQuery();
 
	/**
	 * 获取数据
	 * @param id 主键
	 * @return
	 */
	T get(PK id);
 
	/**
	 * 加载数据
	 * @param id 主键
	 * @return
	 */
	T load(PK id);
 
	/**
	 * 加载全部数据
	 * @return
	 */
	List<T> loadAll();
 
	/**
	 * 查询数据
	 * @param query 查询对象
	 * @return
	 */
	List<T> find(IQuery query);
 
	/**
	 * 保存数据
	 * @param entity 实体类
	 * @return
	 */
	PK save(T entity);
 
	/**
	 * 更新数据
	 * @param entity 实体类
	 */
	void update(T entity);
 
	/**
	 * 保存或更新数据
	 * @param entity 实体类
	 */
	void saveOrUpdate(T entity);
 
	/**
	 * 保存或更新全部数据
	 * @param entities 实体类集合
	 */
	void saveOrUpdateAll(Collection<T> entities);
 
	/**
	 * 删除数据
	 * @param entity 实体类
	 */
	void delete(T entity);
 
	/**
	 * 依据主键删除数据
	 * @param id 主键
	 */
	void deleteByKey(PK id);
 
	/**
	 * 删除全部数据
	 * @param entities 实体类集合
	 */
	void deleteAll(Collection<T> entities);
}

说明：

该接口是本系统数据库框架对外提供服务的核心接口，也是各个数据库实现框架（hibernate、ibatis、）的抽象接口，使本系统不局限于某种数据库实现框架，支持各种常见数据库实现框架。

系统其它框架都要统一调用接口，不可直接调用实现类。

支持泛型。第一个T为返回对象类型，第二个PK为主键类型。

 

2. IQuery

package com.core.dao;
 
import java.util.List;
 
/**
 * 查询操作对象
 * @author Wang
 */
public interface IQuery {
 
	/**
	 * 获取对象查询语句
	 * @return
	 */
	String getQueryString();
 
	/**
	 * 获取sql查询语句
	 * @return
	 */
	String getSQLString();
 
	/**
	 * 获取查询参数集合
	 * @return
	 */
	Object[] getParamValues();
 
	/**
	 * 获取查询数据的起始位号，用于分页
	 * @return
	 */
	int getFirstResult();
 
	/**
	 * 获取查询数据的最大长度，用于分页
	 * @return
	 */
	int getMaxResults();
 
	/**
	 * 设置表的实体类集合
	 * @param entityClasses 实体类class集合
	 */
	@SuppressWarnings("rawtypes")
	void setEntityClass(Class[] entityClasses);
 
	/**
	 * 设置对象查询语句
	 * @param queryStr 对象查询语句字符串
	 */
	void setQueryString(String queryStr);
 
	/**
	 * 设置sql查询语句
	 * @param sql sql查询语句字符串
	 */
	void setSQLString(String sql);
 
	/**
	 * 设置查询参数集合
	 * @param values 参数值集合
	 */
	void setParamValues(Object[] values);
 
	/**
	 * 设置查询数据的起始值，用于分页
	 * @param value 起始值
	 */
	void setFirstResult(int value);
 
	/**
	 * 设置查询数据的最大长度，用于分页
	 * @param value 最大值
	 */
	void setMaxResults(int value);
 
	/**
	 * 执行查询
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	List execute();
}

说明：

该接口是专门针对于查询数据库设计的，不同数据库，其查询语言都不太一样，而增删改操作则都较为简单。任何涉及到查询数据库的操作都要统一采用此接口的方式实现。

提供对原生SQL的支持，即getSQLString、setSQLString，同时该方法并不仅仅用于SQL语句，同样适用于非关系数据库的一些特殊的查询语句（如Mongodb），而getQueryString、setQueryString则是针对面向对象的查询语句而独自提供的方法。

为了防止一些查询语句无法彻底封装，提供了一个excute方法来完成查询。

提供getFirstResult等方法来对分页查询提供支持。

 

3. IPageModel

package com.core.dao;
 
import java.io.Serializable;
import java.util.List;
 
/**
 * 分页操作对象
 * @author Wang
 * @param <T> 数据对象类型
 */
public interface IPageModel<T extends Serializable> {
 
	/**
	 * 获取一页显示多少条数据的值
	 * @return
	 */
	int getPageSize();
 
	/**
	 * 获取总页数的值
	 * @return
	 */
	int getTotalPages();
 
	/**
	 * 获取当前页号
	 * @return
	 */
	int getPageNumber();
 
	/**
	 * 获取该页第一条数据的行号
	 * @return
	 */
	int getFirstResult();
 
	/**
	 * 获取该页数据
	 * @return
	 */
	List<T> getDataResult();
 
	/**
	 * 是否是首页
	 * @return
	 */
	boolean isFirstPage();
 
	/**
	 * 是否是尾页
	 * @return
	 */
	boolean isLastPage();
 
	/**
	 * 设置一页显示多少条数据
	 * @param value
	 */
	void setPageSize(int value);
 
	/**
	 * 设置总页数
	 * @param value
	 */
	void setTotalPages(int value);
 
	/**
	 * 设置当前页号
	 * @param value
	 */
	void setPageNumber(int value);
 
	/**
	 * 设置该页第一条数据的行号
	 * @param value
	 */
	void setFirstResult(int value);
 
	/**
	 * 设置该页数据
	 * @param data
	 */
	void setDataResult(List<T> data);
}

说明：

该接口用于分页功能，任何分页的实现都必须用该接口。

 

4. ITreeModel

package com.core.dao;
 
import java.io.Serializable;
 
public interface ITreeModel<PK extends Serializable> {
 
	PK getNodeId();
	
	PK getNodePid();
	
	String getNodeName();
	
	int getNodeOrder();
	
	String getNodeImage();
	
	int getNodeLevel();
	
	void setNodeId(PK nodeId);
	
	void setNodePid(PK nodePid);
	
	void setNodeName(String nodeName);
	
	void setNodeOrder(PK nodeOrder);
	
	void setNodeImage(String nodeImage);
	
	void setNodeLevel(int nodelLevel);
}

说明：

该接口用于树形功能。任何树形的实现都必须用该接口。

 

5. BaseDao

package com.core.dao.hibernate;
 
import java.io.Serializable;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
 
import javax.annotation.Resource;
 
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
 
import com.core.dao.IDataBaseDao;
import com.core.dao.IQuery;
import com.util.BeanUtil;
 
public class BaseDao<T extends Serializable, PK extends Serializable> implements IDataBaseDao<T, PK> {
 
	@Resource
	private HibernateTemplate hibernateTemplate;
	
	@Resource
	private IQuery query;
 
	private Class<T> entityClass;
 
	@Override
	public void setEntityClass(Class<T> entityClass) {
		this.entityClass = entityClass;
	}
	
	@Override
	public IQuery createQuery() {
		return query;
	}
 
	@SuppressWarnings("unchecked")
	@Override
	public T get(PK id) {
		return (T) hibernateTemplate.get(entityClass, id);
	}
 
	@SuppressWarnings("unchecked")
	@Override
	public T load(PK id) {
		return (T) hibernateTemplate.load(entityClass, id);
	}
 
	@SuppressWarnings("unchecked")
	@Override
	public List<T> loadAll() {
		return hibernateTemplate.loadAll(entityClass);
	}
 
	@SuppressWarnings("unchecked")
	@Override
	public List<T> find(IQuery query) {
		final String queryString = query.getQueryString();
		if (!BeanUtil.isNull(queryString)) {
			final Object[] values = query.getParamValues();
			final int firstResult = query.getFirstResult();
			final int maxResult = query.getMaxResults();
 
			if (!BeanUtil.isNull(values)) {
				if (maxResult > 0) {
					hibernateTemplate.executeFind(new HibernateCallback() {
 
						@Override
						public Object doInHibernate(Session session) throws HibernateException, SQLException {
							Query query = session.createQuery(queryString);
							query.setFirstResult(firstResult);
							query.setMaxResults(maxResult);
							for (int i = 0; i < values.length; i++) {
								query.setParameter(i + 1, values[i]);
							}
							return query.list();
						}
					});
				}
				return hibernateTemplate.find(queryString, values);
			} else {
				if (maxResult > 0) {
					hibernateTemplate.executeFind(new HibernateCallback() {
 
						@Override
						public Object doInHibernate(Session session) throws HibernateException, SQLException {
							Query query = session.createQuery(queryString);
							query.setFirstResult(firstResult);
							query.setMaxResults(maxResult);
							return query.list();
						}
					});
				}
				return hibernateTemplate.find(queryString);
			}
		}
 
		String sql = query.getSQLString();
		if (!BeanUtil.isNull(sql)) {
			return query.execute();
		} else {
			//  需要抛出异常
			return null;
		}
	}
 
	@SuppressWarnings("unchecked")
	@Override
	public PK save(T entity) {
		return (PK) hibernateTemplate.save(entity);
	}
 
	@Override
	public void update(T entity) {
		hibernateTemplate.update(entity);
	}
 
	@Override
	public void saveOrUpdate(T entity) {
		hibernateTemplate.saveOrUpdate(entity);
	}
 
	@Override
	public void saveOrUpdateAll(Collection<T> entities) {
		hibernateTemplate.saveOrUpdateAll(entities);
	}
 
	@Override
	public void delete(T entity) {
		hibernateTemplate.delete(entity);
	}
 
	@Override
	public void deleteByKey(PK id) {
		T t = this.get(id);
		hibernateTemplate.delete(t);
	}
 
	@Override
	public void deleteAll(Collection<T> entities) {
		hibernateTemplate.deleteAll(entities);
	}
}

说明：

该类是对IDataBaseDao的实现，也是基于Hibernate框架的实现类。

 

6. Query

package com.core.dao.hibernate;
 
import java.util.List;
 
import com.core.dao.IQuery;
 
public class Query implements IQuery {
 
	private String queryStr;
 
	private String sql;
 
	private Object[] params;
 
	private int firstResult;
 
	private int maxResult;
 
	@SuppressWarnings({ "rawtypes", "unused" })
	private Class[] entityClasses;
 
	@Override
	public String getQueryString() {
		return queryStr;
	}
 
	@Override
	public String getSQLString() {
		return sql;
	}
 
	@Override
	public Object[] getParamValues() {
		return params;
	}
 
	@Override
	public int getFirstResult() {
		return firstResult;
	}
 
	@Override
	public int getMaxResults() {
		return maxResult;
	}
 
	@SuppressWarnings("rawtypes")
	@Override
	public void setEntityClass(Class[] entityClasses) {
		this.entityClasses = entityClasses;
	}
 
	@Override
	public void setQueryString(String queryStr) {
		this.queryStr = queryStr;
	}
 
	@Override
	public void setSQLString(String sql) {
		this.sql = sql;
	}
 
	@Override
	public void setParamValues(Object[] values) {
		this.params = values;
	}
 
	@Override
	public void setFirstResult(int value) {
		this.firstResult = value;
	}
 
	@Override
	public void setMaxResults(int value) {
		this.maxResult = value;
	}
 
	@SuppressWarnings("rawtypes")
	@Override
	public List execute() {
		return null;
	}
 
}

该类是对IQuery的实现，也是基于Hibernate框架的实现类。

 

6. applicationContext.xml（部分，其他的自己配）

	<bean id="baseDao" class="com.core.dao.hibernate.BaseDao"></bean>
	
	<bean id="query" class="com.core.dao.hibernate.Query" scope="prototype"></bean>
	
	<bean name="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

 

 

四、结语

目前这个框架还处于初期阶段，只实现了对Hibernate的支持，今后我仍会逐步完善（本篇文章会同步更新），后续文章中也会出现连载。

这里也可以看做是给大家一个思路，如果各位有好的想法和建议，清多多留言交流！