Cet article présente un exemple de construction de Spring Boot + Spring MVC + JPA pour le projet Maven. Il est partagé avec vous. Les détails sont les suivants:
Ajouter la prise en charge de Spring Boot et introduire des packages connexes:
1. Le projet Maven est indispensable pour pom.xml. Pour l'introduction de Spring Boot, veuillez vous référer au site officiel:
<parent> <proupId> org.springframework.boot </proupId> <ArtifActid> printemps-boot-starter-Parent </ artifactid> <version> 1.5.9.9release </DERVIRDE> </paredences> <Dedency> <proupId> javax.servlet </proupId> <ArtifActid> Javax.Servlet-API </ GroupID> <ccope> fourni </cope> <! - Compiler et publier des packages JAR indésirables -> </Dependency> <Dedency> <GroupId> org.springFramework </pruimId> <Ertifactid> Spring-webmvc </letefactid> </peedency> <Dedency> <ProupId> org.SpringFramework. <ArtefactId> Spring-boot-starter-web </ artifactid> </dependency> <! - Package JPA Jar, opération de la base de données -> <dependency> <proupId> org.springframework.boot </proupatid> </ dépendance> <dependance> <GroupId> org.springframework.boot </proupId> <Artifactid> printemps-boot-starter-data-redis </retifactid> </dependency> <! - MySql Driver -> <Dedency> <ProupId> MySql </prounid> <Artifactid> MySQL-Connector-Java </RitifActid> <GroupId> org.apache.shiro </rompuprid> <Artifactid> shiro-core </ artifactId> <Dersion> 1.2.2 </preffen> </Dependency> <Dependency> <ProupId> org.apache.shiro </prouprid> <Artifactid> Shiro-Spring </ Artifactid> <version> 1.2.2 </De version> --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-ehcache</artifactId> <version>1.2.2</version> </dependency> </dependencies> <build> <plugins> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <Executions> <exécution> <objectifs> <tobjectif> Repackage </ but> </ buts> </ exécution> </Executions> </gingin> </Glugins> <inalName> Nom </inalName> </ build>
2. Le code ci-dessus introduit le démarrage Spring. Spring MVC et JPA, ainsi que le pot de pilote pour la base de données MySQL;
Écrivez une classe de démarrage et installez le fichier de configuration:
1. La classe de démarrage est la suivante:
import org.springframework.boot.springApplication; import org.springframework.boot.autoconfigure.enableAutoConfiguration; import org.springframework.boot.autoconfigure.springbootapplication; import; org.springframework.data.jpa.repository.config.enablejpaauditing; import java.io.ioexception; importer com.my.config.commonproperties; @ SpringbootApplication @ perteautoconfiguration @vablejpauditingPublic Application {public static Void Main (string) loc = CommonProperties.LoadProperties2System (System.getProperty ("Spring.config.location")); System.getProperties (). SetProperty ("Application.Version", CommonProperties.getVersion (application.class)); System.getProperties (). SetProperty ("app.home", loc + "/ .."); SpringApplication.Run (application.class, args); }}2. Placez le fichier de configuration en dehors du chemin de classe pour faciliter la modification sans reconditionnement. Les projets de démarrage de printemps sont généralement transformés en packages en pot:
import java.io.file; import java.io.fileInputStream; import java.io.ioException; import java.util.properties; import org.springframework.util.stringutils public final class communproperties {public static final string ppt_key_app_home = "app.home"; public static final String default_app_home = "./"; Public Static Final String GetAppHome () {return System.getProperty ("./", "./"); } public static String loadProperties2System (String Location) lève ioException {String ConfigLocation = Location; Fichier cnf; if (! stringUtils.hasLength (emplacement)) {configLocation = "./config"; cnf = nouveau fichier (configLocation); if (! cnf.exists () ||! cnf.isdirectory ()) {configLocation = "../config"; cnf = nouveau fichier (configLocation); }} else {cnf = nouveau fichier (emplacement); } Fichier [] arg2 = cnf.listFiles (); int arg3 = arg2.length; for (int arg4 = 0; arg4 <arg3; ++ arg4) {file file = arg2 [arg4]; if (file.isfile () && file.getName (). Endswith (". Properties")) {Properties ppt = new Properties (); FileInputStream fi = new FileInputStream (fichier); Arg8 jetable = null; essayez {ppt.load (fi); System.getProperties (). Putall (PPT); } Catch (Throwable Arg17) {Arg8 = Arg17; lancer arg17; } enfin {if (fi! = null) {if (arg8! = null) {try {fi.close (); } catch (throwable arg16) {arg8.addsupprress (arg16); }} else {fi.close (); }}}} return configLocation; } public static String getVersion (class <?> Clazz) {package pkg = Clazz.getPackage (); String ver = pkg! = Null? pkg.getIMPlementationVersion (): "Undefined"; return ver == null? "Undefined": ver; }Placez le fichier de configuration dans le dossier de configuration du répertoire du package JAR au même niveau, y compris la configuration du journal, le fichier application.yml, d'autres fichiers de configuration, etc.;
Écrire des classes de configuration automatique
Utilisé pour scanner la société *, au lieu du fichier de configuration Spring.xml de Spring MVC:
import org.springframework.context.annotation.componentscan; import org.springframework.context.annotation.configuration; @ configuration @ composantscan (baspackages = {"com.my.rs", "com.my.service", "com.my.repository"}) org.springframework.boot.autoconfigure.web.httpmessageConverters; import org.springframework.context.annotation.bean; import org.springframework.context.annotation.configuration; import org.springframework.web.servlet.config.annotation. org.springframework.web.servlet.config.annotation.webmvcconfigureradapter; / ** * preconfiguration * * / @ configurationPublic class myConfiguration étend webmvcconfigurerAdapter {@Bean public httpMessagConverters;); } @Override public void addResourceHandlers (ResourceHandlerRegistry Registry) {//registry.addresourcehandler("/** ") // .AddreSourceLocations (" classpath: / meta-inf / ressources / ** "); }Écrire RS, service, référentiel
package com.my.rs; import java.util.list; import org.springframework.web.bind.annotation.requestbody; import org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.requestmethod; import org.springframework.web.bind.annotation.requestParam; import org.springframework.web.bind.annotation.responsebody; import com.my.entity.user; @requestmapping ({"/ api / user"}) interface publique userrs { @RequestMapping (value = "/ add", méthode = {requestMethod.post}) @ResponseBody public utilisateur public SaveUser (@Requestbody User utilisateur); @RequestMapping (value = "/ update", méthode = {requestMethod.post}) @ResponseBody Public User UpdateUser (@Requestbody User utilisateur); @RequestMapping (value = "/ delete", méthode = {requestMethod.post, requestMethod.Delete}) public void DeleteUser (@requestParam String [] userrids); @RequestMapping (value = "/ get", méthode = {requestMethod.get}) @ResponseBody Public User GetUser (@RequestParam String userId); @RequestMapping (value = "/ query / all", méthode = {requestMethod.get}) public list <server> queryall (); @RequestMapping (value = "/ query / byname", méthode = {requestMethod.get}) public list <server> queryByName (@requestParam String name); @RequestMapping (value = "/ query / byparentid", méthode = {requestMethod.get}) public list <server> querychildren (@requestParam String parentid); // Aucune pagination de paramètre Query @RequestMapping (value = "/ query / page", méthode = {requestMethod.get}) public List <Derser> QueryByPage (@RequestParam int pageno, @requestParam int pageSize, @RequestBody (required = false) Uset User);} package com.my.rs.impl; import java.util.list; import org.slf4j.logger; import org.slf4j.loggerfactory; import org.springframework.beans.factory.annotation.autowired; import org.springframework.web.bind.annotation.requequedbody; import org.springframework.web.bind.annotation.restController; import com.my.entity.user; import com.my.rs.userrs; import com.my.service.userservice; @restControllerPublic class userrsimplt implémente userrs {public static logger = loggerfactory.getLogger (userrsimger); @Autowired UserService _UserService; @Override public utilisateur SaveUser (@Requestbody User utilisateur) {try {return _userservice.save (utilisateur); } catch (Throwable E) {logger.Error (e.getMessage (), e); jeter e; }} @Override Public User UpdateUser (@Requestbody User utilisateur) {return _userservice.update (utilisateur); } @Override public void DeleteUser (String [] userIdS) {for (String userId: userrids) {_userservice.deleteById (userId); }} @Override public list <server> queryall () {return _userservice.queryall (); } @Override public list <User> QueryByName (String Name) {return _UserService.FindByName (name); } @Override public list <User> QueryChildren (String parentid) {return _userservice.FindByParentId (parentid); } @Override public User GetUser (String userId) {return _UserService.FindById (userId); } @Override public list <serser> QueryByPage (int pageno, int pagesize, utilisateur utilisateur) {return null; }} package com.my.service; import java.util.list; import org.springframework.beans.factory.annotation.autowired; import org.springframework.sterreotype.service; import com.my.entity.user; import com.my.repository.userrepository; @Servicepublic Class Class se propage à uservice se propage à uservice.UserRepository; @Servicepublic Class se propage à uservice se propage. BaseService <Serser> {@autowired userRepository _UserRepository; public list <User> findByName (String name) {return _userRepository.FindByName (name); } public list <ser utilisateur> findByParentId (String parentid) {return _userRepository.FindByParentId (parentid); }}package com.my.repository; import java.util.list; import com.my.entity.user; interface publique userRepository étend BasErepository <ser utilis List <ser utilisateur> findByPaRentid (String parentid);}
Ce qui précède adopte un modèle en couches, qui est un peu lourd, mais il est plus pratique de modifier la logique métier de chaque couche plus tard.
Les cours liés à la JPA sont les suivants:
package com.my.service; import java.io.serializable; import javax.persistence.entityManager; import javax.transaction.transactional; import org.springframework.beans.factory.annotation.autowired; Importer com.my.repository.basepository; / ** * certaines méthodes communes sont ici * BaseService <e étend Serializable> {@Autowired BasErepository <e> _BaseRepository; @Autowired EntityManager EM; public e Save (e BaseUnit) {return _BaseRoSitery.SaveandFlush (BaseUnit); } public e Update (e BaseUnit) {return _BaseRopository.saveandflush (BASISUNIT); } public void DeleteById (String id) {_BaseRopository.Delete (id); } public java.util.list <e> queryall () {return _baseRepository.findall (); } public e findById (String id) {return _baseRepository.getOne (id); }} package com.my.repository; import java.io.serializable; import org.springframework.data.jpa.repository.jParepository; import org.springframework.data.repository.norepositoryBean; @NorepositoryBeanPublic Baserepository <e> extend JPareOspository <E, interface Baserepository <e> Sérialisable> {}Classe d'entité: En rapport avec les champs de base de données, vous devez prêter attention à l'annotation dans la classe parent @MappySuperclass
package com.my.entity; import java.util.arraylist; import java.util.list; import javax.persistence.entity; import javax.persistence.manytomany; import org.hibernate.annotations.dynamicinssert; import org.hibernate.annotations.damicupdate; importation; import org.hibernate.validator.constraints.email; @entity (name = "db_user") @ dynamicinsert @ dynamicupdatePublic User étend la baseUnit {/ ** * Compte Status * / public static enum accountstatus {/ ** * Normal * / activer, // / ** * Disable * / Disable} private stic -3101319619397064425L; mot de passe de chaîne privé; sel de cordes privées; / ** Statut du compte * / Statut de compte privé; / ** Email d'authentification * / @email (message = "user.email L'attribut doit se conformer au format de messagerie") Email de chaîne privée; / ** Numéro de téléphone mobile * / Private String Mobileno; / ** Numéro d'identification * / String Private Cardid; @ManyTomany (ciblentity = role.class) Liste privée <string> RoleIDS; /** Surnom. Facultatif. * / surnom de chaîne privée; public String getCardid () {return Cardid; } public String getEmail () {return e-mail; } public String getmobileno () {return mobileno; } public String getNickName () {return newame; } public String getPassword () {return mot de passe; } public list <string> getroleids () {if (roleids == null) {roleids = new ArrayList <> (); } RETOUR RoleIDS; } public String getSalt () {return salin; } public AccountStatus GetStatus () {Retour Status; } public void setCardid (String Cardid) {this.cardid = cardid; } public void setEmail (chaîne e-mail) {this.email = e-mail; } public void setMobileno (String mobileno) {this.mobileno = mobileno; } public void setNickName (String Nelname) {this.nickName = Nontes; } public void setPassword (String Motword) {this.password = mot de passe; } public void setroleids (list <string> roleids) {this.roleids = roleids; } public void setSalt (String Salt) {this.salt = sel; } public void setStatus (CompteStatus Status) {this.status = statut; }} package com.my.entity; importer java.io.serializable; import java.util.date; import javax.persistence.id; import javax.persistence.mappingsuperclass; import javax.validation.constraints.notnull; importer javax.validation.constraints.size; importation; org.springframework.data.annotation.createdby; import org.springframework.data.annotation.createddate; import org.springframework.data.annotation.lastmodifiedby; import org.springframework.data.annotation Implasse Serializable {@id @notnull public String id; / ** * ID de l'unité parent * / @size (max = 32, message = "BASEUNIT.Parentid Attribut, la longueur ne peut pas être supérieure à 32") Public String Parentid; / ** Type d'unité parent * / public parentType parentType; / ** * Nom de l'unité * / @notnull (message = "BaseUnit.Name Attribut ne peut pas être vide") Nom de la chaîne publique; @CreatedBy Public String CreateBy; @CreatedDate Public Date CreateDate; @LastModifiedBy Public String LastModifiedBy; / ** * Dernière date mise à jour * / @LastModifiedDate Date publique LastModifiedDate; public String getID () {return id; } public void setid (String id) {this.id = id; } / ** * Obtenez le nom de l'unité * * @return requis * / public String getName () {RETOUR NAME; } / ** * * @return UUID, excluant {} et - * / public String getParentid () {return parentid; } public parentType getParentType () {return parentType; } public String getStationID () {return stareId; } public String gettHumbnailid () {return thumbNailid; } public String getCreateBy () {return CreateBy; } public void setCreateBy (String createby) {this.createby = createby; } public Date getCreatEdate () {return CreateDate; } public void setCreatEdate (date créée) {this.createdate = CreateDate; } / ** * Définissez le nom de l'unité * * @param name * requis * / public void setName (String name) {this.name = name; } / ** * Définissez l'ID de l'unité parent * * @param parentid * UUID, à l'exclusion {} et - * / public void setPaRentid (String parentid) {this.parentid = parentid; } public String getLastModifiedBy () {return lastModifiedBy; } public void SetLastModifiedBy (String LastModifiedBy) {this.lastModifiedBy = LastModifiedBy; } Public Date getLastModifiedDate () {return LastModifiedDate; } public void setLastModifiedDate (date lastmodifiedDate) {this.lastmodifiedDate = lastmodifiedDate; }}Fichier de configuration:
Serveur: Port: 16800 ContextPath: / Logging: config: ./config/logback.xml Spring: http: multipart: activé: false dataSource: url: jdbc: mysql: //127.0.0.1: 3306 / db? useunicode = true & caractéristique = utf-8 usagename: Root Paynway: 123456 conducteur: utf-8 usagename: Root Pround: 123456 ConductCol com.mysql.jdbc.Driver JPA: base de données: mysql show-sql: true hibernate: ddl-auto: update jackson: serialization: indent_output: true: true
#Hibernate: le comportement spécifique de la classe d'entité conservant la structure de la table de base de données. La mise à jour signifie que lorsque les propriétés de la classe d'entité changent, la structure du tableau sera mise à jour. Ici, nous pouvons également prendre la création de valeur. Cette création signifie que la dernière table générée a été supprimée au démarrage et régénérer la table en fonction de la classe d'entité. À l'heure actuelle, les données du tableau précédent seront effacées; Il peut également prendre la valeur de création de valeur, ce qui signifie que le tableau est généré en fonction de la classe d'entité au démarrage, mais lorsque le SessionFactory est fermé, le tableau sera supprimé; Valider signifie que la classe d'entité et le tableau de données sont cohérents au démarrage; Personne ne signifie que rien n'est fait. # Show-SQL signifie que Hibernate imprime la véritable instruction SQL sur la console lorsque le fonctionnement de #jackson signifie la sortie JSON de sortie formatée
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.