Aufrufen gespeicherter Prozeduren aus Spring Data JPA-Repositorys

1. Übersicht

Eine gespeicherte Prozedur ist eine Gruppe vordefinierter SQL-Anweisungen, die in der Datenbank gespeichert sind. In Java gibt es verschiedene Möglichkeiten, auf gespeicherte Prozeduren zuzugreifen. In diesem Lernprogramm wird gezeigt, wie gespeicherte Prozeduren aus Spring Data JPA-Repositorys aufgerufen werden.

2. Projekteinrichtung

In diesem Tutorial verwenden wir das Spring Boot Starter Data JPA-Modul als Datenzugriffsschicht . Wir werden auch MySQL als Backend-Datenbank verwenden. Daher benötigen wir in unserer Projektdatei pom.xml die Abhängigkeiten von Spring Data JPA, Spring Data JDBC und MySQL Connector :

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

Sobald wir die MySQL-Abhängigkeitsdefinition haben, können wir die Datenbankverbindung in der Datei application.properties konfigurieren :

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

3. Entitätsklasse

In Spring Data JPA repräsentiert eine Entität eine in einer Datenbank gespeicherte Tabelle. Daher können wir eine Entitätsklasse erstellen, um die Fahrzeugdatenbanktabelle abzubilden :

@Entity public class Car { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column private long id; @Column private String model; @Column private Integer year; // standard getters and setters }

4. Erstellung gespeicherter Prozeduren

Eine gespeicherte Prozedur kann Parameter haben, so dass wir basierend auf der Eingabe unterschiedliche Ergebnisse erhalten können. Zum Beispiel können wir eine gespeicherte Prozedur erstellen, die einen Eingabeparameter vom Typ Integer verwendet und eine Liste von Autos zurückgibt:

CREATE PROCEDURE FIND_CARS_AFTER_YEAR(IN year_in INT) BEGIN SELECT * FROM car WHERE year >= year_in ORDER BY year; END

Eine gespeicherte Prozedur kann auch Ausgabeparameter verwenden, um Daten an die aufrufenden Anwendungen zurückzugeben. Beispielsweise können wir eine gespeicherte Prozedur erstellen, die einen Eingabeparameter vom Typ Zeichenfolge verwendet und das Abfrageergebnis in einem Ausgabeparameter speichert:

CREATE PROCEDURE GET_TOTAL_CARS_BY_MODEL(IN model_in VARCHAR(50), OUT count_out INT) BEGIN SELECT COUNT(*) into count_out from car WHERE model = model_in; END

5. Referenz gespeicherte Prozeduren im Repository

In Spring Data JPA stellen wir in Repositorys Datenbankoperationen bereit. Daher können wir ein Repository für die Datenbankoperationen für die Car- Entität erstellen und gespeicherte Prozeduren in diesem Repository referenzieren:

@Repository public interface CarRepository extends JpaRepository { // ... } 

Als nächstes fügen wir unserem Repository einige Methoden hinzu, die gespeicherte Prozeduren aufrufen.

5.1. Ordnen Sie einen Namen für gespeicherte Prozeduren direkt zu

Wir können eine Methode für gespeicherte Prozeduren mithilfe der Annotation @Procedure definieren und den Namen der gespeicherten Prozedur direkt zuordnen .

Dafür gibt es vier gleichwertige Möglichkeiten. Zum Beispiel können wir den Namen der gespeicherten Prozedur direkt als Methodennamen verwenden:

@Procedure int GET_TOTAL_CARS_BY_MODEL(String model); 

Wenn wir einen anderen Methodennamen definieren möchten, können wir den Namen der gespeicherten Prozedur als Element der Annotation @Procedure einfügen :

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

Wir können auch das Attribut procedureName verwenden , um den Namen der gespeicherten Prozedur zuzuordnen:

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

In ähnlicher Weise können wir das value- Attribut verwenden, um den Namen der gespeicherten Prozedur zuzuordnen:

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

5.2. Verweisen Sie auf eine in Entität definierte gespeicherte Prozedur

Wir können auch die Annotation @NamedStoredProcedureQuery verwenden , um eine gespeicherte Prozedur in der Entitätsklasse zu definieren:

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

Dann können wir auf diese Definition im Repository verweisen:

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

Wir verwenden das Attribut name , um auf die in der Entitätsklasse definierte gespeicherte Prozedur zu verweisen. Für die Repository-Methode verwenden wir @Param , um den Eingabeparameter der gespeicherten Prozedur abzugleichen . Außerdem passen wir den Ausgabeparameter der gespeicherten Prozedur an den Rückgabewert der Repository-Methode an.

5.3. Verweisen Sie mit @Query Annotation auf eine gespeicherte Prozedur

Wir können eine gespeicherte Prozedur auch direkt mit der Annotation @Query aufrufen :

@Query(value = "CALL FIND_CARS_AFTER_YEAR(:year_in);", nativeQuery = true) List findCarsAfterYear(@Param("year_in") Integer year_in);

Bei dieser Methode verwenden wir eine native Abfrage, um die gespeicherte Prozedur aufzurufen. Wir speichern die Abfrage im value- Attribut der Annotation.

In ähnlicher Weise verwenden wir @Param , um den Eingabeparameter der gespeicherten Prozedur abzugleichen . Außerdem ordnen wir die Ausgabe der gespeicherten Prozedur der Liste der Entitäts- Car- Objekte zu.

6. Zusammenfassung

In diesem Tutorial haben wir gezeigt, wie Sie über JPA-Repositorys auf gespeicherte Prozeduren zugreifen können. Außerdem haben wir zwei einfache Möglichkeiten zum Verweisen auf die gespeicherten Prozeduren in JPA-Repositorys erörtert.

Wie immer ist der Quellcode für den Artikel auf GitHub verfügbar.