Hibernate JPA自定义通用DAO，自定义SQL，返回自定义对象。没有强关联实体基类。

已于 2023-08-18 14:43:55 修改
阅读量474 收藏 3
点赞数 1
文章标签： hibernate sql java
于 2023-08-18 14:41:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35984182/article/details/132361018
版权

基于Hibernate JPA，使用EntityManager实现

全部serviceImpl服务都继承通用服务类。避免频繁创建实体类。通用一个dao层。使用手搓SQL查询（sql注入使用其他方式解决）

支持返回：List<Map>、List<T>、Integer、String、<T>、Map

支持方法：save、delete、update、findOne、executeBySQL、batchSave、batchUpdate、getListBySQL、getNumBySQL、getStringBySQL

1、SQL结果转换类
import lombok.extern.slf4j.Slf4j;
import org.hibernate.transform.AliasToBeanResultTransformer;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * sql结果转换类，实体里驼峰命名法 与数据库里下划线命名 自动匹配
 */
@Slf4j
public class SqlResultTransformer extends AliasToBeanResultTransformer {

    private Class resultClass;
    public SqlResultTransformer(Class resultClass) {
        super(resultClass);
        this.resultClass = resultClass;
    }

    public Object transformTuple(Object[] tuple, String[] aliases) {
        Object obj = null;
        try {
            obj = resultClass.newInstance();
        } catch (InstantiationException e1) {
            e1.printStackTrace();
        } catch (IllegalAccessException e1) {
            e1.printStackTrace();
        }
        Method[] methods = resultClass.getMethods();// 返回这个类里面方法的集合
        for(int k=0;k<aliases.length;k++){
            String aliase=aliases[k];
            // cdd 把字段名中所有的下杠去除
            aliase = aliase.replaceAll("_", "").toLowerCase();
            char[] ch = aliase.toCharArray();
            ch[0] = Character.toUpperCase(ch[0]);
            String s = new String(ch);
            String[] names = new String[] { ("set" + s).intern(),
                    ("get" + s).intern(), ("is" + s).intern(),
                    ("read" + s).intern() };
            Method setter = null;
            Method getter = null;
            int length = methods.length;
            for (int i = 0; i < length; ++i) {
                Method method = methods[i];
                /**
                 * 检查该方法是否为公共方法,如果非公共方法就继续
                 */
                if (!Modifier.isPublic(method.getModifiers()))
                    continue;
                String methodName = method.getName();

                for (String name : names) {
                    if (name.toLowerCase().equals(methodName.toLowerCase())) {
                        if (name.startsWith("set") || name.startsWith("read"))
                            setter = method;
                        else if (name.startsWith("get") || name.startsWith("is"))
                            getter = method;

                    }
                }
            }
            if(getter!=null){
                Object[] param = buildParam(getter.getReturnType().getName(), tuple[k]);
                try {
                    setter.invoke(obj, param);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return obj;
    }

    private final static Object[] buildParam(String paramType, Object value) {
        Object[] param = new Object[1];
        if (paramType.equalsIgnoreCase("java.lang.String")) {
            param[0] = (String)(value);
        } else if (paramType.equalsIgnoreCase("int")
                || paramType.equalsIgnoreCase("java.lang.Integer")) {
            try {
                param[0] = (Integer)(value);
            } catch (Exception e) {
                param[0] = Integer.valueOf(value.toString());
            }
        } else if (paramType.equalsIgnoreCase("long")|| paramType.equalsIgnoreCase("java.lang.Long")) {
            param[0] = (Long)(value);
        } else if (paramType.equalsIgnoreCase("double")|| paramType.equalsIgnoreCase("java.lang.Double")) {
            try {
                param[0] = (Double)(value);
            } catch (Exception e) {
                param[0] = Double.valueOf(value.toString());
            }
        } else if (paramType.equalsIgnoreCase("float")|| paramType.equalsIgnoreCase("java.lang.Float")) {
            param[0] = (Float)(value);
        } else if (paramType.equalsIgnoreCase("char")
                || paramType.equalsIgnoreCase("Character")) {
            param[0] = (char)(value);
        } else if (paramType.equalsIgnoreCase("java.util.Date")){
            param[0] = (java.util.Date)(value);
        }
        else if (paramType.equalsIgnoreCase("java.sql.Timestamp")){
            param[0] = (java.sql.Timestamp)(value);
        }else if (paramType.equalsIgnoreCase("java.math.BigInteger")){
            param[0] = (java.math.BigInteger)(value);
        }else if (paramType.equalsIgnoreCase("java.math.BigDecimal")){
            param[0] = (java.math.BigDecimal)value;
        }
        return param;
    }

}
2、Dao
import org.hibernate.query.internal.NativeQueryImpl;
import org.hibernate.transform.ResultTransformer;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component  //标记为组件，spring启动时要将该类扫描进容器
public class BaseDaoImp {

    @PersistenceContext //注入的是实体管理器,执行持久化操作
    private EntityManager entityManager;


    public void save(Object obj) {
        entityManager.persist(obj);
    }

    public <T, ID extends Serializable> void delete(Class<T> cls, ID id) {
        T t = entityManager.find(cls, id);
        entityManager.remove(t);
    }

    public <T> T update(T obj) {
        return entityManager.merge(obj);
    }

    public <T, ID extends Serializable> T findOne(Class<T> cls, ID id) {
        return entityManager.find(cls, id);
    }

    @Transactional(readOnly = true)
    public Object getObjectBySQL(final String sql, final ResultTransformer rt) {
        Object obj = null;
        try {
            Query query = entityManager.createNativeQuery(sql);
            if (rt != null) {
                query.unwrap(NativeQueryImpl.class).setResultTransformer(rt);
            }
            List list = query.getResultList();
            if (null != list && list.size() > 0) {
                obj = list.get(0);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }

    @Transactional(readOnly = true)
    public List getListBySQL(String sql, ResultTransformer rt) {
        Query query = entityManager.createNativeQuery(sql);
        if (rt != null) {
            query.unwrap(NativeQueryImpl.class).setResultTransformer(rt);
        }
        List list = query.getResultList();
        return list;
    }

    @Transactional(readOnly = true)
    public List<Map> getListBySQL(String sql) {
        Query query = entityManager.createNativeQuery(sql);
        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List<Map> list = query.getResultList();
        return list;
    }


    public List findBySQL(String sql) {
        Query query = entityManager.createNativeQuery(sql);
        List list = query.getResultList();
        return list;
    }

    public Integer getNumBySQL(String sql) {
        Integer num = 0;
        Query query = entityManager.createNativeQuery(sql);
        Object obj = query.getSingleResult();
        num = Integer.valueOf(obj.toString());
        return num;
    }

    public String getStringBySQL(String sql) {
        Query query = entityManager.createNativeQuery(sql);
        Object obj = query.getSingleResult();
        return obj.toString();
    }

    public Integer executeBySQL(String sql) {
        Query query = entityManager.createNativeQuery(sql);
        final int i = query.executeUpdate();
        return i;
    }

    public void batchSave(List list) {
        for (int i = 0; i < 10000 && i < list.size(); i++) {
            entityManager.persist(list.get(i));
            if (i % 1000 == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
    }

    public void batchUpdate(List list) {
        for (int i = 0; i < list.size(); i++) {
            entityManager.merge(list.get(i));
            if (i % 100 == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
    }

    /**
     * 新增实体，数据库主键自增，同时实体主键为空
     *
     * @param obj
     */
    public void insert(Object obj) {
        entityManager.persist(obj);
    }

    @Transactional(readOnly = true)
    public List<Map> getBySQL(String sql) {
        Query nativeQuery = entityManager.createNativeQuery(sql);
        nativeQuery.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List resultList = nativeQuery.getResultList();
        return resultList;
    }

    public Map uniqueResult(String sql) {

        Map re = new HashMap();
        List<Map> listMap = getBySQL(sql);
        if (null != listMap && listMap.size() > 0) {
            re = listMap.get(0);
        }
        return re;
    }
4、Service

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import java.util.Map;

public class BaseServiceImp<T extends Object, ID extends Serializable> {

    @Autowired
    private BaseDaoImp baseDaoImp;


    @Transactional
    public void save(T t) {
        baseDaoImp.save(t);
    }

    @Transactional
    public void delete(ID id) {
        Class<T> tClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        baseDaoImp.delete(tClass, id);
    }

    @Transactional
    public void deleteByIds(String ids) {
        String strIdArr[] = ids.split(",");
        for (String idStr : strIdArr) {
            ID id = (ID) idStr;
            delete(id);
        }
    }

    @Transactional
    public T update(T t) {
        return baseDaoImp.update(t);
    }

    @Transactional
    public void batchSave(List list) {
        baseDaoImp.batchSave(list);
    }

    @Transactional
    public void batchUpdate(List list) {
        baseDaoImp.batchUpdate(list);
    }

    @Transactional
    public Integer executeBySQL(String sql) {
        return baseDaoImp.executeBySQL(sql);
    }

    @Transactional
    public T findOne(ID id) {
        Class<T> tClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        return baseDaoImp.findOne(tClass, id);
    }

    @Transactional
    public void insert(Object obj) {
        baseDaoImp.insert(obj);
    }

    /**
     * 建议单表查询时候使用； 复杂的sql语句不要用这个方法，比如带Group By分组的语句，统计count会出问题
     *
     * @param querySql
     * @param cls
     * @return
     */
    public QueryResultVO queryBySql(String querySql, Class cls) {
        int lastIndex = querySql.length();
        if (querySql.toLowerCase().indexOf("order by") != -1) {
            lastIndex = querySql.toLowerCase().indexOf("order by");
        }
        String countSql = "select count(*) " + querySql.substring(querySql.toLowerCase().indexOf("from"), lastIndex);
        QueryResultVO queryResultVO = new QueryResultVO();
        List list = baseDaoImp.getListBySQL(querySql, new SqlResultTransformer(cls));
        int count = baseDaoImp.getNumBySQL(countSql);
        queryResultVO.setResultList(list);
        queryResultVO.setTotalRecords(count);
        return queryResultVO;
    }

    public List getListBySQL(String sql, Class cls) {
        return baseDaoImp.getListBySQL(sql, new SqlResultTransformer(cls));
    }

    public List<Map> getListBySQL(String sql) {
        return baseDaoImp.getListBySQL(sql);
    }

    public Integer getNumBySQL(String sql) {
        return baseDaoImp.getNumBySQL(sql);
    }

    public Object getObjectBySQL(String sql, Class cls) {
        return baseDaoImp.getObjectBySQL(sql, new SqlResultTransformer(cls));
    }

    public <E> E getObjectBySQL(String sql, E e) {
        return (E) baseDaoImp.getObjectBySQL(sql, new SqlResultTransformer(e.getClass()));
    }
5、使用

@Service
public class ServiceImpl extends BaseServiceImp implements Service 

    public List<TableDTO> getTableDTOList(VO vo) {
        String sql = "SELECT * FROM table ";
        sql += this.getWhereSql(vo);
        sql += "GROUP BY field";
        List<TableDTO> list = this.getListBySQL(sql, TableDTO.class);
        return list ;
    }
}


@Service
public class ServiceImpl extends BaseServiceImp<MO, Integer> {
	
    @Transactional
	public void addMo(MO mo){
		this.save(mo);
	}
}


import lombok.Data;
import javax.persistence.*;

@Data
@Entity
@Table(name = "table_name")
public class MO {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
}
欧阳海瞬
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate的baseDao和原生SQL
pssalways的博客
11-03 507
1、 BaseDAO 需求： 按名字分页查询对应书籍信息 package com.zking.eight.dao; import java.util.Collection; import java.util.List; import java.util.Map; import org.hibernate.Session; import org.hibernate.query.Query; /...
hibernate自定义SQL
我的IT之路
04-09 3881
//修改 @Override     public int update(RsAttr bean) {         String hql = "update JC_CONTENT_ATTR t set t.attr_value = '即将到期' where t.content_id = ? and t.attr_name = ?";          SQLQuery query
springboot jpa自定义查询结果封装自定义对象
fanglinxing的专栏
05-18 4343
使用Jpa自定义查询时，需要将查询结果自动封装对象中，有两种比较简单的方法： 方法一：返回对象为interface，只需要定义属性的get方法，jdk动态代理封装数据，执行原生sql比较方便，只需要字段和属性名一致。 数据表实体类 @Setter @Getter @Entity @ToString @DynamicUpdate @DynamicInsert @Table(name = "user") public class User implements Serializable { @Id
JPA EntityManager采用原生SQL语句执行后，返回LIst自定义对象的方法
kiss002wk的博客
10-30 953
2、返回List类型 3、返回List类型 在此记录一下，避免忘记！
jpa查询返回自定义对象、返回指定VO、POJO
凌康的博客
08-13 3310
jpa查询返回自定义对象、返回指定VO、POJO，JPA查询前会做大量处理，还有线程通知的操作。若并发大，处理性能直线下降。但是jpa就因为做了大量处理，对多数据库兼容极好，操作方便。有时候你想查询某个表，不想要某个字段内容太长时；
JPA下将查询到的数据封装成自定义实体类
农名工
07-02 2744
unwrap : 自定义封装实体 setResultTransformer： 设置返回实体类型 // 运行原始SQL， 返回指定类型的对象列表 public static <T> List<T> getEntityList(EntityManager em, String sql, Class<T> clazz){ List<T> rows = em.createNativeQuery(sql) .unwra
javaEE Hibernate，orm元数据配置文件中配置HQL语句。通用Dao层基类BaseDaoImpl.java
houyanhua1的专栏
09-10 208
  User.hbm.xml（orm元数据配置文件）： &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-m...
hibernate不是泛型的通用DAo1
05-23
在Java开发中，Hibernate是一个非常流行的ORM（对象关系映射）框架，它允许开发者使用面向对象的方式来操作数据库，而无需关心底层SQL语句的编写。然而，为了提高代码的复用性和可维护性，通常会设计一个通用DAO...
hibernate通用dao
11-08
**hibernate通用DAO（Data Access Object）**是软件开发中的一个重要概念，它主要用于数据库操作的抽象，使得业务逻辑层可以无需关注具体的SQL语句，从而实现数据访问的解耦。在Java EE应用中，Hibernate作为一款...
Hibernate泛型Dao
10-18
【内容】在使用Hibernate泛型Dao时，首先需要定义一个基类，比如`AbstractGenericDao<T>`，其中T代表泛型类型，对应你要操作的实体类。这个基类会包含一些通用的CRUD（Create, Read, Update, Delete）方法，如`save...
Java的Spring框架中DAO数据访问对象的使用示例
09-02
Spring框架提供了对DAO的支持，包括与JDBC、Hibernate、JDO和JPA等不同数据访问技术的集成。在本示例中，我们将探讨Spring如何与JDBC和Hibernate一起使用DAO。 首先，Spring的`JdbcDaoSupport`是为JDBC数据访问对象...
spring data简化jpa开发_动力节点Java学院整理
08-29
JPA本身是Java EE的一个标准，用于处理对象关系映射（ORM），使得开发者可以使用面向对象的方式操作数据库。 首先，让我们理解JPA的基本概念。JPA允许开发者定义实体类，这些类代表数据库中的表，实体类的属性对应...
hibernate查询返回List<T>类型数据
qq_33172029的博客
11-19 1029
情况：通过hibernate查询，一堆类型为T的集合，其中为防止SQL注入，SQL中用?代替，并传入参数 代码： public List&lt;OrderMeetUpload&gt; findListByOrderUuid(String orderUuid) throws Exception { StringBuilder sql = new StringBuilder(); sq...
hibernate/SpringDataJpa使用@Query返回类型
qq_35642849的博客
07-24 1544
对于@Query自定义查询时 1、如果返回的是整张表数据，可以直接映射到实体类，用Bean或者List<Bean>皆可 2、返回的是统计数据，那么可以用Integer接收，或者其他的类，这是单个数据的返回值，也可以直接映射 3、当返回值是两列数据时，可以用Map映射，如果是多行可以用List<Map>映射，这时候每一行都被映射成一个Map。 4、当返回值是两列及以上时，最好的办法就是用Object接收，多行用List<Object>映射，取到对应的值后，可以通过手
springboot jpa 自定义返回对象
weixin_33859665的博客
03-26 3234
为什么80%的码农都做不了架构师？>>> ...
HibernateDAO: 通用DAO,基于Hibernate的DAO实现
yhf
05-10 4077
对于后端开发者来说，经常跟数据库打交道，hibernate mybatis是常用是的持久化层，mybatis简单、灵活，易上手，但要写大量的sql；Hibernate太复杂，但对基于对象的操作则方便些，但是对于复杂的查询也是比较麻烦。但在实际项目中，大部分语句是比较简单的，只有部分会比较复杂些，但若简单的语句写多了也是麻烦。此DAO层正是由此而来，基于Hibernate开发，解决小sql的问...
hibernate查询SQL语句返回自定义实体对象
wqxuihwf
12-10 762
[1].[代码] [Java]代码 跳至 [1] [2] ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
Hibernate查询结果封装成一个自定义实体
xlin
04-17 1132
public void testSql() { List listdata = getHibernateTemplate().executeWithNativeSession( new HibernateCallback() { @Override public List doInHibernate(Session session) thr...
深入探索Stage #2：属性中的XSS注入技术
最新发布
weixin_43822401的博客
06-04 655
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
jpa返回自定义对象
09-12
在 JPA 中，你可以使用以下几种方式来返回自定义对象： 1. 使用构造函数表达式：你可以在查询中使用构造函数表达式来创建自定义对象。假设你有一个名为 `CustomObject` 的类，它有一个带有参数的构造函数，你可以在查询中使用这个构造函数来返回自定义对象。例如： ```java String jpql = "SELECT NEW com.example.CustomObject(c.name, c.age) FROM Customer c"; TypedQuery<CustomObject> query = entityManager.createQuery(jpql, CustomObject.class); List<CustomObject> resultList = query.getResultList(); ``` 2. 使用 `@SqlResultSetMapping`：你可以在实体类中使用 `@SqlResultSetMapping` 注解来定义结果映射。首先，在实体类中定义一个构造函数，然后在 `@SqlResultSetMapping` 注解中指定该构造函数的参数映射。例如： ```java @SqlResultSetMapping( name = "CustomObjectMapping", classes = @ConstructorResult( targetClass = CustomObject.class, columns = { @ColumnResult(name = "name", type = String.class), @ColumnResult(name = "age", type = Integer.class) } ) ) @Entity public class Customer { // ... } ``` 然后，在查询时使用 `@SqlResultSetMapping` 注解的名称来指定结果映射。例如： ```java String jpql = "SELECT c.name, c.age FROM Customer c"; TypedQuery<CustomObject> query = entityManager.createNativeQuery(jpql, "CustomObjectMapping"); List<CustomObject> resultList = query.getResultList(); ``` 3. 使用投影（Projection）：你可以使用投影的方式来选择实体类的部分属性，并将它们映射到自定义对象中。例如： ```java String jpql = "SELECT c.name, c.age FROM Customer c"; TypedQuery<Object[]> query = entityManager.createQuery(jpql, Object[].class); List<Object[]> resultList = query.getResultList(); List<CustomObject> customObjects = resultList.stream() .map(objArr -> new CustomObject((String) objArr[0], (Integer) objArr[1])) .collect(Collectors.toList()); ``` 这些是几种常见的在 JPA 中返回自定义对象的方式。你可以根据具体的业务需求选择最适合你的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值