Java-Repository

Im Java Spring Framework werden häufig JPA-basierte Repositorys verwendet. Diese Repositorys sind für die Verwaltung von Datenbankvorgängen von entscheidender Bedeutung und Teil des Spring Data JPA-Moduls. Repositorys definieren eine neue elegante Methode zum Speichern, Aktualisieren und Extrahieren der von JAVA-Anwendungen im Backend gespeicherten Daten. Alle CRUD-Vorgänge (Erstellen, Lesen, Aktualisieren und Löschen) können mithilfe einer Repository-Schnittstelle implementiert werden. JPA ist eine Abkürzung für JAVA Persistence API (Application Program Interface). Wie der Name schon sagt, hilft JPA dabei, die Java-Objekte in relationalen Datenbanken beizubehalten. Es gibt zwei Möglichkeiten, dies zu tun, und zwar:

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

1. Relationale Tabellen werden mithilfe von Zuordnungsklassen Subsystemen zugeordnet.
2. EntityManager-API.

In diesem Artikel lesen wir über Syntax und die Verwendung von JPA-Repositorys für CRUD-Operationen.

Syntax:

Sobald alle notwendigen Bibliotheken importiert und im Klassenpfad des Projekts mit Spring, Persistence-Objekten und Java EE verknüpft wurden, besteht der nächste Schritt darin, eine Schnittstelle zu erstellen, indem die „JpaRepository“-Schnittstelle erweitert wird. Dies ist eine Erweiterung der Repository-Bibliothek und enthält andere Repositorys wie CrudRepository und PagingAndSortingRepository sowie die Grundfunktionen von Repositorys.

Struktur:

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import net.guides.springboot.jparepository.model.Employee;
@Repository
public interface repositoryname extends JpaRepository<Parameter 1 column name, parameter 2 data type>
{
}
//Invocation of the interface created above.
private repositoryname RepositoryName;
@Override
//Different functions from JPA library to be used for enabling transactions with databases.
public void run(String…... arguments) throws Exception {
RepositoryName.save(new TableName("Data1", "Data2", "Data3"));
RepositoryName.save(new TableName("Data1", "Data2", "Data3"));
RepositoryName.save(new TableName("Data1", "Data2", "Data3"));
RepositoryName.save(new TableName("Data1", "Data2", "Data3"));
logger.info("number of elements in table now: {}", RepositoryName.count());

Wie funktioniert das JPA-Repository?

Diese Implementierungen sind entscheidend für die Ermöglichung der Persistenz in Web- oder Desktopanwendungen, die mit Java entwickelt wurden. Damit diese Schnittstellen funktionieren, müssen alle abhängigen Bibliotheken im Klassenpfad geladen werden. Sobald die Schnittstelle erstellt ist, werden Funktionen wie „save()“, „count()“, „info()“, „findAll()“, „sort()“ und andere verwendet, um die Datenabfrage durchzuführen oder erforderlich Datenmanipulation. Wir müssen eine Datenbank einrichten, um die Werte aus den Tabellen unten über eine Java-Anwendung einzufügen, zu aktualisieren oder zu löschen. Die Verwendung von Repositorys ermöglicht eine einfache Handhabung von Daten aus Datenbanken sowie sichere Transaktionen.

Beispiele für Java Repository

Die Implementierung eines JPA-Repositorys ist für Anfänger ein komplexes Zeitprojekt. Alle verknüpften Bibliotheken, JARs, Abhängigkeiten, Server-Setup und Datenbank-Setup sind Voraussetzungen.

Datei: pom.xml

Code: Dieser kann von https://start.spring.io heruntergeladen werden. Sie können eine Datei erstellen und diese herunterladen, nachdem Sie die Werte entsprechend Ihren System- und Anwendungsanforderungen ausgewählt haben.

Datei: UserControl.java

Code:

package test.controller;
import test.model.User
import test.repository.UserJpaRespository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/users")
public class UsersControl {
@Autowired
private UserJpaRespository userJpaRespository;
@GetMapping(value = "/all")
public List<User> findAll() {
return userJpaRespository.findAll();
}
@PostMapping(value = "/load")
public User load(@RequestBody final User users) {
userJpaRespository.save(users);
return userJpaRespository.findByName(users.getName());
}
}

Datei: User.java

Code:

package test.model
import test.controller;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
@Entity
public class User {
private Long id;
private String name;
@Id
@GeneratedValue
public Long getId() {
return id;}
public void setId(Long id) {
this.id = id;}
public String getName() {
return name;}
public void setName(String name) {
this.name = name;}
}

Datei: UserJPARepository.java

Code:

package test.repository;
import test.controller;
import package.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Component;
@Component
public interface UserJpaRespository extends JpaRepository<User, Long>{
}

Datei:Implementation.java

Code:

package test.implementation;
import static org.hamcrest.CoreMatchers.is;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import java.util.ArrayList;
import java.util.List;
import test.controller;
import org.junit.Before;
import org.junit.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import com.fasterxml.jackson.databind.ObjectMapper;
import test.model.user;
import com.fasterxml.jackson.databind.ObjectMapper;
import test.repository.UserJpaRespository;
@RunWith(SpringRunner.class)
public class Implementation {
private User user;
@MockBean
private UserJpaRespository userJpaRespository;
@Before
public void setUp()
{
user = new User();
user.setId(1l);
user.setName("Virat");
}
}

Ausgabe:

Hier wird der Wert in die Datenbank eingefügt.

Erklärung

Die erste Datei, „UserControl“, enthält Details zum Extrahieren oder Speichern der Werte mithilfe von JPA-Funktionen wie „@GetMapping()“ und „@PostMapping“, für deren Funktion einige Basisdateien erforderlich sind. Diese Unterstützungsdateien sind User.java und UserJPARepository.java.

Die Datei „User.java“ verwaltet die Struktur der Datenbank in Form von Java-Objekten und ermöglicht den Zugriff auf die Datenbank mithilfe von Java-Persistenzobjekten. Um mit der Arbeit am Projekt zu beginnen, müssen Sie die Datei „pom.xml“ mithilfe des bereitgestellten Quellcodes in Schritt 1 generieren. In der bereitgestellten Ausgabe ist die Datei „pom.xml“ für die Einrichtung aller für das Projekt erforderlichen Abhängigkeiten verantwortlich . Abhängigkeiten enthalten „Spring Framework“-bezogene Daten und Persistenzobjekt-bezogene Daten. Die Datei UserJPARepository.java ermöglicht die Initiierung eines JPA-Repositorys durch Erweiterung der integrierten Bibliothek JpaRepository.

Fazit

JPA-Repositorys sind sehr nützlich, da sie eine generische Plattform zum Erstellen von Abfragen in der JAVA-Sprache bieten, aber mit jeder darunter liegenden Datenbank verwendet werden können. Es reduziert die Anzahl der Codezeilen, indem es elegante Funktionen zur Ausführung der von Bibliotheken unterstützten Aufgaben bereitstellt. Es reduziert die Verwendung von „Boiler-Plate“-Code und verbessert so das Aussehen und die Geschwindigkeit der Ausführung.

Das obige ist der detaillierte Inhalt vonJava-Repository. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!