`
hyj_dx
  • 浏览: 101553 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

泛型dao架构实现,封装crud等基本操作

DAOHibernateSQLJDBCSpring 
阅读更多

今天闲着没事,根据公司的框架中的程序架构进行了修改增加了泛型实现

 

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

 

1. dao接口基类

 

/**
 * 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实现类

 

/**
 * 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. 业务逻辑基类接口

 

/**
 * BaseManager.java
 *
 * Copyright 2007 easou, Inc. All Rights Reserved.
 */
package com.easou.ad.bl;

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

/**
 * TODO 业务逻辑基类接口
 * 
 * Revision History
 * 
 * 
 */
public interface BaseManager<E> {
    /**
     * 根据主键获得实体
     * 
     * @param id 主键id
     * @return BaseEntity
     */
    E get(Long id);

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

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

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

    /**
     * 分页搜索
     * @param con
     * @param page
     * @param rowsPerPage
     * @return
     */
    public List<E> search(HashMap con ,int page,int rowsPerPage);
    /**
     * 搜索
     * @param con
     * @return
     */
	public List<E> search(HashMap con);
}

 4.业务逻辑实现基类

 

/**
 * BaseManagerImpl.java
 *
 * Copyright 2007 easou, Inc. All Rights Reserved.
 */
package com.easou.ad.bl.impl;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.easou.ad.bl.BaseManager;
import com.easou.ad.dao.BaseDAO;

/**
 * 业务逻辑基类
 * 
 * Revision History
 * 
 * 
 */
public class BaseManagerImpl<E,D extends BaseDAO<E>> implements BaseManager <E> {
    protected final Log log = LogFactory.getLog(getClass().getName());

    /**
     * 数据访问接口
     */
    protected D dao;

    /**
     * @return List 所有实体
     */
    public final List<E> getAll() {
        return dao.getAllEntity();
    }

    /**
     * @param id 实体主键
     * @return 实体
     */
    public final E get(final Long id) {
    
        return dao.getEntity(id);
    }

    /**
     * @param id 实体主键
     */
    public final void remove(final Long id) {
        dao.removeEntity(id);
    }
    
    public List<E> search(HashMap con, int page, int rowsPerPage) {
		return ((D)dao).search(con, page, rowsPerPage);
	}

	public List<E> search(HashMap con) {
		return ((D)dao).search(con);
	}
    /**
     * @param entity 实体
     */
    public final void save(final E entity) {
        dao.saveEntity(entity);
    }

    /**
     * 
     * @return 获取泛形
     */
    public final D getDao() {
        return dao;
    }

    /**
     * 
     * @param dao 泛形
     */
    public final void setDao(final D dao) {
        this.dao = dao;
    }
	

}

 

 

  接下来只需要实现基类,就包含了基本crud操作

分享到：
| 不一样的互联网危机
评论
13 楼 zhu_chen001 2008-12-18  
我有个dao和你的差不多，封装了30多种常用的方法，用在开发上发现基本DAO的代码就是0，看来大家的想法是一致的
12 楼 nlslzf 2008-12-18  
呵呵，appfuse里面已经有封装好的
11 楼 aning543 2008-12-10  
.    
10 楼 fjlyxx 2008-12-10  
可以考虑异常的抛出，在这种切面代码中没有可测异常的抛出是比较危险的。个人感觉。
9 楼 hyj_dx 2008-12-04  
呵呵，上面的兄弟说的很对 ，万一是字符窜就麻烦了， 可以改进下把主键类型也范型就可以了
8 楼 tangshd 2008-12-04  
我认为这样就很不错,因为楼主说了吗只是关乎CRUD的BaseDAO
7 楼 e_ville 2008-12-02  
楼主这个万一主键是字符串类型怎么办呢？
6 楼 hyj_dx 2008-11-27  
这是项目中使用的很久的代码，没有问题
5 楼 hyj_dx 2008-11-27  
有这些就足够了，弄的太过于复杂反而不好用，让别人用的也不顺心，实在需要的地方，自己再定义接口另外实现
4 楼 jiyanliang 2008-11-18  
EXvision 写道
楼主的abstractDao封装的方法过于少了。
其实可以整合criteria，另外一般情况下用hibernate写sql的时候比较少。

建议参照SpringSide的泛型DAO。很漂亮。

说的对，如果一个范型dao就封装这几个方法，那确实是没有必要了。
关键是整合其它一些方法，这样才能真正的减少dao数量。
3 楼 EXvision 2008-11-18  
楼主的abstractDao封装的方法过于少了。
其实可以整合criteria，另外一般情况下用hibernate写sql的时候比较少。

建议参照SpringSide的泛型DAO。很漂亮。
2 楼 EXvision 2008-11-18  
逆风的香1314 写道
你的代码好像有点问题啊？太复杂了。
还有一个问题就是为什么你们总喜欢用HIBERNATE呢？莫非你是做外包的/
我个人比较喜欢用Spring做底层，抑或是直接JDBC连接。
这样好控制。


所以你这辈子都不会明白ORM。
1 楼 逆风的香1314 2008-11-15  
你的代码好像有点问题啊？太复杂了。
还有一个问题就是为什么你们总喜欢用HIBERNATE呢？莫非你是做外包的/
我个人比较喜欢用Spring做底层，抑或是直接JDBC连接。
这样好控制。
发表评论

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

相关推荐

    泛型dao

    在研究泛型DAO的源码时，我们可以学习到如何实现泛型类，以及如何在具体操作中使用反射或类型信息来处理泛型类型。例如，Hibernate的`Session`接口和`SessionFactory`类就提供了泛型版本的`get()`和`load()`方法，...

    SSH 泛型DAO分页

    - 实现泛型DAO：创建泛型接口和实现，定义基本的CRUD操作，并添加分页方法。 - 编写Service层：调用DAO接口实现业务逻辑，处理分页参数。 - 创建Struts2 Action：接收用户请求，调用Service方法，将分页数据传递给视...

    ssh通用泛型DAO

    BaseHibernateDAO是基于Hibernate框架的一个基类，它封装了常见的数据库操作，如增删查改（CRUD）。通过继承这个基类，开发者可以快速创建自定义的DAO实现，避免重复编写相似的代码。BaseHibernateDAO通常会包含以下...

    ssh整合下的通用泛型DAO+分页

    在这个特定的讨论中，我们聚焦于SSH1中的一个关键概念：通用泛型DAO（Data Access Object）以及分页功能的实现。DAO层是模型层和数据访问层之间的桥梁，它的主要职责是处理数据库操作，为业务层提供无状态的数据访问...

    Hibernate泛型DAO及使用方法

    这个接口包含了基本的CRUD（创建、读取、更新、删除）操作，以及一些高级操作如加锁、批量操作和HSQL（Hibernate SQL）查询。 1. **基本操作**： - `get(PK id)`：根据主键获取一个实体，如果不存在则返回null。 ...

    泛型通用DAO，可以很简化DAO层的代码

    在泛型DAO中，反射主要用于在运行时动态获取数据实体的属性，以便进行CRUD操作。例如，通过反射可以找到实体类的`id`字段，并根据这个字段执行SQL查询。 `MyTestDao`可能是实现泛型DAO的一个具体示例，它可能包含了...

    DAO模式设计

    - `泛型dao的实现.doc`：可能详细描述了创建泛型DAO的具体步骤，包括如何处理CRUD（Create, Read, Update, Delete）操作。 - `使用AOP实现类型安全的泛型DAO.doc`：可能阐述了如何利用Spring AOP来增强泛型DAO，确保...

    hibernate不是泛型的通用DAo1

    例如，`DynamicDao`可能是一个非泛型接口，它包含了一些基本的CRUD操作，可以直接被任何类实现，而不需要指定特定的实体类型。`DynamicDaoImpl`可能是实现了`DynamicDao`接口的具体类，它包含了与Hibernate集成的...

    基于泛型反射的数据层封装+MSSQLJDBC3.0驱动

    `MyDAO`可能是实现了上述泛型反射数据层封装的自定义DAO类，包含了具体的数据库操作逻辑。这个类可能包含了一些如`insert(T entity)`, `update(T entity)`, `deleteById(ID id)`, `selectById(ID id)`等方法，这些...

    hibenate 对DAO的封装

    然后，用户只需要为自己的实体类创建一个继承自泛型DAO模板的接口，即可获得CRUD操作。例如，对于一个名为`User`的实体类，我们可以创建一个`UserDAO`接口，如下： ```java public interface UserDAO extends ...

    Mybatis通用DAO设计封装（mybatis）

    这个接口通常会包含CRUD（Create, Read, Update, Delete）的基本方法，如`insert`, `update`, `delete`, `selectById`, `selectAll`等。这些方法可以通过Mybatis的注解或XML配置来绑定SQL语句。 2. **动态SQL**： ...

    java软件开发dao层泛型模式

    泛型DAO模式的核心在于定义一个泛型接口`GenericDao`，该接口用于封装所有基本的数据库操作。如上所述的接口定义示例中： ```java public interface GenericDao, PK extends Serializable&gt; { // 基本检索、增加、...

    基于MAVEN的SpringMVC+Mybatis整合及dao、service强封装

    另一种机制采用xml文件形式实现dao、service、controller层封装，具体业务类只需继承就可实现基本的CRUD操作，整个工程导入即可运行（一个月心算之作，稍贵一点，下载以后大部分资料都不需要看了）

    Hibernate封装dao层

    - **CRUD操作**：封装基本的Create（创建）、Read（读取）、Update（更新）、Delete（删除）方法。例如，`save()`用于保存对象，`getById()`用于根据ID获取对象，`update()`用于更新对象，`deleteById()`用于删除...

    数据库Dao封装类

    使用Dao封装类的好处在于，开发人员可以专注于业务逻辑，而不必关心底层数据库的细节，同时，由于所有数据库操作集中在Dao层，便于进行性能优化和维护。在大型项目中，这种封装方式尤为重要，因为它使得团队成员可以...

    ssh数据库基本操作封装

    在这个主题中，“ssh数据库基本操作封装”指的是将常用的数据库交互功能，如增删改查（CRUD），通过SSH框架进行封装，以便在项目中更方便地调用。这通常涉及到Spring的IoC（Inversion of Control）容器来管理数据库...

    C#特性标签实现通用Dao层

    这样，我们就无需为每个实体类编写单独的Dao，而是使用泛型Dao实例即可处理所有带有`[DatabaseEntity]`特性的类。 总结起来，通过C#的特性标签和反射技术，我们可以构建一个灵活且可扩展的通用Dao层，大大减少了...

    泛型解决方案

    这样，一个DAO实例就能处理任何符合特定接口或基类的数据实体，实现插入、更新、删除等操作。 3. CRUD操作：插入（Create）、读取（Read）、更新（Update）和删除（Delete）是数据库操作的基本功能。泛型可以帮助...

    通用DAO

    1. **创建泛型DAO接口**：定义一个泛型接口，如`GenericDAO&lt;T&gt;`，其中T代表数据库实体类型。 2. **实现DAO接口**：在实现类中，使用反射获取实体类的字段信息，构造SQL语句。 3. **执行SQL操作**：使用JDBC或其他ORM...

    自定义Dao，反射实现

    在Java开发中，数据访问对象（DAO）模式是一种常见的设计模式，用于封装对数据库的操作，以提高代码的可重用性和可维护性。本篇将深入探讨如何自定义Dao，并利用反射技术来实现这一目标。博客链接：[此处无法提供...

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