`
lzkyo
  • 浏览: 468264 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Hibernate的通用dao

DAOHibernateCC++C# 
阅读更多

Hibernate+spring通用的dao.
首先定义一个SimpleDao接口,里面的方法如下:

Java代码 复制代码
  1. /*  
  2.  *   
  3.  * @author zyong  
  4.  *  
  5.  * @date 2009-9-19 下午11:02:34  
  6.  *  
  7.  * @action 一个简单公共的hibernate通用dao实现类  
  8.  */  
  9. package com.wind.dao;   
  10.   
  11. import java.io.Serializable;   
  12. import java.util.Collection;   
  13. import java.util.List;   
  14. import java.util.Map;   
  15.   
  16. import org.hibernate.Criteria;   
  17. import org.hibernate.HibernateException;   
  18. import org.hibernate.LockMode;   
  19. import org.hibernate.criterion.DetachedCriteria;   
  20.   
  21. /**  
  22.  *   
  23.  * @author zyong  
  24.  *   
  25.  * @action 一个通用的Hibernate的dao接口<br>  
  26.  *         数据访问层里面的每一个接口都应该继承这个接口<br>  
  27.  *         而不用重写里面的方法  
  28.  */  
  29. public interface SimpleDao<E extends Serializable, PK extends Serializable> {   
  30.   
  31.     /**  
  32.      *   
  33.      * 该枚举类型用于,getStackValue方法中的Stack枚举  
  34.      *   
  35.      */  
  36.     enum Stack {   
  37.         MAX, MIN, AVG, SUM;   
  38.     }   
  39.   
  40.     /**  
  41.      *   
  42.      * @param id  
  43.      *            根据主键查询一个实体  
  44.      * @return 一个实体对象  
  45.      */  
  46.     E get(PK id);   
  47.   
  48.     /**  
  49.      *   
  50.      * @param id  
  51.      *            根据主键查询一个实体  
  52.      * @param lock  
  53.      *            加锁实体  
  54.      * @return 一个实体对象  
  55.      */  
  56.     E get(PK id, LockMode lock);   
  57.   
  58.     /**  
  59.      * 使用数据库函数  
  60.      *   
  61.      * @param criteria  
  62.      *            一个DetacherCriteria对象  
  63.      * @param propertyName  
  64.      *            实体类属性名  
  65.      * @param stackName  
  66.      *            Stack枚举类型中的任意一个  
  67.      * @return 一行一列数据库  
  68.      */  
  69.     Object getStackValue(DetachedCriteria criteria, String propertyName,   
  70.             String stackName);   
  71.   
  72.     /**  
  73.      * 查询数据库对应的记录数  
  74.      *   
  75.      * @param criteria  
  76.      *            一个DetachedCriteria对象  
  77.      * @return 记录数  
  78.      */  
  79.     Integer getRowCount(DetachedCriteria criteria);   
  80.   
  81.     /**  
  82.      *   
  83.      * @param id  
  84.      *            根据主键加裁一个实体对象  
  85.      * @return 一个实体对象  
  86.      */  
  87.     E load(PK id);   
  88.   
  89.     /**  
  90.      *   
  91.      * @param id  
  92.      *            根据主键加裁实体  
  93.      * @param lock  
  94.      *            加锁实体  
  95.      * @return 一个实体对象  
  96.      */  
  97.     E load(PK id, LockMode lock);   
  98.   
  99.     /**  
  100.      *   
  101.      * @return 加裁所有对象  
  102.      */  
  103.     List<E> loadAll();   
  104.   
  105.     /**  
  106.      *   
  107.      * @param entity  
  108.      *            保存一个实体  
  109.      * @throws HibernateException  
  110.      *             抛出Exception异常  
  111.      */  
  112.     void save(E entity) throws HibernateException;   
  113.   
  114.     /**  
  115.      *   
  116.      * @param entity  
  117.      *            删除一个实体  
  118.      * @throws HibernateException  
  119.      *             抛出异常  
  120.      */  
  121.     void delete(E entity) throws HibernateException;   
  122.   
  123.     /**  
  124.      *   
  125.      * @param entity  
  126.      *            删除一个实体  
  127.      * @param lock  
  128.      *            加锁实体  
  129.      * @throws HibernateException  
  130.      *             抛出异常  
  131.      */  
  132.     void delete(E entity, LockMode lock) throws HibernateException;   
  133.   
  134.     /**  
  135.      *   
  136.      * @param entitys  
  137.      *            删除多个实体  
  138.      * @throws HibernateException  
  139.      *             抛出异常  
  140.      */  
  141.     void delete(Collection<E> entitys) throws HibernateException;   
  142.   
  143.     /**  
  144.      *   
  145.      * @param entity  
  146.      *            修改一个实体  
  147.      * @throws HibernateException  
  148.      *             抛出异常  
  149.      */  
  150.     void update(E entity) throws HibernateException;   
  151.   
  152.     /**  
  153.      *   
  154.      * @param entity  
  155.      *            修改一个实体  
  156.      * @param lock  
  157.      *            加锁实体  
  158.      * @throws HibernateException  
  159.      *             抛出异常  
  160.      */  
  161.     void update(E entity, LockMode lock) throws HibernateException;   
  162.   
  163.     /**  
  164.      *   
  165.      * @param entity  
  166.      *            当实体在数据库不在在与之对应记录时,则保存实体,在在实体,则更新实体  
  167.      * @throws HibernateException  
  168.      *             抛出异常  
  169.      */  
  170.     void saveOrUpdate(E entity) throws HibernateException;   
  171.   
  172.     /**  
  173.      *   
  174.      * @param entitys  
  175.      *            保存多个实体  
  176.      * @throws HibernateException  
  177.      *             抛出异常  
  178.      */  
  179.     void saveOrUpdate(Collection<E> entitys) throws HibernateException;   
  180.   
  181.     /*---------------------------利用hql,sql对数据库进行操作--------------------------------*/  
  182.   
  183.     /**  
  184.      *   
  185.      * @param hql  
  186.      *            使用hql语句进行数据库增删改操作  
  187.      * @return 受影响行的记录数  
  188.      */  
  189.     Integer bulkUpdate(String hql);   
  190.   
  191.     /**  
  192.      *   
  193.      * @param hql  
  194.      *            使用hql语句进行数据库增删改操作  
  195.      * @param params  
  196.      *            hql语句参数  
  197.      * @return 受影响行的记录数  
  198.      */  
  199.     Integer bulkUpdate(String hql, Object... values);   
  200.   
  201.     /**  
  202.      *   
  203.      * @param hql  
  204.      *            使用hql语句,检索数据  
  205.      * @return 一个list集合  
  206.      */  
  207.     List<E> find(String hql);   
  208.   
  209.     /**  
  210.      *   
  211.      * @param hql  
  212.      *            使用hql语句,检索数据  
  213.      * @param params  
  214.      *            hql语句参数  
  215.      * @return 一个list集合  
  216.      */  
  217.     List<E> find(String hql, Object... values);   
  218.   
  219.     /**  
  220.      *   
  221.      * @param queryName  
  222.      *            使用命名的hql语句进行查询  
  223.      * @return 一个list集合  
  224.      */  
  225.     List<E> findByNamedQuery(String queryName);   
  226.   
  227.     /**  
  228.      *   
  229.      * @param queryName  
  230.      *            使用带参数的命名hql语句进行查询  
  231.      * @param values  
  232.      *            参数集合  
  233.      * @return 一个list集合  
  234.      */  
  235.     List<E> findByNamedQuery(String queryName, Object... values);   
  236.   
  237.     /**  
  238.      *   
  239.      * @param queryName  
  240.      *            使用带参数的命名hql语句进行查询  
  241.      * @param params  
  242.      *            参数集合<br>  
  243.      *            Map的键为参数名称即paramName<br>  
  244.      *            Map的值则为values  
  245.      * @return 一个list集合  
  246.      */  
  247.     List<E> findByNamedParam(String queryName, Map<String, Object> params);   
  248.   
  249.     /**  
  250.      *   
  251.      * @param queryName  
  252.      *            使用带参数的命名hql语句进行查询  
  253.      * @param params  
  254.      *            参数集合<br>  
  255.      *            Map的键为参数名称即paramName<br>  
  256.      *            Map的值则为values  
  257.      * @return 一个list集合  
  258.      */  
  259.     List<E> findByNamedQueryAndNamedParam(String queryName,   
  260.             Map<String, Object> params);   
  261.   
  262.     /**  
  263.      *   
  264.      * @param criteria  
  265.      *            使用指定的检索标准来检索数  
  266.      * @return 一个list集合  
  267.      */  
  268.     List<E> findByCriteria(DetachedCriteria criteria);   
  269.   
  270.     /**  
  271.      *   
  272.      * @param criteria  
  273.      *            使用指定的检索标准来分页检索数据  
  274.      * @param firstResult  
  275.      *            开始条数  
  276.      * @param maxResults  
  277.      *            返回记录数  
  278.      * @return 一个list集合  
  279.      */  
  280.     List<E> findByCriteria(DetachedCriteria criteria, Integer firstResult,   
  281.             Integer maxResults);   
  282.   
  283.     /**  
  284.      * 加锁指定的实体  
  285.      *   
  286.      * @param entity  
  287.      *            实体对象  
  288.      *   
  289.      * @param lock  
  290.      *            加锁  
  291.      */  
  292.     void lock(E entity, LockMode lock) throws HibernateException;   
  293.   
  294.     /**  
  295.      * 强制立即更新到数据库,否则需要事务提交后,才会提交到数据库  
  296.      */  
  297.     void flush() throws HibernateException;   
  298.   
  299.     /**  
  300.      *   
  301.      * @return 根据SimpleDao泛型类型,创建一个与会话无关的检索对象  
  302.      */  
  303.     DetachedCriteria createDetachedCriteria();   
  304.   
  305.     /**  
  306.      *   
  307.      * @param c  
  308.      *            为一个实体类型  
  309.      * @return 根据指定的类型创建一个与会话无关的检索对象  
  310.      */  
  311.     DetachedCriteria createDetachedCriteria(Class<? extends Serializable> c);   
  312.   
  313.     /**  
  314.      *   
  315.      * @return 创建与会话绑定的检索标准对象  
  316.      */  
  317.     Criteria createCriteria();   
  318.   
  319. }  
/*
 * 
 * @author zyong
 *
 * @date 2009-9-19 下午11:02:34
 *
 * @action 一个简单公共的hibernate通用dao实现类
 */
package com.wind.dao;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;

/**
 * 
 * @author zyong
 * 
 * @action 一个通用的Hibernate的dao接口<br>
 *         数据访问层里面的每一个接口都应该继承这个接口<br>
 *         而不用重写里面的方法
 */
public interface SimpleDao<E extends Serializable, PK extends Serializable> {

	/**
	 * 
	 * 该枚举类型用于,getStackValue方法中的Stack枚举
	 * 
	 */
	enum Stack {
		MAX, MIN, AVG, SUM;
	}

	/**
	 * 
	 * @param id
	 *            根据主键查询一个实体
	 * @return 一个实体对象
	 */
	E get(PK id);

	/**
	 * 
	 * @param id
	 *            根据主键查询一个实体
	 * @param lock
	 *            加锁实体
	 * @return 一个实体对象
	 */
	E get(PK id, LockMode lock);

	/**
	 * 使用数据库函数
	 * 
	 * @param criteria
	 *            一个DetacherCriteria对象
	 * @param propertyName
	 *            实体类属性名
	 * @param stackName
	 *            Stack枚举类型中的任意一个
	 * @return 一行一列数据库
	 */
	Object getStackValue(DetachedCriteria criteria, String propertyName,
			String stackName);

	/**
	 * 查询数据库对应的记录数
	 * 
	 * @param criteria
	 *            一个DetachedCriteria对象
	 * @return 记录数
	 */
	Integer getRowCount(DetachedCriteria criteria);

	/**
	 * 
	 * @param id
	 *            根据主键加裁一个实体对象
	 * @return 一个实体对象
	 */
	E load(PK id);

	/**
	 * 
	 * @param id
	 *            根据主键加裁实体
	 * @param lock
	 *            加锁实体
	 * @return 一个实体对象
	 */
	E load(PK id, LockMode lock);

	/**
	 * 
	 * @return 加裁所有对象
	 */
	List<E> loadAll();

	/**
	 * 
	 * @param entity
	 *            保存一个实体
	 * @throws HibernateException
	 *             抛出Exception异常
	 */
	void save(E entity) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            删除一个实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void delete(E entity) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            删除一个实体
	 * @param lock
	 *            加锁实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void delete(E entity, LockMode lock) throws HibernateException;

	/**
	 * 
	 * @param entitys
	 *            删除多个实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void delete(Collection<E> entitys) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            修改一个实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void update(E entity) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            修改一个实体
	 * @param lock
	 *            加锁实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void update(E entity, LockMode lock) throws HibernateException;

	/**
	 * 
	 * @param entity
	 *            当实体在数据库不在在与之对应记录时,则保存实体,在在实体,则更新实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void saveOrUpdate(E entity) throws HibernateException;

	/**
	 * 
	 * @param entitys
	 *            保存多个实体
	 * @throws HibernateException
	 *             抛出异常
	 */
	void saveOrUpdate(Collection<E> entitys) throws HibernateException;

	/*---------------------------利用hql,sql对数据库进行操作--------------------------------*/

	/**
	 * 
	 * @param hql
	 *            使用hql语句进行数据库增删改操作
	 * @return 受影响行的记录数
	 */
	Integer bulkUpdate(String hql);

	/**
	 * 
	 * @param hql
	 *            使用hql语句进行数据库增删改操作
	 * @param params
	 *            hql语句参数
	 * @return 受影响行的记录数
	 */
	Integer bulkUpdate(String hql, Object... values);

	/**
	 * 
	 * @param hql
	 *            使用hql语句,检索数据
	 * @return 一个list集合
	 */
	List<E> find(String hql);

	/**
	 * 
	 * @param hql
	 *            使用hql语句,检索数据
	 * @param params
	 *            hql语句参数
	 * @return 一个list集合
	 */
	List<E> find(String hql, Object... values);

	/**
	 * 
	 * @param queryName
	 *            使用命名的hql语句进行查询
	 * @return 一个list集合
	 */
	List<E> findByNamedQuery(String queryName);

	/**
	 * 
	 * @param queryName
	 *            使用带参数的命名hql语句进行查询
	 * @param values
	 *            参数集合
	 * @return 一个list集合
	 */
	List<E> findByNamedQuery(String queryName, Object... values);

	/**
	 * 
	 * @param queryName
	 *            使用带参数的命名hql语句进行查询
	 * @param params
	 *            参数集合<br>
	 *            Map的键为参数名称即paramName<br>
	 *            Map的值则为values
	 * @return 一个list集合
	 */
	List<E> findByNamedParam(String queryName, Map<String, Object> params);

	/**
	 * 
	 * @param queryName
	 *            使用带参数的命名hql语句进行查询
	 * @param params
	 *            参数集合<br>
	 *            Map的键为参数名称即paramName<br>
	 *            Map的值则为values
	 * @return 一个list集合
	 */
	List<E> findByNamedQueryAndNamedParam(String queryName,
			Map<String, Object> params);

	/**
	 * 
	 * @param criteria
	 *            使用指定的检索标准来检索数
	 * @return 一个list集合
	 */
	List<E> findByCriteria(DetachedCriteria criteria);

	/**
	 * 
	 * @param criteria
	 *            使用指定的检索标准来分页检索数据
	 * @param firstResult
	 *            开始条数
	 * @param maxResults
	 *            返回记录数
	 * @return 一个list集合
	 */
	List<E> findByCriteria(DetachedCriteria criteria, Integer firstResult,
			Integer maxResults);

	/**
	 * 加锁指定的实体
	 * 
	 * @param entity
	 *            实体对象
	 * 
	 * @param lock
	 *            加锁
	 */
	void lock(E entity, LockMode lock) throws HibernateException;

	/**
	 * 强制立即更新到数据库,否则需要事务提交后,才会提交到数据库
	 */
	void flush() throws HibernateException;

	/**
	 * 
	 * @return 根据SimpleDao泛型类型,创建一个与会话无关的检索对象
	 */
	DetachedCriteria createDetachedCriteria();

	/**
	 * 
	 * @param c
	 *            为一个实体类型
	 * @return 根据指定的类型创建一个与会话无关的检索对象
	 */
	DetachedCriteria createDetachedCriteria(Class<? extends Serializable> c);

	/**
	 * 
	 * @return 创建与会话绑定的检索标准对象
	 */
	Criteria createCriteria();

}

 

SimpleDaoImpl为一个SimpleDao的实现类.代码如下：

Java代码 复制代码
  1. /*  
  2.  *   
  3.  * @author zyong  
  4.  *  
  5.  * @date 2009-9-19 下午11:02:34  
  6.  *  
  7.  * @action 一个简单公共的hibernate通用dao实现类  
  8.  */  
  9. package com.wind.dao.impl;   
  10.   
  11. import java.io.Serializable;   
  12. import java.lang.reflect.ParameterizedType;   
  13. import java.lang.reflect.Type;   
  14. import java.util.Collection;   
  15. import java.util.List;   
  16. import java.util.Map;   
  17.   
  18. import org.hibernate.Criteria;   
  19. import org.hibernate.HibernateException;   
  20. import org.hibernate.LockMode;   
  21. import org.hibernate.criterion.DetachedCriteria;   
  22. import org.hibernate.criterion.Projections;   
  23. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;   
  24.   
  25. import com.wind.dao.SimpleDao;   
  26.   
  27. /**  
  28.  *   
  29.  * @author zyong  
  30.  *   
  31.  * @action 一个公共的Hibernate通用dao实现类<br>  
  32.  *         数据库访问层,每一个实现类都应该来继承该类<br>  
  33.  *         不应该重写里面的方法,需要相应的方法,直接到数据访问层每个类对应的接口中添加  
  34.  */  
  35. public abstract class SimpleDaoImpl<E extends Serializable, PK extends Serializable>   
  36.         extends HibernateDaoSupport implements SimpleDao<E, PK> {   
  37.   
  38.     /**  
  39.      * 为E对应的实例类型  
  40.      */  
  41.     private Class<?> entityClass;   
  42.   
  43.     /**  
  44.      * 获取E实例类的类型  
  45.      */  
  46.     public SimpleDaoImpl() {   
  47.         Class<?> c = this.getClass();   
  48.         Type t = c.getGenericSuperclass();   
  49.         if (t instanceof ParameterizedType) {   
  50.             this.entityClass = (Class<?>) ((ParameterizedType) t)   
  51.                     .getActualTypeArguments()[0];   
  52.         }   
  53.     }   
  54.   
  55.     @SuppressWarnings("unchecked")   
  56.     public E get(PK id) {   
  57.         return (E) this.getHibernateTemplate().get(this.entityClass, id);   
  58.     }   
  59.   
  60.     @SuppressWarnings("unchecked")   
  61.     public E get(PK id, LockMode lock) {   
  62.         E entity = (E) this.getHibernateTemplate().get(this.entityClass, id,   
  63.                 lock);   
  64.         if (entity != null) {   
  65.             this.flush();// 如果实体不为null,立即刷新,否则锁不会生效   
  66.         }   
  67.         return entity;   
  68.     }   
  69.   
  70.     public Object getStackValue(DetachedCriteria criteria, String propertyName,   
  71.             Stack value) {   
  72.         switch (value) {   
  73.         case MAX:   
  74.             criteria.setProjection(Projections.max(propertyName));   
  75.             break;   
  76.         case MIN:   
  77.             criteria.setProjection(Projections.min(propertyName));   
  78.             break;   
  79.         case AVG:   
  80.             criteria.setProjection(Projections.avg(propertyName));   
  81.             break;   
  82.         default:   
  83.             criteria.setProjection(Projections.sum(propertyName));   
  84.             break;   
  85.         }   
  86.         return this.findByCriteria(criteria, 0, 1).get(0);   
  87.     }   
  88.   
  89.     public Integer getRowCount(DetachedCriteria criteria) {   
  90.         criteria.setProjection(Projections.rowCount());   
  91.         return (Integer) this.findByCriteria(criteria, 0, 1).get(0);   
  92.     }   
  93.   
  94.     @SuppressWarnings("unchecked")   
  95.     public E load(PK id) {   
  96.         return (E) this.getHibernateTemplate().load(this.entityClass, id);   
  97.     }   
  98.   
  99.     @SuppressWarnings("unchecked")   
  100.     public E load(PK id, LockMode lock) {   
  101.         E entity = (E) this.getHibernateTemplate().load(this.entityClass, id,   
  102.                 lock);   
  103.         if (entity != null) {   
  104.             this.flush();// 如果实体不为null,立即刷新,否则锁不会生效   
  105.         }   
  106.         return entity;   
  107.     }   
  108.   
  109.     @SuppressWarnings("unchecked")   
  110.     public List<E> loadAll() {   
  111.         return this.getHibernateTemplate().loadAll(entityClass);   
  112.     }   
  113.   
  114.     @SuppressWarnings("unchecked")   
  115.     public List<E> find(String hql) {   
  116.         return this.getHibernateTemplate().find(hql);   
  117.     }   
  118.   
  119.     @SuppressWarnings("unchecked")   
  120.     public List<E> find(String hql, Object... values) {   
  121.         return this.getHibernateTemplate().find(hql, values);   
  122.     }   
  123.   
  124.     @SuppressWarnings("unchecked")   
  125.     public List<E> findByNamedQuery(String queryName, Object... values) {   
  126.         return this.getHibernateTemplate().findByNamedQuery(queryName, values);   
  127.     }   
  128.   
  129.     @SuppressWarnings("unchecked")   
  130.     public List<E> findByNamedQuery(String queryName) {   
  131.         return color: #7f0
    • dao.zip (3.5 KB)
    • 下载次数: 19
    分享到：
    | Linux 环境下weblogic domain配置
    评论
    发表评论

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

相关推荐

    Hibernate通用Dao

    通用dao,简单全面,所有dao都可以继承这个dao.

    Hibernate通用Dao设计。

    综上所述，Hibernate通用DAO设计的核心在于抽象出共性的数据库操作，并通过泛型和继承等面向对象设计原则，达到代码复用的目的。这样不仅可以降低开发难度，还能提升系统的可维护性，对于大型项目尤其重要。通过学习...

    hibernate通用dao

    **hibernate通用DAO（Data Access Object）**是软件开发中的一个重要概念，它主要用于数据库操作的抽象，使得业务逻辑层可以无需关注具体的SQL语句，从而实现数据访问的解耦。在Java EE应用中，Hibernate作为一款...

    hibernate spring通用dao

    spring集成hibernate通用dao，泛型，server都可以调用

    本人写的Hibernate超级通用DAO

    《深入浅出Hibernate通用DAO设计与实践》 在软件开发中，数据访问对象（DAO）是用于处理数据库操作的重要组件，它可以将业务逻辑与数据访问层进行解耦，提高代码的可复用性和可维护性。本文将围绕“Hibernate超级...

    hibernate4 通用dao,service

    标题中的“hibernate4 通用dao,service”指的是在Java开发中使用Hibernate框架实现的通用数据访问对象（DAO）和业务服务层（Service）。Hibernate是一个流行的对象关系映射（ORM）工具，它允许开发者使用面向对象的...

    Hibernate 原生通用DAO

    **Hibernate原生通用DAO**是基于Hibernate框架设计的一种简化数据访问操作的方式，它模仿了Spring框架中的`HibernateTemplate`类，旨在提供一个简单易用的DAO（Data Access Object）层，方便开发人员进行数据库操作...

    Hibernate_通用DAO模式，一个写好的dao层

    本资源“Hibernate_通用DAO模式”提供了一种适用于不同类型表单的DAO实现，基于SSH（Struts2、Spring、Hibernate）框架，特别强调简洁、易懂和高可移植性。 首先，SSH框架是Java Web开发中的经典组合，Struts2负责...

    HibernateDao 通用

    HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao ...

    Hibernate封装dao层

    为了进一步提高代码的复用性，可以使用泛型来创建通用的DAO接口和实现。例如，`BaseDao&lt;T&gt;`，其中T代表实体类类型，这样就可以在不改变基本结构的情况下，为不同的实体类创建DAO。 6. **查询方法**： - 使用HQL...

    hibernate不是泛型的通用DAo1

    "hibernate不是泛型的通用DAo1"这个标题暗示了我们讨论的是一种非泛型化的DAO实现，可能是因为开发者想要避免强制继承和泛型模板。 在描述中提到，开发者在网上寻找的大多数DAO实现都是泛型的，需要继承来使用。...

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

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

    HibernateDao.java

    - **设计模式**：考虑使用模板方法模式或者策略模式，将通用的数据库操作抽象出来，使得`HibernateDao.java`更具有复用性和灵活性。 总结，`HibernateDao.java`是Hibernate框架在实际项目中的重要实现，它封装了...

    Hibernate泛型Dao

    【标题】"Hibernate泛型Dao"是针对Java开发中的数据持久化框架Hibernate的一个高级应用，主要目的是为了提高代码的复用性和简洁性。在传统的Hibernate使用中，针对每个实体类，我们都需要创建一个对应的Dao（Data ...

    hibernate 通用接口架构

    "hibernate 通用接口架构"是指利用Hibernate框架，通过设计DAO（Data Access Object）层的接口来实现业务逻辑与数据访问的解耦，从而提高代码的可复用性和可维护性。 首先，我们来理解DAO层的作用。DAO层作为业务...

    Haha.Hibernate SprintSideExt 通用HibernateDAO

    Haha.Hibernate SprintSideExt 通用HibernateDAO 文章资源 详见：http://blog.csdn.net/lijun7788/article/details/6658847

    java ssh通用DAO另类实现示例

    总结：这个另类的Java SSH通用DAO实现利用了动态代理和Hibernate的特性，降低了代码复杂度，提高了代码复用性。它使得DAO层的维护变得更加简单，同时保持了良好的封装性和扩展性。在实际项目中，这样的设计可以显著...

    vc生成hibernate的dao类

    3. **模板定制**: 创建或编辑DAO类模板，模板中应包含通用的数据库操作方法，如save(), get(), update(), delete()等。 4. **代码生成工具**: 使用VC6.0中的插件或独立的代码生成工具，根据模板和实体类信息，自动...

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