À propos des données de printemps
Un grand projet de la communauté printanière est principalement utilisé pour simplifier l'accès des données (relationnel et non relationnel). Si nous utilisons les données de printemps pour développer des programmes, nous pouvons enregistrer de nombreuses opérations d'accès aux données de bas niveau, telles que la rédaction d'instructions de requête de données, les classes DAO, etc. Nous n'avons qu'à rédiger des interfaces abstraites et de définir les opérations connexes. Spring créera des instances de proxy lors de l'opération pour implémenter les opérations définies dans notre interface.
À propos de Spring Data Subproject
Les données de printemps ont de nombreux sous-projets, en plus de Spring Data JPA, il existe également les sous-projets suivants.
Spring Data Commons
Données de printemps MongoDB
Redis de données de printemps
Spring Data Solr
GEMFIRE DE DONNÉES SPRING
Reste des données de printemps
Données de printemps Neo4j
À propos des données de printemps JPA
Les données de printemps JPA sont un sous-projet de données de printemps. Il est principalement utilisé pour simplifier la mise en œuvre de la couche d'accès aux données. À l'aide de Spring Data JPA, vous pouvez facilement implémenter l'ajout, la suppression, la modification, la pagination, le tri, etc.
Exemple, Spring Boot + Spring Data JPA
1. Ajouter un fichier pom.xml
Comme indiqué ci-dessous:
<? xml version = "1.0" Encoding = "utf-8"?> <project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" XSI: ScheMalation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <mackversion> 4.0.0 </ Modelversion> <proupid> com.example </ GroupId> <ArtifActid> Demo </ ArtiFact> Com.example </ GroupId> <ArtifActid> Demio </ Artiford> Com.example </ GroupId> <ArtifActid> Demo </ Artiford> COMM <version> 0.0.1-snapshot </ version> <packaging> jar </packaging> <name> printemp-data-jpa-example </name> <description> Project de démonstration pour le démarrage de Spring </cription> <parent> <proupId> org.springframework.boot </prandid> <artifactid> Spring-Boot-starter-Parent </ptifActid>> <version> 1.4. <LelativePath /> <! - Lookup Parent du référentiel -> </parent> <properties> <project.build.sourceencoding> utf-8 </project.build.sourceencoding> <project.reporting.outputencoding> utf-8 </project.reporting.outputending> <java.version> </properties> <Dependces> <Dependency> <GroupId> org.springframework.boot </proncId> <Ertifactive> printemps-boot-starter-data-jpa </lefactive> </pedigency> <dependency> <proupId> org.springframework.boot </prounid> <ArtifActid> Spring-boot-Starterweb </prounid> </Dependency> <Dedency> <ProupId> org.springframework.boot </proncId> <Artifactid> Spring-Boot-starter-test </ artifactid> <ccope> test </cope> </dEpendency> <Dedency> <ProupId> MySQL </prounid> </ artifactive> mysql-contector-java <GroupId> org.springframework.boot </proupId> <Artifactid> printemps-boot-starter-cache </ artifactid> </dependency> </peedences> <fuild> <glugins> <proupId> org.springframework.boot </proupatid> <prichactid> sprins-maven-plugin </ artifactid> </fuild> </propwe>
Parmi eux, Spring-Boot-Starter-Parent chargera toutes les configurations par défaut requises par l'application Spring Boot;
Spring-boot-starter-data-jpa téléchargera toutes les dépendances requises par Spring Data JPA;
Ajouter le spring-boot-starter-web car notre projet est une application Web;
De plus, notre base de données est MySQL, donc la dépendance MySQL-Connector-Java est également requise;
Étant donné que le cache est utilisé, ajoutez une autre dépendance à Spring-Boot-Starter-Cache;
2. Écrivez l'utilisateur de l'entité
package com.example.domain; importer java.io.serializable; import javax.persistence.column; importer javax.persistence.entity; import javax.persistence.id; import javax.persistence.namedquery; @ entité @ nameDery (nom = "user.findbyname", query = "SELECT NAD, Address from user u.name =? L'utilisateur implémente Serializable {private static final long SerialVersionUID = 1l; @Id long id; @Column (name = "name") String name; @Column (name = "Address") Adresse de chaîne; public long getID () {return id; } public void setid (long id) {this.id = id; } public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } public String getAddress () {return adresse; } public void setAddress (adresse de chaîne) {this.address = adresse; }}Il n'y a rien d'autre à dire. Faites attention à l'annotation @NameDquery ici. Cela signifie à peu près que la méthode FindByName que nous définissons dans l'interface du référentiel n'utilise pas l'implémentation de requête par défaut, mais utilise plutôt cette instruction de requête personnalisée pour interroger. S'il n'y a pas d'annotation ici, l'implémentation par défaut sera utilisée.
3. Écrivez l'interface du référentiel
Ici, nous rédigerons deux interfaces de référentiel, qui ne sont utilisées que pour des exemples, et peuvent être fusionnées en une dans la pratique:
UserjParepository
package com.example.repository; import org.springframework.data.jpa.repository.jParepository; import com.example.domain.user; interface publique userjParePository étend jParePository <user, long> {}L'interface UserJParePository implémente ici l'interface JParePository;
En fait, JParePository implémente l'interface PAGINGAndSortingRepository, l'interface PagingAndSortingRepository implémente l'interface CruDrepository et l'interface CruDrepository implémente l'interface du référentiel;
Une brève explication:
L'interface du référentiel est une interface d'identification, et elle est vide à l'intérieur;
L'interface CruDrepository définit les méthodes d'ajout, de supprimer, de modifier et de rechercher;
L'interface PAGINETANDSORTINGREPOSITORY est utilisée pour la pagination et le tri;
Étant donné que l'interface JParePository hérite de toutes les interfaces ci-dessus, il a toutes les méthodes déclarées par eux;
Notez également que la prise de la méthode Findall à titre d'exemple, la liste des renvoyages de l'interface JParePository, PagingandSortingRepository et CruDrePository Return Iterator;
UserRepository
package com.example.repository; import java.util.list; import org.springframework.data.jpa.repository.query; import org.springframework.data.repository.repository; import org.springframework.data.repository.query.param; import com.example.user; UserRepository étend le référentiel <utilisateur, long> {list <utilisateur> findByNameAndAddress (nom de chaîne, adresse de chaîne); @Query (valeur = "de l'utilisateur u où nous @Query (Value = "SELECT * FROM # {# EntityName} u où u.Name =? 1", nativeQuery = true) List <User> findByName2 (String Name); List <utilisateur> findByName (nom de chaîne);}L'interface UserRepository définit ici principalement certaines méthodes de requête;
Par exemple, nous pouvons exécuter directement sans définir d'autres instructions de requête ici. Spring Data JPA implémentera automatiquement la méthode en fonction du nom d'attribut et du nom de la méthode de la classe d'entité; PS: Puisque nous déclarons l'annotation @NameDquery dans la classe d'entité, en fait, la méthode FindByName utilisera la déclaration de requête annotée par l'annotation @NameDquery à la question;
De plus, la méthode FindByName1 ici utilise la requête de l'instruction HQL;
La méthode FindByName2 utilise la requête de l'instruction SQL d'origine;
4. Service d'écriture
Interface de service:
package com.example.service; import java.util.list; import com.example.domain.user; interface publique iuserservice {public list <serv> findall (); public void SaveUser (livre d'utilisateurs); utilisateur public findOne (Long ID); PUBLIC VOID DELETE (Long ID); Liste publique <User> findByName (nom de chaîne);}Classe d'implémentation d'interface:
package com.example.service.impl; importer java.util.list; import org.springframework.beans.factory.annotation.autowired; import org.springframework.cache.annotation.cacheable; import org.springframework.toryannotype.svice; import org.springframeworkwork.transaction.transaction.transaction; com.example.domain.user; import com.example.repository.userRepository; import com.example.repository.userjParepository; import com.example.service.iuserservice; @ service @ transactionalpublic class userserviceimpl impléments iUserService {@Autowired private jarepository userJPaSitory; @Autowired UserRepository privé UserRepository; public list <ser utilisateur> findall () {return userJParePository.Findall (); } public list <User> findByName (String name) {list <ser utilisateur> userList1 = userRepository.FindByName1 (name); List <ser user> userList2 = userRepository.FindByName2 (name); List <ser user> userList3 = userRepository.findByNameAndAddress (nom, "3"); System.out.println ("UserList1:" + UserList1); System.out.println ("UserList2:" + UserList2); System.out.println ("UserList3:" + UserList3); return userRepository.FindByName (name); } public void SaveUser (livre d'utilisateurs) {userJParePository.save (livre); } @Cacheable ("Users") Utilisateur public FindOne (Long ID) {System.out.println ("Pages mises en cache"); return userJParePository.FindOne (id); } public void Delete (Long ID) {UserJParePository.Delete (ID); }}Il n'y a rien à dire à ce sujet, appelez simplement la méthode d'interface du référentiel.
5. Écrivez le contrôleur
Il n'y a rien à dire sur le contrôleur, juste un service d'appel. Notez que le contrôleur ici est annoté à l'aide de l'annotation @RestController, et le nom du chemin d'URL est nommé selon le style Restful;
package com.example.web; import java.util.list; import org.springframework.beans.factory.annotation.autowired; import org.springframework.web.bind.annotation.pathvariable; import org.springframework.web.bind.annotation.requestmapping; import; org.springframework.web.bind.annotation.restController; import com.example.domain.user; import com.example.service.iuserservice; @ restController @ requestmapping (value = "/ users") public class userController {@Autowired private iuserserviceservice; @RequestMapping (value = "/ add / {id} / {name} / {adresse}") public utilisateur addUser (@pathvariable int id, @pathvariable string name, @pathvariable String Address) {user user = new user (); user.setid (id); user.setName (nom); user.setAddress (adresse); userService.saveuser (utilisateur); RETOUR UTILISATEUR; } @RequestMapping (value = "/ delete / {id}") public void DeleteBook (@Pathvariable int id) {userService.delete (id); } @RequestMapping (value = "/") public list <serv> getBooks () {return userservice.findall (); } @RequestMapping (value = "/ {id}") utilisateur public getUser (@Pathvariable int id) {user user = userService.FindOne (id); RETOUR UTILISATEUR; } @RequestMapping (value = "/ search / name / {name}") public list <serv> getBookByName (@Pathvariable String name) {list <user> usersthers = userService.findByName (name); retourner les utilisateurs; }}6. Configurer une source de données
Ajoutez la configuration suivante au fichier application.properties:
printemps.jpa.show-sql = truelogging.level.org.springframework.data = debugspring.jpa.hibernate.ddl-uto = printemps.datasource.url = jdbc: mysql: // localhost: 33 06 / Demospring.datasource.username = rootspring.datasource.password = rootspring.datasource.Driver-Class-Name = com.mysql.jdbc.
Si vous utilisez STS IDE, ces configurations d'attribut seront automatiquement invitées, vous pouvez donc enregistrer des recherches.
Si vous souhaitez afficher la configuration de Spring.datasource, vous pouvez vous référer à cette classe: DataSourceProperties.java
7. Écrivez une classe de démarrage
C'est relativement simple. Notez que le niveau de package auquel appartient cette classe doit être supérieur ou égal à d'autres classes pour s'assurer que les annotations d'autres classes peuvent être analysées.
package com.example; import org.springframework.boot.springApplication; import org.springframework.boot.autoconfigure.springbootapplication; import org.springframework.cache.annotation.enablecaching; @ springbootapplication @ pertecachPublic Classic void main (String [] args) {SpringApplication.Run (SpringDatajpaExampleApplication.class, args); }}Exécuter et tester le programme
Démarrez la méthode principale ou tapez-la dans un package JAR à exécuter;
Entrez l'URL suivante dans le navigateur et testez-le:
http: // localhost: 8080 / utilisateurs /
http: // localhost: 8080 / utilisateurs / add / 100/110/111
http: // localhost: 8080 / utilisateurs / supprimer / 100
http: // localhost: 8080 / utilisateurs / 2
http: // localhost: 8080 / utilisateurs / search / name / 2
Code source du programme
https://github.com/peterchenhdu/spring-data-jpa-example
Références
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/
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.