基于hibernate的BaseDAO接口

最新推荐文章于 2020-09-15 14:47:09 发布
最新推荐文章于 2020-09-15 14:47:09 发布
阅读量1.8w 收藏 25
点赞数 8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjxgood/article/details/45170349
版权
本文详细介绍了如何在Hibernate中创建并使用BaseDAO接口，包括BaseDao.java的设计，DataObjectDescriptor.java的数据对象描述，SessionTimeoutException.java的会话超时异常处理，以及PagerFactory.java分页工具类的实现和应用。
摘要由CSDN通过智能技术生成

BaseDao.java

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

import com.xxx.finance.utils.HibernateHandler;
import com.xxx.finance.utils.Pagination;

public interface BaseDao<T> {

    /**
     * 保存实体
     * 
     * @param entity
     *            实体对象
     * @return 实体主键
     */
    Object save(Object entity);

    /**
     * 
     * 删除实体
     * 
     * @param entity
     *            实体对象
     * 
     */
    void delete(Object entity);

    /**
     * 
     * 更新实体
     * 
     * @param entity
     *            实体对象
     * 
     */
    void update(Object entity);

    /**
     * 
     * 保存或更新实体, 实体没有主键时保存，否则更新
     * 
     * @param entity
     *            实体对象
     * 
     */
    void saveOrUpdate(Object entity);

    /**
     * 
     * 批量保存实体
     * 
     * @param entities
     *            实体集合
     */
    void saveAll(Collection<?> entities);

    /**
     * 
     * 批量删除实体
     * 
     * @param entities
     *            实体集合
     * 
     */
    void deleteAll(Collection<?> entities);

    /**
     * 
     * 批量更新实体
     * 
     * @param entities
     *            实体集合
     * 
     */
    void updateAll(Collection<?> entity);

    /**
     * 
     * 批量保存或更新实体, 实体没有主键时保存，否则更新
     * 
     * @param entity
     *            实体集合
     * 
     */
    void saveOrUpdateAll(Collection<?> entities);

    /**
     * 
     * 获取单个实体，根据实体类及实体的主键获取。
     * 
     * @param entityClass
     *            实体类
     * @param id
     *            实体主键
     * @return 实体对象
     */
    @SuppressWarnings("hiding")
    <T> T get(Class<T> entityClass, Serializable id);

    /**
     * 获取单个实体，根据查询语句及参数获取。
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @return 单个实体，如果查询结果有多个，则返回第一个实体
     */
    @SuppressWarnings("hiding")
    <T> T get(CharSequence queryString, Map<String, Object> params);

    /**
     * 获取单个实体，根据查询语句及参数获取。
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @return 单个实体，如果查询结果有多个，则返回第一个实体
     */
    @SuppressWarnings("hiding")
    <T> T get(CharSequence queryString, Object... params);

    /**
     * 
     * 查询实体列表
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @return 实体列表
     */
    @SuppressWarnings("hiding")
    <T> List<T> findList(CharSequence queryString, Object... params);

    /**
     * 
     * 查询实体列表
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @return 实体列表
     */
    @SuppressWarnings("hiding")
    <T> List<T> findList(CharSequence queryString, Map<String, Object> params);

    /**
     * 分页查询实体
     * 
     * @param queryString
     *            查询语句
     * @param pageIndex
     *            当前页码，如果pageIndex<1则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * @param params
     *            可选的查询参数
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
    <T> Pagination<T> findPagination(CharSequence queryString, int pageIndex, int pageSize, Object... params);

    /**
     * 分页查询实体
     * 
     * @param queryString
     *            查询语句
     * @param params
     *            可选的查询参数
     * @param pageIndex
     *            当前页码，如果pageIndex<2则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * 
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
    <T> Pagination<T> findPagination(CharSequence queryString, Map<String, Object> params, int pageIndex, int pageSize);

    /**
     * 分页查询实体，自定义总条数查询语句，适合复杂的hql分页查询
     * 
     * @param queryString
     *            查询语句
     * @param countString
     *            查询记录总条数语句
     * @param pageIndex
     *            当前页码，如果pageIndex<1则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * @param params
     *            可选的查询参数
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
    <T> Pagination<T> findPagination(CharSequence queryString, CharSequence countString, int pageIndex, int pageSize,
            Object... params);

    /**
     * 分页查询实体，自定义总条数查询语句，适合复杂的hql分页查询
     * 
     * @param queryString
     *            查询语句
     * @param countString
     *            查询记录总条数语句
     * @param params
     *            可选的查询参数
     * @param pageIndex
     *            当前页码，如果pageIndex<2则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * 
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
    <T> Pagination<T> findPagination(CharSequence queryString, CharSequence countString, Map<String, Object> params,
            int pageIndex, int pageSize);

    /**
     * 分页查询实体，自定义总条数查询语句，适合复杂的sql分页查询
     * 
     * @param queryString
     *            查询语句
     * @param countString
     *            查询记录总条数语句
     * @param params
     *            可选的查询参数
     * @param pageIndex
     *            当前页码，如果pageIndex<2则不分页，且返回pageSize条记录。
     * @param pageSize
     *            每页记录数，如果pageSize<1则返回所有记录。
     * 
     * @return 实体分页对象
     */
    @SuppressWarnings("hiding")
    public <T> Pagination<T> findSqlPagination(final CharSequence queryString, final CharSequence countString,
            final Map<String, Object> params, int pageIndex, int pageSize);

    /**
     * 执行数据库更新操作
     * 
     * @deprecated 用{@link #executeUpdate(String)}替换
     * @param hql
     */
    void execute(String hql);

    /**
     * 执行数据库更新操作
     * 
     * @deprecated 用{@link #executeUpdate(HibernateHandler)}替换
     * @param hql
     */
    void execute(HibernateHandler handler);

    /**
     * 执行数据库更新操作
     * 
     * @deprecated 用{@link #executeSqlUpdate(String)}替换
     * @param sql
     */
    void executeSql(String sql);

    /**
     * 执行数据库查询操作
     * 
     * @param handler
     *            处理器
     * @return
     * @throws Exception
     */
    Object executeQuery(HibernateHandler handler);

    /**
     * 执行数据库更新操作
     * 
     * @param sql
     * @return 更新的记录条数
     */
    int executeSqlUpdate(String sql);

    /**
     * 执行数据库更新操作
     * 
     * @param hql
     * @return 更新的记录条数
     */
    int executeUpdate(String hql);

    /**
     * 执行数据库更新操作
     * 
     * @param handler
     *            处理器
     * @return
     * @throws Exception
     */
    Object executeUpdate(HibernateHandler handler);

    public T getById(Serializable id);

    public T saveEntity(T o);

    public T insert(T o);

    public void save(List<T> list);

    public void insert(List<T> list);

    public void delete(List<T> list);

    public void update(List<T> list);

    public List<T> findByProperty(String name, Object value);

    public List<T> findByProperty(Map<String, Object> conditionMap);

    /**
     * 
     * 查询实体列表
     * 
     * @param queryString
     *            查询语句
     * @param maxResults
     *            列表最大数
     * @param params
     *            可选的查询参数
     * @return 实体列表
     */
    public <V> List<V> findListByMax(CharSequence queryString, int maxResults, Object... params);

    /**
     * 
     * 查询实体列表
     * 
     * @param queryString
     *            查询语句
     * @param maxResults
     *            列表最大数
     * @param params
     *            可选的查询参数
     * @return 实体列表
     */
    public <V> List<V> findListByMax(CharSequence queryString, int maxResults, Map<String, Object> params);
}

BaseDaoImpl.java 

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Repository;

import com.xxx.finance.dao.BaseDao;
import com.xxx.finance.utils.HibernateHandler;
import com.xxx.finance.utils.ObjectUtil;
import com.xxx.finance.utils.Pagination;

/**
 * @author 
 */
@Repository
public class BaseDaoImpl<T> implements BaseDao<T> {

    protected Class<T> entityClazz;

    protected SessionFactory sessionFactory;

    @SuppressWarnings("unchecked")
    public BaseDaoImpl() {
        Type type = getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            this.entityClazz = (Class<T>) ((ParameterizedType) type).getActualTypeArguments()[0];
        } else {
            this.entityClazz = null;
        }
    }

    @Resource
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    protected Session getSession() {
        return sessionFactory.getCurrentSession();
    }

    @SuppressWarnings("unchecked")
    public Object save(Object entity) {
        return (T) getSession().save(entity);
    }

    public void delete(Object entity) {

        getSession().delete(entity);
    }

    public void update(Object entity) {

        getSession().update(entity);
    }

    public void saveOrUpdate(Object entity) {

        getSession().saveOrUpdate(entity);
    }

    public void saveAll(Collection<?> entities) {

        for (@SuppressWarnings("rawtypes")
        Iterator localIterator = entities.iterator(); localIterator.hasNext();) {
            Object entity = localIterator.next();
            getSession().save(entity);
        }
    }

    public void deleteAll(Collection<?> entities) {

        for (@SuppressWarnings("rawtypes")
        Iterator localIterator = entities.iterator(); localIterator.hasNext();) {
            Object entity = localIterator.next();
            getSession().delete(entity);
        }
    }

    public void updateAll(Collection<?> entities) {

        for (@SuppressWarnings("rawtypes")
        Iterator localIterator = entities.iterator(); localIterator.hasNext
最低0.47元/天 解锁文章
hjxgood
关注
基于hibernate的BaseDao及其实现类的设计
kklt21cn的专栏
12-20 6364
以前做设计的时候dao接口和它的实现了，这样子就不必写这么多的重复代码了。但由于对反射没有了解，除非依赖hibernate的其他组件，否则写不出来。不过，有了反射，我们可以通过泛型来实现我们想要做的功能了。          首先是接口： package com.sms.dao.base; import java.util.List; public interface BaseDa
基于hibernate封装的BaseDao
01-02
基于hibernate封装的BaseDao，有完整的增删改查，分页，执行hql sql 方法 约 20个方法，详情地址 https://blog.csdn.net/qq_41861261/article/details/85595872
HibernateBaseDAO
weixin_30421809的博客
04-12 105
HibernateBaseDAO接口 1 package com.iotek.homework.dao; 2 3 import java.io.Serializable; 4 import java.util.List; 5 6 /** 7 * Created by Bo on 2017/4/9. 8 */ 9 public interface Hi...
Hibernate 原生通用DAO
10-30
[保证可用] 仿照Spring中HibernateTemplate方法实现的简易DAO [原文链接] http://www.cnblogs.com/yzxk/p/4924287.html
BaseHibernateDAO
11-19
BaseHibernateDAO是用于获取数据库信息的公共访问类 有了它，数据增删改查将会更加方便
basic-common2h3:基于hibernate3的BaseDao,完成增删改查、分页操作
06-07
实现一个基于hibernate3的基本的dao，实现CRUD； 一行代码完成CRUD，提供多种重载方法详见IBaseDao，但是项目需要基于SSH框架。 ============ 使用方法，以用户添加为例： 1、定义User类，并提供get和set方法。 2、...
spring和hibernate集成后，通用的basedao
08-03
在基于Spring和Hibernate的应用中，实现分页通常涉及到使用Hibernate的Criteria API或HQL来添加LIMIT和OFFSET子句，或者使用Spring Data JPA的Pageable接口。 总结起来，这个"ssh"压缩包中的示例代码展示了如何在...
basedao_basedao数据库_
09-30
"基于BaseDao的手动数据库操作"是一个常见的话题，尤其在Java开发中。BaseDao是一种设计模式，它通常被用来作为数据库访问对象（DAO）的基础，用于封装数据库的基本CRUD（创建、读取、更新、删除）操作。这种模式...
基于hibernate的baseDao
06-11
基于hibernate的baseDao，注释很详细，方便实用
hibernate basedao（泛型版本）
05-18
利用泛型编写的hibernate basedao，涵盖几乎所有数据库操作方法,需导入spring相关jar包
通用的HibernateBaseDAO
程序员的杯具--你懂的！
12-06 180
通用一个HibernateBaseDAO 有了这个基类在一般的项目里面可以对项目一切的数据操作,不需要任何SQL语句： package com.doer.template.hibernate.dao.impl; import java.io.Serializable; import java.lang.reflect.InvocationTargetException; imp...
hibernate BaseDao
Code-lover's Learning Notes
01-27 1373
hibernate BaseDao
Hibernat的通用BaseDao
Student108的博客
09-15 304
1 hibernate的通用BaseDao 1.1 该通用Dao的功能简介 在很多的时候,有些如果只是简单的增删改查的能力,很多的Dao会非常的相似,这就不太好了,所以我们可以将一些通用的能力给抽取出来 增加保存功能 修改功能 删除功能 查全部功能 分页查询功能 查个数功能 1.2 通用Dao接口 /** * 通用的Dao接口 */ public interface BaseDao<T> { /** * 增加对象 * @Description: save
BaseHibernateDAO.java
andy的专栏
05-26 1252
/** *  */package com.core.base.persistent.impl;import java.io.Serializable;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.dao.DataRet
Hibernate 通用操作类 BaseHibernateDao
窗边冷月光
08-15 5048
在用HIbernate的时候，写DAO每次都要获取session，query，感觉很繁琐，就自己写了一个类，实现了绝大多数功能，代码简化了很多，话不多说，直接上代码： BaseHibernateDao类package cn.util;import java.io.Serializable; import java.lang.reflect.ParameterizedType; import ja
基于hibernate的BaseDao
人生如逆旅，我亦是行人。。。
03-03 709
1.BaseDao接口： package com.dear.simpler.dao; import java.io.Serializable; import java.util.List; import com.dear.simpler.db.utils.SPLDBException; /** * * @author lixiang * * 定义所有表的公共的方法接口 */ pu
Spring下的BaseHibernateDAO
愤怒的coder
02-23 269
package com.accp.myzf.hibernate.dao.impl; import java.io.Serializable; import java.util.List; import org.hibernate.Transaction; import org.hibernate.criterion.Example; import org.springframework....
编写 BaseDaoImpl<T> 继承 BaseDao 接口
最新发布
03-26
public class BaseDaoImpl<T> implements BaseDao<T> { @Override public void save(T t) { // 实现保存逻辑 } @Override public void delete(T t) { // 实现删除逻辑 } @Override public void update(T t) { // 实现更新逻辑 } @Override public T findById(int id) { // 实现根据id查询逻辑 return null; } }
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值