Wir haben im vorherigen Artikel eine einfache Springboot-Anwendung erstellt, mit der die Verwendung von Spring-DATA-JPA zum Betrieb der Datenbank eingeführt wird.
Erstellen Sie eine neue MySQL -Datenbank, in der die Datenbank als Springboot bezeichnet wird, und erstellen Sie eine Datei table user_info als Tabellenobjekt für unseren Beispieloperation.
Die Information von User_info lautet wie folgt:
Droptabelle, wenn existiert `user_info`; erstellen table` user_info` (`id` int (11) nicht null auto_increment,` username` varchar (255) Standardnull Null, `password` varchar (255) Standardnull, primärer Schlüssel (` id`)). -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nachdem die Datenbank und Tabellen erfolgreich erstellt wurden, kehren Sie zu unserem Projekt zurück
Schritt 0: Stellen Sie zunächst die Maven -Abhängigkeitspakete von MySQL und JPA vor:
<De vorhöhe> <gruppe> Mysql </Groupid> <artifactId> mysql-connector-java </artifactId> </abhängig> <depeaponcy> <GroupId> org.springframework
Der erste Schritt besteht darin, die Datenbankverbindungsinformationen in der YML -Konfigurationsdatei zu konfigurieren:
Frühling: DataSource: Treiberklassenname: com.mysql.jdbc.driver URL: JDBC: MySQL: // localhost: 3306/Springboot? UseUnicode = True & CharakterCoding = UTF-8 & USSSL = False Username: Root Passwort: 1011 JPA: SHOW-SQL: TRUE: TRUE: TRUE: TRUE: TRUE: TRUE: TRUE: TRUE: TRUE: TRUE: TRUE: TRUE.
Der zweite Schritt besteht darin, eine Entitätsklasse zu erstellen, die der Datentabellen -Entitätskarte entspricht:
package com.javazhiyin;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;/*** Created by 57783 on 2018/7/4.*/@Entitypublic class UserInfo { @Id @GeneratedValue(strategy = GenerationType.identity) Private Integer ID; privater String -Benutzername; privates Zeichenfolgenkennwort; public Integer getid () {return id; } public void setId (Integer id) {this.id = id; } public String getUnername () {return userername; } public void setUnername (String -Benutzername) {this.username = userername; } public String getPassword () {Kennwort zurückgeben; } public void setPassword (String -Passwort) {this.password = password; } public userInfo () {}}Der dritte Schritt besteht darin, eine Repository -Klasse zu erstellen und die JParepository -Klasse zu erben:
Paket com.javazhiyin; import org.springframework.data.jpa.repository.jparepository;/*** Erstellt von 57783 unter 2018/7/4.
Hier vererben wir die JParePository -Klasse, die einige grundlegende Methoden für Datenbankoperationen zusammenfasst. Überprüfen Sie, welche Methoden über den Quellcode in jarepository verfügbar sind:
///// Quellcode aus einer .class -Datei von Intellij idee // (Powered by Farnflower Decompiler) // Paket org.springframework.data.Repository; Java.util.Optional; var1); <S erweitert t> iterable <s> Saveall (iterable <s> var1); Optional <t> findById (id var1); boolean existbyId (id var1); Iterable <t> findAll (); Iterable <t> findAllById (iterable <Id> var1); Long Count (); void deletebyId (id var1); Hohlraum delete (t var1); void DeleteAll (iterable <? erweitert t> var1); void DeleteAll ();}
Schritt 4: Erstellen Sie einen neuen Controller, um den Betrieb des Hinzufügens, Löschens, Änderns und Überprüfens der Datenbank zu implementieren:
Paket com.javazhiyin; import org.springframework.bean.factory.annotation.autowired; UserInforePository userInforePository; /*** prüfen* @return*/@getmapping (value = "/list") publiclist <userInfo> getUserList () {return userInforePository.findall (); }/** * add * @param userername * @param password * @return */@postmapping (value = "/adduser") public userInfo adduser (@RequestParam ("userername") String -Benutzername, @RequestParam ("Passwort") Zeichenkennwort {userInfo user = new userinfo (); user.SetUnername (Benutzername); user.setPassword (Passwort); userInforePository.save (Benutzer) zurückgeben; }/** * ändern * @param id * @param userername * @param password * @return */@putmapping (value = "upduser/{id}") public userInfo upduser (@PathVariable ("id") Integer id, @RequestParam ("username") username, @Requestaram ("Passwort") {username, @Requestaram ("Passwort") {{username, @Requestaram ("Passwort"). UserInfo (); user.setId (id); user.SetUnername (Benutzername); user.setPassword (Passwort); userInforePository.save (Benutzer) zurückgeben; }/*** löschen* @param id*/@DeletMapping (value = "deluser/{id}") public void deluser (@PathVariable ("id") Integer id) {userInfo user = new userInfo (); user.setId (id); userInforePository.delete (Benutzer); }}Um den obigen Code zu testen, verwenden wir Postman, um ihn zu testen, was sehr bequem ist:
Abfragetest:
Neue Tests:
Ändern Sie den Test:
Den Test löschen:
Wir können sehen, dass alle Tests bestanden werden können. Springboot verwendet Spring-DATA-JPA, um die Vorgänge hinzuzufügen, zu löschen, zu ändern und zu überprüfen.
Mehrere Fragen:
1. Was ist das Konzept und die Verwendung von Annotation @generatedValue in der Mapping -Klasse für Objektentität?
JPA verlangt, dass jede Entitätsentität einen Primärschlüssel haben muss und nur einen Primärschlüssel hat, und die @generatedValue -Annotation erzeugt einen einzigartig identifizierten Primärschlüssel für eine Entität.
JPA liefert vier Strategien für die wichtigste Schlüsselgenerierung, die in der Engagement der Aufzählungsklassen generell definiert sind, nämlich:
GenerationType.table
Verwenden Sie eine bestimmte Datenbanktabelle, um den Primärschlüssel zu speichern, und die Persistenz -Engine generiert den Primärschlüssel über eine bestimmte Tabelle in der relationalen Datenbank. Der Vorteil dieser Strategie besteht darin, dass sie nicht von der spezifischen Implementierung der externen Umgebung und Datenbank abhängt und leicht zwischen verschiedenen Datenbanken portiert werden kann. Da es jedoch die Eigenschaften der Datenbank nicht vollständig verwenden kann, wird sie nicht zuerst verwendet.
GenerationType. Sequenz
Das Selbstwachstum des Hauptschlüssels wird in einigen Datenbanken wie Oracle nicht unterstützt. Es bietet einen Mechanismus, der als "Sequenz" bezeichnet wird, um Primärschlüssel zu erzeugen. Zu diesem Zeitpunkt kann GenerationType.Sequence als Richtlinien für die Hauptschlüsselerzeugung verwendet werden. Die Mängel dieser Strategie sind genau das Gegenteil der Tabelle. Da nur einige Datenbanken (Oracle, PostgreSQL, DB2) Sequenzobjekte unterstützen, wird diese Strategie im Allgemeinen nicht auf andere Datenbanken angewendet.
GenerationType.identity
Primärschlüssel-Selbstwachstumstrategie. Wenn die Datenbank Daten einfügt, wird dem Primärschlüssel automatisch Werte zugewiesen. Beispielsweise kann MySQL beim Erstellen einer Tabelle "auto_increment" deklarieren, um das Selbstwachstum des Primärschlüssels anzugeben. Diese Richtlinie wird in den meisten Datenbanken unterstützt (angegebene Methoden oder Schlüsselwörter können unterschiedlich sein), aber es gibt immer noch einige Datenbanken, die sie nicht unterstützen, daher ist sie etwas weniger tragbar.
GenerationType.auto
Überlassen Sie die Strategie der wichtigsten Schlüsselgenerierung der Persistenzmotor. Die Persistenz -Engine wählt eine der oben genannten drei Hauptstrategien zur Erzeugung der Hauptschlüssel aus, die auf der Datenbank basieren. Diese Strategie für die wichtigste Schlüsselgenerierung wird häufiger angewendet. Da die Strategie zur Standardgenerierung von JPA GenerationType.auto ist, können Sie @generatedValue (Strategy = GenerationType.auto) explizit angeben, wenn Sie diese Strategie oder @generatedValue direkt verwenden.
2. Welche Schnittstellen bietet Spring Data JPA und welche Funktionen können implementiert werden?
Der Quellcode, der in diesem Artikel ausgeführt werden kann: https://github.com/javazhiyin/springboot/tree/master/bootdemo_01
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.