`
jetway
  • 浏览: 483889 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

泛型dao

    博客分类：
  • java
DAOSQLHibernateApacheORM 
阅读更多

 

其中包括4个基类 BaseDao.java, BaseDAOHibernate.java,BaseManager.java,BaseManagerImpl.java

 

1. dao接口基类

 

Java代码 复制代码
  1. /**  
  2.  * BaseDAO.java  
  3.  *  
  4.  *  
  5.  */  
  6. package com.easou.ad.dao;   
  7.   
  8. import java.util.HashMap;   
  9. import java.util.List;   
  10.   
  11. public interface BaseDAO<E> {   
  12.   
  13.     /**  
  14.      * 根据主键获得实体  
  15.      *   
  16.      * @param id 实体主键  
  17.      * @return BaseEntity  
  18.      */  
  19.     E getEntity(Long id);   
  20.   
  21.     /**  
  22.      * 获得所有实体  
  23.      *   
  24.      * @return List  
  25.      */  
  26.     List<E> getAllEntity();   
  27.   
  28.     /**  
  29.      * 保存实体  
  30.      *   
  31.      * @param entity pojo instance  
  32.      */  
  33.     void saveEntity(E entity);   
  34.   
  35.     /**  
  36.      * 根据主键删除实体  
  37.      *   
  38.      * @param id 实体主键  
  39.      */  
  40.     void removeEntity(Long id);   
  41.   
  42.     public List<E> search(HashMap con ,int page,int rowsPerPage);   
  43.     public List<E> search(HashMap con);   
  44. }  
/**
 * BaseDAO.java
 *
 *
 */
package com.easou.ad.dao;

import java.util.HashMap;
import java.util.List;

public interface BaseDAO<E> {

    /**
     * 根据主键获得实体
     * 
     * @param id 实体主键
     * @return BaseEntity
     */
    E getEntity(Long id);

    /**
     * 获得所有实体
     * 
     * @return List
     */
    List<E> getAllEntity();

    /**
     * 保存实体
     * 
     * @param entity pojo instance
     */
    void saveEntity(E entity);

    /**
     * 根据主键删除实体
     * 
     * @param id 实体主键
     */
    void removeEntity(Long id);

    public List<E> search(HashMap con ,int page,int rowsPerPage);
	public List<E> search(HashMap con);
}

 

2. dao实现类

 

Java代码 复制代码
  1. /**  
  2.  * BaseDAOHibernate.java  
  3.  *  
  4.  *Copyright 2007 easou, Inc. All Rights Reserved.  
  5.  */  
  6. package com.easou.ad.dao.hibernate;   
  7.   
  8. import java.lang.reflect.ParameterizedType;   
  9. import java.util.List;   
  10.   
  11. import org.apache.commons.logging.Log;   
  12. import org.apache.commons.logging.LogFactory;   
  13. import org.hibernate.HibernateException;   
  14. import org.hibernate.Query;   
  15. import org.hibernate.Session;   
  16. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;   
  17.   
  18.   
  19. import com.easou.framework.util.PageList;   
  20. import com.easou.ad.dao.BaseDAO;   
  21.   
  22.   
  23. public abstract class BaseDAOHibernate<E> extends HibernateDaoSupport implements  
  24.         BaseDAO<E> {   
  25.     protected final Log log = LogFactory.getLog(this.getClass().getName());   
  26.     protected Class<E> clazz;   
  27.     
  28.     public BaseDAOHibernate() {   
  29.         
  30.         this.clazz =(Class<E>)((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];        
  31.     }   
  32.     /**  
  33.      * 根据主键获得实体  
  34.      *   
  35.      * @param id 实体主键  
  36.      * @return 实体对象  
  37.      */  
  38.     @SuppressWarnings("unchecked")   
  39.     public final E getEntity(final Long id) {   
  40.         return (E)getHibernateTemplate().get(clazz, id);   
  41.     }   
  42.   
  43.     /**  
  44.      * 获得所有实体  
  45.      *   
  46.      * @return List  
  47.      */  
  48.     @SuppressWarnings("unchecked")   
  49.     public final List<E> getAllEntity() {   
  50.         PageList result = new PageList();   
  51.         List l = getHibernateTemplate().loadAll(clazz);   
  52.         result.addAll(l);   
  53.         result.setCurrentPage(1);   
  54.         result.setPageCount(1);   
  55.         result.setTotalRowCount(l.size());   
  56.         return result;   
  57.     }   
  58.   
  59.     /**  
  60.      * 保存实体  
  61.      *   
  62.      * @param entity 实体对象  
  63.      */  
  64.     public final void saveEntity(final E entity) {    
  65.             getHibernateTemplate().saveOrUpdate(entity);   
  66.     }   
  67.   
  68.     /**  
  69.      * 根据主键删除实体  
  70.      *   
  71.      * @param id 实体主键  
  72.      */  
  73.     public final void removeEntity(final Long id) {   
  74.         Object o = getEntity(id);   
  75.         if (null != o) {   
  76.             getHibernateTemplate().delete(o);   
  77.         }   
  78.     }   
  79.   
  80.     /**  
  81.      * 执行批量更新和删除操作的HQL  
  82.      *   
  83.      * @param sql hql语句  
  84.      * @return PageList  
  85.      */  
  86.     @SuppressWarnings("unchecked")   
  87.     protected final List<E> executeHQL(final String sql) {   
  88.         Session session = null;   
  89.         List<E> ret = null;   
  90.         try {   
  91.             log.info(sql);   
  92.             session = this.getSession();   
  93.             if (sql.toUpperCase().startsWith("DELETE")   
  94.                     || sql.toUpperCase().startsWith("UPDATE")) {   
  95.                 session.createQuery(sql).executeUpdate();   
  96.             } else {   
  97.                 ret = session.createQuery(sql).list();   
  98.             }   
  99.         } catch (HibernateException e) {   
  100.             log.error("executeHQL() error:" + sql, e);   
  101.             throw convertHibernateAccessException(e);   
  102.         } finally {   
  103.             this.releaseSession(session);   
  104.         }   
  105.         return ret;   
  106.     }   
  107.   
  108.     /**  
  109.      * 执行分页查询  
  110.      *   
  111.      * @param selectField HQL语句中，SELECT 的内容(如果设置了此参数值,则sql参数中不可带SELCT语句部分)  
  112.      * @param countField HQL语句中，count 的内容  
  113.      * @param sql HQL语句  
  114.      * @param page 第几页  
  115.      * @param rowsPerPage 每页记录数  
  116.      * @return PageList  
  117.      */  
  118.     @SuppressWarnings("unchecked")   
  119.     protected final List<E> pageListQuery(final String selectField,   
  120.             String countField, String sql, int page, int rowsPerPage) {   
  121.         PageList result = new PageList();   
  122.         Session session = null;   
  123.         try {   
  124.             session = this.getSession();   
  125.             // 预留count的sql语句   
  126.             String countSql = sql.substring(sql.toUpperCase().indexOf("FROM"));   
  127.             // 设置返回的列，进行查询   
  128.             if (null != selectField) {   
  129.                 sql = "SELECT " + selectField + sql;   
  130.             }   
  131.             if (page <= 0) {   
  132.                 page = 1; // page最小为1   
  133.             }   
  134.             log.debug("query sql:" + sql);   
  135.             Query q = session.createQuery(sql);   
  136.             if (rowsPerPage > 0) { // rowsPerPage的值是0或-1时,都返回全部结果集   
  137.                 q.setFirstResult(rowsPerPage * (page - 1));   
  138.                 q.setMaxResults(rowsPerPage);   
  139.             }   
  140.   
  141.             result.addAll(q.list());   
  142.   
  143.             // 设置分页查询的列   
  144.             if (null == countField) {   
  145.                 countField = "*";   
  146.             }   
  147.   
  148.             int rowsCount = result.size();   
  149.             if (rowsPerPage > 1 && rowsCount > 0) {   
  150.                 // 每页记录数大于1且结果集大于0才计算分页信息,否则当前页记录数就作为总的记录数   
  151.                 // TODO 解决page值过大,可能导致rowsCount为0的问题   
  152.                 countSql = "select count(" + countField + ") " + countSql;   
  153.                 // 计算总记录数时,消除 Order by语句，提高性能   
  154.                 int oPos = countSql.toUpperCase().indexOf("ORDER BY");   
  155.                 if (oPos > 0) {   
  156.                     countSql = countSql.substring(0, oPos);   
  157.                 }   
  158.                 rowsCount = ((Integer) session.createQuery(countSql).iterate().next()).intValue();   
  159.             }   
  160.   
  161.             if (0 == rowsCount) {   
  162.                 page = 0;   
  163.             }   
  164.             if (rowsPerPage < 0) {   
  165.                 page = 1;   
  166.                 rowsPerPage = rowsCount;   
  167.             }   
  168.   
  169.             result.setCurrentPage(page);   
  170.             result.setTotalRowCount(rowsCount);   
  171.             result.calcPageCount(rowsPerPage);   
  172.   
  173.         } catch (HibernateException e) {   
  174.             log.error("pageListQuery() error:" + sql, e);   
  175.             throw convertHibernateAccessException(e);   
  176.         } finally {   
  177.             this.releaseSession(session);   
  178.         }   
  179.         return result;   
  180.     }   
  181.   
  182.     /**  
  183.      * 执行分页查询  
  184.      *   
  185.      * @param selectField HQL语句中，SELECT 的内容(如果设置了此参数值,则sql参数中不可带SELCT语句部分)  
  186.      * @param sql HQL语句  
  187.      * @param page 第几页  
  188.      * @param rowsPerPage 每页记录数  
  189.      * @param totalRowCount HQL语句获得的总记录数  
  190.      * @return PageList  
  191.      */  
  192.     @SuppressWarnings("unchecked")   
  193.     protected final PageList pageListQuery(final String selectField,   
  194.             String sql, int page, int rowsPerPage, final int totalRowCount) {   
  195.         PageList result = new PageList();   
  196.         Session session = null;   
  197.         try {   
  198.             session = this.getSession();   
  199.             // 设置返回的列，进行查询   
  200.             if (null != selectField) {   
  201.                 sql = "SELECT " + selectField + sql;   
  202.             }   
  203.             if (page <= 0) {   
  204.                 page = 1; // page最小为1   
  205.             }   
  206.   
  207.             Query q = session.createQuery(sql);   
  208.             if (rowsPerPage > 0) { // rowsPerPage的值是0或-1时,都返回全部结果集   
  209.                 q.setFirstResult(rowsPerPage * (page - 1));   
  210.                 q.setMaxResults(rowsPerPage);   
  211.             }   
  212.   
  213.             result.addAll(q.list());   
  214.   
  215.             if (0 == totalRowCount) {   
  216.                 page = 0;   
  217.             }   
  218.             if (rowsPerPage < 0) {   
  219.                 page = 1;   
  220.                 rowsPerPage = totalRowCount;   
  221.             }   
  222.   
  223.             result.setCurrentPage(page);   
  224.             result.setTotalRowCount(totalRowCount);   
  225.             result.calcPageCount(rowsPerPage);   
  226.   
  227.         } catch (HibernateException e) {   
  228.             log.error("pageListQuery() error:" + sql, e);   
  229.             throw convertHibernateAccessException(e);   
  230.         } finally {   
  231.             this.releaseSession(session);   
  232.         }   
  233.         return result;   
  234.     }   
  235.   
  236.     /**  
  237.      * 执行分页查询  
  238.      *   
  239.      * @param sql HQL语句  
  240.      * @param page 第几页  
  241.      * @param rowsPerPage 每页记录数  
  242.      * @param totalRowCount HQL语句获得的总记录数  
  243.      * @return PageList  
  244.      */  
  245.     protected final PageList pageListQuery(final String sql, final int page,   
  246.             final int rowsPerPage, final int totalRowCount) {   
  247.         return pageListQuery(null, sql, page, rowsPerPage, totalRowCount);   
  248.     }   
  249.   
  250.     /**  
  251.      * 执行分页查询  
  252.      *   
  253.      * @param sql HQL语句  
  254.      * @param rowsPerPage 每页记录数  
  255.      * @param page 第几页  
  256.      * @return PageList  
  257.      * @throws HibernateException hibernate 异常  
  258.      */  
  259.     protected List<E> pageListQuery(final String sql, final int page,   
  260.             final int rowsPerPage) throws HibernateException {   
  261.         return pageListQuery(null, null, sql, page, rowsPerPage);   
  262.     }   
  263.   
  264.     /**  
  265.      * 执行分页查询  
  266.      *   
  267.      * @param countField HQL语句中，count 的内容  
  268.      * @param sql HQL语句  
  269.      * @param rowsPerPage 每页记录数  
  270.      * @param page 第几页  
  271.      * @return PageList  
  272.      * @throws HibernateException hibernate 异常  
  273.      */  
  274.     protected List pageListQuery(final String countField, final String sql,   
  275.             final int page, final int rowsPerPage) throws HibernateException {   
  276.         return pageListQuery(null, countField, sql, page, rowsPerPage);   
  277.     }   
  278.   
  279.     /**  
  280.      * 计算HQL查询的返回记录数  
  281.      *   
  282.      * @param sql 查询语句  
  283.      * @param countField count语句操作的字段  
  284.      * @return 记录数  
  285.      */  
  286.     protected int countHQL(String sql, String countField) {   
  287.   
  288.         int rowsCount = 0;   
  289.         Session session = null;   
  290.         try {   
  291.             session = this.getSession();   
  292.             if (null == countField) {   
  293.                 countField = "*";   
  294.             }   
  295.             sql = "select count(" + countField + ") " + sql;   
  296.             rowsCount = ((Integer) session.createQuery(sql).iterate().next())   
  297.                     .intValue();   
  298.         } catch (HibernateException e) {   
  299.             log.error("countHQL() error:" + sql, e);   
  300.             throw convertHibernateAccessException(e);   
  301.         } finally {   
  302.             this.releaseSession(session);   
  303.         }   
  304.         return rowsCount;   
  305.     }   
  306.   
  307.     /**  
  308.      * 计算HQL查询的返回记录数  
  309.      *   
  310.      * @param sql 查询语句  
  311.      * @return 记录数  
  312.      */  
  313.     protected int countHQL(String sql) {   
  314.         return countHQL(sql, null);   
  315.     }   
  316. }  
/**
 * BaseDAOHibernate.java
 *
 *Copyright 2007 easou, Inc. All Rights Reserved.
 */
package com.easou.ad.dao.hibernate;

import java.lang.reflect.ParameterizedType;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;


import com.easou.framework.util.PageList;
import com.easou.ad.dao.BaseDAO;


public abstract class BaseDAOHibernate<E> extends HibernateDaoSupport implements
        BaseDAO<E> {
    protected final Log log = LogFactory.getLog(this.getClass().getName());
    protected Class<E> clazz;
 
    public BaseDAOHibernate() {
     
        this.clazz =(Class<E>)((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];     
    }
    /**
     * 根据主键获得实体
     * 
     * @param id 实体主键
     * @return 实体对象
     */
    @SuppressWarnings("unchecked")
	public final E getEntity(final Long id) {
        return (E)getHibernateTemplate().get(clazz, id);
    }

    /**
     * 获得所有实体
     * 
     * @return List
     */
    @SuppressWarnings("unchecked")
    public final List<E> getAllEntity() {
        PageList result = new PageList();
        List l = getHibernateTemplate().loadAll(clazz);
        result.addAll(l);
        result.setCurrentPage(1);
        result.setPageCount(1);
        result.setTotalRowCount(l.size());
        return result;
    }

    /**
     * 保存实体
     * 
     * @param entity 实体对象
     */
    public final void saveEntity(final E entity) { 
            getHibernateTemplate().saveOrUpdate(entity);
    }

    /**
     * 根据主键删除实体
     * 
     * @param id 实体主键
     */
    public final void removeEntity(final Long id) {
        Object o = getEntity(id);
        if (null != o) {
            getHibernateTemplate().delete(o);
        }
    }

    /**
     * 执行批量更新和删除操作的HQL
     * 
     * @param sql hql语句
     * @return PageList
     */
    @SuppressWarnings("unchecked")
	protected final List<E> executeHQL(final String sql) {
        Session session = null;
        List<E> ret = null;
        try {
        	log.info(sql);
            session = this.getSession();
            if (sql.toUpperCase().startsWith("DELETE")
                    || sql.toUpperCase().startsWith("UPDATE")) {
                session.createQuery(sql).executeUpdate();
            } else {
                ret = session.createQuery(sql).list();
            }
        } catch (HibernateException e) {
            log.error("executeHQL() error:" + sql, e);
            throw convertHibernateAccessException(e);
        } finally {
            this.releaseSession(session);
        }
        return ret;
    }

    /**
     * 执行分页查询
     * 
     * @param selectField HQL语句中，SELECT 的内容(如果设置了此参数值,则sql参数中不可带SELCT语句部分)
     * @param countField HQL语句中，count 的内容
     * @param sql HQL语句
     * @param page 第几页
     * @param rowsPerPage 每页记录数
     * @return PageList
     */
    @SuppressWarnings("unchecked")
	protected final List<E> pageListQuery(final String selectField,
            String countField, String sql, int page, int rowsPerPage) {
        PageList result = new PageList();
        Session session = null;
        try {
            session = this.getSession();
            // 预留count的sql语句
            String countSql = sql.substring(sql.toUpperCase().indexOf("FROM"));
            // 设置返回的列，进行查询
            if (null != selectField) {
                sql = "SELECT " + selectField + sql;
            }
            if (page <= 0) {
                page = 1; // page最小为1
            }
            log.debug("query sql:" + sql);
            Query q = session.createQuery(sql);
            if (rowsPerPage > 0) { // rowsPerPage的值是0或-1时,都返回全部结果集
                q.setFirstResult(rowsPerPage * (page - 1));
                q.setMaxResults(rowsPerPage);
            }

            result.addAll(q.list());

            // 设置分页查询的列
            if (null == countField) {
                countField = "*";
            }

            int rowsCount = result.size();
            if (rowsPerPage > 1 && rowsCount > 0) {
                // 每页记录数大于1且结果集大于0才计算分页信息,否则当前页记录数就作为总的记录数
                // TODO 解决page值过大,可能导致rowsCount为0的问题
                countSql = "select count(" + countField + ") " + countSql;
                // 计算总记录数时,消除 Order by语句，提高性能
                int oPos = countSql.toUpperCase().indexOf("ORDER BY");
                if (oPos > 0) {
                    countSql = countSql.substring(0, oPos);
                }
                rowsCount = ((Integer) session.createQuery(countSql).iterate().next()).intValue();
            }

            if (0 == rowsCount) {
                page = 0;
            }
            if (rowsPerPage < 0) {
                page = 1;
                rowsPerPage = rowsCount;
            }

            result.setCurrentPage(page);
            result.setTotalRowCount(rowsCount);
            result.calcPageCount(rowsPerPage);

        } catch (HibernateException e) {
            log.error("pageListQuery() error:" + sql, e);
            throw convertHibernateAccessException(e);
        } finally {
            this.releaseSession(session);
        }
        return result;
    }

    /**
     * 执行分页查询
     * 
     * @param selectField HQL语句中，SELECT 的内容(如果设置了此参数值,则sql参数中不可带SELCT语句部分)
     * @param sql HQL语句
     * @param page 第几页
     * @param rowsPerPage 每页记录数
     * @param totalRowCount HQL语句获得的总记录数
     * @return PageList
     */
    @SuppressWarnings("unchecked")
    protected final PageList pageListQuery(final String selectField,
            String sql, int page, int rowsPerPage, final int totalRowCount) {
        PageList result = new PageList();
        Session session = null;
        try {
            session = this.getSession();
            // 设置返回的列，进行查询
            if (null != selectField) {
                sql = "SELECT " + selectField + sql;
            }
            if (page <= 0) {
                page = 1; // page最小为1
            }

            Query q = session.createQuery(sql);
            if (rowsPerPage > 0) { // rowsPerPage的值是0或-1时,都返回全部结果集
                q.setFirstResult(rowsPerPage * (page - 1));
                q.setMaxResults(rowsPerPage);
            }

            result.addAll(q.list());

            if (0 == totalRowCount) {
                page = 0;
            }
            if (rowsPerPage < 0) {
                page = 1;
                rowsPerPage = totalRowCount;
            }

            result.setCurrentPage(page);
            result.setTotalRowCount(totalRowCount);
            result.calcPageCount(rowsPerPage);

        } catch (HibernateException e) {
            log.error("pageListQuery() error:" + sql, e);
            throw convertHibernateAccessException(e);
        } finally {
            this.releaseSession(session);
        }
        return result;
    }

    /**
     * 执行分页查询
     * 
     * @param sql HQL语句
     * @param page 第几页
     * @param rowsPerPage 每页记录数
     * @param totalRowCount HQL语句获得的总记录数
     * @return PageList
     */
    protected final PageList pageListQuery(final String sql, final int page,
            final int rowsPerPage, final int totalRowCount) {
        return pageListQuery(null, sql, page, rowsPerPage, totalRowCount);
    }

    /**
     * 执行分页查询
     * 
     * @param sql HQL语句
     * @param rowsPerPage 每页记录数
     * @param page 第几页
     * @return PageList
     * @throws HibernateException hibernate 异常
     */
    protected List<E> pageListQuery(final String sql, final int page,
            final int rowsPerPage) throws HibernateException {
        return pageListQuery(null, null, sql, page, rowsPerPage);
    }

    /**
     * 执行分页查询
     * 
     * @param countField HQL语句中，count 的内容
     * @param sql HQL语句
     * @param rowsPerPage 每页记录数
     * @param page 第几页
     * @return PageList
     * @throws HibernateException hibernate 异常
     */
    protected List pageListQuery(final String countField, final String sql,
            final int page, final int rowsPerPage) throws HibernateException {
        return pageListQuery(null, countField, sql, page, rowsPerPage);
    }

    /**
     * 计算HQL查询的返回记录数
     * 
     * @param sql 查询语句
     * @param countField count语句操作的字段
     * @return 记录数
     */
    protected int countHQL(String sql, String countField) {

        int rowsCount = 0;
        Session session = null;
        try {
            session = this.getSession();
            if (null == countField) {
                countField = "*";
            }
            sql = "select count(" + countField + ") " + sql;
            rowsCount = ((Integer) session.createQuery(sql).iterate().next())
                    .intValue();
        } catch (HibernateException e) {
            log.error("countHQL() error:" + sql, e);
            throw convertHibernateAccessException(e);
        } finally {
            this.releaseSession(session);
        }
        return rowsCount;
    }

    /**
     * 计算HQL查询的返回记录数
     * 
     * @param sql 查询语句
     * @return 记录数
     */
    protected int countHQL(String sql) {
        return countHQL(sql, null);
    }
}

 

3. 业务逻辑基类接口

 

Java代码 复制代码
  1. /**  
  2.  * BaseManager.java  
  3.  *  
  4.  * Copyright 2007 easou, Inc. All Rights Reserved.  
  5.  */  
  6. package com.easou.ad.bl;   
  7.   
  8. import java.util.HashMap;   
  9. import java.util.List;   
  10.   
分享到：
| 动态表单自定义
评论
发表评论

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

相关推荐

    泛型dao 泛型dao 泛型dao

    Struts2、Hibernate、Spring整合的泛型DAO （本人评价: 代码开发效率提高30% 代码出错率减少70%） 对于大多数开发人员，系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

    经典泛型dao层代码，非常好用简易

    ### 泛型DAO层在SSH框架中的应用与详解 #### 引言 在现代软件开发中，特别是基于Java的企业级应用开发中，DAO（Data Access Object）层的设计扮演着至关重要的角色。它作为业务逻辑层与数据持久层之间的桥梁，承担...

    一个很好的通用泛型dao（含源码）

    而泛型DAO是一个类型安全的，代码精简的设计模式（相对于传统DAO），尤其在DAO组件数量庞大的时候，代码量的减少更加明显。 泛型DAO的核心是定义一个GenericDao接口，声明基本的CRUD操作： 用hibernate作为持久化...

    Hibernate泛型DAO（结合spring模板支持）

    至于`Dao经典泛型.doc`文件，可能是更深入的关于Hibernate泛型DAO的文档，可能包含了如何配置Spring、如何处理复杂查询以及如何优化泛型DAO的更多细节。阅读这份文档将进一步提升你对泛型DAO的理解和应用能力。 ...

    Hibernate泛型Dao

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

    JdbcTemplate通用泛型Dao实现

    本文将深入探讨`JdbcTemplate`通用泛型Dao实现的相关知识点，帮助开发者更好地理解和应用这一技术。 首先，让我们了解什么是`JdbcTemplate`。它是Spring框架的一部分，用于处理SQL操作。`JdbcTemplate`提供了一组...

    大家看看我设计的泛型DAO（使用Spring的Anotation和Hibernate）

    本篇文章将深入探讨一个使用Spring注解和Hibernate实现的泛型DAO设计，以提高代码的复用性和可维护性。 首先，`HibernateBaseDao.java`是基础的Hibernate DAO类，它提供了对Hibernate操作的基本封装。这个类通常会...

    S2SH整合例子 注解配置 JSON 泛型Dao

    6. **泛型Dao**：在Java开发中，泛型Dao（Generic Dao）是一种设计模式，用于减少重复的数据库操作代码。通过定义一个通用的Dao接口，可以实现对不同类型的实体对象进行CRUD操作，提高了代码的复用性和可维护性。...

    泛型DAO模式在Java Web开发中的应用.pdf

    泛型DAO模式在Java Web开发中的应用 摘要： 泛型DAO模式是Java Web开发中的一种重要模式，它可以提高数据访问代码的类型安全性和可读性。该模式可以与Struts、Spring和JPA框架集成，实现用户管理系统的开发。通过...

    泛型DAO，注释详细

    泛型DAO（Generic DAO）是DAO模式的一个扩展，它引入了泛型的概念，提高了代码的复用性和类型安全性。本篇文章将深入探讨泛型DAO的实现原理、优势以及如何在实际项目中应用。 首先，我们来理解什么是泛型。泛型是...

    Java Web程序运用中泛型DAO的作用.pdf

    本文探讨了在Java Web程序中应用泛型DAO模式的作用和意义。首先，文章明确了Java Web技术的定义和在互联网领域中的重要性，阐述了随着软件功能需求的不断提高，Java Web技术也在不断升级和改造。随后，文章指出泛型...

    spring hibernate 泛型DAO

    本文将深入探讨“Spring Hibernate 泛型DAO”这一主题，以及如何通过泛型DAO实现更加高效、可复用的代码。 首先，让我们理解什么是DAO（Data Access Object）模式。DAO是一种设计模式，它的主要作用是隔离业务逻辑...

    Hibernate泛型DAO及使用方法.doc

    而泛型DAO（Data Access Object）则是基于Hibernate进一步抽象出来的一个设计模式，用于提供更通用的数据操作方法。本文档主要探讨了如何在Spring+Hibernate环境中创建和使用泛型DAO。 首先，我们来看一下泛型DAO...

    Java Web程序运用中泛型DAO的作用.zip

    而泛型DAO是DAO模式的一个进阶应用，它通过引入泛型来提高代码的复用性和可维护性。 泛型（Generics）是Java 5引入的一个重要特性，它可以让我们在编译时检查类型安全，并且允许我们创建参数化的类型。在泛型DAO中...

    SSH 泛型DAO分页

    这个压缩包文件的标题"SSH 泛型DAO分页"表明它提供了一个实现SSH框架整合的示例，特别关注了泛型DAO（Data Access Object）以及分页功能。下面将详细介绍SSH框架及其分页和泛型DAO的概念。 1. **Struts2**: Struts2...

    基于hibernate的泛型Dao框架

    标题中的“基于Hibernate的泛型Dao框架”是指在Java开发中使用Hibernate ORM工具，并结合泛型设计模式构建的数据库访问对象（DAO）框架。这样的框架旨在提高代码复用性，减少重复工作，使得数据访问层的实现更加简洁...

    ssh通用泛型DAO

    在这个主题中，我们将深入探讨"ssh通用泛型DAO"的相关知识点。 首先，我们来了解"BaseHibernateDAO"。BaseHibernateDAO是基于Hibernate框架的一个基类，它封装了常见的数据库操作，如增删查改（CRUD）。通过继承这...

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