Über Federdaten
Ein Top-Projekt in der Frühjahrsgemeinschaft wird hauptsächlich zur Vereinfachung von Daten (relationaler und nicht-relationaler) Zugriff verwendet. Wenn wir Springdaten verwenden, um Programme zu entwickeln, können wir viele Datenzugriffsvorgänge auf niedriger Ebene sparen, z. B. das Schreiben von Datenabfrageanweisungen, DAO-Klassen usw. Wir müssen nur einige abstrakte Schnittstellen schreiben und verwandte Operationen definieren. Spring erstellt Proxy -Instanzen während des Betriebs, um die in unserer Schnittstelle definierten Vorgänge zu implementieren.
Über Frühlingsdaten -Unterprojekt
Federdaten haben viele Unterprojekte, zusätzlich zu den Federdaten JPA gibt es auch die folgenden Unterprojekte.
Spring Data Commons
Federdaten MongoDB
Federdaten Redis
Federdaten Solr
Federdaten Gemfire
Federdaten ruhen
Federdaten Neo4j
Über Frühlingsdaten JPA
Spring Data JPA ist ein Unterprojekt von Federdaten. Es wird hauptsächlich verwendet, um die Implementierung der Datenzugriffsschicht zu vereinfachen. Mit Spring Data JPA können Sie die Addition, Löschung, Änderung, Pagination, Sortierung usw. problemlos implementieren.
Beispiel, Spring Boot + Spring Data JPA
1. Fügen Sie die Datei pom.xml hinzufügen
Wie unten gezeigt:
<? XSI: Schemalocation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion> 4.0.0 </modelversion> <gruppe> com.example; <version> 0.0.1-Snapshot </Version> <Packages> jar </packaging> <name> Spring-data-jpa-exampel </name> <beschreibung> Demo-Projekt für Spring-Boot </Beschreibung> <in <Stupes> org.springFramework.boot </GroupId> <artifactid> Spring-boot-starter-parent </artifactid> </ten-boot-starter-parent </artifactId> </ten-boot-starter-parent </artifactId> </boot-starter-parent </artifactId> </boot-starter-parent </artifactId> </boot-starter-parent </artifactid> i. <RelativePath/> <!-SOOKUP PORTER aus Repository-> </übergeordnet> <properties> <project.build.sourceEncoding> utf-8 </project.build.SourceCoding> <projekts.Reporting.outputcode> utf-8 </project.Reporting.Outputation> <java.Version> 1.7 </proportieren.-Worts.Outputation> <java.version> <Version.version.version> <java.Version> <Version.version> <java.Version> <Version.version> <java.Version> <Version> <java.version> <Version> <Version> <Version> <Version> </properties> <depeopcies> <depeopecy> <GroupId> org.springFramework.boot </GroupId> <artifactId> Spring-Boot-Starter-Data-jpa </artifactId> </abhängig> <De vorangehen </abhängig> <depeopecy> <GroupId> org.springFramework <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> </dependencies> <build> <plugins> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
Unter ihnen lädt Spring-Boot-Starter-Elternteil alle Standardkonfigurationen, die von der Spring-Boot-Anwendung erforderlich sind.
Spring-Boot-Starter-Data-JPA lädt alle Abhängigkeiten herunter, die von Frühlingsdaten JPA erforderlich sind.
Fügen Sie Spring-Boot-Starter-Web hinzu, da unser Projekt eine Webanwendung ist.
Darüber hinaus ist unsere Datenbank MySQL, daher ist MySQL-Connector-Java-Abhängigkeit erforderlich.
Da Cache verwendet wird, fügen Sie eine weitere Spring-Boot-Starter-Cache-Abhängigkeit hinzu.
2. Benutzer schreiben
Paket com.example.domain; import java.io.serializable; import Javax.Persistence.Column; import Javax.Persistence.Entity; Import Javax.Persistence.id; Id; Javax.Persistence.namedQuery; Benutzer implementiert serialisierbar {private statische endgültige lange Serialversionuid = 1L; @Id Long ID; @Column (name = "name") String -Name; @Column (name = "adresce") String -Adresse; 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; } public String getAddress () {Rückgabeadresse; } public void setAddress (String -Adresse) {this.address = address; }}Es gibt nichts anderes zu sagen. Achten Sie hier auf die @NamedQuery Annotation. Es bedeutet grob, dass die FindByName -Methode, die wir in der Repository -Schnittstelle definieren, nicht die Standardabfrage -Implementierung verwendet, sondern diese benutzerdefinierte Abfrageanweisung zur Abfrage verwendet. Wenn hier keine Annotation vorliegt, wird die Standardimplementierung verwendet.
3. Schreiben Sie die Repository -Schnittstelle
Hier schreiben wir zwei Repository -Schnittstellen, die nur für Beispiele verwendet werden, und können in der Praxis zu einem zusammengeführt werden:
UserJarePository
Paket com.example.Repository; import org.springframework.data.jpa.repository.jparepository; importieren com.example.domain.user; öffentliche Schnittstelle UserJarePository erweitert JParepository <Benutzer, Long> {}Die Benutzeroberfläche userJParePository implementiert die JarePository -Schnittstelle.
Tatsächlich implementiert JParePository die PagagingandSortingRepository -Schnittstelle, die PagagingandSortingRepository -Schnittstelle implementiert die Crudrepository -Schnittstelle, und die Crrudrepository -Schnittstelle implementiert die Repository -Schnittstelle.
Eine kurze Erklärung:
Die Repository -Schnittstelle ist eine Identifikationsschnittstelle und im Inneren leer.
Die Crudrepository -Schnittstelle definiert die Methoden zum Hinzufügen, Löschen, Ändern und Durchsuchen.
Die PagagingandSortingRepository -Schnittstelle wird zum Paging und Sortieren verwendet.
Da die JarePository -Schnittstelle alle oben genannten Schnittstellen erbt, werden alle von ihnen deklarierten Methoden angegeben.
Beachten Sie auch, dass die JParePository -Schnittstelle die Liste, PagagingandSortingRepository und Crudrepository -Return -Iterator, die FindAll -Methode als Beispiel einnehmen;
UserRepository
paket com.example.repository; import java.util.list; import org. UserRepository erweitert Repository <Benutzer, long> {list <Unter> findBynameAnDAddress (String -Name, String -Adresse); @Query (value = "von Benutzer u wobei u.Name =: name") list <Bener> findByName1 (@param ("Name") String -Name); @Query (value = "aus #{ #enttityName} u wobei u.name =? 1", nativeQuery = true) LIST <KUSNER> FINDBYNAME2 (STRING -NAME); LISTE <Bener> FindByName (String -Name);}Die UserRepository -Schnittstelle hier definiert hauptsächlich einige Abfragemethoden.
Zum Beispiel können wir hier direkt ausführen, ohne andere Abfrageanweisungen zu definieren. Spring Data JPA implementiert die Methode automatisch basierend auf dem Attributnamen und dem Methodennamen der Entitätsklasse. PS: Da wir die @NamedQuery -Annotation in der Entitätsklasse deklarieren, wird die FindByName -Methode tatsächlich die von der Annotation @NamedQuery annotierte Abfrageanweisung verwenden.
Darüber hinaus verwendet die FindByName1 -Methode hier eine HQL -Anweisung -Abfrage.
Die FindByName2 -Methode verwendet die ursprüngliche SQL -Anweisung -Abfrage.
4. Schreiben Sie Dienst
Serviceschnittstelle:
paket com.example.service; import java.util.list; import com.example.domain.user; public interface iuserService {public list <Unter> findAll (); public void SaveUser (Benutzerbuch); Public User FindOne (Long ID); öffentliche Leere Delete (Long ID); public list <Nutzern> findByName (String -Name);}Schnittstellen -Implementierungsklasse:
paket com.example.service.impl; import java.util.list; import org.springframework.bean.factory.Annotation.autowired; com.example.domain.User;import com.example.repository.UserRepository;import com.example.repository.UserJpaRepository;import com.example.service.IUserService;@Service@Transactionalpublic class UserServiceImpl implements IUserService{ @Autowired private UserJpaRepository userJpaRepository; @Autowired Private userrepository userrepository; public list <user> findAll () {userjParePository.findall () zurückgeben; } public List <Bener> findByName (String -Name) {List <Unter> userList1 = userRepository.findByName1 (Name); LIST <BENE> userList2 = userRepository.findByName2 (Name); LIST <BENE> userList3 = userrepository.findbynamandaddress (Name, 3 "); System.out.println ("userList1:" + userList1); System.out.println ("userList2:" + userList2); System.out.println ("userList3:" + userList3); userRepository.FindByName (Name) zurückgeben; } public void SaveUser (Benutzerbuch) {userJParePository.save (Buch); } @Cacheable ("Benutzer") öffentlicher Benutzer findOne (Long ID) {System.out.println ("zwischengespeicherte Seiten"); userJParePository.Findone (ID) zurückgeben; } public void delete (long id) {userJParePository.delete (id); }}Darüber gibt es nichts zu sagen. Rufen Sie einfach die Repository -Schnittstellenmethode an.
5. Schreiben Sie Controller
Über den Controller gibt es nichts zu sagen. Rufen Sie einfach Dienst an. Beachten Sie, dass der Controller hier mit der @restController -Annotation und dem URL -Pfadnamen nach dem erholsamen Stil bezeichnet wird.
paket com.example.web; import java.util.list; import org.springframework.beans.factory.annotation.autowired; import org.springframework.web.bind.annotation org.springframework.web.bind.annotation.restcontroller; import com.example.domain.user; importieren com.example.service.iuserservice;@rastcontroller@requestMapPing (value = "/user") öffentlicher usercontroller {@autoWered privat iusserservice userervice; @RequestMapPing (value = "/add/{id}/{name}/{address}") public user adduser (@PathVariable int id, @PathVariable String Name, @PathVariable String -Adresse) {user user = new user (); user.setId (id); user.setName (name); user.setAddress (Adresse); UserService.Saveuser (Benutzer); Benutzer zurückgeben; } @RequestMapping (value = "/delete/{id}") public void DeleteBook (@PathVariable int id) {UserService.delete (id); } @RequestMapping (value = "/") publiclist <Unter> getBooks () {return userService.findall (); } @RequestMapping (value = "/{id}") public User getUser (@PathVariable int id) {user user = userService.findone (id); Benutzer zurückgeben; } @RequestMapPing (value = "/search/name/{name}") publiclist <Unter> getBookByName (@PathVariable String -Name) {list <Unter> user> userService.findByName (Name); Rückkehrbenutzer; }}6. DataSource konfigurieren
Fügen Sie der Datei application.Properties die folgende Konfiguration hinzu:
spring.jpa.show-sql = Truelogging.Level.org.springframework.data = debugpring.jpa.hibernate.ddl-auto = spring.datasource.url = jdbc: mysql: // localhost: 33 06/Demospring.datasource.username = rootspring.datasource.password = rootspring.dataSource.Driver-Class-Name = com.mysql.jdbc.driver
Wenn Sie STS IDE verwenden, werden diese Attributkonfigurationen automatisch aufgefordert, sodass Sie die Suche speichern können.
Wenn Sie die Konfiguration von Spring.DataSource anzeigen möchten, können Sie sich auf diese Klasse beziehen: DataSourceProperties.java
7. Schreiben Sie eine Start -up -Klasse
Es ist relativ einfach. Beachten Sie, dass die Paketebene, zu der diese Klasse gehört, größer oder gleich anderer Klassen sein sollte, um sicherzustellen, dass die Anmerkungen anderer Klassen gescannt werden können.
Paket com.example; import org.springframework.boot.springapplication; import org.springframework void main (String [] args) {SpringApplication.run (SpringDatajpaExampleApplication.class, Args); }}Das Programm ausführen und testen
Starten Sie die Hauptmethode oder geben Sie sie in ein JAR -Paket ein, um es auszuführen.
Geben Sie die folgende URL in den Browser ein und testen Sie sie:
http: // localhost: 8080/user/
http: // localhost: 8080/user/add/100/110/111
http: // localhost: 8080/user/delete/100
http: // localhost: 8080/user/2
http: // localhost: 8080/user/such/name/2
Programmquellcode
https://github.com/peterchenhdu/spring-data-jpa-example
Referenzen
http://docs.spring.io/spring-data/jpa/docs/1.11.0.release/reference/html/
http://javabeat.net/spring-data-jpa/
https://spring.io/guides/gs/caching/
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.