Hibernate也须要呵护——Hibernate的泛型DAO
2017-05-22 17:53
363 查看
众所周之。面向对象的基础是抽象。也能够说,抽象促使编程在不断发展。
对于数据库的訪问,以前写过HqlHelper。EFHelper。编写Spring+Hibernate框架下的应用。也相同离不了编写一个通用的泛型GenericHibernateDao。查阅了网上不少的GenericHibernateDao实现,归纳整理为例如以下实现,供兴许编码參考。
一、 DAO泛型的接口 GenericDao
二、 GenericDao接口的实现类 GenericHibernateDao
以上就实现了泛型的 Hibernate Dao 了,以下的样例就是业务对象对 GenericHibernateDao的使用
三、 业务对象 Article
四、 业务对象Article 的Dao 接口 IArticleDao
定义 Article 业务对象的Dao 接口 IArticleDao ,它继承自 GenericDao 接口,以获得当中的方法。
能够在 IArticleDao 中加入 Article 业务对象特有的方法,也能够直接使用 GenericDao 中提供的全部方法IArticleDao接口指定业务对象的类型和主键的类型 <Article,Long>
五、 ArticleHibernateDao 类
如今就能够定义 ArticleHibernateDao 类了,它仅仅要实现 IArticleDao 接口并继承 GenericHibernateDao 类 就能够使用全部的 Generic 接口和 IArticleDao 接口中的定义的方法。假设你在 IArticleDao 接口里指定了Article业务对象特有的方法,就在ArticleHibernateDao实现这些方法。而Generic 接口中的方法。在ArticleHibernateDao 的父类 GenericHibernateDao
中已经所有实现了,直接调用就能够方便的訪问数据库。
故:
其它的业务对象也能够參照 Article 和 ArticleHibernateDao 类来定义 , GenericDao 接口中有的通用方法就直接调用,不足的以后补充。其它业务对象特有的方法就 在其它业务对象的 Dao接口(继承GenericDao接口) 中定义并通过 GenericHibernateDao 子类来实现。 节省非常多反复代码。简单几步就能够使用GenericDao接口的实现类 GenericHibernateDao 方便地訪问数据库。
补:
最后提供一个 Article 业务对象的 Hibernate 映射文件和一个 ArticleHibernateDao 类的測试类。
Article的映射文件
ArticleHibernateDao的測试类,仅仅提供了seve(article) 方法的測试代码
对于数据库的訪问,以前写过HqlHelper。EFHelper。编写Spring+Hibernate框架下的应用。也相同离不了编写一个通用的泛型GenericHibernateDao。查阅了网上不少的GenericHibernateDao实现,归纳整理为例如以下实现,供兴许编码參考。
一、 DAO泛型的接口 GenericDao
package ICT.framework.orm.hibernate; import java.io.Serializable; import java.util.Collection; import java.util.Iterator; import java.util.List; import org.hibernate.Criteria; import org.hibernate.LockMode; import org.hibernate.criterion.DetachedCriteria; /** * * @author lianhai */ public interface GenericDao<T extends Serializable, PK extends Serializable> { // -------------------- 基本检索、添加、改动、删除操作 -------------------- // 依据主键获取实体。 假设没有对应的实体。返回 null。 public T get(PK id); // 依据主键获取实体并加锁。假设没有对应的实体。返回 null。 public T getWithLock(PK id, LockMode lock); // 依据主键获取实体。 假设没有对应的实体。抛出异常。 public T load(PK id); // 依据主键获取实体并加锁。假设没有对应的实体,抛出异常。 public T loadWithLock(PK id, LockMode lock); // 获取所有实体。 public List<T> loadAll(); // loadAllWithLock() ? // 更新实体 public void update(T entity); // 更新实体并加锁 public void updateWithLock(T entity, LockMode lock); // 存储实体到数据库 public void save(T entity); // saveWithLock() // 添加或更新实体 public void saveOrUpdate(T entity); // 添加或更新集合中的所有实体 public void saveOrUpdateAll(Collection<T> entities); // 删除指定的实体 public void delete(T entity); // 加锁并删除指定的实体 public void deleteWithLock(T entity, LockMode lock); // 依据主键删除指定实体 public void deleteByKey(PK id); // 依据主键加锁并删除指定的实体 public void deleteByKeyWithLock(PK id, LockMode lock); // 删除集合中的所有实体 public void deleteAll(Collection<T> entities); // -------------------- HQL ---------------------------------------------- // 使用HQL语句直接添加、更新、删除实体 public int bulkUpdate(String queryString); // 使用带參数的HQL语句添加、更新、删除实体 public int bulkUpdate(String queryString, Object[] values); // 使用HQL语句检索数据 public List find(String queryString); // 使用带參数的HQL语句检索数据 public List find(String queryString, Object[] values); // 使用带命名的參数的HQL语句检索数据 public List findByNamedParam(String queryString, String[] paramNames,Object[] values); // 使用命名的HQL语句检索数据 public List findByNamedQuery(String queryName); // 使用带參数的命名HQL语句检索数据 public List findByNamedQuery(String queryName, Object[] values); // 使用带命名參数的命名HQL语句检索数据 public List findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values); // 使用HQL语句检索数据,返回 Iterator public Iterator iterate(String queryString); // 使用带參数HQL语句检索数据,返回 Iterator public Iterator iterate(String queryString, Object[] values); // 关闭检索返回的 Iterator public void closeIterator(Iterator it); // -------------------------------- Criteria ------------------------------ // 创建与会话无关的检索标准对象 public DetachedCriteria createDetachedCriteria(); // 创建与会话绑定的检索标准对象 public Criteria createCriteria(); // 使用指定的检索标准检索数据 public List findByCriteria(DetachedCriteria criteria); // 使用指定的检索标准检索数据。返回部分记录 public List findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults); // 使用指定的实体及属性检索(满足除主键外属性=实体值)数据 public List<T> findEqualByEntity(T entity, String[] propertyNames); // 使用指定的实体及属性(非主键)检索(满足属性 like 串实体值)数据 public List<T> findLikeByEntity(T entity, String[] propertyNames); // 使用指定的检索标准检索数据。返回指定范围的记录 public Integer getRowCount(DetachedCriteria criteria); // 使用指定的检索标准检索数据,返回指定统计值 public Object getStatValue(DetachedCriteria criteria, String propertyName, String StatName); // -------------------------------- Others -------------------------------- // 加锁指定的实体 public void lock(T entity, LockMode lockMode); // 强制初始化指定的实体 public void initialize(Object proxy); // 强制马上更新缓冲数据到数据库(否则仅在事务提交时才更新) public void flush(); }
二、 GenericDao接口的实现类 GenericHibernateDao
package ICT.framework.orm.hibernate.impl; import java.io.Serializable; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.Collection; import java.util.Iterator; import java.util.List; import org.apache.commons.beanutils.PropertyUtils; import org.hibernate.Criteria; import org.hibernate.LockMode; import org.hibernate.criterion.DetachedCriteria; import org.hibernate.criterion.Example; import org.hibernate.criterion.MatchMode; import org.hibernate.criterion.Order; import org.hibernate.criterion.Projections; import org.hibernate.criterion.Restrictions; import org.springframework.orm.hibernate3.support.HibernateDaoSupport; /** * GenericHibernateDao 继承 HibernateDao。简单封装 HibernateTemplate 各项功能, * 简化基于Hibernate Dao 的编写。 * * @author lianhai */ @SuppressWarnings("unchecked") public class GenericHibernateDao<T extends Serializable, PK extends Serializable> extends HibernateDaoSupport implements GenericDao<T, PK> { // 实体类类型(由构造方法自己主动赋值) private Class<T> entityClass; // 构造方法,依据实例类自己主动获取实体类类型 public GenericHibernateDao() { this.entityClass = null; Class c = getClass(); Type t = c.getGenericSuperclass(); if (t instanceof ParameterizedType) { Type[] p = ((ParameterizedType) t).getActualTypeArguments(); this.entityClass = (Class<T>) p[0]; } } // -------------------- 基本检索、添加、改动、删除操作 -------------------- // 依据主键获取实体。 假设没有对应的实体。返回 null。 public T get(PK id) { return (T) getHibernateTemplate().get(entityClass, id); } // 依据主键获取实体并加锁。 假设没有对应的实体,返回 null。 public T getWithLock(PK id, LockMode lock) { T t = (T) getHibernateTemplate().get(entityClass, id, lock); if (t != null) { this.flush(); // 马上刷新,否则锁不会生效。 } return t; } // 依据主键获取实体。 假设没有对应的实体,抛出异常。 public T load(PK id) { return (T) getHibernateTemplate().load(entityClass, id); } // 依据主键获取实体并加锁。假设没有对应的实体,抛出异常。 public T loadWithLock(PK id, LockMode lock) { T t = (T) getHibernateTemplate().load(entityClass, id, lock); if (t != null) { this.flush(); // 马上刷新,否则锁不会生效。 } return t; } // 获取所有实体。 public List<T> loadAll() { return (List<T>) getHibernateTemplate().loadAll(entityClass); } // loadAllWithLock() ? // 更新实体 public void update(T entity) { getHibernateTemplate().update(entity); } // 更新实体并加锁 public void updateWithLock(T entity, LockMode lock) { getHibernateTemplate().update(entity, lock); this.flush(); // 马上刷新,否则锁不会生效。 } // 存储实体到数据库 public void save(T entity) { getHibernateTemplate().save(entity); } // saveWithLock()? // 添加或更新实体 public void saveOrUpdate(T entity) { getHibernateTemplate().saveOrUpdate(entity); } // 添加或更新集合中的所有实体 public void saveOrUpdateAll(Collection<T> entities) { getHibernateTemplate().saveOrUpdateAll(entities); } // 删除指定的实体 public void delete(T entity) { getHibernateTemplate().delete(entity); } // 加锁并删除指定的实体 public void deleteWithLock(T entity, LockMode lock) { getHibernateTemplate().delete(entity, lock); this.flush(); // 马上刷新,否则锁不会生效。 } // 依据主键删除指定实体 public void deleteByKey(PK id) { this.delete(this.load(id)); } // 依据主键加锁并删除指定的实体 public void deleteByKeyWithLock(PK id, LockMode lock) { this.deleteWithLock(this.load(id), lock); } // 删除集合中的所有实体 public void deleteAll(Collection<T> entities) { getHibernateTemplate().deleteAll(entities); } // -------------------- HQL ---------------------------------------------- // 使用HSQL语句直接添加、更新、删除实体 public int bulkUpdate(String queryString) { return getHibernateTemplate().bulkUpdate(queryString); } // 使用带參数的HQL语句添加、更新、删除实体 public int bulkUpdate(String queryString, Object[] values) { return getHibernateTemplate().bulkUpdate(queryString, values); } // 使用HQL语句检索数据 public List find(String queryString) { return getHibernateTemplate().find(queryString); } // 使用带參数的HQL语句检索数据 public List find(String queryString, Object[] values) { return getHibernateTemplate().find(queryString, values); } // 使用带命名的參数的HQL语句检索数据 public List findByNamedParam(String queryString, String[] paramNames, Object[] values) { return getHibernateTemplate().findByNamedParam(queryString, paramNames,values); } // 使用命名的HSQL语句检索数据 public List findByNamedQuery(String queryName) { return getHibernateTemplate().findByNamedQuery(queryName); } // 使用带參数的命名HQL语句检索数据 public List findByNamedQuery(String queryName, Object[] values) { return getHibernateTemplate().findByNamedQuery(queryName, values); } // 使用带命名參数的命名HQL语句检索数据 public List findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values) { return getHibernateTemplate().findByNamedQueryAndNamedParam(queryName,paramNames, values); } // 使用HQL语句检索数据,返回 Iterator public Iterator iterate(String queryString) { return getHibernateTemplate().iterate(queryString); } // 使用带參数HQL语句检索数据。返回 Iterator public Iterator iterate(String queryString, Object[] values) { return getHibernateTemplate().iterate(queryString, values); } // 关闭检索返回的 Iterator public void closeIterator(Iterator it) { getHibernateTemplate().closeIterator(it); } // -------------------------------- Criteria ------------------------------ // 创建与会话无关的检索标准 public DetachedCriteria createDetachedCriteria() { return DetachedCriteria.forClass(this.entityClass); } // 创建与会话绑定的检索标准 public Criteria createCriteria() { return this.createDetachedCriteria().getExecutableCriteria( this.getSession()); } // 检索满足标准的数据 public List findByCriteria(DetachedCriteria criteria) { return getHibernateTemplate().findByCriteria(criteria); } // 检索满足标准的数据,返回指定范围的记录 public List findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults) { return getHibernateTemplate().findByCriteria(criteria, firstResult, maxResults); } // 使用指定的实体及属性检索(满足除主键外属性=实体值)数据 public List<T> findEqualByEntity(T entity, String[] propertyNames) { Criteria criteria = this.createCriteria(); Example exam = Example.create(entity); exam.excludeZeroes(); String[] defPropertys = getSessionFactory().getClassMetadata( entityClass).getPropertyNames(); for (String defProperty : defPropertys) { int ii = 0; for (ii = 0; ii < propertyNames.length; ++ii) { if (defProperty.equals(propertyNames[ii])) { criteria.addOrder(Order.asc(defProperty)); break; } } if (ii == propertyNames.length) { exam.excludeProperty(defProperty); } } criteria.add(exam); return (List<T>) criteria.list(); } // 使用指定的实体及属性检索(满足属性 like 串实体值)数据 public List<T> findLikeByEntity(T entity, String[] propertyNames) { Criteria criteria = this.createCriteria(); for (String property : propertyNames) { try { Object value = PropertyUtils.getProperty(entity, property); if (value instanceof String) { criteria.add(Restrictions.like(property, (String) value, MatchMode.ANYWHERE)); criteria.addOrder(Order.asc(property)); } else { criteria.add(Restrictions.eq(property, value)); criteria.addOrder(Order.asc(property)); } } catch (Exception ex) { // 忽略无效的检索參考数据。 } } return (List<T>) criteria.list(); } // 使用指定的检索标准获取满足标准的记录数 public Integer getRowCount(DetachedCriteria criteria) { criteria.setProjection(Projections.rowCount()); List list = this.findByCriteria(criteria, 0, 1); return (Integer) list.get(0); } // 使用指定的检索标准检索数据,返回指定统计值(max,min,avg,sum) public Object getStatValue(DetachedCriteria criteria, String propertyName, String StatName) { if (StatName.toLowerCase().equals("max")) criteria.setProjection(Projections.max(propertyName)); else if (StatName.toLowerCase().equals("min")) criteria.setProjection(Projections.min(propertyName)); else if (StatName.toLowerCase().equals("avg")) criteria.setProjection(Projections.avg(propertyName)); else if (StatName.toLowerCase().equals("sum")) criteria.setProjection(Projections.sum(propertyName)); else return null; List list = this.findByCriteria(criteria, 0, 1); return list.get(0); } // -------------------------------- Others -------------------------------- // 加锁指定的实体 public void lock(T entity, LockMode lock) { getHibernateTemplate().lock(entity, lock); } // 强制初始化指定的实体 public void initialize(Object proxy) { getHibernateTemplate().initialize(proxy); } // 强制马上更新缓冲数据到数据库(否则仅在事务提交时才更新) public void flush() { getHibernateTemplate().flush(); } }
以上就实现了泛型的 Hibernate Dao 了,以下的样例就是业务对象对 GenericHibernateDao的使用
三、 业务对象 Article
public class Article implements Serializable { private static final long serialVersionUID = 1072812006693587010L; private long id; private String title; private String author; private Date pubDate; private String content; public long getId() { return id; } public void setId(long id) { this.id = id; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getAuthor() { return author; } public void setAuthor(String author) { this.author = author; } public Date getPubDate() { return pubDate; } public void setPubDate(Date pubDate) { this.pubDate = pubDate; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } }
四、 业务对象Article 的Dao 接口 IArticleDao
定义 Article 业务对象的Dao 接口 IArticleDao ,它继承自 GenericDao 接口,以获得当中的方法。
能够在 IArticleDao 中加入 Article 业务对象特有的方法,也能够直接使用 GenericDao 中提供的全部方法IArticleDao接口指定业务对象的类型和主键的类型 <Article,Long>
public interface IArticleDAO extends GenericDao <Article,Long> { // public void findById(Long id); }
五、 ArticleHibernateDao 类
如今就能够定义 ArticleHibernateDao 类了,它仅仅要实现 IArticleDao 接口并继承 GenericHibernateDao 类 就能够使用全部的 Generic 接口和 IArticleDao 接口中的定义的方法。假设你在 IArticleDao 接口里指定了Article业务对象特有的方法,就在ArticleHibernateDao实现这些方法。而Generic 接口中的方法。在ArticleHibernateDao 的父类 GenericHibernateDao
中已经所有实现了,直接调用就能够方便的訪问数据库。
public class ArticleHibernateDao extends GenericHibernateDao<Article,Long> implements IArticleDAO { }
故:
其它的业务对象也能够參照 Article 和 ArticleHibernateDao 类来定义 , GenericDao 接口中有的通用方法就直接调用,不足的以后补充。其它业务对象特有的方法就 在其它业务对象的 Dao接口(继承GenericDao接口) 中定义并通过 GenericHibernateDao 子类来实现。 节省非常多反复代码。简单几步就能够使用GenericDao接口的实现类 GenericHibernateDao 方便地訪问数据库。
补:
最后提供一个 Article 业务对象的 Hibernate 映射文件和一个 ArticleHibernateDao 类的測试类。
Article的映射文件
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Article.hbm.xml --> <hibernate-mapping> <class name="com.pplsunny.model.Article" table="article"> <id name="id" type="java.lang.Long"> <column name="id" /> <generator class="native" /> </id> <property name="title" type="java.lang.String"> <column name="title" length="100" /> </property> <property name="author"> <column name="author" length="32" /> </property> <property name="pubDate" type="java.util.Date"> <column name="pubDate" /> </property> <property name="content" type="java.lang.String"> <column name="content" /> </property> </class> </hibernate-mapping>
ArticleHibernateDao的測试类,仅仅提供了seve(article) 方法的測试代码
public class ArticleHibernateDaoTest extends TestCase { ApplicationContext ctx = new ClassPathXmlApplicationContext( "applicationContext.xml"); ArticleHibernateDao adh = (ArticleHibernateDao) ctx .getBean("articleHibernateDao"); public void testSave() { Article art = (Article) ctx.getBean("article"); art.setId(1); art.setTitle("标题1"); art.setAuthor("作者1"); adh.save(art); } }
相关文章推荐
- Hibernate也需要呵护——Hibernate的泛型DAO
- spring hibernate注解实现泛型dao
- spring2.5整合hibernate3.3的泛型Dao并加入spring jdbc的支持
- spring2.5整合hibernate3.3的泛型Dao并加入spring jdbc的支持
- 使用 Hibernate 和 Spring AOP 构建泛型类型安全的 DAO
- 使用 Hibernate 和 Spring AOP 构建泛型类型安全的 DAO
- 一个通用的泛型 GenericHibernateDao
- 改进版的hibernate泛型dao(依赖spring)
- Hibernate泛型DAO设计
- spring2.5整合hibernate3.3的泛型Dao并加入spring jdbc的支持
- Hibernate--泛型DAO
- 一个通用的泛型GenericHibernateDAO
- Hibernate---泛型DAO
- 基于泛型DAO的Facade设计模式. - Hibernate - Java
- 详细介绍 Hibernate 泛型 DAO 及其使用方法
- 不要重复DAO!使用Hibernate 和Spring AOP 构建泛型类型安全的DAO
- 详细介绍 Hibernate 泛型 DAO 及其使用方法
- Hibernate泛型DAO(结合spring模板支持)
- 泛型 Hibernate DAO 例
- 详细介绍 Hibernate 泛型 DAO 及其使用方法