Opgeslagen procedures oproepen vanuit Spring Data JPA-opslagplaatsen

1. Overzicht

Een opgeslagen procedure is een groep vooraf gedefinieerde SQL-instructies die in de database zijn opgeslagen. In Java zijn er verschillende manieren om toegang te krijgen tot opgeslagen procedures. In deze zelfstudie laten we zien hoe u opgeslagen procedures aanroept vanuit Spring Data JPA Repositories.

2. Projectconfiguratie

In deze tutorial we gebruiken de Spring Boot Starter Data JPA-module als de gegevenstoegangslaag. We zullen MySQL ook gebruiken als onze backend-database. Daarom hebben we Spring Data JPA, Spring Data JDBC en MySQL Connector-afhankelijkheden nodig in ons project pom.xml het dossier:

 org.springframework.boot spring-boot-starter-data-jpa org.springframework.boot spring-boot-starter-data-jdbc mysql mysql-connector-java 

Zodra we de MySQL-afhankelijkheidsdefinitie hebben, kunnen we de databaseverbinding configureren in het application.properties het dossier:

spring.datasource.url = jdbc: mysql: // localhost: 3306 / baeldung spring.datasource.username = baeldung spring.datasource.password = baeldung

3. Entiteitsklasse

In Spring Data JPA vertegenwoordigt een entiteit een tabel die is opgeslagen in een database. Daarom kunnen we een entiteitsklasse construeren om het auto databasetabel:

@Entity openbare klasse Auto {@Id @GeneratedValue (strategie = GenerationType.IDENTITY) @Column privé lange id; @Column privé String-model; @Column privé Geheel getal jaar; // standaard getters en setters}

4. Creëren van opgeslagen procedures

Een opgeslagen procedure kan parameters hebben zodat we verschillende resultaten kunnen krijgen op basis van de input. We kunnen bijvoorbeeld een opgeslagen procedure maken die een invoerparameter van het type integer accepteert en een lijst met auto's retourneert:

AANMAKEN PROCEDURE FIND_CARS_AFTER_YEAR (IN jaar_in INT) BEGIN SELECTEREN * VAN auto WAAR jaar> = jaar_in BESTEL OP jaar; EINDE

Een opgeslagen procedure kan ook uitvoerparameters gebruiken om gegevens te retourneren naar de oproepende applicaties. We kunnen bijvoorbeeld een opgeslagen procedure maken die een invoerparameter van het stringtype gebruikt en het queryresultaat opslaat in een uitvoerparameter:

CREËER PROCEDURE GET_TOTAL_CARS_BY_MODEL (IN model_in VARCHAR (50), OUT count_out INT) BEGIN SELECTEER COUNT (*) in count_out van auto WHERE model = model_in; EINDE

5. Referentie opgeslagen procedures in repository

In Spring Data JPA zijn repositories waar we databasebewerkingen bieden. Daarom kunnen we een repository bouwen voor de databasebewerkingen op het Auto entiteit en referentie opgeslagen procedures in deze repository:

@Repository openbare interface CarRepository breidt JpaRepository uit {// ...} 

Laten we vervolgens enkele methoden aan onze repository toevoegen die opgeslagen procedures aanroepen.

5.1. Wijs een opgeslagen procedurenaam direct toe

We kunnen een opgeslagen proceduremethode definiëren met behulp van de @Procedure annotatie en breng de opgeslagen procedurenaam direct in kaart.

Er zijn vier gelijkwaardige manieren om dat te doen. We kunnen bijvoorbeeld de naam van de opgeslagen procedure rechtstreeks gebruiken als de naam van de methode:

@Procedure int GET_TOTAL_CARS_BY_MODEL (String-model); 

Als we een andere methodenaam willen definiëren, kunnen we de naam van de opgeslagen procedure als het element van @Procedure annotatie:

@Procedure ("GET_TOTAL_CARS_BY_MODEL") int getTotalCarsByModel (String-model); 

We kunnen ook de procedureName attribuut om de naam van de opgeslagen procedure toe te wijzen:

@Procedure (procedureName = "GET_TOTAL_CARS_BY_MODEL") int getTotalCarsByModelProcedureName (String-model); 

Evenzo kunnen we de waarde attribuut om de naam van de opgeslagen procedure toe te wijzen:

@Procedure (value = "GET_TOTAL_CARS_BY_MODEL") int getTotalCarsByModelValue (String-model); 

5.2. Verwijs naar een opgeslagen procedure die in de entiteit is gedefinieerd

We kunnen ook de @NamedStoredProcedureQuery annotatie om een ​​opgeslagen procedure in de entiteitsklasse te definiëren:

@Entity @NamedStoredProcedureQuery (name = "Car.getTotalCardsbyModelEntity", procedureName = "GET_TOTAL_CARS_BY_MODEL", parameters = {@StoredProcedureParameter (mode = ParameterMode.IN, name = "model_in", type = StringModeParameter), @arameterModeParameter .OUT, name = "count_out", type = Integer.class)}) public class Car {// class definition}

Vervolgens kunnen we naar deze definitie verwijzen in de repository:

@Procedure (name = "Car.getTotalCardsbyModelEntity") int getTotalCarsByModelEntiy (@Param ("model_in") String-model); 

Wij gebruiken de naam attribuut om te verwijzen naar de opgeslagen procedure die is gedefinieerd in de entiteitsklasse. Voor de repository-methode gebruiken we @Param om overeen te komen met de invoerparameter van de opgeslagen procedure. We matchen ook de outputparameter van de opgeslagen procedure met de retourwaarde van de repository-methode.

5.3. Verwijs naar een opgeslagen procedure met @Query Annotatie

We kunnen ook rechtstreeks een opgeslagen procedure oproepen met de @Query annotatie:

@Query (value = "CALL FIND_CARS_AFTER_YEAR (: year_in);", nativeQuery = true) Lijst findCarsAfterYear (@Param ("year_in") Geheel getal year_in);

Bij deze methode gebruiken we een native query om de opgeslagen procedure aan te roepen. We slaan de zoekopdracht op in het waarde attribuut van de annotatie.

Evenzo gebruiken we @Param om overeen te komen met de invoerparameter van de opgeslagen procedure. We wijzen ook de uitvoer van de opgeslagen procedure toe aan de lijst met entiteiten Auto voorwerpen.

6. Samenvatting

In deze zelfstudie hebben we laten zien hoe u toegang kunt krijgen tot opgeslagen procedures via JPA-opslagplaatsen. We hebben ook twee eenvoudige manieren besproken om te verwijzen naar de opgeslagen procedures in JPA-repositories.

Zoals altijd is de broncode voor het artikel beschikbaar op GitHub.