spring-data-jpa使用自定义repository来实现原生sql

目录
  • 使用自定义repository实现原生sql
    • 自定义Repository接口
    • 创建自定义RepositoryFactoryBean
  • SpringDataJpa原生SQL查询
    • a.首先在StudentRepository里添加如下方法
    • b.在StudentController里面进行调用以上方法

使用自定义repository实现原生sql

Spring Data JPA中的Repository是接口,是JPA根据方法名帮我们自动生成的。但很多时候,我们需要为Repository提供一些自定义的实现。今天我们看看如何为Repository添加自定义的方法。

自定义Repository接口

首先我们来添加一个自定义的接口:

  • 添加BaseRepository接口
  • BaseRepository继承了JpaRepository,这样可以保证所有Repository都有jpa提供的基本方法。
  • 在BaseRepository上添加@NoRepositoryBean标注,这样Spring Data Jpa在启动时就不会去实例化BaseRepository这个接口
/**
 * Created by liangkun on 2016/12/7.
 */
@NoRepositoryBean
public interface BaseRepository<T,ID extends Serializable> extends JpaRepository<T,ID> {

    //sql原生查询
    List<Map<String, Object>> listBySQL(String sql);
}

接下来实现BaseRepository接口,并继承SimpleJpaRepository类,使其拥有Jpa Repository的提供的方法实现。

/**
 * Created by liangkun on 2017/12/7.
 */
public class BaseRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T,ID> implements BaseRepository<T,ID> {
    private final EntityManager entityManager;
    //父类没有不带参数的构造方法,这里手动构造父类
    public BaseRepositoryImpl(Class<T> domainClass, EntityManager entityManager) {
        super(domainClass, entityManager);
        this.entityManager = entityManager;
    }

    //通过EntityManager来完成查询
    @Override
    public  List<Map<String, Object>> listBySQL(String sql) {
        return entityManager.createNativeQuery(sql).getResultList();
    }
}

这里着重说下EntityManager

EntityManager是JPA中用于增删改查的接口,它的作用相当于一座桥梁,连接内存中的java对象和数据库的数据存储。也可以根据他进行sql的原生查找。

源码如下:

public interface EntityManager {
    <T> T find(Class<T> var1, Object var2);
    Query createNativeQuery(String var1);
    Query createNativeQuery(String var1, Class var2);
    Query createNativeQuery(String var1, String var2);
}

由上可以看出其有具体的原生查询实现接口 createNativeQuery

接下来需要将我们自定义的Repository接口,通过工厂模式添加到Spring的容器中:

创建自定义RepositoryFactoryBean

接下来我们来创建一个自定义的RepositoryFactoryBean来代替默认的RepositoryFactoryBean。RepositoryFactoryBean负责返回一个RepositoryFactory,Spring Data Jpa 将使用RepositoryFactory来创建Repository具体实现。

查看JpaRepositoryFactoryBean的源码,通过createRepositoryFactory返回JpaRepositoryFactory实例:

public class JpaRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extends Serializable>
 extends TransactionalRepositoryFactoryBeanSupport<T, S, ID> {
 private EntityManager entityManager;
 public JpaRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
  super(repositoryInterface);
 }

 @PersistenceContext
 public void setEntityManager(EntityManager entityManager) {
  this.entityManager = entityManager;
 }

 @Override
 public void setMappingContext(MappingContext<?, ?> mappingContext) {
  super.setMappingContext(mappingContext);
 }

 @Override
 protected RepositoryFactorySupport doCreateRepositoryFactory() {
  return createRepositoryFactory(entityManager);
 }

 protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
  return new JpaRepositoryFactory(entityManager);
 }

 @Override
 public void afterPropertiesSet() {

  Assert.notNull(entityManager, "EntityManager must not be null!");
  super.afterPropertiesSet();
 }
}

终上我们可根据相应的规则进行创建自定义RepositoryFactoryBean

/**
 * Created by liangkun on 2018/07/20.
 */
public class BaseRepositoryFactoryBean<R extends JpaRepository<T, I>, T, I extends Serializable> extends JpaRepositoryFactoryBean<R, T, I> {
    public BaseRepositoryFactoryBean(Class<? extends R> repositoryInterface) {
        super(repositoryInterface);
    }

    @Override
    protected RepositoryFactorySupport createRepositoryFactory(EntityManager em) {
        return new BaseRepositoryFactory(em);
    }

    //创建一个内部类,该类不用在外部访问
    private static class BaseRepositoryFactory<T, I extends Serializable> extends JpaRepositoryFactory {
        private final EntityManager em;
        public BaseRepositoryFactory(EntityManager em) {
            super(em);
            this.em = em;
        }

        //设置具体的实现类是BaseRepositoryImpl
        @Override
        protected Object getTargetRepository(RepositoryInformation information) {
            return new BaseRepositoryImpl<T, I>((Class<T>) information.getDomainType(), em);
        }

        //设置具体的实现类的class
        @Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            return BaseRepositoryImpl.class;
        }
    }
}

自定义完成。

SpringDataJpa原生SQL查询

一些比较复杂的关联查询要怎么实现呢,JPA的处理方法是:利用原生的SQL命令来实现那些复杂的关联查询,通过设置nativeQuery = true 来设置开启使用数据库原生SQL语句。下面就在上一个案例的基础上实现原生sql的增删改查,代码如下。

a.首先在StudentRepository里添加如下方法

//利用原生的SQL进行查询操作
@Query(value = "select s.* from studenttb s where s.student_name=?1", nativeQuery = true)
public List<Student> findStudentByName(String name);
//利用原生的SQL进行删除操作
@Query(value = "delete from studenttb where student_id=?1 ", nativeQuery = true)
@Modifying
@Transactional
public int deleteStudentById(int uid);
//利用原生的SQL进行修改操作 @Query(value = "update studenttb set student_name=?1 where student_id=?2 ", nativeQuery = true)
@Modifying
@Transactional
public int updateStudentName(String name,int id);
//利用原生的SQL进行插入操作
@Query(value = "insert into studenttb(student_name,student_age) value(?1,?2)", nativeQuery = true)
@Modifying
@Transactional
public int insertStudent(String name,int age);
@Query(value=" SELECT * FROM studenttb WHERE STUDENT_NAME LIKE %:name% ",nativeQuery=true)
List<Student> queryBynameSQL(@Param(value = "name") String name);

b.在StudentController里面进行调用以上方法

代码如下:

//原生sql的调用
/***
* http://localhost:8090/findStudentByName?name=刘一
* @param name
* @return */
@RequestMapping("/findStudentByName")
public Object findStuByName(String name) {
    List<Student> student = repository.findStudentByName(name);
    return student;
}
/***
* http://localhost:8090/deleteStudentById?id=刘
* @param name
* @return */
@RequestMapping("/deleteStudentById")
public Object deleteStudentById(int id) {
    int i = repository.deleteStudentById(id);
    Map<String,Object> map=new HashMap<String,Object>();
    if(i>0) {
        map.put("success", true);
    } else {
        map.put("success", false);
    }
    return map;
}
/***
* http://localhost:8090/updateStudentName?name=Tom&id=1
* @param name
* @return */
@RequestMapping("/updateStudentName")
public Object updateStudentName(String name,int id) {
    int i = repository.updateStudentName(name,id);
    Map<String,Object> map=new HashMap<String,Object>();
    if(i>0) {
        map.put("success", true);
    } else {
        map.put("success", false);
    }
    return map;
}
/***
* http://localhost:8090/insertStudent?name=xiao&age=18
* @param name
* @return */
@RequestMapping("/insertStudent")
public Object insertStudent(String name,int age) {
    int i = repository.insertStudent(name,age);
    Map<String,Object> map=new HashMap<String,Object>();
    if(i>0) {
        map.put("success", true);
    } else {
        map.put("success", false);
    }
    return map;
}
/***
* http://localhost:8090/queryBynameSQL?name=刘
* @param name
* @return */
@RequestMapping("/queryBynameSQL")
public Object queryBynameSQL(String name) {
    List<Student> student= repository.queryBynameSQL(name);
    return student;
}

运行效果请各位自行测试。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

时间: 2021-11-23

解决springdataJPA对原生sql支持的问题

springdataJPA对原生sql支持问题 在项目中用到的是springdataJPA连接数据库进行操作,但是JPA中的hql语句不能够满足业务要求,因而需要用到原生sql 但是有一个问题: @Query(value = "SELECT ppd.* FROM zt_productionplandetails AS ppd \n" + " \tLEFT JOIN zt_salesplan sp ON sp.id=ppd.salesPlan_id \n" + &qu

Spring Data JPA使用JPQL与原生SQL进行查询的操作

1.使用JPQL语句进行查询 JPQL语言(Java Persistence Query Language)是一种和SQL非常类似的中间性和对象化查询语言,它最终会被编译成针对不同底层数据库的SQL语言,从而屏蔽不同数据库的差异. JPQL语言通过Query接口封装执行,Query 接口封装了执行数据库查询的相关方法.调用 EntityManager 的 Query.NamedQuery 及 NativeQuery 方法可以获得查询对象,进而可调用Query接口的相关方法来执行查询操作. JPQ

聊聊Spring data jpa @query使用原生SQl,需要注意的坑

目录 Spring data jpa @Query 使用原生Sql的坑 根据代码来解说: 需要注意的方法有以下几点 SpringData JPA @Query动态SQL语句 思路 实现 Spring data jpa @Query 使用原生Sql的坑 根据代码来解说: @Query(value = "select bill.id_ as id, bill.created_date as date, bill.no, lawyer_case .case_no as caseNo, " +

Spring Data JPA 实现多表关联查询的示例代码

多表查询在spring data jpa中有两种实现方式,第一种是利用hibernate的级联查询来实现,第二种是创建一个结果集的接口来接收连表查询后的结果,这里介绍第二种方式. 一.一对一映射 实体 UserInfo :用户. 实体 Address:家庭住址. 这里通过外键的方式(一个实体通过外键关联到另一个实体的主键)来实现一对一关联. 实体类 1.实体类 UserInfo.java package com.johnfnash.learn.domain; import java.io.Ser

SpringBoot集成Spring Data JPA及读写分离

相关代码: github OSCchina JPA是什么 JPA(Java Persistence API)是Sun官方提出的Java持久化规范,它为Java开发人员提供了一种对象/关联映射工具 来管理Java应用中的关系数据.它包括以下几方面的内容: 1.ORM映射 支持xml和注解方式建立实体与表之间的映射. 2.Java持久化API 定义了一些常用的CRUD接口,我们只需直接调用,而不需要考虑底层JDBC和SQL的细节. 3.JPQL查询语言 这是持久化操作中很重要的一个方面,通过面向对象

spring Data jpa简介_动力节点Java学院整理

前言 自 JPA 伴随 Java EE 5 发布以来,受到了各大厂商及开源社区的追捧,各种商用的和开源的 JPA 框架如雨后春笋般出现,为开发者提供了丰富的选择.它一改之前 EJB 2.x 中实体 Bean 笨重且难以使用的形象,充分吸收了在开源社区已经相对成熟的 ORM 思想.另外,它并不依赖于 EJB 容器,可以作为一个独立的持久层技术而存在.目前比较成熟的 JPA 框架主要包括 Jboss 的 Hibernate EntityManager.Oracle 捐献给 Eclipse 社区的 E

spring data jpa分页查询示例代码

最近项目上用就hibernate+spring data jpa,一开始感觉还不错,但是随着对业务的复杂,要求处理一些复杂的sql,就顺便研究了下,把结果记录下,以便日后查看.用到Specification,需要继承JpaSpecificationExecutor接口.(下面代码有的分页从0开始作为第一页,有的从1开始作为作为第一页,我也忘记,请自己测试) DAO层: import java.util.List; import org.springframework.data.domain.Pa

Spring Data JPA实现动态查询的两种方法

前言 一般在写业务接口的过程中,很有可能需要实现可以动态组合各种查询条件的接口.如果我们根据一种查询条件组合一个方法的做法来写,那么将会有大量方法存在,繁琐,维护起来相当困难.想要实现动态查询,其实就是要实现拼接SQL语句.无论实现如何复杂,基本都是包括select的字段,from或者join的表,where或者having的条件.在Spring Data JPA有两种方法可以实现查询条件的动态查询,两种方法都用到了Criteria API. Criteria API 这套API可用于构建对数据

Spring Data JPA中的动态查询实例

spring Data JPA大大的简化了我们持久层的开发,但是实际应用中,我们还是需要动态查询的. 比如,前端有多个条件,这些条件很多都是可选的,那么后端的SQL,就应该是可以定制的,在使用hibernate的时候,可以通过判断条件来拼接SQL(HQL),当然,Spring Data JPA在简化我们开发的同时,也是提供了支持的. 通过实现Criteria二实现的动态查询,需要我们的Repo接口继承JpaSpecificationExecutor接口,这是个泛型接口. 然后查询的时候,传入动态

spring data jpa使用详解(推荐)

使用Spring data JPA开发已经有一段时间了,这期间学习了一些东西,也遇到了一些问题,在这里和大家分享一下. 前言: Spring data简介: Spring Data是一个用于简化数据库访问,并支持云服务的开源框架.其主要目标是使得对数据的访问变得方便快捷,并支持map-reduce框架和云计算数据服务. Spring Data 包含多个子项目: Commons - 提供共享的基础框架,适合各个子项目使用,支持跨数据库持久化 JPA - 简化创建 JPA 数据访问层和跨存储的持久层

Spring Data JPA例子代码[基于Spring Boot、Mysql]

关于Spring Data Spring社区的一个顶级工程,主要用于简化数据(关系型&非关系型)访问,如果我们使用Spring Data来开发程序的话,那么可以省去很多低级别的数据访问操作,如编写数据查询语句.DAO类等,我们仅需要编写一些抽象接口并定义相关操作即可,Spring会在运行期间的时候创建代理实例来实现我们接口中定义的操作. 关于Spring Data子项目 Spring Data拥有很多子项目,除了Spring Data Jpa外,还有如下子项目. Spring Data Comm

详解Spring Data Jpa 模糊查询的正确用法

模糊查询 Spring Data Jpa的使用可以减少开发者对sql语句的编写,甚至完全不需要编写sql语句.但是,开发过程中总会遇到各种复杂的场景以及大大小小的坑. 今天项目中某个功能模块需要用到模糊查询.原生sql中模糊查询关键字'Like',而Spring Data Jpa的Repository接口中恰恰也有实体字段对应的Like.但是,如果直接使用它,那么恭喜你,你幸运地掉坑了. Spring Data Jpa 模糊查询正确用法 首先,我们先创建一个实体用来存储我们的数据 /** * 实

Spring Data JPA分页复合查询原理解析

Spring Data JPA是Spring Data家族的一部分,可以轻松实现基于JPA的存储库. 此模块处理对基于JPA的数据访问层的增强支持. 它使构建使用数据访问技术的Spring驱动应用程序变得更加容易. 在相当长的一段时间内,实现应用程序的数据访问层一直很麻烦. 必须编写太多样板代码来执行简单查询以及执行分页和审计. Spring Data JPA旨在通过减少实际需要的工作量来显著改善数据访问层的实现. 作为开发人员,您编写repository接口,包括自定义查找器方法,Spring