Erstellen Sie mit Spring Boot und JPA eine ORM-basierte Datenzugriffsschicht

In der modernen Anwendungsentwicklung spielt die Datenzugriffsschicht eine Schlüsselrolle als Brücke zwischen der Anwendung und der Datenbank. ORM (Object Relational Mapping) ist zu einer wichtigen Technologie geworden, um die Entwicklungseffizienz der Datenzugriffsschicht zu verbessern und die Datenbankprogrammierung zu vereinfachen. In diesem Artikel wird erläutert, wie Sie mit Spring Boot und JPA eine ORM-basierte Datenzugriffsschicht erstellen.

1. Einführung

Spring Boot ist ein leichtes Java-Framework zum schnellen Erstellen von Webanwendungen. Es bietet viele praktische Funktionen wie automatische Konfiguration und schnelle Entwicklung. JPA (Java Persistence API) ist ein Java-ORM-Framework, das Java-Objekte Tabellen in einer relationalen Datenbank zuordnet. Mithilfe von Spring Boot und JPA können wir schnell und effizient eine ORM-basierte Datenzugriffsschicht aufbauen.

2. Konfigurationsabhängigkeiten

Spring Boot bietet viele Abhängigkeiten, um andere Frameworks einfach zu integrieren. Zuerst müssen wir die folgenden Abhängigkeiten im POM hinzufügen. Für die Verwendung des JPA-Frameworks wird „h2“ für die In-Memory-Datenbank verwendet, damit wir unsere Anwendungen schnell entwickeln und testen können.

3. Bevor wir JPA für den Datenzugriff verwenden, müssen wir Entitätsklassen erstellen, die den Datenbanktabellen entsprechen. Hier erstelle ich eine Entitätsklasse namens „Benutzer“, die einer Datenbanktabelle namens „Benutzer“ zugeordnet wird. Das Folgende ist der Code für die Entitätsklasse:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Im obigen Code wird die Annotation „@Entity“ verwendet, um die Java-Klasse der Entitätsklasse zuzuordnen, und die Annotation „@Table“ wird verwendet, um die entsprechende Tabelle anzugeben Namen in der Datenbank. Darüber hinaus wird die Annotation „@Id“ verwendet, um den Primärschlüssel der Entität zu identifizieren, und die Annotation „@GeneratedValue“ gibt die Generierungsstrategie des Primärschlüssels an.

Jetzt können wir eine Datenzugriffsschicht erstellen, um JPA für den Datenzugriff zu verwenden. Hier werde ich eine Schnittstelle namens „UserRepository“ erstellen, die die „CrudRepository“-Schnittstelle von Spring Data JPA erbt. Das Folgende ist der Code für „UserRepository“:

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String firstName;
    
    private String lastName;
    
    private String email;
    
    // getters and setters
}

Im obigen Code wird die Annotation „@Repository“ verwendet, um die Datenzugriffsschicht als Spring-Komponente zu identifizieren, und die Schnittstelle „CrudRepository“ stellt einige grundlegende CRUD-Operationen bereit (z Beispiel: Entität speichern, aktualisieren oder löschen).

Jetzt können wir die zuvor erstellte Datenzugriffsschicht in die Serviceschicht der Anwendung injizieren. Hier werde ich eine Klasse namens „UserService“ erstellen, die „UserRepository“ verwendet, um den Datenzugriff durchzuführen. Das Folgende ist der Code für „UserService“:

@Repository
public interface UserRepository extends CrudRepository<User, Long> {
    
}

Im obigen Code wird die Annotation „@Service“ verwendet, um die Serviceschicht als Spring-Komponente zu identifizieren, und die Annotation „@Autowired“ wird verwendet, um „UserRepository“ einzufügen. in „UserService“ für den Datenzugriff. Darüber hinaus ruft die Methode „getUsers“ mithilfe der Methode „findAll“ alle Benutzer aus der Datenbank ab, die Methode „saveUser“ speichert die Benutzer in der Datenbank und die Methode „deleteUsers“ löscht alle Benutzer.

Schließlich müssen wir eine Controller-Klasse schreiben, um die Serviceschicht als REST-API verfügbar zu machen. Hier werde ich eine Controller-Klasse namens „UserController“ erstellen, die „UserService“ zur Verarbeitung von HTTP-Anfragen verwendet. Das Folgende ist der Code für „UserController“:

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public Iterable<User> getUsers() {
        return userRepository.findAll();
    }
    
    public void saveUser(User user) {
        userRepository.save(user);
    }
    
    public void deleteUsers() {
        userRepository.deleteAll();
    }
}

Im obigen Code wird die Annotation „@RestController“ verwendet, um die Controller-Klasse als Spring MVC-Controller zu identifizieren, und die Annotation „@RequestMapping“ wird zum Zuordnen der Anforderung verwendet zur Controller-Klasse. Darüber hinaus ordnet die Methode „getUsers“ HTTP-GET-Anfragen dem Pfad „/users“ zu und ruft alle Benutzer mithilfe von „UserService“ ab. Die Methode „saveUser“ ordnet HTTP-POST-Anfragen dem Pfad „/users“ zu und speichert die Benutzer im Datenbank ordnet die Methode „deleteUsers“ die HTTP-DELETE-Anfrage dem Pfad „/users“ zu und löscht alle Benutzer aus der Datenbank.

7. In diesem Artikel haben wir vorgestellt, wie man mit Spring Boot und JPA eine ORM-basierte Datenzugriffsschicht erstellt. Durch die Erstellung von Entitätsklassen, Datenzugriffsschichten und Serviceschichten sowie deren Integration in Controller-Klassen können wir problemlos grundlegende CRUD-Operationen ausführen und Daten als REST-API verfügbar machen. Der Einsatz von ORM hat die Art und Weise der Datenbankprogrammierung verändert und die Entwicklungseffizienz verbessert.

Das obige ist der detaillierte Inhalt vonErstellen Sie mit Spring Boot und JPA eine ORM-basierte Datenzugriffsschicht. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!