[JAVA] Ich habe das Spring Boot-Einführungshandbuch [Zugriff auf Daten mit JPA] ausprobiert.
Zweck
Für diejenigen, die mit der Arbeit an Spring Quickstart Guide fertig sind, diejenigen, die angefangen haben, Spring Boot zu lernen, und diejenigen, die eine Überprüfung durchführen möchten
Der Beamte ist ein beliebter Reiseführer, probieren Sie es aus! Ich werde mitteilen, was ich gelernt habe, indem ich tatsächlich an [Zugriff auf Daten mit JPA] gearbeitet habe (https://spring.io/guides/gs/accessing-data-jpa/).
Entwicklungsumgebung
Betriebssystem: macOS Mojave Version 10.14.6
Texteditor: Visual Studio Code (im Folgenden VSCode)
Java: 11.0.2
Klicken Sie hier, um eine Übersicht über die Kurzanleitung zu erhalten. Klicken Sie hier, um eine Übersicht über das Erstellen eines RESTful-Webdiensts zu erhalten. Klicken Sie hier, um eine Übersicht über den Verbrauch eines RESTful-Webdienstes zu erhalten.
1. Starten Sie das Spring Boot Projekt!
Greifen Sie zunächst auf spring initial izr zu.
- Klicken Sie auf die Schaltfläche ADD DEPENDENCIES (Abhängigkeiten hinzufügen), um "Spring Data JPA" und "H2 Database" hinzuzufügen.
** Spring Data JPA (Java Persistence API) ist eine API zum Speichern und Abrufen von Java-Objekten in der Datenbank (O / R-Zuordnung). ** **.
** H2 Database toha ist eine in Java standardmäßig bereitgestellte Datenbank. Wenn Sie es hier hinzufügen, ist dies praktisch, da kein separater Server wie MySQL eingerichtet werden muss. ** **.
2.Artifact, Name geändert in accessing-data-jpa.
3. Ändern Sie Java in 11.
Klicken Sie dann auf die Schaltfläche "GENERATE", um die Zip-Datei herunterzuladen.
Extrahieren Sie die heruntergeladene Zip-Datei und Sie können loslegen.
2. Code hinzufügen!
Öffnen Sie den vorherigen Ordner mit VS Code. Wir empfehlen, das Java Extension Pack für Erweiterungen zu installieren. Es wird gesagt, dass Sie es installieren sollten. (Nur für diejenigen, die nicht installiert haben)
Lassen Sie uns Customer.java erstellen!
Erstellen Sie eine Customer.java-Datei in src / main / java / com / example / accessingdatajpa /.
Wir werden den Code in die Datei Customer.java einfügen.
Customer.java
package com.example.accessingdatajpa;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Customer {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private Long id;
private String firstName;
private String lastName;
protected Customer() {}
public Customer(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
@Override
public String toString() {
return String.format(
"Customer[id=%d, firstName='%s', lastName='%s']",
id, firstName, lastName);
}
public Long getId() {
return id;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
}
Wir werden uns eingehender mit dem Code befassen, den wir der Datei Customer.java hinzugefügt haben.
①@Entity
Customer.java
@Entity
public class Customer {
//Kürzung
}
Die Annotation "@ Entity" ist eine Klasse, die einer DB-Tabelle (Entitätsklasse) zugeordnet ist. In dieser Entitätsklasse definierte Variablen sind DB-Spalten zugeordnet.
@ @ Id,@GeneratedValue (Strategie = GenerationType.AUTO), Konstruktor
Customer.java
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private Long id;
private String firstName;
private String lastName;
protected Customer() {}
public Customer(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
In der Annotation "@ Id" wird die zugewiesene Variable zum Primärschlüssel der Tabelle. Mit der Annotation "@GeneratedValue (Strategy = GenerationType.AUTO)" werden IDs automatisch mit Seriennummern generiert.
In dieser Kundentabelle lautet der Primärschlüssel id, und die anderen Spalten haben Vorname und Nachname.
Als Anforderung der Entitätsklasse ist ein Konstruktor ohne Argumente erforderlich. Definieren Sie daher einen Konstruktor ohne Argumente. Ein Konstruktor mit Argumenten ist definiert, um eine Instanz zu erstellen, die in der Datenbank gespeichert werden soll.
③ Definition der toString-Methode und der Getter-Methode
Customer.java
@Override
public String toString() {
return String.format(
"Customer[id=%d, firstName='%s', lastName='%s']",
id, firstName, lastName);
}
public Long getId() {
return id;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
Die toString-Methode ist eine Methode, die eine Zeichenfolgendarstellung zurückgibt, wie sie in der Klasse java.lang.Object definiert ist.
Die Annotation @ Override überschreibt die in derObject-Klasse mit dieser Klasse definierte toString-Methode. Es ist eine Anmerkung, umanzugeben.
Wenn es nicht richtig überschrieben wird, tritt ein Fehler auf. Wenn Sie also einen Tippfehler wie "toStrign ()" machen, tritt beim Kompilieren ein Fehler auf, der Sie darüber informiert.
Dieses Mal überschreibe ich eine Methode, die eine Zeichenfolge zurückgibt, um ID, Vorname und Nachname anzuzeigen.
Wenn Sie die Methode String.format verwenden, müssen Sie das angegebene Format als erstes Argument angeben % s gibt eine Zeichenfolge an und% d gibt eine dezimale Ganzzahl und ein Format an.
Danach definieren wir eine Getter-Methode, um jede Variable abzurufen.
Lassen Sie uns CustomerRepository.java erstellen!
Erstellen Sie eine CustomerRepository.java-Datei in src / main / java / com / example / accessingdatajpa /.
Wir werden Code in die Datei CustomerRepository.java einfügen.
CustomerRepository.java
package com.example.accessingdatajpa;
import java.util.List;
import org.springframework.data.repository.CrudRepository;
public interface CustomerRepository extends CrudRepository<Customer, Long> {
List<Customer> findByLastName(String lastName);
Customer findById(long id);
}
Wir werden uns eingehender mit dem Code befassen, den wir der Datei CustomerRepository.java hinzugefügt haben.
① Erstellen Sie eine Repository-Schnittstelle
CustomerRepository.java
public interface CustomerRepository extends CrudRepository<Customer, Long> {
//Kürzung
}
Ich erstelle eine Schnittstelle namens CustomerRepository. Zu diesem Zeitpunkt erbt es eine Schnittstelle namens Crud Repository. `Die CrudRepository-Schnittstelle gibt Customer, den Typ der Entität, und Long, den Typ der ID, als generische Parameter an. ``
Die CrudRepository-Schnittstelle ist eine Schnittstelle, über die Sie Vorgänge wie Erstellen, Lesen, Aktualisieren und Löschen (CRUD) ausführen können. Daher kann die Customer Repository-Schnittstelle auch die oben genannten Vorgänge ausführen.
② Implementierung der Methode
CustomerRepository.java
List<Customer> findByLastName(String lastName);
Customer findById(long id);
In Spring Data JPA werden findBy 〇〇 und eine Methode, die eine bestimmte Namensregel erfüllt als ** Abfragemethoden basierend auf ihrem Inhalt definiert. ** **.
Dieses Mal gilt "findByLastName (String lastName)". Es ist eine Methode, mit der alle Daten abgerufen werden können, die mit dem als Argument empfangenen Nachnamen übereinstimmen. findById (lange ID) ist eine Methode, mit der Daten abgerufen werden können, die einer bestimmten ID entsprechen.
Lassen Sie uns AccessingDataJpaApplication.java bearbeiten!
Ich denke, der Standardzustand ist wie folgt.
AccessingDataJpaApplication.java
package com.example.accessingdatajpa;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class AccessingDataJpaApplication {
public static void main(String[] args) {
SpringApplication.run(AccessingDataJpaApplication.class, args);
}
}
Fügen Sie den Code hinzu, während Sie sich auf die Formel beziehen.
AccessingDataJpaApplication.java
package com.example.accessingdatajpa;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//Code hinzugefügt
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class AccessingDataJpaApplication {
//Code hinzugefügt
private static final Logger log = LoggerFactory.getLogger(AccessingDataJpaApplication.class);
public static void main(String[] args) {
SpringApplication.run(AccessingDataJpaApplication.class);
}
//Code hinzugefügt
@Bean
public CommandLineRunner demo(CustomerRepository repository) {
return (args) -> {
// save a few customers
repository.save(new Customer("Jack", "Bauer"));
repository.save(new Customer("Chloe", "O'Brian"));
repository.save(new Customer("Kim", "Bauer"));
repository.save(new Customer("David", "Palmer"));
repository.save(new Customer("Michelle", "Dessler"));
// fetch all customers
log.info("Customers found with findAll():");
log.info("-------------------------------");
for (Customer customer : repository.findAll()) {
log.info(customer.toString());
}
log.info("");
// fetch an individual customer by ID
Customer customer = repository.findById(1L);
log.info("Customer found with findById(1L):");
log.info("--------------------------------");
log.info(customer.toString());
log.info("");
// fetch customers by last name
log.info("Customer found with findByLastName('Bauer'):");
log.info("--------------------------------------------");
repository.findByLastName("Bauer").forEach(bauer -> {
log.info(bauer.toString());
});
// for (Customer bauer : repository.findByLastName("Bauer")) {
// log.info(bauer.toString());
// }
log.info("");
};
}
}
Wir werden uns eingehender mit dem Code befassen, den wir der Datei AccessingDataJpaApplication.java hinzugefügt haben.
① Protokoll für Protokollausgabe
AccessingDataJpaApplication.java
//Code hinzugefügt
private static final Logger log = LoggerFactory.getLogger(AccessingDataJpaApplication.class);
Logger und LoggerFactory werden verwendet, um das Protokoll im Terminal anzuzeigen. Sie können das Protokoll abrufen, indem Sie die Klasse im Argument "LoggerFactory.getLogger ()" angeben.
② Datenregistrierung und -erfassung
AccessingDataJpaApplication.java
//Code hinzugefügt
@Bean
public CommandLineRunner demo(CustomerRepository repository) {
return (args) -> {
// save a few customers
repository.save(new Customer("Jack", "Bauer"));
repository.save(new Customer("Chloe", "O'Brian"));
repository.save(new Customer("Kim", "Bauer"));
repository.save(new Customer("David", "Palmer"));
repository.save(new Customer("Michelle", "Dessler"));
// fetch all customers
log.info("Customers found with findAll():");
log.info("-------------------------------");
for (Customer customer : repository.findAll()) {
log.info(customer.toString());
}
log.info("");
// fetch an individual customer by ID
Customer customer = repository.findById(1L);
log.info("Customer found with findById(1L):");
log.info("--------------------------------");
log.info(customer.toString());
log.info("");
// fetch customers by last name
log.info("Customer found with findByLastName('Bauer'):");
log.info("--------------------------------------------");
repository.findByLastName("Bauer").forEach(bauer -> {
log.info(bauer.toString());
});
// for (Customer bauer : repository.findByLastName("Bauer")) {
// log.info(bauer.toString());
// }
log.info("");
};
}
Registrieren und Erfassen von Daten Die Methode "CommandLineRunner-Demo (CustomerRepository-Repository)" wird von Spring Boot aufgerufen, nachdem die Anwendung ausgeführt wurde.
Zunächst registrieren wir Daten. Beim Instanziieren eines Kunden übergeben wir eine Zeichenfolge (Vorname, Nachname) als Argument an den Konstruktor. Anschließend wird das generierte Java-Objekt von der Speichermethode des Repositorys in der Kundentabelle registriert.
python
repository.save(new Customer("Jack", "Bauer"));
Als nächstes erhalte ich alle Daten mit findAll ().
Die erweiterte for-Anweisung dreht die Schleife, empfängt mehrere erfasste Daten mit dem Argument customer und gibt sie einzeln aus.
Ich verwende bei der Ausgabe das überschriebene toString ().
python
for (Customer customer : repository.findAll()) {
log.info(customer.toString());
}
Als nächstes werden die Daten mit der ID 1 von findById (1L) erfasst. Da dies nur bestimmte Daten erfassen kann, werden diese ohne Schleife ausgegeben.
python
// fetch an individual customer by ID
Customer customer = repository.findById(1L);
log.info(customer.toString());
Schließlich erhalten wir mit findByLastName ("Bauer") die Daten mit dem Wert von lastName Bauer.
Es kann mehr als eine dieser Daten geben, daher wurde sie als Empfangstyp definiert.
Die erfassten Mehrfachdaten werden von der forEach-Anweisung, vom Argument bauer empfangen und einzeln ausgegeben. Ich denke, dass die auskommentierte erweiterte for-Anweisung auf diese Weise geschrieben werden kann.
python
// fetch customers by last name
repository.findByLastName("Bauer").forEach(bauer -> {
log.info(bauer.toString());
});
// for (Customer bauer : repository.findByLastName("Bauer")) {
// log.info(bauer.toString());
// }
3. Lass es uns laufen!
Nachdem die Anwendung nun ausgeführt werden kann, überprüfen wir sie.
Geben Sie den folgenden Befehl in das Terminal ein und drücken Sie die Eingabetaste.
Terminal
$ ./mvnw spring-boot:run
Nach einer Weile erscheinen die folgenden Zeichen im Terminal.
Terminal
Customers found with findAll():
-------------------------------
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=2, firstName='Chloe', lastName='O'Brian']
Customer[id=3, firstName='Kim', lastName='Bauer']
Customer[id=4, firstName='David', lastName='Palmer']
Customer[id=5, firstName='Michelle', lastName='Dessler']
Customer found with findById(1L):
--------------------------------
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer found with findByLastName('Bauer'):
--------------------------------------------
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=3, firstName='Kim', lastName='Bauer']
Referenzseite
** Als Grundlage für JPA-bezogene Anmerkungen - Teil 1- ** ** Anforderungen an Entitätsklassen ** CrudRepository ** [Spring Data JPA] Namensregeln für automatisch implementierte Methoden **