封装JPA数据库操作的DAO类

最新推荐文章于 2023-08-28 16:40:47 发布
最新推荐文章于 2023-08-28 16:40:47 发布
阅读量3k 收藏
点赞数
分类专栏： web后端 JPA 文章标签： JPA javaweb框架 java编程

1、DAO接口

/**
 * 数据库通用操作基类接口
 */
public interface IObjectDao<T> extends Serializable {
 
    /**
     * 不需确定新建实体是否已经存在
     */
    public T save(T t);
 
    /**
     * 不需确定新建实体是否已经存在
     */
    public Collection<T> save(Collection<T> ts);
 
    /**
     * 可确定为新建实体；返回处于托管状态的实例
     */
    public T persist(T t);
 
    public boolean persist(Collection<T> ts);
 
    /**
     * 若数据库中已有此记录，置为托管状态
     */
    public T merge(T t);
 
    /**
     * 若数据库中已有此记录，置为托管状态
     */
    public Collection<T> merge(Collection<T> t);
 
    /**
     * 删除
     */
    public void remove(T t);
 
    /**
     * 批量删除 传入集合
     */
    public void remove(Collection<T> ts);
 
    /**
     * 删除指定id、指定class的实例
     */
    public void remove(Class<T> clazz, String id);
 
    /**
     * 删除指定id、指定class的实例
     */
    public void remove(Class<T> clazz, Collection<String> ids);
 
    /**
     * 清除一级缓存
     */
    public void clear();
 
    /**
     * 将对象置为游离状态
     */
    public void detach(T t);
 
    /**
     * 将对象置为游离状态
     */
    public void detach(Collection<T> ts);
 
    /**
     * 检查实例是否处于托管状态
     */
    public boolean isManaged(T t);
 
    /**
     * 同步jpa容器和数据库
     */
    public void flush();

接口的实现类

package cn.jjsoft.bp.dao.impl;
 
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
 
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
 
import org.springframework.stereotype.Component;
 
import cn.jjsoft.bp.dao.IObjectDao;
import cn.jjsoft.bp.model.BaseModel;
import cn.jjsoft.bp.model.Company;
import cn.jjsoft.bp.web.PageResult;
import cn.jjsoft.util.ObjectUtil;
 
/**
 * 数据库通用操作基类 包含共同方法
 */
@Component("objectDao")
public class ObjectDaoImpl<T extends BaseModel> implements IObjectDao<T> {
 
    private static final long serialVersionUID = -4988809011506973125L;
    public EntityManager entityManager;
 
    /**
     * 不需确定新建实体是否已经存在
     */
    @Override
    public T save(T t) throws RuntimeException {
        try {
            t = entityManager.contains(t) ? t : entityManager.merge(t);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("保存失败，请联系管理员！");
        }
        return t;
    }
 
    /**
     * 不需确定新建实体是否已经存在 传入对象集合
     */
    @Override
    public Collection<T> save(Collection<T> ts) {
        Collection<T> collection = new HashSet<T>();
        for (T t : ts) {
            collection.add(save(t));
        }
        return collection;
    }
 
    /**
     * 可确定为新建实体
     */
    @Override
    public T persist(T t) throws RuntimeException {
        try {
            entityManager.persist(t);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("错误：保存新建实例时，发生异常：" + e.getMessage());
        }
    }
 
    /**
     * 可确定为新建实体 成功返回true 失败返回false
     */
    @Override
    public boolean persist(Collection<T> ts) {
 
        try {
            for (T t : ts) {
                entityManager.persist(t);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 若数据库中已有此记录，置为托管状态并刷新实体信息
     */
    @Override
    public T merge(T t) throws RuntimeException {
        try {
            t = entityManager.contains(t) ? t : entityManager.merge(t);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("更新失败，请联系管理员！");
        }
        return t;
    }
 
    /**
     * 若数据库中已有此记录，置为托管状态
     */
    @Override
    public Collection<T> merge(Collection<T> ts) {
        Collection<T> collection = new HashSet<T>();
        for (T t : ts) {
            collection.add(merge(t));
        }
        return collection;
    }
 
    /**
     * 删除
     */
    @Override
    public void remove(T t) {
        if (null == t || isEmpty(t.getId())) {
            throw new RuntimeException("传入条件错误!");
        }
        if (entityManager.contains(t)) {
            entityManager.remove(t);
        } else {
            Object object = entityManager.find(t.getClass(), t.getId());
            if (null == object) {
                throw new RuntimeException("删除数据不存在!");
            }
            entityManager.remove(object);
        }
    }
 
    /**
     * 批量删除 传入集合
     */
    @Override
    public void remove(Collection<T> ts) {
        for (T t : ts) {
            remove(t);
        }
    }
 
    /**
     * 删除
     */
    @Override
    public void remove(Class<T> clazz, String id) {
        if (isEmpty(id)) {
            throw new RuntimeException("请求删除的对象为空!");
        }
        entityManager.remove(entityManager.find(clazz, id));
    }
 
    /**
     * 删除
     */
    @Override
    public void remove(Class<T> clazz, Collection<String> ids) {
        for (String id : ids) {
            remove(clazz, id);
        }
    }
 
    /**
     * 若数据库中存在，返回最新状态；否则，返回空
     * 
     * @param clazz
     * @param t
     * @param id
     * @return
     */
    @Override
    public T refresh(Class<T> clazz, T t) throws RuntimeException {
        if (null == t || isEmpty(t.getId())) {
            throw new RuntimeException("请求刷新的实体为空！");
        }
        if (entityManager.contains(t)) {
            entityManager.refresh(t);
            return t;
        } else {
            return entityManager.find(clazz, t.getId());
        }
    }
 
    /**
     * 清除一级缓存
     */
    @Override
    public void clear() {
        entityManager.clear();
    }
 
    /**
     * 将对象置为游离状态
     */
    @Override
    public void detach(T t) {
        entityManager.detach(t);
    }
 
    /**
     * 将对象置为游离状态
     */
    @Override
    public void detach(Collection<T> ts) {
        for (T t : ts) {
            detach(t);
        }
    }
 
    /**
     * 判断实体是否处于托管状态
     */
    @Override
    public boolean isManaged(T t) {
        return entityManager.contains(t);
    }
 
    /**
     * 同步jpa容器和数据库
     */
    @Override
    public void flush() {
        entityManager.flush();
    }

DataBaseTool 
<span style="font-size:10px;">public EntityManager getEntityManager() {
        return entityManager;
    }
 
    @PersistenceContext
    public void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }
 
    /**
     * 判断一个字符串是否为空
     */
    protected boolean isEmpty(String string) {
        return null == string || string.trim().equals("") ? true : false;
    }
 
    /**
     * 判断company是否为空
     */
    protected boolean isEmpty(Company company) {
        return null == company || isEmpty(company.getId()) ? true : false;
    }
 
    /**
     * 日期转换 ：将java.util.Date类型转换为java.sql.Date
     */
    protected java.sql.Date getSqlDate(java.util.Date date) {
        Long times = date.getTime();
        java.sql.Date sqlDate = new java.sql.Date(times);
        return sqlDate;
    }
 
    /**
     * 无条件查询 对象集 + 总数
     */
    protected PageResult<T> getResult(CriteriaQuery<T> cq, CriteriaQuery<Long> cqCount, int start,
            int pageSize) {
        return getResult(cq, null, cqCount, null, start, pageSize);
    }
 
    /**
     * 统计符合条件的总数
     */
    protected long getResultCountQuery(CriteriaQuery<Long> cqCount, List<Predicate> predicatesCount) {
        if (null != predicatesCount) {
            cqCount.where(predicatesCount.toArray(new Predicate[0]));
        }
        try {
            // 查询符合条件的数据总数
            return getEntityManager().createQuery(cqCount).getSingleResult();
        } catch (Exception e) {
            return 0;
        }
    }
 
    /**
     * 查询对象集
     */
    protected PageResult<T> getResultQuery(CriteriaQuery<T> cq, List<Predicate> predicates,
            int start, int pageSize) {
        return getResult(cq, predicates, null, null, start, pageSize);
    }
 
    /**
     * 数据查询
     * 
     * @param start
     *            数据起始游标值
     * @param pageSize
     *            分页大小
     * @param pageResult
     *            结果集封装对象
     * @param cq
     *            数据查询
     * @param cqCount
     *            符合条件的总条数
     * @return
     */
    protected PageResult<T> getResult(CriteriaQuery<T> cq, List<Predicate> predicates,
            CriteriaQuery<Long> cqCount, List<Predicate> predicatesCount, int start, int pageSize) {
        PageResult<T> pageResult = new PageResult<T>();
        if (null != cqCount) {
            if (null != predicatesCount) {
                cqCount.where(predicatesCount.toArray(new Predicate[0]));
            }
            try {
                // 查询符合条件的数据总数
                long total = getEntityManager().createQuery(cqCount).getSingleResult();
                // 如果结果总数超过了Integer的最大值 则Integer的返回最大值
                pageResult.setTotalCount(total <= Integer.MAX_VALUE ? (int) total
                        : Integer.MAX_VALUE);
            } catch (Exception e) {
                // e.printStackTrace();
                pageResult.setTotalCount(0);
            }
        }
        // 判断分页
        if (start > pageResult.getTotalCount() && pageSize > 0) {
            int newIndex = pageResult.getTotalCount() % pageSize == 0 ? pageResult.getTotalCount()
                    / pageSize : pageResult.getTotalCount() / pageSize + 1;
            start = (newIndex - 1) * pageSize;
            pageResult.setChangeIndex(newIndex);
            pageResult.setFirst(start);
            pageResult.setPageSize(pageSize);
        }
        if (null == cq) {
            return pageResult;
        }
        if (null != predicates) {
            cq.where(predicates.toArray(new Predicate[0]));
        }
        // 分页查询
        TypedQuery<T> tq = entityManager.createQuery(cq);
        if (start >= 0 && pageSize > 0) {
            tq.setFirstResult(start).setMaxResults(pageSize);
        }
        pageResult.setPageResultList(tq.getResultList());
        return pageResult;
    }
 
    /**
     * 返回指定类的静态元模型名称
     * 
     * @param clazz
     * @return
     */
    protected String getStaticMetamodelName(Class<T> clazz) {
        return clazz.getName() + "_";
    }
 
    /**
     * 根据company Id查找单个对象
     * 
     * @param company
     *            company不能为空，若为空以异常处理
     * @param clazz
     *            查询数据类型
     * @param id
     * @return
     * @throws RuntimeException
     */
    protected T findById(Company company, Class<T> clazz, String id) throws RuntimeException {
        if (null == company || isEmpty(company.getId())) {
            throw new RuntimeException("公司信息不能为空！");
        }
        if (isEmpty(id)) {
            return null;
        }
        T t = entityManager.find(clazz, id);
        if (null == t) {
            return null;
        }
        Object object = ObjectUtil.getFieldValueFromObject(
                ObjectUtil.getFieldValueFromObject(t, "company"), "id");
        if (object.equals(company.getId())) {
            return t;
        } else {
            return null;
        }
    }
 
    @Override
    public T findById(Class<T> clazz, String id) throws RuntimeException {
        if (isEmpty(id)) {
            throw new RuntimeException("ID 不能为空!");
        }
        return entityManager.find(clazz, id);
    }
}</span>
转载自http://www.oschina.net/code/snippet_555465_11678#19149

野狼e族
关注
专栏目录
封装JPA的数据操作公共DAO基类
06-05
通过将公共通用操作写进父类简化代码，提高代码的复用。 面向接口 使用继承 泛型 引入JPA API查询 以及 元数据 提高代码的安全性.
spring-boot集成jpa封装个通用的Dao
yinbucheng的博客
04-18 7939
先定义分页用的PageBean和反射用的ReflectUtils工具类import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map...
使用spring data jpa简化dao层编写
cqstart116的专栏
09-15 4371
一、添加maven依赖： org.springframework.data spring-data-jpa org.slf4j jcl-over-slf4j ... 二、增加配置文件（applicationcontext.xml）     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instanc
JPA通用Dao类设计
menghuannvxia的专栏
11-23 4417
设计思路：利用spring对dao层的支持，使用泛行方式对它进行一次包装，此通用DAO只实现最基本的增删改查功能，具体的特殊实现有它的子类实现 接口设计，在原来的工程中建立一个源代码包，名称为common，然后建立包结构 在dao目录下创建BaseDao.java文件，此文件是一个接口，代码如下： /** * 基本的CRUD实现，使用方式： * 比如您有个DAO叫UserDao,
hibernate 获取自增长id_SpringBoot系列教程JPA之指定id保存
weixin_39719018的博客
11-29 498
前几天有位小伙伴问了一个很有意思的问题，使用 JPA 保存数据时，即便我指定了主键 id，但是新插入的数据主键却是 mysql 自增的 id；那么是什么原因导致的呢？又可以如何解决呢?本文将介绍一下如何使用 JPA 的 AUTO 保存策略来指定数据库主键 idI. 环境准备实际开始之前，需要先走一些必要的操作，如安装测试使用 mysql，创建 SpringBoot 项目工程，设置好配置信息等，关于...
使用JPA，Dao层方法名规范
热门推荐
weixin_39676773的博客
07-05 1万+
Jpa把名字写好就不用写sql了，增加了代码可移植性~OK，下面就是名称规则：直接在接口中定义查询方法，如果是符合规范的，可以不用写实现，目前支持的关键字写法如下：JpaRepository会对方法名进行校验 不符合规范会报错 除非添加@Query注解Spring Data JPA框架在进行方法名解析时，会先把方法名多余的前缀截取掉，比如 find、findBy、read、readBy、get、g...
JPA.rar_JPA 封装DAO
09-24
在DAO（Data Access Object）层的封装中，JPA可以帮助我们创建一组通用的方法，如save、update、delete和findAll，以处理常见的CRUD（Create、Read、Update、Delete）操作。这些方法可以应用于任何实体类，大大提高...
对Hibernate框架的二次封装，简化对数据库的操作
最新发布
05-02
在给出的压缩包文件"hoaven-boot-libdbjpa-master"中，可能包含了这样一个已经二次封装好的Hibernate库，它可能集成了Spring Boot，提供了基于JPA（Java Persistence API）的简单易用的数据库操作API。开发者可以...
JPA(hibernate) Dao 和 DaoSupport
04-13
综上所述，`JPA(hibernate) Dao 和 DaoSupport`涉及到Java持久化技术，主要关注如何通过面向对象的方式操作数据库，以及如何设计和使用DAO层来封装数据访问逻辑。在实际项目中，我们还需要了解如何使用Spring Data ...
封装hibernate统一操作接口
07-10
4. **DAO层**：Repository接口的实现，使用Hibernate Session进行实际数据库操作。 5. **配置文件**：包含Hibernate的配置信息，如连接池、数据库URL、用户名和密码等。 五、 使用步骤 1. 引入xjpa-master项目依赖...
Spring使用JPA进行Dao层的数据访问以及事务管理
张维鹏的博客
08-05 5622
在上篇文章中，我们完成了SSH+JPA+Mysql的整合： https://blog.csdn.net/a745233700/article/details/81413306 在这篇文章中，我们主要介绍如何通过Spring使用JPA进行Dao层的数据访问以及事务管理： 一、前言： 1、在SSH整合项目中，获取hibernate中的sessionFactory有两种方式： （1）第一...
Spring Data JPA 规范Dao层接口
tiangoua的博客
01-28 1047
实体类 /** * 1.实体类和表的映射关系 * @Eitity * @Table * 2.类中属性和表中字段的映射关系 * @Id * @GeneratedValue * @Column */ @Data @Entity @Table(name="cst_customer") public class Customer { ...
封装JPA的数据操作DAO类
menghuannvxia的专栏
11-23 5932
对JPA的实体操作进行了简单的封装，降低了数据操作的难度，提高了开发的效率。里面可能会有少许hibernate的元素。 DAO.java /************************* 版权声明 ********************************* * * 版权所有：百洋软件 * Copyright (c) 2009 by Pearl Ocean. * *
JPA封装baseDao
weixin_30352645的博客
09-30 229
1 /** 2 * 3 */ 4 package pw.lizi.base; 5 6 import java.io.Serializable; 7 import java.lang.reflect.ParameterizedType; 8 import java.lang.reflect.Type; 9 import java.uti...
【Web系列二十四】使用JPA简化持久层接口开发
Nicholson的博客
08-28 795
Spring Data JPA 是Spring提供的一套简化JPA开发的持久层框架，根据实体类自动生成表 (注意库仍旧自己创建)，按照约定好的【方法命名规则】写dao层接口，就可以在不写接口实现的情况下，实现对数据库的访问和操作。同时提供了很多除了CRUD之外的功能，如分页、排序、复杂查询等等。
SpringBoot集成JPA（2）
qq_43334498的博客
07-31 614
代码】SpringBoot集成JPA。
SpringBoot多模块项目整合JPA，解决被依赖模块Dao层无法注入的问题
十三月的博客
07-07 1497
原因：被依赖模块继承了JpaRepository的接口在依赖模块的Spring容器启动时，不会给它实例化jpa的实例对象，因此无法注入到依赖模块中去，加上这两个注解才会为其创建jpa的实例对象，有了实例化对象才能被注入到容器中去。解决办法：被依赖模块的DefaultConfig类加上如下注解，问题即解决。
基于springdata JPA的dao层接口实现
Newbie_J的博客
07-07 2828
基于springdata JPA的dao层接口实现以及分页 1、【举例】 只需要继承 JpaRepository<实体类,主键类型> package com.tmall.tmallspringboot.dao; import com.tmall.tmallspringboot.pojo.Category; import org.springframework.data.jpa.re...
如何在IDEA用JPA JSF逆向产生的DAO类
06-10
在IDEA中使用JPA和JSF逆向生成的DAO类非常简单，只需要...需要注意的是，JPA和JSF逆向生成的DAO类是基于Hibernate框架实现的，因此在使用时需要先配置好Hibernate的相关配置信息，比如数据库连接信息、实体类映射等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值