• 如何使用 Spring Data JPA 在存储过程中使用 IN、OUT 和 INOUT 参数

    介绍

    在本教程中，我将向您展示如何使用 Spring Data JPA 在存储过程中使用 IN、OUT 和 INOUT 参数。我还将调用一个完全没有参数的存储过程。

    我将使用 MySQL 服务器，因此 MySQL 服务器可能存在一些限制，或者 Spring Data JPA 本身在调用存储过程时可能存在一些限制，但我至少会向您展示如何根据传递给存储过程的参数类型以不同的方式调用存储过程。

    例如，与Oracle数据库不同，MySQL服务器不支持，因此您不能在实体类中使用参数类型。在这种情况下，您不能使用 Spring Data JPA 存储库样式方法来调用存储过程，您需要作为本机查询调用，或者您需要从中创建实例。REF_CURSORREF_CURSOR@NamedStoredProcedureQueryStoredProcedureQueryEntityManager

    相关文章：

    先决条件

    Java 至少 8， Gradle 6.1.1 – 6.7.1， Maven 3.6.3， MySQL 8.0.17 – 8.0.22， Spring Data JPA 2.2.5 – 2.4.3

    项目设置

    您可以在自己喜欢的 IDE 或工具中创建基于 gradle 或 maven 的项目。该项目的名称是spring-data-jpa-storage-procedure。

    如果你在Eclipse中创建基于gradle的项目，那么你可以使用下面的build.gradle脚本：

    1. buildscript {
    2. 	ext {
    3. 		springBootVersion = '2.2.5.RELEASE' to 2.4.3
    4. 	}
    5.     repositories {
    6.         mavenCentral()
    7.     }
    8.     dependencies {
    9.         classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    10.     }
    11. }
    12.  
    13. plugins {
    14.     id 'java-library'
    15.     id 'org.springframework.boot' version "${springBootVersion}"
    16. }
    17.  
    18. sourceCompatibility = 12
    19. targetCompatibility = 12
    20.  
    21. repositories {
    22.     mavenCentral()
    23. }
    24.  
    25. dependencies {
    26.     implementation("org.springframework.boot:spring-boot-starter:${springBootVersion}")
    27. 	implementation("org.springframework.boot:spring-boot-starter-data-jpa:${springBootVersion}")
    28. 	implementation('mysql:mysql-connector-java:8.0.17') to 8.0.22
    29. 	//required only if jdk 9 or higher version is used
    30.     runtimeOnly('javax.xml.bind:jaxb-api:2.4.0-b180830.0359')
    31. }

    如果你在Eclipse中创建基于maven的项目，那么你可以使用下面的pom.xml文件：

    1. "1.0" encoding="UTF-8"?>
    2.  
    3. <project xmlns="http://maven.apache.org/POM/4.0.0"
    4. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    6. 	<modelVersion>4.0.0modelVersion>
    7.  
    8. 	<groupId>com.roytutsgroupId>
    9. 	<artifactId>spring-data-jpa-stored-procedureartifactId>
    10. 	<version>0.0.1-SNAPSHOTversion>
    11.  
    12. 	<properties>
    13. 		<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    14. 		<maven.compiler.source>12maven.compiler.source>
    15. 		<maven.compiler.target>12maven.compiler.target>
    16. 	properties>
    17.  
    18. 	<parent>
    19. 		<groupId>org.springframework.bootgroupId>
    20. 		<artifactId>spring-boot-starter-parentartifactId>
    21. 		<version>2.2.5.RELEASE to 2.4.3version>
    22. 	parent>
    23.  
    24. 	<dependencies>
    25. 		<dependency>
    26. 			<groupId>org.springframework.bootgroupId>
    27. 			<artifactId>spring-boot-starter-webartifactId>
    28. 		dependency>
    29.  
    30. 		<dependency>
    31. 			<groupId>org.springframework.bootgroupId>
    32. 			<artifactId>spring-boot-starter-data-jpaartifactId>
    33. 		dependency>
    34.  
    35. 		<dependency>
    36. 			<groupId>mysqlgroupId>
    37. 			<artifactId>mysql-connector-javaartifactId>
    38. 		dependency>
    39.  
    40. 		<dependency>
    41. 			<groupId>javax.xml.bindgroupId>
    42. 			<artifactId>jaxb-apiartifactId>
    43. 			<scope>runtimescope>
    44. 		dependency>
    45. 	dependencies>
    46.  
    47. 	<build>
    48. 		<plugins>
    49. 			<plugin>
    50. 				<groupId>org.springframework.bootgroupId>
    51. 				<artifactId>spring-boot-maven-pluginartifactId>
    52. 			plugin>
    53. 		plugins>
    54. 	build>
    55. project>

    MySQL 表

    我将在roytuts数据库下创建一个名为user_details到 MySQL 服务器的表。

    1. CREATE TABLE IF NOT EXISTS `user_details` (
    2.   `id` int unsigned COLLATE utf8mb4_unicode_ci NOT NULL AUTO_INCREMENT,
    3.   `first_name` varchar(20) COLLATE utf8mb4_unicode_ci NOT NULL,
    4.   `last_name` varchar(15) COLLATE utf8mb4_unicode_ci NOT NULL,
    5.   `email` varchar(100) COLLATE utf8mb4_unicode_ci NOT NULL,
    6.   `dob` varchar(16) COLLATE utf8mb4_unicode_ci NOT NULL,
    7.   PRIMARY KEY (`id`)
    8. ) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

    现在，我将立即转储一些数据以测试我们的应用程序。

    1. INSERT INTO `user_details` (`id`, `first_name`, `last_name`, `email`, `dob`) VALUES
    2. 	(7, 'Soumitra', 'Roy', 'contact@roytuts.com', '30-08-2016'),
    3. 	(8, 'Souvik', 'Sanyal', 'souvik.sanyal@email.com', '30-09-1991'),
    4. 	(9, 'Abc', 'Xyz', 'abc@xyz.com', '12-01-1998'),
    5. 	(10, 'Liton', 'Sarkar', 'liton@email.com', '30-08-2012');

    存储过程

    我将创建三个过程来处理存储过程中的 IN、OUT 和 INOUT 参数。

    下面的存储过程从表中返回多行，我没有向其传递任何参数。

    1. DELIMITER //
    2. CREATE DEFINER=`root`@`localhost` PROCEDURE `get_users`()
    3. BEGIN
    4.  
    5. 	SELECT * FROM user_details;
    6.  
    7. END//
    8. DELIMITER ;

    下面的存储过程采用两个参数 – IN 和 OUT。In 参数接受输入，OUT 参数提供输出。

    以下存储过程在连接名字和姓氏后返回用户的全名。

    1. DELIMITER //
    2. CREATE DEFINER=`root`@`localhost` PROCEDURE `get_user_full_name_in_out`(
    3. 	IN `user_id` INT,
    4. 	OUT `full_name` VARCHAR(50)
    5.  
    6. )
    7. BEGIN
    8.  
    9. 	SELECT concat(first_name, ' ', last_name) into full_name FROM user_details WHERE id = user_id;	
    10.  
    11. END//
    12. DELIMITER ;

    以下存储过程仅接受一个参数 INOUT，此参数接受输入并提供输出。

    以下过程还会在连接名字和姓氏后返回用户的全名。

    1. DELIMITER //
    2. CREATE DEFINER=`root`@`localhost` PROCEDURE `get_user_full_name_inout`(
    3. 	INOUT `in_out` VARCHAR(50)
    4.  
    5. )
    6. BEGIN
    7.  
    8. 	SELECT concat(first_name, ' ', last_name) INTO in_out FROm user_details WHERE dob = in_out;
    9. 	
    10. END//
    11. DELIMITER ;

    调用存储过程

    现在，您将了解如何调用存储过程，如何将输入传递给 In 和 INOUT 参数，以及如何从 OUT 和 INOUT 参数接收输出。

    get_users

    此过程列出表user_details 中的所有用户。只需执行 commandon 数据库服务器即可获得以下结果：call get_users()

    现在您将看到如何从 Spring 应用程序调用。

    假设您有以下存储库接口，它扩展了 Spring 的存储库接口：

    1. package spring.data.jpa.stored.procedure.repository;
    2.  
    3. import java.util.List;
    4. import javax.transaction.Transactional;
    5.  
    6. import org.springframework.data.jpa.repository.JpaRepository;
    7. import org.springframework.data.jpa.repository.Query;
    8. import org.springframework.data.jpa.repository.query.Procedure;
    9. import org.springframework.data.repository.query.Param;
    10.  
    11. import spring.data.jpa.stored.procedure.entity.UserDetails;
    12.  
    13. @Transactional
    14. public interface UserDetailsJpaRepository extends JpaRepository {
    15.  
    16.     @Query(value = "call get_users()", nativeQuery = true)
    17.     List findUserDetailsList();
    18.  
    19.     @Procedure(procedureName = "get_user_full_name_in_out", outputParameterName = "full_name")
    20.     String findUserFullNameIn_OutUsingName(@Param("user_id") Integer in);
    21.  
    22. }

    可以使用@Query注释通过以下代码行将过程作为本机查询调用。

    1. @Query(value = "call get_users()", nativeQuery = true)
    2. List findUserDetailsList();

    还可以使用EntityManager以其他方式调用存储过程。假设您有以下存储库类。

    1. package spring.data.jpa.stored.procedure.repository;
    2.  
    3. import java.util.List;
    4.  
    5. import javax.persistence.EntityManager;
    6. import javax.persistence.ParameterMode;
    7. import javax.persistence.PersistenceContext;
    8. import javax.persistence.StoredProcedureQuery;
    9.  
    10. import org.springframework.stereotype.Repository;
    11.  
    12. import spring.data.jpa.stored.procedure.entity.UserDetails;
    13.  
    14. @Repository
    15. public class UserDetailsRepository {
    16.  
    17.     @PersistenceContext
    18.     private EntityManager entityManager;
    19.  
    20.     public List findUserDetailsListUsingAlias() {
    21.         StoredProcedureQuery users = entityManager.createNamedStoredProcedureQuery("getUsers");
    22.         return users.getResultList();
    23.     }
    24.  
    25.     public List findUserDetailsListUsingName() {
    26.         StoredProcedureQuery users = entityManager.createStoredProcedureQuery("get_users");
    27.         return users.getResultList();
    28.     }
    29.  
    30.     public String findUserFullNameInOutUsingName(String dob) {
    31.         StoredProcedureQuery q = entityManager.createStoredProcedureQuery("get_user_full_name_inout");
    32.  
    33.         q.registerStoredProcedureParameter("in_out", String.class, ParameterMode.INOUT);
    34.  
    35.         q.setParameter("in_out", dob);
    36.  
    37.         return q.getOutputParameterValue("in_out").toString();
    38.     }
    39.  
    40.     public String findUserFullNameIn_OutUsingName(Integer in) {
    41.         StoredProcedureQuery q = entityManager.createStoredProcedureQuery("get_user_full_name_in_out");
    42.  
    43.         q.registerStoredProcedureParameter("user_id", Integer.class, ParameterMode.IN);
    44.         q.registerStoredProcedureParameter("full_name", String.class, ParameterMode.OUT);
    45.  
    46.         q.setParameter("user_id", in);
    47.  
    48.         return q.getOutputParameterValue("full_name").toString();
    49.     }
    50.  
    51. }

    现在，可以使用两种不同的方法来调用存储过程：

    1. @PersistenceContext
    2. private EntityManager entityManager;
    3.  
    4. public List findUserDetailsListUsingAlias() {
    5. 	StoredProcedureQuery users = entityManager.createNamedStoredProcedureQuery("getUsers");
    6. 	return users.getResultList();
    7. }
    8.  
    9. public List findUserDetailsListUsingName() {
    10. 	StoredProcedureQuery users = entityManager.createStoredProcedureQuery("get_users");
    11. 	return users.getResultList();
    12. }

    get_user_full_name_in_out

    可以使用以下命令从存储过程中获取结果：

    1. CALL `get_user_full_name_in_out`('7', @full_name);
    2. SELECT @full_name;

    上面的命令将为您提供以下结果：

    现在我将从春季应用程序调用。您可以使用以下代码行从 Spring Data JPA 存储库接口调用：UserDetailsJpaRepository

    1. @Procedure(procedureName = "get_user_full_name_in_out", outputParameterName = "full_name")
    2. String findUserFullNameIn_OutUsingName(@Param("user_id") Integer in);

    您还可以在UserDetailsRepository类中使用以下代码片段：

    1. public String findUserFullNameIn_OutUsingName(Integer in) {
    2. 	StoredProcedureQuery q = entityManager.createStoredProcedureQuery("get_user_full_name_in_out");
    3.  
    4. 	q.registerStoredProcedureParameter("user_id", Integer.class, ParameterMode.IN);
    5. 	q.registerStoredProcedureParameter("full_name", String.class, ParameterMode.OUT);
    6.  
    7. 	q.setParameter("user_id", in);
    8.  
    9. 	return q.getOutputParameterValue("full_name").toString();
    10. }

    get_user_full_name_inout

    您可以在 MySQL 服务器中使用以下命令调用此存储过程：

    1. SET @in_out = '30-08-2016';
    2. CALL `get_user_full_name_inout`(@in_out);
    3. SELECT @in_out;

    上述命令将为您提供以下输出：

    以下代码片段写入UserDetailsRepository类：

    1. public String findUserFullNameInOutUsingName(String dob) {
    2. 	StoredProcedureQuery q = entityManager.createStoredProcedureQuery("get_user_full_name_inout");
    3.  
    4. 	q.registerStoredProcedureParameter("in_out", String.class, ParameterMode.INOUT);
    5.  
    6. 	q.setParameter("in_out", dob);
    7.  
    8. 	return q.getOutputParameterValue("in_out").toString();
    9. }

    实体类

    下面给出了在上述存储库接口和类中使用的相应实体类。

    在类上，我使用@NamedStoredProcedureQueries注释声明了存储过程。

    我使用@Column注释指定了和 Java 属性不同的列名。

    1. @Entity
    2. @Table(name = "user_details")
    3. @NamedStoredProcedureQueries({
    4. 		@NamedStoredProcedureQuery(name = "getUsers", procedureName = "get_users", resultClasses = {
    5. 				UserDetails.class }) })
    6. //@NamedStoredProcedureQuery(name = "getUsers", procedureName = "get_users", resultClasses = { UserDetails.class })
    7. public class UserDetails implements Serializable {
    8.  
    9. 	private static final long serialVersionUID = 1L;
    10.  
    11. 	@Id
    12. 	@Column
    13. 	@GeneratedValue(strategy = GenerationType.IDENTITY)
    14. 	private Integer id;
    15.  
    16. 	@Column(name = "first_name")
    17. 	private String firstName;
    18.  
    19. 	@Column(name = "last_name")
    20. 	private String lastName;
    21.  
    22. 	@Column
    23. 	private String dob;
    24.         
    25.         //getters and setters
    26. }

    服务类

    相应的服务类可以写成：

    1. package spring.data.jpa.stored.procedure.service;
    2.  
    3. import java.util.List;
    4.  
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.stereotype.Service;
    7.  
    8. import spring.data.jpa.stored.procedure.entity.UserDetails;
    9. import spring.data.jpa.stored.procedure.repository.UserDetailsJpaRepository;
    10. import spring.data.jpa.stored.procedure.repository.UserDetailsRepository;
    11.  
    12. @Service
    13. public class UserService {
    14.  
    15.     @Autowired
    16.     private UserDetailsJpaRepository jpaRepository;
    17.  
    18.     @Autowired
    19.     private UserDetailsRepository repository;
    20.  
    21.     public String findUserFullNameIn_OutUsingName(Integer in) {
    22.         return jpaRepository.findUserFullNameIn_OutUsingName(in);
    23.     }
    24.  
    25.     public List getUserListUsingNativeQuery() {
    26.         return jpaRepository.findUserDetailsList();
    27.     }
    28.  
    29.     public List getUserDetailsListUsingProcAlias() {
    30.         return repository.findUserDetailsListUsingAlias();
    31.     }
    32.  
    33.     public List getUserDetailsListUsingProcName() {
    34.         return repository.findUserDetailsListUsingAlias();
    35.     }
    36.  
    37.     public String getUserFullNameInOutUsingProcName(String dob) {
    38.         return repository.findUserFullNameInOutUsingName(dob);
    39.     }
    40.  
    41.     public String getUserFullNameIn_OutUsingProcName(int in) {
    42.         return repository.findUserFullNameIn_OutUsingName(in);
    43.         // return repository.findUserFullNameIn_OutUsingName(in);
    44.     }
    45.  
    46. }

    主类

    一个带有 main 方法的类足以运行我们的 Spring Boot 应用程序。我在这里使用独立应用程序。

    1. package spring.data.jpa.stored.procedure;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.boot.CommandLineRunner;
    5. import org.springframework.boot.SpringApplication;
    6. import org.springframework.boot.autoconfigure.SpringBootApplication;
    7. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
    8.  
    9. import spring.data.jpa.stored.procedure.service.UserService;
    10.  
    11. @SpringBootApplication
    12. @EnableJpaRepositories(basePackages = "spring.data.jpa.stored.procedure.repository")
    13. public class SpringDataJpaStoredProcedureApp implements CommandLineRunner {
    14.  
    15.     @Autowired
    16.     private UserService service;
    17.  
    18.     public static void main(String[] args) {
    19.         SpringApplication.run(SpringDataJpaStoredProcedureApp.class, args);
    20.     }
    21.  
    22.     @Override
    23.     public void run(String... args) throws Exception {
    24.         System.out.println("===========================================");
    25.         System.out.println("User List using Native Query");
    26.  
    27.         service.getUserListUsingNativeQuery().stream().forEach(
    28.                 u -> System.out.println(u.getId() + " " + u.getFirstName() + " " + u.getLastName() + " " + u.getDob()));
    29.  
    30.         System.out.println("===========================================");
    31.         System.out.println("User List using Procedure name");
    32.  
    33.         service.getUserDetailsListUsingProcName().stream().forEach(
    34.                 u -> System.out.println(u.getId() + " " + u.getFirstName() + " " + u.getLastName() + " " + u.getDob()));
    35.  
    36.         System.out.println("===========================================");
    37.         System.out.println("User List using Procedure alias");
    38.  
    39.         service.getUserDetailsListUsingProcAlias().stream().forEach(
    40.                 u -> System.out.println(u.getId() + " " + u.getFirstName() + " " + u.getLastName() + " " + u.getDob()));
    41.  
    42.         System.out.println("===========================================");
    43.  
    44.         System.out.println(
    45.                 "IN and OUT parameters using Procedure name: " + service.getUserFullNameIn_OutUsingProcName(7));
    46.  
    47.         System.out.println("===========================================");
    48.  
    49.         System.out.println(
    50.                 "INOUT parameter using Procedure name: " + service.getUserFullNameInOutUsingProcName("30-08-2016"));
    51.  
    52.         System.out.println("===========================================");
    53.  
    54.         System.out.println(service.findUserFullNameIn_OutUsingName(10));
    55.     }
    56.  
    57. }

    数据库配置

    将以下数据库详细信息放入类路径目录src/main/resources下的application.properties文件中，以连接您的 MySQL 服务器。确保根据数据库详细信息进行更改：

    1. spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
    2. spring.datasource.url=jdbc:mysql://localhost:3306/roytuts
    3. spring.datasource.username=root
    4. spring.datasource.password=root

    测试应用程序

    执行上述主类将给出以下输出：

    1. ===========================================
    2. User List using Native Query
    3. 7 Soumitra Roy 30-08-2016
    4. 8 Souvik Sanyal 30-09-1991
    5. 9 Abc Xyz 12-01-1998
    6. 10 Liton Sarkar 30-08-2012
    7. ===========================================
    8. User List using Procedure name
    9. 7 Soumitra Roy 30-08-2016
    10. 8 Souvik Sanyal 30-09-1991
    11. 9 Abc Xyz 12-01-1998
    12. 10 Liton Sarkar 30-08-2012
    13. ===========================================
    14. User List using Procedure alias
    15. 7 Soumitra Roy 30-08-2016
    16. 8 Souvik Sanyal 30-09-1991
    17. 9 Abc Xyz 12-01-1998
    18. 10 Liton Sarkar 30-08-2012
    19. ===========================================
    20. IN and OUT parameters using Procedure name: Soumitra Roy
    21. ===========================================
    22. INOUT parameter using Procedure name: Soumitra Roy
    23. ===========================================
    24. Liton Sarkar

    存储库接口/类和服务层与任何其他层分离，您可以轻松地注入到任何层中。

    这就是如何使用 Spring Data JPA 框架在存储过程中使用 IN、OUT 和 IN OUT 参数的全部内容。

    源代码

    下载

  • 相关阅读:
    前端面试题总结
    将特征转换为正态分布的一种方法示例
    synchronized的锁策略及优化过程
    力扣解法汇总1175-质数排列
    redis部署与管理
    五金机电行业供应商智慧管理平台解决方案：优化供应链管理，带动企业业绩增长
    安卓高通机型的基带移植 修改 编译的相关 增加信号 支持5G等
    PyCharm 中使用文件监视器自动处理 Python 文件
    算法训练day37|贪心算法 part06(LeetCode738.单调递增的数字)
    万字长文 | 泰康人寿基于 Apache Hudi 构建湖仓一体平台的应用实践
  • 原文地址：https://blog.csdn.net/allway2/article/details/127906490