SpringData JPA 使用SQLQuery原生

最新推荐文章于 2023-07-20 14:31:58 发布
最新推荐文章于 2023-07-20 14:31:58 发布
阅读量1k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/billluffy/article/details/75299082

使用原生SQL

public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = "SELECT * FROM USERS WHERE EMAIL_ADDRESS = ?1", nativeQuery = true)
  User findByEmailAddress(String emailAddress);
}
给上nativeQuery=true就能很方便的使用原生sql了。


下面这些其实是走hibernate那边了，之前对jpa的理解还不是很深，现在懂了更好的方式。

1.用注解创建EntityManager:

/*unitName是用来选择特定的PersistenceContext,默认会选择主数据源，这个在创建数据源的bean的时候会通过   .persistenceUnit( "secondaryPersistenceUnit" ) 来创建，这个方法是在 EntityManagerFactoryBuilder的对象上的*/

@PersistenceContext(unitName = "secondaryPersistenceUnit")

EntityManager entityManager;  


2.创建SQLQuery:

  1. Session session = entityManager.unwrap(org.hibernate.Session.class);  
  2. SQLQuery query = session.createSQLQuery(sql);  
  3. List list=query.list();

3.需要注意的：

数据库操作需要添加事务注解   @Transactional

4.封装好的一个工具类：

[java]  view plain  copy
  print ?
  1. package com.dean.app.service.system;  
  2.   
  3. import java.beans.Introspector;  
  4. import java.beans.PropertyDescriptor;  
  5. import java.lang.reflect.Method;  
  6. import java.math.BigInteger;  
  7. import java.util.ArrayList;  
  8. import java.util.List;  
  9. import java.util.Map;  
  10.   
  11. import javax.persistence.EntityManager;  
  12. import javax.persistence.PersistenceContext;  
  13. import javax.persistence.Query;  
  14. import javax.transaction.Transactional;  
  15.   
  16. import org.apache.commons.beanutils.ConvertUtils;  
  17. import org.hibernate.SQLQuery;  
  18. import org.hibernate.Session;  
  19. import org.hibernate.transform.Transformers;  
  20. import org.springframework.stereotype.Repository;  
  21. import org.springframework.util.CollectionUtils;  
  22.   
  23. @Transactional  
  24. @Repository  
  25. public class CommonDao {  
  26.       
  27.     @PersistenceContext  
  28.     EntityManager entityManager;  
  29.       
  30.     /** 
  31.      * * 查询数据集合 
  32.      * @param sql 查询sql sql中的参数用:name格式  
  33.      * @param params 查询参数map格式，key对应参数中的:name 
  34.      * @param clazz 实体类型为空则直接转换为map格式 
  35.      * @return 
  36.      */  
  37.     @SuppressWarnings("unchecked")  
  38.     public List<?> queryListEntity(String sql,Map<String, Object> params, Class<?> clazz){  
  39.         Session session = entityManager.unwrap(org.hibernate.Session.class);  
  40.         SQLQuery query = session.createSQLQuery(sql);  
  41.         if (params != null) {  
  42.             for (String key : params.keySet()) {  
  43.                 query.setParameter(key, params.get(key));  
  44.             }  
  45.         }  
  46.         query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);  
  47.         List<Map<String, Object>> result =  query.list();  
  48.         if (clazz != null) {  
  49.             List<Object>  entityList = convert(clazz, result);  
  50.             return entityList;  
  51.         }  
  52.         return result;  
  53.     }  
  54.   
  55.     private List<Object> convert(Class<?> clazz, List<Map<String, Object>> list) {  
  56.         List<Object> result;  
  57.         if (CollectionUtils.isEmpty(list)) {  
  58.             return null;  
  59.         }  
  60.         result = new ArrayList<Object>();  
  61.         try {  
  62.              PropertyDescriptor[] props = Introspector.getBeanInfo(clazz).getPropertyDescriptors();  
  63.              for (Map<String, Object> map : list) {  
  64.                  Object obj = clazz.newInstance();  
  65.                  for (String key:map.keySet()) {  
  66.                      String attrName = key.toLowerCase();  
  67.                      for (PropertyDescriptor prop : props) {  
  68.                          attrName = removeUnderLine(attrName);  
  69.                          if (!attrName.equals(prop.getName())) {  
  70.                              continue;  
  71.                          }  
  72.                          Method method = prop.getWriteMethod();  
  73.                          Object value = map.get(key);  
  74.                          if (value != null) {  
  75.                              value = ConvertUtils.convert(value,prop.getPropertyType());  
  76.                          }  
  77.                          method.invoke(obj,value);  
  78.                      }  
  79.                  }  
  80.                  result.add(obj);  
  81.              }  
  82.         } catch (Exception e) {  
  83.             throw new RuntimeException("数据转换错误");  
  84.         }  
  85.         return result;  
  86.     }  
  87.   
  88.     private String removeUnderLine(String attrName) {  
  89.         //去掉数据库字段的下划线  
  90.          if(attrName.contains("_")) {  
  91.             String[] names = attrName.split("_");  
  92.             String firstPart = names[0];  
  93.             String otherPart = "";  
  94.             for (int i = 1; i < names.length; i++) {  
  95.                 String word = names[i].replaceFirst(names[i].substring(0, 1), names[i].substring(0, 1).toUpperCase());  
  96.                 otherPart += word;  
  97.             }  
  98.             attrName = firstPart + otherPart;  
  99.          }  
  100.         return attrName;  
  101.     }  
  102.       
  103.     /** 
  104.      * 获取记录条数 
  105.      * @param sql 
  106.      * @param params 
  107.      * @return 
  108.      */  
  109.     public Integer getCountBy(String sql,Map<String, Object> params){  
  110.         Query query =  entityManager.createNativeQuery(sql);  
  111.         if (params != null) {  
  112.             for (String key : params.keySet()) {  
  113.                 query.setParameter(key, params.get(key));  
  114.             }  
  115.         }  
  116.         BigInteger bigInteger  = (BigInteger) query.getSingleResult();  
  117.         return bigInteger.intValue();  
  118.     }  
  119.       
  120.     /** 
  121.      * 新增或者删除 
  122.      * @param sql 
  123.      * @param params 
  124.      * @return 
  125.      */  
  126.     public Integer deleteOrUpDate(String sql,Map<String, Object> params){  
  127.         Query query =  entityManager.createNativeQuery(sql);  
  128.         if (params != null) {  
  129.             for (String key : params.keySet()) {  
  130.                 query.setParameter(key, params.get(key));  
  131.             }  
  132.         }  
  133.         return query.executeUpdate();  
  134.     }  
  135. }  

1.上面代码中getCountBy（）方法返回的integer，因为数据库返回的是BigInteger因此需要转化一下

2.还有数据中要是存在下划线的字段与实体对应时对应不上因此需要将下划线去掉并且下划线后面的字符串首字母需要转换为大写，比如数据库中字段为login_name而自己定义的实体对象为loginName，这里转换只是为了做到能够通用。不转化的时候只需要写SQL的时候取个别名和实体对应即可。

3.如果不需要转化成具体的实体可以直接使用List<Map<String,Object>>集合，也可以直接使用query.setResultTransformer(Transformers.toBean(clazz))转化为指定的实体，但是要是数据库中的某些字段为bigint(我使用的是MySQL数据库)那么自己定义的实体的对应属性需要用BigInterger类型，否则会报类型转换错误。其他数据库没有测试过，对照着改就可以了。


Spring Data JPA使用JPQL与原生SQL进行查询
weixin_46183674的博客
09-22 595
1、使用JPQL语句进行查询 JPQL是面向对象进行查询的语言，可以通过自定义的JPQL完成UPDATE和DELETE操作。JPQL不支持使用INSERT。对于UPDATE或DELETE操作，必须使用注解 @Modifying 进行修饰。 package com.pjb.jpauserdemo.dao; import com.pjb.jpauserdemo.entity.UserInfo; import org.springframework.data.jpa.repository.JpaReposit
Spring Data JPA使用基础教程
最新发布
ning的博客
01-22 1050
Spring Data JPA 支持通过方法命名规则定义查询。例如：java复制调用将根据用户名查询用户。Spring Data JPA 是一个强大的数据访问框架，它通过简洁的接口和方法命名规则，极大地简化了数据库操作。通过本教程，读者可以快速掌握 Spring Data JPA 的基本使用方法，并应用于实际项目中。版权声明：本博客内容为原创，转载请保留原文链接及作者信息。参考文章[Spring Data JPA使用:看这一篇就够了 - SegmentFault 思否]
spring boot jpa写原生sql报Cannot resolve table错误解决方法
08-25
在本篇文章里小编给大家整理的是关于spring boot jpa写原生sql报Cannot resolve table错误的解决方法，需要的朋友学习下。
Spring Boot中使用Spring-data-jpa让数据访问更简单、更优雅
weixin_33804990的博客
03-24 370
在上一篇Spring中使用JdbcTemplate访问数据库中介绍了一种基本的数据访问方式，结合构建RESTful API和使用Thymeleaf模板引擎渲染Web视图的内容就已经可以完成App服务端和Web站点的开发任务了。 然而，在实际开发过程中，对数据库的操作无非就“增删改查”。就最为普遍的单表操作而言，除了表和字段不同外，语句...
springboot—Jpa原生sql使用
weixin_30302609的博客
08-30 421
package com.savingyu.dao; import java.util.List; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.PersistenceUnit; import java...
jpa@query对象sql，plsql
qq_52736300的博客
06-04 1535
Query是JPA中的一种注解，用于自定义查询语句。其主要作用是允许用户使用自己的SQL查询来获取数据，而不是直接从实体类中查询。对于一般的查询，如果直接在@query主街上加上nativeQuery = true，经过我的测试，发现jpa对于手写sql并不是很友好，经常出现数据库可以查出来，但是手写sql却查不出来，这样我百思不得其解。
架构小白到砖家-10-【数据存储问题】-JpaRepository支持原生sql操作
jea_dong的博客
01-10 588
俗话说金无足赤，人无完人，jpa作为一个存储层技术方案肯定也有不完美的地方，在多表模型和特殊数据库操作方面，还是需要传统sql来进行处理。那么咱们就继续讨论如何通过jpa来实现原生sql的支持？ jpa已经提供了JpaRepository的默认实现类SimpleJpaRepository，咱们现在想自定义方法来扩展JpaRepository，就只能写一个自定义BaseRepository接口继承它...
详解Spring Data JPA使用@Query注解（Using @Query）
08-29
Spring Data JPA 使用 @Query 注解 Spring Data JPA 是一个基于 Java Persistence API（JPA）的数据访问技术，它提供了一种简洁的方式来访问数据库。在 Spring Data JPA 中，我们可以使用 @Query 注解来定义查询...
Spring Data Jpa实现自定义repository转DTO
08-18
在本文中，我们将详细介绍如何使用 Spring Data Jpa 实现自定义 Repository 转 DTO。 自定义 Repository 在 Spring Data Jpa 中，我们可以通过继承 JpaRepository 或者 CrudRepository 来创建自定义 Repository。...
Spring Data JPA 调用原生(Native) SQL 查询
浅尚湖间
07-09 4531
本文使用了 SpringBoot 中的 spring-boot-starter-data-jpa 模块来加入 JPA 功能，单独使用 Spring Data JPA 可能有差异，JDK 版本为 8 介绍 Spring Data JPA 是 Spring Data 项目众多子项目中的一个，是对 Java JPA 规范扩展，本身使用了 Hibernate 的 JPA 实现，并提供了更丰富的 AP...
jpa原生sql@Query操作增删改查
m0_58680865的博客
08-19 742
jpa原生sql@Query操作增删改查 一个使用@Query注解的简单例子 @Query(value = "select name,author,price from Book b where b.price>?1 and b.price<?2") List<Book> findByPriceRange(long price1, long price2); Like表达式 @Query(value = "select name,author,price from Book
基于Spring Boot，使用JPA动态调用Sql查询数据
weixin_30680385的博客
10-20 97
这是个牛人啊，虽然写的不多但是坚持写博客写了这么多年了！0.0 @白色的海 这是作者写的这篇文档的地址 http://www.cnblogs.com/kongxianghai/p/7575988.html 我的评论就两个字：受用。 博客园牛人多，坚持下来的我就很佩服。 转载于:https://www.cnblogs.com/shiyinan/p/7699065.html...
JPA查询方式：方法命名规则、@Query查询、结果集类型转化器
qq_43975645的博客
07-20 1691
注意：在这里的SQL操作都是基于对象，使用的为对象属性，非数据库字段。在持久层接口中，可以直接根据方法的名字进行条件查询。，而非复杂的、定制的SQL的处理，表中的字段，所以最终封装到。保留了写SQL的方法，
JPA执行原生SQL返回指定对象
热门推荐
丹凤朝阳
06-22 2万+
//生成EntityManger protected EntityManager em; //执行原生SQL Query nativeQuery = em.createNativeQuery(String sql); //指定返回对象类型 nativeQuery.unwrap(SQLQuery.class).setResultTransformer(Transformers.aliasToBean(
JPA系列十一：JPQL-Query接口
苍穹尘的博客
05-03 1554
 JPQL语言，即 Java Persistence Query Language 的简称。JPQL 是一种和 SQL 非常类似的中间性和对象化查询语言，它最终会被编译成针对不同底层数据库的 SQL 查询，从而屏蔽不同数据库的差异。  JPQL语言的语句可以是 select 语句、update 语句或delete语句，它们都通过 Query 接口封装执行。  Query接口封装了执行数据库查询的相...
Hibernate JPA 如何使用SQL文直接查询
weixin_30741653的博客
03-06 242
对于复杂SQL，可以直接调用native sql来是实现 public List<Partner> findPartners() { List<Partner> partnerList = new ArrayList<>(); // 这里的em是注入的EntityManager List<...
spring dataJPA 返回结果集数据类型异常问题
博客
10-07 1020
问题： 在使用Spring Data JPA时，采用原生SQL语句来进行数据库查询数据，返回某个字段，代码如下： @Query(value = "SELECT distinct sys_user_id FROM sys_user_merch WHERE merch_id = :merchId", nativeQuery = true) List<String> seLectByMerchId(@Param("merchId") String merchId); 返回结果集List,执行List
spring data jpa使用原生sql去分页
03-14
可以使用@Query注解和Pageable参数来实现原生SQL分页查询，示例代码如下： ``` @Query(value = "SELECT * FROM table_name WHERE condition = ?1 ORDER BY id DESC", countQuery = "SELECT COUNT(*) FROM table_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值