Java >> Java Tutorial >  >> Tag >> Spring

Spring Data JPA Tutorial:Abrufen der erforderlichen Abhängigkeiten

Spring

Bevor wir eine Anwendung erstellen können, die Spring Data JPA verwendet, müssen wir die erforderlichen Abhängigkeiten abrufen.

Dieser Blogbeitrag identifiziert die erforderlichen Komponenten und beschreibt, wie wir sie mithilfe von Maven erhalten können.

Fangen wir an.

Welche Komponenten brauchen wir?

Wenn wir eine Persistenzschicht implementieren möchten, die Spring Data JPA verwendet, benötigen wir die folgenden Komponenten:

  • Der JDBC-Treiber bietet eine datenbankspezifische Implementierung der JDBC-API. Wir verwenden die In-Memory-Datenbank von H2, weil sie unsere Beispielanwendung einfacher auszuführen macht.
  • Die Datenquelle stellt Datenbankverbindungen zu unserer Anwendung bereit. Wir verwenden die HikariCP-Datenquelle, weil sie die schnellste Datenquelle auf diesem Planeten ist.
  • Der JPA-Anbieter implementiert die Java-Persistenz-API. Wir verwenden Hibernate, weil es der gebräuchlichste JPA-Anbieter ist.
  • Spring Data JPA verbirgt den verwendeten JPA-Provider hinter seiner Repository-Abstraktion.

Lassen Sie uns weitermachen und herausfinden, wie wir die erforderlichen Abhängigkeiten mit Maven erhalten können.

Erforderliche Abhängigkeiten mit Maven erhalten

Wir können die erforderlichen Abhängigkeiten mit Maven erhalten, indem wir eine dieser Optionen verwenden:

  1. Wir können unsere Abhängigkeiten mithilfe der Spring IO-Plattform verwalten.
  2. Wir können unsere Abhängigkeiten "manuell" verwalten.

Sehen wir uns beide Optionen an.

Verwendung der Spring.IO-Plattform

Wenn wir die Spring IO-Plattform verwenden, müssen wir die folgenden Schritte ausführen:

  1. Aktivieren Sie die Spring IO-Plattform.
  2. Konfigurieren Sie die erforderlichen Abhängigkeiten in der Datei pom.xml.

Zuerst , können wir die Spring IO-Plattform aktivieren, indem wir unserer POM-Datei den folgenden XML-Code hinzufügen:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.spring.platform</groupId>
            <artifactId>platform-bom</artifactId>
            <version>1.1.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Nachdem wir die Spring IO-Plattform aktiviert haben, müssen wir uns keine Gedanken mehr über Abhängigkeitsversionen machen, da sich die Spring IO-Plattform darum kümmert. Das bedeutet, dass wir die erforderlichen Abhängigkeiten erhalten können, indem wir den folgenden XML-Code zu den Abhängigkeiten hinzufügen Abschnitt unserer POM-Datei:

<!-- Database (H2) -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency>
        
<!-- DataSource (HikariCP) -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
</dependency>

<!-- JPA Provider (Hibernate) -->
<dependency>
	<groupId>org.hibernate</groupId>
	<artifactId>hibernate-entitymanager</artifactId>
</dependency>

<!-- Spring Data JPA -->
<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-jpa</artifactId>
</dependency>

Fahren wir fort und finden heraus, wie wir unsere Abhängigkeiten manuell verwalten können.

Manuelles Verwalten unserer Abhängigkeiten

Wenn wir unsere Abhängigkeiten "manuell" verwalten, müssen wir die Versionsnummern aller Abhängigkeiten angeben. Wir können dies tun, indem wir die folgenden Abhängigkeitsdeklarationen zu den Abhängigkeiten hinzufügen Abschnitt unserer pom.xml Datei:

<!-- Database (H2) -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
	<version>1.4.185</version>
</dependency>
        
<!-- DataSource (HikariCP) -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
	<version>2.2.5</version>
</dependency>

<!-- JPA Provider (Hibernate) -->
<dependency>
	<groupId>org.hibernate</groupId>
	<artifactId>hibernate-entitymanager</artifactId>
	<version>4.3.8.Final</version>
</dependency>

<!-- Spring Data JPA -->
<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-jpa</artifactId>
	<version>1.7.2.RELEASE</version>
</dependency>

Ich denke, die offensichtliche Frage ist:Welche Option sollten wir verwenden?

Was ist der beste Weg, um unsere Abhängigkeiten zu verwalten?

Wenn wir ein neues Projekt starten, sollten wir die Spring IO-Plattform verwenden, weil

  • Wir müssen uns keine Gedanken über die Abhängigkeitsversionen machen. Beispielsweise müssen wir uns keine Gedanken über Inkompatibilitätsprobleme machen, da wir wissen, dass unsere Abhängigkeiten wie ein Zauber zusammenarbeiten.
  • Wir können die von der Spring.IO-Plattform bereitgestellten Abhängigkeitsversionen jederzeit überschreiben.

Wenn wir andererseits Spring Data JPA zu einem bestehenden Projekt hinzufügen, ist es oft klüger, unsere Abhängigkeiten manuell zu verwalten, da dies weniger Arbeit erfordert.

Fahren wir fort und fassen zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogbeitrag hat uns vier Dinge gelehrt:

  • Wenn wir eine Persistenzschicht implementieren möchten, die Spring Data JPA verwendet, benötigen wir die folgenden Komponenten:einen JDBC-Treiber, eine Datenquelle, einen JPA-Anbieter und das Spring Data JPA.
  • Wir können die erforderlichen Abhängigkeiten erhalten, indem wir die Spring IO-Plattform verwenden oder unsere Abhängigkeiten manuell verwalten.
  • Wenn wir ein neues Projekt starten, sollten wir die Spring IO-Plattform verwenden, da sie sicherstellt, dass unsere Abhängigkeiten wie am Schnürchen zusammenarbeiten.
  • Wenn wir Spring Data JPA zu einem bestehenden Projekt hinzufügen, sollten wir unsere Abhängigkeiten manuell verwalten, da dies weniger Arbeit erfordert.

Der nächste Teil dieses Tutorials beschreibt, wie wir Spring Data JPA konfigurieren können.

P.S. Sie können die Beispielanwendung dieses Blogposts von Github herunterladen.


Java-Tag