Cet article présentera le projet Java le plus élémentaire, au projet Web, à l'intégration de Spring, SpringMVC, SpringDatajpa + Hibernate.
Habituellement, nous pouvons créer un projet via un modèle ou importer directement un projet. Cependant, cet article choisit de commencer par le projet Java le plus fondamental, dans le but de montrer plus de principes.
Bien sûr, nous commençons toujours par le projet Maven le plus basique. En fait, le processus de construction de projets non mavés ordinaires est presque le même. Le package JAR doit être ajouté manuellement au projet, tandis que le projet Maven modifie simplement le fichier de configuration.
Ce qui suit est officiellement démarré.
1. Créez le projet Java le plus basique basé sur Maven (si vous n'utilisez pas Maven, vous pouvez également utiliser des projets traditionnels)
Pour créer un nouveau projet, sélectionnez Maven Project, Suivant:
Vérifiez-le comme créez un projet simple, suivant:
L'ID de groupe est l'ordre inverse de votre nom de domaine, qui correspond généralement au nom du package du code source du projet. L'ID d'artefact est le seul nom du projet dans cet ID de groupe. Il peut être rempli de quelque manière que ce soit en fonction de vos passe-temps, puis finir:
Ceci est le résultat de la structure du répertoire de projet comme ceci:
pom.xml est le fichier central de Maven.
2. Définissez le projet sur le mode Web dynamique
Ensuite, convertissez le projet en projet Web, cliquez avec le bouton droit pour ouvrir les propriétés du projet, comme indiqué sur la figure, cliquez sur Facets du projet dans le menu à gauche, puis cliquez sur Convertir en facette à partir de ...:
À droite, nous cochez le module Web dynamique et cliquez sur OK:
À l'heure actuelle, un répertoire WebContent supplémentaire apparaîtra:
Dans le répertoire Web-Inf, ajoutez le fichier web.xml, comme suit:
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd "version =" 3.0 "> <splay-name> springDatajpa </sisplay-name> </venke-file-list> </loge> web-app>
Puis ajoutez une page de bienvenue index.html:
<Html> <A-head> </ head> <body> <h1> bonjour mot! </h1> </body> </html>
La structure du répertoire est la suivante:
Pour le moment, vous pouvez cliquer avec le bouton droit sur le projet et s'exécuter sur le serveur. Vous pouvez voir l'effet:
3. Intégrer le printemps + printemps
Créez un nouveau package et ajoutez des interfaces et des classes (le code spécifique sera répertorié plus tard). La structure du package est comme indiqué sur la figure:
Si vous devez ajouter un package JAR, modifiez simplement le fichier POM directement. S'il s'agit d'un projet normal, ajoutez-le simplement au projet en appuyant sur le package JAR dans pom.xml.
Tout d'abord, ajoutez la version à ressort utilisée pour faciliter la gestion unifiée, puis ajoutez tous les packages de pot requis. Ce qui suit est d'ajouter tous les packages de pot nécessaires ici. Le pom.xml terminé est le suivant:
<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 "> <ModelVersion> 4.0.0 </ ModelVersion> <proupId> com.anxpp </rom grouped> <ArtifActid> SpringDatajpa </ Artifactid> <version> 0.0.1-Snapshot </De version> <preperties> <! <printemps.version> 4.2.5.release </sspring.version> </properties> <dependces> <! - Spring Core Package -> <Dedency> <proupId> org.springFramework </proncId> <ArtefactId> Spring-core </ artifactId> <version> $ {Spring.Version} </De version> </Dependency> <Dedency> <GroupId> org.springframework </proupId> <Artifactid> printemps-web </ artifactid> <De version> $ {printemps.version} </ version> </dependency> <pedidency> <proupId> org.springframework </prowprid> spring.version} </pteridence> <version> $ {spring.version} <dependency> <proupId> org.springframework </proncId> <Artifactid> spring-tx </retifactid> <DERSE> $ {printemps.springframework </pruidency> <dependency> <proupId> org.springframework </proupId> <Artifactid> Spring-JDBC </pterifactid> </Dependency> <Dedency> <GroupId> org.springFramework </rom grouped> <ArtifActid> Spring-webmvc </ artifactId> <DERVIÈRE> $ {printemps.version} </-version> </Dedency> <Dependency> <proupId> org.springframework </proupId> <ArtifActid> Spring-Aop </tifactId> <version> $ {printemps.version} </ version> </ Dependency> <Dedency> <GroupId> org.springFramework </proupId> <ArtifActid> Spring-Context-Support </ Dependency> <Deropportid> ORG.SPRINGSFRAME </ Version> </Dedency> <Dedency> <ProupId> Org.SPringFrameworkworkworkwork </ GroupId> <ArtefactId> Spring-Test </ ArfactId> <Dersion> $ {printemps.version} </ version> </ Dependency> <Dedency> <GroupId> org.springFramework </proupId> <ArtefactId> Spring-Lorm </ ArtifactId> <Dection> $ {Spring.Version} </De version> </Dedency> <Dedency> <GroupId> org.springframework.data </rom grouped> <ArtefactId> printemps-data-jpa </ artifactid> <version> 1.10.1.release </DERNIERSE> </DENDENCENCE> </DENDENCESS> </DRIGE>Ajoutez un fichier de configuration Spring ApplicationContext.xml dans le répertoire Web-inff et ajoutez le contenu suivant:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: p = "http://www.springfrramework.org/schema" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: mvc = "http://www.springframework.org/schema/mvc" xsi: schemalation = "http://www.springframeworkwork.orga/Bes http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsdd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd "> <! - Allumez l'annotation IOC -> <Context: Component-Scan-Package =" com.anxpp.demo "/ <! Annotation Scan -> <MVC: annotation-Driven /> </ Beans>
Modifier web.xml et ajouter le ressort à:
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version = "3.0"> <Display-Name> SpringDatajpa </ Display-Name> <Sounerer> <auditeur-class> org.springframework.web.context.contextLoadherListener </ auteur-class> </ounerner> <ptext -param> <param-name> contextConfigLocation </ param-name> <param-valu> web-inff / applicationConConCon </ context-Param> <Servlet> <Servlet-Name> Springmvc </ Servlet-Name> <Servlet-Class> org.springFramework.web.servlet.dispatcherservlet </vrect-Class> <Init-Param> <Am paramn-Name> <Am param-Value> CLASSPATH *: Springmvc-servlet.xml </ Param-Value> </ Init-Param> <Charot-on-Startup> 1 </ Loadlet-Startup> </ Servlet> <Servlet-Mapping> <Serplet-Mapping> <Servlet-Name> Springmvc </ Servlet-Name> <Url-Pattern> / * </url-Pattern> <Deen wreend-file-list> <ven welcome-file> index.html </venke-file> </ welcome-file-list> </ web-app>
Commençons à écrire le code ci-dessous, veillez à ne pas oublier d'écrire les annotations, la hiérarchie des packages a été donnée au début de cette section.
Utilisateur de l'entité:
package com.anxpp.demo.core.entity; public classe utilisateur {ID entier privé; nom de chaîne privé; Utilisateur public (ID entier, nom de chaîne) {this.id = id; this.name = name; } public Integer getID () {return id; } public void setid (INGER ID) {this.id = id; } public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } @Override public String toString () {return "id:" + id + ", name:" + name; }}Interface de couche UserDao:
package com.anxpp.demo.core.dao; import com.anxpp.demo.core.entity.user; interface publique userdao {user GetUser (ID entier, nom de chaîne);}La couche DAO implémente UserDaoimpl:
Package com.anxpp.demo.core.dao.impl getUser (INTER ID, nom de chaîne) {return nouvel utilisateur (id, nom); }}Interface de couche de service Interface UserService:
package com.anxpp.demo.core.service; import com.anxpp.demo.core.entity.user; interface publique userService {user GetUser (ID INGER, nom de chaîne);}Implémentation de la couche de service:
package com.anxpp.demo.core.service.impl; import org.springframework.beans.factory.annotation.autowired; import org.springframework.sterreotype.service; import com.anxpp.demo.core.entrey.userda; import com.anxpp.demo.core.entrey.user; com.anxpp.demo.core.service.UserService; @ServicePublic Class UseserServiceIMPL implémente UserService {@Autowired UserDao UserDao; @Override public User GetUser (INTER ID, nom de chaîne) {return userdao.getUser (id, nom); }}Democontroller de la couche de contrôleur:
package com.anxpp.demo.Controller; import org.springframework.beans.factory.annotation.autowired; import org.springframework.sterreotype.Controller; import org.springframe com.anxpp.demo.core.service.userservice; @ contrôleur @ requestmapping ("/") public class Democontroller {@autowired userService UserService; @RequestMapping ("/") @ResponseBody Public String index () {return "index"; } @RequestMapping ("/ GetUser") @ResponseBody public String GetUser (INTER ID, String Name) {return userservice.getUser (id, name) .toString (); }}Cela n'est pas possible d'exécuter directement sur le serveur, car le package JAR ne sera pas publié ensemble, nous devons configurer ce qui suit:
Cliquez avec le bouton droit sur le projet pour sélectionner les propriétés et la configurer en fonction de la figure ci-dessous:
Pour le moment, vous pouvez exécuter le test, l'effet est le suivant:
À ce stade, nous n'avons pas encore exploité la base de données.
4. Ajouter et renvoyer la prise en charge des données de format JSON
Maintenant, nous utilisons souvent JSON comme format de transmission de données. Ajoutons la prise en charge du retour JSON pour SpringMVC.
Ajoutez d'abord le package JAR:
<Dedency> <ProupId> com.fasterxml.jackson.core </rom grouped> <ArtifactId> Jackson-Databind </lefactive> <version> 2.5.0 </ version> </Dependency> <Dedency> <ProupId> com.fasterxml.jackson.core </proupId> <erifactive> jackson-core </letifactid> <a version> </ptetifActid> Jackson-Core </ Artifactid> </Dependency> <Dedency> <GroupId> com.fasterxml.jackson.core </rombandid> <ArtifactId> Jackson-Annotations </retifactId> <Dersion> 2.5.0 </DERNIFRIENT> </ Dependency>
Puis réécrivez la méthode getuser () comme suit:
@RequestMapping ("/ GetUser") @ResponseBody Public Map <String, Object> GetUser (INTER ID, String Name) {Map <String, Object> Map = new HashMap <String, Object> (); map.put ("état", "succès"); map.put ("data", userService.getUser (id, nom)); carte de retour; }Après la relance, l'effet d'accès est le suivant:
Pour le moment, vous pouvez retourner les données JSON.
5. Configurer l'accès aux ressources statiques
D'une manière générale, nous ne pouvons pas accéder directement aux ressources dans le répertoire Web-Inf. Si notre site Web est composé de HTML + AJAX, vous pouvez créer un nouveau répertoire HTML en dehors de Web-Inf et configurer le filtre par défaut pour web.xml. Cependant, veillez à le mettre avant le filtre SpringMVC:
<servlet-mapping> <servlet-name> default </vrlet-name> <url-sattern> *. html </url-sattern> </ servlet-mapping>
Si vous devez accéder aux ressources dans le répertoire Web-Inf, en vérifiant les documents officiels de Spring, vous constaterez qu'il existe deux façons
1. Écriture manuscrite d'un mappeur de ressources:
@ Configuration @ activerwebmvcpublic class webconfig étend webmvcconfigurerAdapter {@Override public void addResourceHandlers (ResourceHandlerRegistry Registry) {registry.addresourcehandler ("/ Resources / **") .AddreSourcelocations ("/ public-resources /") .SetCacheControl (CacheControl.maxage (1, timeunit.hours) .CachePublic ()); }}Comme vous pouvez le voir, vous pouvez également définir le temps de cache, et la manière plus simple est de configurer le XML:
<MVC: Ressources Mapping = "/ Resources / **" Location = "/ public-Resources /"> <Mvc: Cache-Control Max-Age = "3600" Cache-Public = "True" /> </ MVC: Ressources>
Vous pouvez également ajouter ce qui suit:
<! - L'accès aux fichiers de ressources statiques sera remis au gestionnaire de servlet par défaut pour le traitement en accédant au chemin qui ne peut pas être mappé sur le contrôleur -> <MVC: par défaut-service-handler />
6. Solution de code d'ordures
Nous utilisons généralement AJAX pour soumettre des demandes, mais nous utilisons également la barre d'adresse pour tester directement. Demandez les soumissions à obtenir et à publier.
Soumettre les demandes en utilisant la publication, il n'y aura généralement pas de code brouillé chinois, mais si le code brouillé apparaît, vous pouvez résoudre le problème en ajoutant un filtre d'encodage à web.xml:
<filter> <filter-name> CaractorEncoding </ Filter-Name> <Filter-Class> org.springframework.web.filter.characterencodingFilter </ Filter-Class> <Init-Param> <Amar-Name> Encoding </ Param-name> <param-valent> UTF-8 </onsam-Value> <Innit-Param> <Am param-name> Forceencoding </ Param-name> <Amar-Value> true </ Param-Value> </ Init-Param> </filter> <Imlter-Mapping> <Filter-Name> Caracterencoding </filter-name> <Url-Pattern> / * </url-Pattern> </filter-mapping>
Ce qui précède ne peut résoudre que le code de poste brouillé chinois. Pour GET (y compris la méthode de soumission directe de la barre d'adresse du navigateur), nous devons modifier la configuration Tomcat, la trouver dans server.xml dans le répertoire confre et la modifier comme suit:
<Connector ConnectionTimeout = "20000" port = "8080" protocole = "http / 1.1" redirectport = "8443" uriencoding = "utf-8" />
Si nous ne faisons que des tests et que le projet n'est pas déployé, nous pouvons trouver directement Server.xml sous le serveur dans Eclipse et apporter les mêmes modifications que ci-dessus:
7. Intégrer Springdatajpa + Hibernate
Vous pouvez en apprendre davantage sur JPA: Introduction aux spécifications et exemples de JPA (solution de persistance Java Data)
SpringDatajpa est également une solution aussi légère, et l'hibernate préféré implémente JPA.
Tout d'abord, le package JAR, le package JAR SpringDatajpa, a été additionné lors de l'intégration du printemps. Vous trouverez ci-dessous le package JAR de Hibernate (et le pilote MySQL).
<! - HiberNate -> <dependency> <proupId> org.hibernate </proncId> <Artifactid> hibernate-core </retifactid> <version> $ {hibernate.version} </prenid> </petifactid> hibernate-ehcache </prounid> <artifactid> hibernate-ehcache </prounid> <artifactive> hibernate-ehcache </prounid> <artifactid> hibernate-ehcache </prounid> <artifactive> hibernate-ehcache </prounid> <artifactive> hibernate-ehcache </prounid> <ArtifActid> Hibernate-ehcache </prouniD> <version> $ {hibernate.version} </ version> </ dépendance> <dependency> <proupId> org.hibernate </proupId> <artifactive> hibernate-entityManager </ artifactid> <dependency> $ {hibernate.version} </ version> </Dedency> <Dedency> <proupId> Org.hiberNate </ GroupID> <ArtefactId> Hibernate-C3p0 </letefactId> <Sease> $ {HiberNate.Version} </ Version> </Dependency> <Dedidency> <ProupId> MySQL </prouventid> <prefactId> MySQL-Connector-Java </ Artifactid> <version> 5.1.9 </DERNIFRODITIONS> </DEPENCENCE>La version de gestion unifiée est:
<! - Numéro de version hibernate -> <hibernate.version> 5.1.0.final </hibernate.version>
Ajoutez le fichier de configuration de JPA persistance.xml au répertoire Meta-Inf. La base de données utilise MySQL lors de l'introduction de cet article. Et ajouter le contenu suivant:
<? xml version = "1.0" encoding = "utf-8"?> <persistance version = "1.0" xmlns = "http://java.sun.com/xml/ns/persistence" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence_1_0.xsd"> <persistance-unit name = "Demo" transaction-type = "ressource_local"> <! - Provider> org.eclipse.persistence.jpa.PersistenceProvider </purder -> <purder> org.hibernate.ejb.hibernatepersistence </purder> </cass> com.ninelephas.meerkat.pojo.user </cassinde> <! name = "hibernate.connection.driver_class" value = "com.mysql.jdbc.driver" /> <propriété name = "hibernate.connection.url" value = "jdbc: mysql: //127.0.0.1: 3306 / DEMO? CreateDataSIfNotexist = true" /> <ftperway name = "hibernate.connection.username" value = "root" /> <propriété name = "hibernate.connection.password" value = "root" /> <propriété name = "hibernate.dialect" value = "org.hibernate.dialect.mysqldialect" /> </properties> </ persistence-unnit> </ persistance>
Le contenu complet après avoir ajouté la prise en charge de JPA au fichier de configuration de Spring ApplicationContext.xml:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: p = "http://www.springfrramework.org/schema" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: mvc = "http://www.springframework.org/schema/mvc" xmlns: jpa = "http://www.springframework.org/schema/data/jpa" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd "> <! - Activer la balanne de l'annotation IOC" / Context: Component-scan Base <bean id = "EntityManagerFactory"> <propriété name = "jpavendoradapter"> <anan> <propriété name = "générédl" value = "true" /> <propriété name = "database" value = "mysql" /> </ bean> </ propriété> <propriété name = "persistenceUnitName" scan - "Demo" /> </ bean> <! <mvc: annotation-driven /> <ean> <propriété name = "ViewResolvers"> <sist> <anEn> <propriété name = "prefix" value = "/ web-inf / voir /" /> <propriété name = "suffixe" value = ". </ list> </ propriété> </ bean> <! - L'accès aux fichiers de ressources statiques laissera le chemin d'accès qui ne peut pas être mappé au contrôleur au gestionnaire de servlet par défaut pour le traitement-> <mvc: default-servlet-handler /> <! - Configurer le gestionnaire de transaction -> <bean id = "transactionmanager"> <propriété name = "EntityManAgerfactory" Ref = "EntityManAgor" transaction d'annotation -> <tx: transaction-manager-manager = "transactionmanager" /> <! - Configurer le répertoire de numérisation JPA de Spring Data JPA -> <JPA: RepoSitories Base-Package = "com.anxpp.demo" /> </ beeps>
Modifiez l'entité:
package com.anxpp.demo.core.entity; import javax.persistence.entity; import javax.persistence.generatedvalue; import javax.persistence.generationtype; import javax.persistence.id; import javax.persistence.table; @ entity @ tablePublic Class user {@id @generakewue (stratégie = Tablepublic Classe User {@id @generatedValue (Strategrey = tablepublic Class Class user {@id @generatedValue (Strategrey = TabledPublic Class User {@id @generakewue (Strategrey = Tablep GenerationType.Auto) ID entier privé; nom de chaîne privé; user public () {} public utilisateur (nom de chaîne) {this.name = name; } public Integer getID () {return id; } public void setid (INGER ID) {this.id = id; } public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } @Override public String toString () {return "id:" + id + ", name:" + name; }}Vous pouvez supprimer la mise en œuvre de la couche DAO. Nous nous souvenons hériter de l'interface de couche DAO à partir du puissant JParepository:
Interface publique UserDao étend JParePository <utilisateur, Serializable> {utilisateur findById (INTER ID);}Cela semble-t-il particulièrement concis et ne nécessite pas d'écriture de la mise en œuvre? SpringDatajpa nous aidera automatiquement à le terminer.
Modifiez l'interface de couche de service:
package com.anxpp.demo.core.service; import java.util.list; import com.anxpp.demo.core.entity.user; interface publique userService {utilisateur findbyid (id integer); User Save (Nom de la chaîne); List <ser user> findall ();}Modifiez l'implémentation de la couche de service:
package com.anxpp.demo.core.service.impl; import java.util.list; import org.springframework.beans.factory.annotation.autowired; import org.springframework.sterreotype.service; import com.anxpp.demo.core.dao.userdao; Importer; com.anxpp.demo.core.entity.user; import com.anxpp.demo.core.service.UserService; @ServicePublic Class userserviceIMPl implémente userService {@Autowired userdao userdao; @Override public utilisateur findbyid (INTER ID) {return userdao.findById (id); } @Override public utilisateur Save (nom de chaîne) {return userdao.save (nouvel utilisateur (nom)); } @Override public list <ser utilisateur> findall () {return userdao.findall (); }}Modifiez le contrôleur pour fournir plusieurs interfaces de test:
Package com.anxpp.demo.Controller; import java.util.hashmap; import java.util.map; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.sterereotype.contreller; import org.springframework.web.bind.annotation.requerson org.springframework.web.bind.annotation.ResponseBody; import com.anxpp.demo.core.service.userservice; @ contrôleur @ requestmapping ("/") public Class DeMoController {@Autowired UserService Service; @RequestMapping ("/") @ResponseBody Public String index () {return "index"; } @RequestMapping ("/ info") public String info () {return "info"; } @RequestMapping ("/ Findall") @ResponseBody Public Map <String, Object> GetUser () {Map <String, Object> Map = new HashMap <String, Object> (); map.put ("état", "succès"); map.put ("data", userService.Findall ()); carte de retour; } @RequestMapping ("/ FindById") @ResponseBody Public Map <String, Object> FindById (INTER ID) {map <String, Object> Map = new HashMap <String, Object> (); map.put ("état", "succès"); map.put ("data", userService.FindById (id)); carte de retour; } @RequestMapping ("/ Add") @ResponseBody Public Map <String, Object> Save (nom de chaîne) {map <string, object> map = new HashMap <String, Object> (); map.put ("état", "succès"); map.put ("data", userservice.save (nom)); carte de retour; }}Effet de course:
Alors, que se passe-t-il si vous avez besoin d'ajouter des données qui recherchent un nom de famille spécifié avec un ID supérieur à la valeur spécifiée?
Si c'est SQL, nous écrivons de cette façon (? Représente les paramètres):
Sélectionnez * à partir de l'utilisateur où id>? Et nom comme «?%»;
Mais ici, nous n'avons même pas besoin d'écrire SQL (ou HQL) et d'ajouter simplement une méthode à l'interface de couche DAO:
Liste <User> findByIdGreaterThanAndNameLike (ID entier, nom de chaîne);
Vous n'avez pas besoin de douter que la méthode ci-dessus réussira si elle est exécutée (Remarque: utilisez l'implémentation du service, n'oubliez pas le nom + "%" lorsque vous appelez cette méthode)!
Ce qui précède est les connaissances pertinentes qui vous sont présentées sur la construction de SpringMVC + SpringDatajpa + Hibernate du projet Java le plus élémentaire. J'espère que ce sera utile à tout le monde. Si vous souhaitez en savoir plus d'informations, veuillez faire attention au site Web Wulin.com!