devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：酷酷是懒虫 | 2024-07-17 09:15:18

赞

踩

本地数据库框架设计

一、设计目标

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

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

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

二、框架图

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

三、代码实现

1. IDataBaseDao

  1. package com.core.dao;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Collection;
  5. import java.util.List;
  6.  
  7. /**
  8.  * 数据库访问操作对象
  9.  * @author Wang
  10.  * @param <T> 实体类
  11.  * @param <PK> 主键类型
  12.  */
  13. public interface IDataBaseDao<T extends Serializable, PK extends Serializable> {
  14.  
  15. 	/**
  16. 	 * 设置实体类
  17. 	 * @param entityClass 实体类class
  18. 	 */
  19. 	void setEntityClass(Class<T> entityClass);
  20.  
  21. 	/**
  22. 	 * 新建一个查询对象
  23. 	 * @return
  24. 	 */
  25. 	IQuery createQuery();
  26.  
  27. 	/**
  28. 	 * 获取数据
  29. 	 * @param id 主键
  30. 	 * @return
  31. 	 */
  32. 	T get(PK id);
  33.  
  34. 	/**
  35. 	 * 加载数据
  36. 	 * @param id 主键
  37. 	 * @return
  38. 	 */
  39. 	T load(PK id);
  40.  
  41. 	/**
  42. 	 * 加载全部数据
  43. 	 * @return
  44. 	 */
  45. 	List<T> loadAll();
  46.  
  47. 	/**
  48. 	 * 查询数据
  49. 	 * @param query 查询对象
  50. 	 * @return
  51. 	 */
  52. 	List<T> find(IQuery query);
  53.  
  54. 	/**
  55. 	 * 保存数据
  56. 	 * @param entity 实体类
  57. 	 * @return
  58. 	 */
  59. 	PK save(T entity);
  60.  
  61. 	/**
  62. 	 * 更新数据
  63. 	 * @param entity 实体类
  64. 	 */
  65. 	void update(T entity);
  66.  
  67. 	/**
  68. 	 * 保存或更新数据
  69. 	 * @param entity 实体类
  70. 	 */
  71. 	void saveOrUpdate(T entity);
  72.  
  73. 	/**
  74. 	 * 保存或更新全部数据
  75. 	 * @param entities 实体类集合
  76. 	 */
  77. 	void saveOrUpdateAll(Collection<T> entities);
  78.  
  79. 	/**
  80. 	 * 删除数据
  81. 	 * @param entity 实体类
  82. 	 */
  83. 	void delete(T entity);
  84.  
  85. 	/**
  86. 	 * 依据主键删除数据
  87. 	 * @param id 主键
  88. 	 */
  89. 	void deleteByKey(PK id);
  90.  
  91. 	/**
  92. 	 * 删除全部数据
  93. 	 * @param entities 实体类集合
  94. 	 */
  95. 	void deleteAll(Collection<T> entities);
  96. }

说明：

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

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

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

 

2. IQuery

  1. package com.core.dao;
  2.  
  3. import java.util.List;
  4.  
  5. /**
  6.  * 查询操作对象
  7.  * @author Wang
  8.  */
  9. public interface IQuery {
  10.  
  11. 	/**
  12. 	 * 获取对象查询语句
  13. 	 * @return
  14. 	 */
  15. 	String getQueryString();
  16.  
  17. 	/**
  18. 	 * 获取sql查询语句
  19. 	 * @return
  20. 	 */
  21. 	String getSQLString();
  22.  
  23. 	/**
  24. 	 * 获取查询参数集合
  25. 	 * @return
  26. 	 */
  27. 	Object[] getParamValues();
  28.  
  29. 	/**
  30. 	 * 获取查询数据的起始位号，用于分页
  31. 	 * @return
  32. 	 */
  33. 	int getFirstResult();
  34.  
  35. 	/**
  36. 	 * 获取查询数据的最大长度，用于分页
  37. 	 * @return
  38. 	 */
  39. 	int getMaxResults();
  40.  
  41. 	/**
  42. 	 * 设置表的实体类集合
  43. 	 * @param entityClasses 实体类class集合
  44. 	 */
  45. 	@SuppressWarnings("rawtypes")
  46. 	void setEntityClass(Class[] entityClasses);
  47.  
  48. 	/**
  49. 	 * 设置对象查询语句
  50. 	 * @param queryStr 对象查询语句字符串
  51. 	 */
  52. 	void setQueryString(String queryStr);
  53.  
  54. 	/**
  55. 	 * 设置sql查询语句
  56. 	 * @param sql sql查询语句字符串
  57. 	 */
  58. 	void setSQLString(String sql);
  59.  
  60. 	/**
  61. 	 * 设置查询参数集合
  62. 	 * @param values 参数值集合
  63. 	 */
  64. 	void setParamValues(Object[] values);
  65.  
  66. 	/**
  67. 	 * 设置查询数据的起始值，用于分页
  68. 	 * @param value 起始值
  69. 	 */
  70. 	void setFirstResult(int value);
  71.  
  72. 	/**
  73. 	 * 设置查询数据的最大长度，用于分页
  74. 	 * @param value 最大值
  75. 	 */
  76. 	void setMaxResults(int value);
  77.  
  78. 	/**
  79. 	 * 执行查询
  80. 	 * @return
  81. 	 */
  82. 	@SuppressWarnings("rawtypes")
  83. 	List execute();
  84. }

说明：

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

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

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

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

 

3. IPageModel

  1. package com.core.dao;
  2.  
  3. import java.io.Serializable;
  4. import java.util.List;
  5.  
  6. /**
  7.  * 分页操作对象
  8.  * @author Wang
  9.  * @param <T> 数据对象类型
  10.  */
  11. public interface IPageModel<T extends Serializable> {
  12.  
  13. 	/**
  14. 	 * 获取一页显示多少条数据的值
  15. 	 * @return
  16. 	 */
  17. 	int getPageSize();
  18.  
  19. 	/**
  20. 	 * 获取总页数的值
  21. 	 * @return
  22. 	 */
  23. 	int getTotalPages();
  24.  
  25. 	/**
  26. 	 * 获取当前页号
  27. 	 * @return
  28. 	 */
  29. 	int getPageNumber();
  30.  
  31. 	/**
  32. 	 * 获取该页第一条数据的行号
  33. 	 * @return
  34. 	 */
  35. 	int getFirstResult();
  36.  
  37. 	/**
  38. 	 * 获取该页数据
  39. 	 * @return
  40. 	 */
  41. 	List<T> getDataResult();
  42.  
  43. 	/**
  44. 	 * 是否是首页
  45. 	 * @return
  46. 	 */
  47. 	boolean isFirstPage();
  48.  
  49. 	/**
  50. 	 * 是否是尾页
  51. 	 * @return
  52. 	 */
  53. 	boolean isLastPage();
  54.  
  55. 	/**
  56. 	 * 设置一页显示多少条数据
  57. 	 * @param value
  58. 	 */
  59. 	void setPageSize(int value);
  60.  
  61. 	/**
  62. 	 * 设置总页数
  63. 	 * @param value
  64. 	 */
  65. 	void setTotalPages(int value);
  66.  
  67. 	/**
  68. 	 * 设置当前页号
  69. 	 * @param value
  70. 	 */
  71. 	void setPageNumber(int value);
  72.  
  73. 	/**
  74. 	 * 设置该页第一条数据的行号
  75. 	 * @param value
  76. 	 */
  77. 	void setFirstResult(int value);
  78.  
  79. 	/**
  80. 	 * 设置该页数据
  81. 	 * @param data
  82. 	 */
  83. 	void setDataResult(List<T> data);
  84. }

说明：

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

 

4. ITreeModel

  1. package com.core.dao;
  2.  
  3. import java.io.Serializable;
  4.  
  5. public interface ITreeModel<PK extends Serializable> {
  6.  
  7. 	PK getNodeId();
  8. 	
  9. 	PK getNodePid();
  10. 	
  11. 	String getNodeName();
  12. 	
  13. 	int getNodeOrder();
  14. 	
  15. 	String getNodeImage();
  16. 	
  17. 	int getNodeLevel();
  18. 	
  19. 	void setNodeId(PK nodeId);
  20. 	
  21. 	void setNodePid(PK nodePid);
  22. 	
  23. 	void setNodeName(String nodeName);
  24. 	
  25. 	void setNodeOrder(PK nodeOrder);
  26. 	
  27. 	void setNodeImage(String nodeImage);
  28. 	
  29. 	void setNodeLevel(int nodelLevel);
  30. }

说明：

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

 

5. BaseDao

  1. package com.core.dao.hibernate;
  2.  
  3. import java.io.Serializable;
  4. import java.sql.SQLException;
  5. import java.util.Collection;
  6. import java.util.List;
  7.  
  8. import javax.annotation.Resource;
  9.  
  10. import org.hibernate.HibernateException;
  11. import org.hibernate.Query;
  12. import org.hibernate.Session;
  13. import org.springframework.orm.hibernate3.HibernateCallback;
  14. import org.springframework.orm.hibernate3.HibernateTemplate;
  15.  
  16. import com.core.dao.IDataBaseDao;
  17. import com.core.dao.IQuery;
  18. import com.util.BeanUtil;
  19.  
  20. public class BaseDao<T extends Serializable, PK extends Serializable> implements IDataBaseDao<T, PK> {
  21.  
  22. 	@Resource
  23. 	private HibernateTemplate hibernateTemplate;
  24. 	
  25. 	@Resource
  26. 	private IQuery query;
  27.  
  28. 	private Class<T> entityClass;
  29.  
  30. 	@Override
  31. 	public void setEntityClass(Class<T> entityClass) {
  32. 		this.entityClass = entityClass;
  33. 	}
  34. 	
  35. 	@Override
  36. 	public IQuery createQuery() {
  37. 		return query;
  38. 	}
  39.  
  40. 	@SuppressWarnings("unchecked")
  41. 	@Override
  42. 	public T get(PK id) {
  43. 		return (T) hibernateTemplate.get(entityClass, id);
  44. 	}
  45.  
  46. 	@SuppressWarnings("unchecked")
  47. 	@Override
  48. 	public T load(PK id) {
  49. 		return (T) hibernateTemplate.load(entityClass, id);
  50. 	}
  51.  
  52. 	@SuppressWarnings("unchecked")
  53. 	@Override
  54. 	public List<T> loadAll() {
  55. 		return hibernateTemplate.loadAll(entityClass);
  56. 	}
  57.  
  58. 	@SuppressWarnings("unchecked")
  59. 	@Override
  60. 	public List<T> find(IQuery query) {
  61. 		final String queryString = query.getQueryString();
  62. 		if (!BeanUtil.isNull(queryString)) {
  63. 			final Object[] values = query.getParamValues();
  64. 			final int firstResult = query.getFirstResult();
  65. 			final int maxResult = query.getMaxResults();
  66.  
  67. 			if (!BeanUtil.isNull(values)) {
  68. 				if (maxResult > 0) {
  69. 					hibernateTemplate.executeFind(new HibernateCallback() {
  70.  
  71. 						@Override
  72. 						public Object doInHibernate(Session session) throws HibernateException, SQLException {
  73. 							Query query = session.createQuery(queryString);
  74. 							query.setFirstResult(firstResult);
  75. 							query.setMaxResults(maxResult);
  76. 							for (int i = 0; i < values.length; i++) {
  77. 								query.setParameter(i + 1, values[i]);
  78. 							}
  79. 							return query.list();
  80. 						}
  81. 					});
  82. 				}
  83. 				return hibernateTemplate.find(queryString, values);
  84. 			} else {
  85. 				if (maxResult > 0) {
  86. 					hibernateTemplate.executeFind(new HibernateCallback() {
  87.  
  88. 						@Override
  89. 						public Object doInHibernate(Session session) throws HibernateException, SQLException {
  90. 							Query query = session.createQuery(queryString);
  91. 							query.setFirstResult(firstResult);
  92. 							query.setMaxResults(maxResult);
  93. 							return query.list();
  94. 						}
  95. 					});
  96. 				}
  97. 				return hibernateTemplate.find(queryString);
  98. 			}
  99. 		}
  100.  
  101. 		String sql = query.getSQLString();
  102. 		if (!BeanUtil.isNull(sql)) {
  103. 			return query.execute();
  104. 		} else {
  105. 			//  需要抛出异常
  106. 			return null;
  107. 		}
  108. 	}
  109.  
  110. 	@SuppressWarnings("unchecked")
  111. 	@Override
  112. 	public PK save(T entity) {
  113. 		return (PK) hibernateTemplate.save(entity);
  114. 	}
  115.  
  116. 	@Override
  117. 	public void update(T entity) {
  118. 		hibernateTemplate.update(entity);
  119. 	}
  120.  
  121. 	@Override
  122. 	public void saveOrUpdate(T entity) {
  123. 		hibernateTemplate.saveOrUpdate(entity);
  124. 	}
  125.  
  126. 	@Override
  127. 	public void saveOrUpdateAll(Collection<T> entities) {
  128. 		hibernateTemplate.saveOrUpdateAll(entities);
  129. 	}
  130.  
  131. 	@Override
  132. 	public void delete(T entity) {
  133. 		hibernateTemplate.delete(entity);
  134. 	}
  135.  
  136. 	@Override
  137. 	public void deleteByKey(PK id) {
  138. 		T t = this.get(id);
  139. 		hibernateTemplate.delete(t);
  140. 	}
  141.  
  142. 	@Override
  143. 	public void deleteAll(Collection<T> entities) {
  144. 		hibernateTemplate.deleteAll(entities);
  145. 	}
  146. }

说明：

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

 

6. Query

  1. package com.core.dao.hibernate;
  2.  
  3. import java.util.List;
  4.  
  5. import com.core.dao.IQuery;
  6.  
  7. public class Query implements IQuery {
  8.  
  9. 	private String queryStr;
  10.  
  11. 	private String sql;
  12.  
  13. 	private Object[] params;
  14.  
  15. 	private int firstResult;
  16.  
  17. 	private int maxResult;
  18.  
  19. 	@SuppressWarnings({ "rawtypes", "unused" })
  20. 	private Class[] entityClasses;
  21.  
  22. 	@Override
  23. 	public String getQueryString() {
  24. 		return queryStr;
  25. 	}
  26.  
  27. 	@Override
  28. 	public String getSQLString() {
  29. 		return sql;
  30. 	}
  31.  
  32. 	@Override
  33. 	public Object[] getParamValues() {
  34. 		return params;
  35. 	}
  36.  
  37. 	@Override
  38. 	public int getFirstResult() {
  39. 		return firstResult;
  40. 	}
  41.  
  42. 	@Override
  43. 	public int getMaxResults() {
  44. 		return maxResult;
  45. 	}
  46.  
  47. 	@SuppressWarnings("rawtypes")
  48. 	@Override
  49. 	public void setEntityClass(Class[] entityClasses) {
  50. 		this.entityClasses = entityClasses;
  51. 	}
  52.  
  53. 	@Override
  54. 	public void setQueryString(String queryStr) {
  55. 		this.queryStr = queryStr;
  56. 	}
  57.  
  58. 	@Override
  59. 	public void setSQLString(String sql) {
  60. 		this.sql = sql;
  61. 	}
  62.  
  63. 	@Override
  64. 	public void setParamValues(Object[] values) {
  65. 		this.params = values;
  66. 	}
  67.  
  68. 	@Override
  69. 	public void setFirstResult(int value) {
  70. 		this.firstResult = value;
  71. 	}
  72.  
  73. 	@Override
  74. 	public void setMaxResults(int value) {
  75. 		this.maxResult = value;
  76. 	}
  77.  
  78. 	@SuppressWarnings("rawtypes")
  79. 	@Override
  80. 	public List execute() {
  81. 		return null;
  82. 	}
  83.  
  84. }

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

 

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

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

 

 

四、结语

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

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

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号