Parties de base
1. Introduction à Fastjson
FastJson est une bibliothèque Java qui peut être utilisée pour convertir les objets Java en représentations JSON. Il peut également être utilisé pour convertir une chaîne JSON en un objet Java équivalent. Il devrait être la vitesse de conversion la plus rapide et est presque devenue la configuration standard des projets (FastJson est généralement utilisé à la place de Jackson lors de la demande Ajax et du développement d'interface).
Github: https://github.com/alibaba/fastjson (téléchargement local)
caractéristiques:
Caractéristiques principales:
2. API Fastjson
La classe d'entrée de l'API Fastjson est com.alibaba.fastjson.json. Les opérations de sérialisation communes peuvent être directement complétées par des méthodes statiques sur la classe JSON.
// analyse le texte JSON en tant que jsonObject ou JSONArray Public Static Final Object Parse (Text de chaîne); // analyse le texte JSON dans jsonObject public static final jsonObject paSeObject (texte de chaîne); // analyse le texte JSON en tant que Javabean Public Static Final <T> T ParseObject (Texte de chaîne, classe <T> Clazz); // analyser le texte JSON dans jsonArray public static final jsonArray parsearray (texte de chaîne); // Analyser le texte JSON dans la collection Javabean Public Static Final <T> List <T> PARSEARRAY (Texte de chaîne, classe <T> Clazz); // Serialize JavaBean dans JSON Text Public Static Final String TOJSONSTRING (Object Object); // sérialiser JavaBean dans JSONSTRING formaté (objet objet, boolean joliformat); // Converti JavaBean en jsonObject ou JSONArrayPublic Objet final statique TOJSON (objet JavaObject);
JSONArray: équivalent à List <Bject>
JSONObject: équivalent à map <string, objet>
SerializEconfig: est une configuration spéciale pour certains processus de sérialisation pendant le processus de sérialisation, comme la mise en forme de certains champs (date, énumération, etc.)
SerializeWriter: équivalent à StringBuffer
SérializerFeature Propriété:
Pratique
1. Introduire les dépendances Spring MVC et FastJson dans POM.xml
<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/maven-v4_0_0.xsd "> <ModelVersion> 4.0.0 </ ModelVersion> <ProupID> com.mengdee </prouverid> <ArtifActid> plate-forme-springmvc-webapp </snaptid> </packaging> war </packaging> <version> 0.0.1-snaptid> </packaging> war </packaging> <version> 0.0.1-SNAPID> </packaging> war </packaging> <version> 0.0.1-SNAPS <name> plate-forme-springmvc-webapp maven webapp </name> <url> http://maven.apache.org </url> <properties> <project.build.sourceencoding> utf-8 </project.build.sourceencod> <junit.version> 3.8.1 </junit.version> <log4j.version> 2.5 </log4j.version> <jstl.version> 1.2 </jstl.version> <printemps.version> 4.2.3.release </spring.version> <fastjson.version> 1.2.32 </fastjson.version> </properties> <dependance> <dependency> <proupId> JUNIT </proupId> <ArtefactId> JUnit </ ArfactId> <DersonDe> 3.8.1 </ Version> <Scope> Test </cope> </Dependency> <Dendency> <proupId> Javax.servlet </prouverid> <lefactive> JSTL </ ArtifactId> <Dersion> $ {JSTL.VERSION} </DERNIFROITIONS> </DEpendency> <! <GroupId> org.springframework </proncId> <Artifactid> printemps-webmvc </ artifactid> <version> $ {printemps.sversion} </ version> </dependency> <dependency> <proupId> org.springFramework </proupId> <Artifactid> Spring-core </ptetifActid> <DERNÉRATION> <dependency> <proupId> org.springframework </proncId> <Artifactid> Spring-Context </ ArtifactId> <DERSE> $ {printemps.sversion} </-version> </dependency> <Dedency> <ProupId> org.springFramework </proupId> <Ertifactive> Spring-Context-Support </ralidwork> <version> $ {printemps.version} </ version> </ dépendance> <dependency> <groupId> org.springframework </proncId> <Artifactid> printemps-jdbc </letefactid> <version> $ {Spring.version} </ version> </pedigency> <dependency> <proupId> comenibaba </proncId> <ralid> Fastjon </ ArtiSiDACTID> <version> $ {Fastjson.Version} </DERNIFRIGNE> </ Dependency> </Dependces> <! - Utilisation d'Aliyun Mirror -> <Depositories> <Fepository> <id> Aliyun </ id> <name> Aliyun </ Name> <urlant/Groups/public </ url> </ Repository> </ Repository> </ Repository> </ Repository> <Duild> <FinalName> Platform-Springmvc-webApp </ finalName> </ build> </ project>2. Configurer web.xml
<! Doctype Web-App Public "- // Sun Microsystems, Inc.//dtd Application Web 2.3 // en" "http://java.sun.com/dtd/web-app_2_3.dtd"> <web-app> <plawing-name> Archetype Created Application </splay-name> <context-param> <paramment-name> Archetype Created Application </ Param-Name> <Am param-Value> CLASSPATH: conf / printemps / printemps - *. XML </ Param-Value> </ Context-Param> <Dusiner> <D, description> Spring auditeur </ Description> <écouteur-class> Org.SpringFramework.Web.Context.Context-Name> Spring-Mvc </ Server> </Verger> <Serplet> <Serplet-Name> Spring-Mvc </ Server> </ounerfrlet> <Servlet-Class> org.springframework.web.servlet.dispatcherServlet </vrlet-Class> <Init-Param> <AmAn-Name> ContextConfiglocation </ Param-Name> <Amvin-Value> / Init--inf/Spring-Servlet.xml </ Param-value> </IniT-Param> <Office-on-startup> 1; </ servlet> <servlet-mapping> <servlet-mapping> <servlet-name> printemps-mvc </ servlet-name> <url-potern> / </url-potern> </ servlet-mapping> <filter> <filter-name> CharacterEncodingFilter </filter-name> <Filter-Class> org.springFramework.web.filter.CaracTerencodingFilter </ Filter-Class> <Init-Param> <Amam-Name> Encoding </ Param-Name> <Anit-Value> UTF-8 </ Param-Value> <Am param-Value> true </ param-Value> </nitt-Param> </filter> <Imlter-Mapping> <Lifter-Name> CaracterEncodingFilter </ Filter-Name> <Url-Pattern> / * </url-Pattern> </ Filter-Mapping> <Welcome-File-List> <Deargel> / Pattern.Jsp </Deen wreending-file> <Reur-Code> 404 </ Error-Code> <Location> /Index.jsp </ Location> </ Error-Page> </low-App>
3. Configurer Spring-Servit.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: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/contex xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4. Base-Package = "com.Mengdee.manage.Controller" /> <Bean Id = "ViewResolver"> <Propriété Name = "Prefix" Value = "/"> </ Property> <! - Préfixe de fichier de vue -> <propriété Name = "Suffix" Value = ". -> <propriété name = "ViewClass" value = "org.springframework.web.servlet.view.jstlview"> </ propriété> </ank> <! - Démarrez la fonction d'annotation MVC Spring pour compléter la cartographie des demandes et annotation POJO Remplacez la prise en charge d'origine Jackson -> <an Bean> <propriété name = "SupportEdMediaTypes"> <Sist> <Value> text / html; charset = utf-8 </value> <value> application / json </ value> </sist> </ propriété> <propriété name = "fonctionnalités"> <s list> <value> QuoteFieldNames </value> <! - Que ce soit <value> writeMapNullValue </value> <! - Que ce soit à produire un champ avec une valeur nul, par défaut à false -> <! - <value> DisableCircularReferendect </value> <value> WRIDERDATEUDATEFORMAT </value> <value> WriteLullStringasempty </value> Si le champ de type de caractère est null, si la sortie est ", non, pas null> Le champ numérique est null, la sortie est 0, pas nul <value> le champ booléen de Broolean est nul, la sortie est fausse, pas nul <value> writenullListasempty </value> le champ de liste est nul </ mvc: annotation-axé> </ beans>
4. Java
Éducation: éducation (classe d'énumération)
Package com.mengdee.manage.entity; import java.util.hashmap; importer java.util.map; / ** * éducation * @author administrateur * * / public Enum Education {maternelle ("maternelle", 1), élémentaire ("école élémentaire", 2), lycée, 4), 4), 4), lycée, "lycée", 3), Senior_Middle ("Highdle), 4), 4), 4), 4), 4), 4), 4), 4), 4), 4), 4). University ("University", 5), College ("College", 6); Carte finale statique privée <Integer, Education> Education_Map = New Hashmap <Integer, Education> (); Statique {pour (Education Education: Education.Values ()) {education_map.put (education.getIndex (), Education); }} texte de chaîne privée; Index int privé; Éducation privée (Texte de chaîne, int index) {this.text = text; this.index = index; } public String getText () {return text; } public void setText (String Text) {this.text = text; } public int getSindex () {return index; } public void setIndex (int index) {this.index = index; } public static Education Getenum (INTEGER INDEX) {return education_map.get (index); }}Personne:
package com.mengdee.manage.entity; import java.util.arraylist; import java.util.date; import java.util.list; import java.util.map; import com.alibaba.fastjson.annotation.jsonfield; Personne publique {private long id; nom de chaîne privé; Sexte d'octets privé; // Sexe 1: Mâle 2: Femme Private Short-Agel; // vieillir le salaire long privé; // salaire double poids privé; // Ponds le niveau de charbon privé; // note adulte booléen privé; // Si adulte privé date d'anniversaire; // Éducation à l'enseignement privé d'anniversaire; // Qualification éducative String privé [] passe-temps; // Liste privée de passe-temps <Agineuse> chiens; // Pet Dog Private Map <String, Object> Adresse; // Adresse // Utiliser des annotations pour contrôler si vous souhaitez sérialiser @jsonfield (serialize = false) Liste privée <Bject> Obj = new ArrayList <> (); Public () {} Personne publique (Id long, nom de chaîne, octet de genre, âge court, salaire long, double poids, niveau de char, adulte booléen, anniversaire de date, chaîne [] passe-temps, liste <chien> chiens, carte <chaîne, adresse>) {super (); this.id = id; this.name = name; this.gender = genre; this.age = âge; this.salary = salaire; this.weight = poids; this.level = niveau; this.adult = adulte; this.birthday = anniversaire; this.hobbies = hobbies; this.dogs = chiens; this.address = adresse; } 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 octet getgender () {return Gender; } public void setGender (Byte Sexe) {this.gender = genre; } public Short Getage () {Return Age; } public void Setage (âge court) {this.age = age; } public long getSalary () {return salaire; } public void setsalary (salaire long) {this.salary = salaire; } public double getweight () {return poids; } public void setweight (double poids) {this.weight = poids; } public char getlevel () {NIVEAU RETOUR; } public void SetLevel (charbon niveau) {this.level = niveau; } public boolean isadult () {return adulte; } public void setadult (booléen adulte) {this.adult = adulte; } Public Date getBirthday () {retour anniversaire; } public void SetBirthday (date d'anniversaire) {this.birthday = anniversaire; } // Gire les types d'énumération sérialisés, la valeur par défaut est la chaîne de valeur enum sérialisée, plutôt que l'index de liaison en énum ou le texte @jsonfield (name = "edu") public int getedu () {return education.getIndex (); } @Jsonfield (name = "edu") public void setedu (int index) {this.education = education.getEnum (index); } @Jsonfield (serialize = false) Éducation publique GetEducation () {return education; } @Jsonfield (serialize = false) public Void SetEtucation (Education Education) {this.education = éducation; } public String [] gethobbies () {return hobbies; } public void sethobbies (string [] hobbies) {this.hobbies = hobbies; } Liste publique <Ago> GetDogs () {Retour Dogs; } public void setDogs (list <dog> chiens) {this.dogs = chiens; } public map <string, objet> getAddress () {return adresse; } public void setAddress (map <string, objet> adresse) {this.address = adresse; }}Test Controller
package com.mengdee.manage.controller; import java.text.decimalformat; import java.util.arraylist; import java.util.list; import java.util.hashmap; import java.util.list; org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.responsebody; import com.alibaba.fastjson.json; import com.alibaba.fastjson.jsonarray; import com.alibaba.fastjson.serializer.serializonfig; import com.alibaba.fastjson.serializer.simpledateformatSerializer; import com.mengdee.manage.entity.address; import com.mengdee.manage.entity.dog; import com.mengdee.manage.entity.education; com.mengdee.manage.entity.eson; @ControllerPublic classe TestController {private static serializEconfig SerializEConfig = new SerializEConfig (); statique {serializEConfig.put (date.class, new SimpledateFormatSerializer ("yyyy-mm-dd hh: mm: ss")); serializEconfig.put (double.class, nouveau double (newcimalformat ("0,00"))); } @RequestMapping ("/ index") public String index () {return "index"; } // javabean à objet @RequestMapping ("/ json") @ResponseBody Object JSON () {personne personne = new personne (); personne.setid (1L); personne.setName ("Mengdee"); Person.Setage ((court) 18); // / * {"anniversaire": null, "poids": 0, "chiens": null, "adulte": false, "hobbies": null, "éducation": null, "id": 1, "niveau": "", "adresse": "Âge": 18, "nom": "Mengdee", "Gender": "Salaire": 0} * * / Mengdee "Personjon = Jon.Toj); retour Personjson; } // javabean to string @RequestMapping ("/ json2") @ResponseBody public String JSON2 () {personne personne = new personne (); personne.setid (1L); personne.setName ("Mengdee"); Person.Setage ((court) 18); // Si la valeur de NULL est utilisée, elle ne peut pas être testée. <value> WriteMapNullValue </value> // "{" adulte ": false," Âge ": 18," Gender ": 0," id ": 1," Level ":" "," name ":" Mengdee "," salaire ": 0," poids ": 0.0}" String JSontring = JSON.TOJSONSTRING (personne); retourner jsonstring; } @RequestMapping ("/ JSON3") @ResponseBody Objet public JSON3 () {Person Person = new Person (); personne.setid (1L); personne.setName ("Mengdee"); Person.Setage ((court) 18); Person.SetBirthday (nouveau Date ()); Object Personjson = JSON.Tojson (personne); // json.tojson (personne) par défaut en millisecondes "anniversaire": 1495073314780, // Utilisez le numéro de série SerializeConfig pour configurer le formatage pour les dates // "{" anniversaire ":" 2017-05-18 10:19:55 "," poids ": 0.0," adulte ": false," id ": 1," niveau ":" "," âge ": 18," nom ":" Mengdee "," Gender ": 0," Salaire ": 0}" String JSontring = JSON.TOJSONSTRING (Personjson, serialiseconfig); retourner jsonstring; } @RequestMapping ("/ JSON4") @ResponseBody Objet public JSON4 () {Person Person = new Person (); personne.setid (1L); personne.setName ("Mengdee"); Person.Setage ((court) 18); Person.SetBirthday (nouveau Date ()); Person.SetEducation (Education.University); // String d'énumération [] Hobbies = {"Reading", "Tourism"}; Person.Sethobbies (passe-temps); Dog dog1 = nouveau chien (1L, "dog1", (court) 1); Dog dog2 = nouveau chien (2L, "dog2", (court) 2); List <og> dogs = new ArrayList <> (); chien.add (dog1); dogs.add (dog2); personne.setdogs (chiens); Adresse d'adresse1 = nouvelle adresse (1L, "Shanghai Pudong New District"); Adresse d'adresse2 = nouvelle adresse (2L, "District de Shanghai Baoshan"); Map <string, object> adressemap = new hashmap <> (); AddressMap.put (adresse1.getID () + "", adresse1); AddressMap.put (adresse2.getId () + "", adresse2); Person.SetAddress (AddressMap); Object Personjson = JSON.Tojson (personne); retour Personjson; } @RequestMapping ("/ JSON5") @ResponseBody String public JSON5 () {dog dog1 = new dog (1l, "dog1", (short) 1); Dog dog2 = nouveau chien (2L, "dog2", (court) 2); List <og> dogs = new ArrayList <> (); chien.add (dog1); dogs.add (dog2); // Liste <T> -> JSON String JSontring = JSON.TojSontring (Dogs, False); System.out.println (jsonstring); // JSON -> Liste <T> List <Gog> PARSEARRAY = JSON.PARSEARRAY (JSONSTRING, dog.class); pour (chien de chien: parsearray) {System.out.println (chien); } Map <string, dog> map = new hashmap <string, dog> (); map.put ("dog1", nouveau chien (1L, "dog1", (short) 1)); map.put ("dog2", nouveau chien (2L, "dog2", (court) 2)); map.put ("dog3", nouveau chien (3l, "dog3", (short) 3)); // map -> JSON String mapjSontring = json.tojSontring (map, true); System.out.println (MapJSontring); // JSON -> map @SuppressWarnings ("Unchecked") Map <String, Dog> Map1 = (map <String, Dog>) JSON.Parse (MapJSontring); for (String key: map1.KeySet ()) {System.out.println (key + ":" + map1.get (key)); } // Array -> JSON String [] hobbies = {"a", "b", "c"}; String HobbiSString = JSON.TojSontring (Hobbies, True); System.out.println (hobbies); // JSON -> Array JSONArray JSONArray = JSON.PaSEARRAY (HobbiSsstring); pour (objet o: jsonArray) {System.out.println (o); } System.out.println (JSONArray); retourner jsonstring; }}Intégration de fanfaronnade
Étape 1: introduire des dépendances connexes
<dependency> <proupId> io.springfox </rom grouped> <Artifactid> Springfox-Swagger2 </ ArtiFactId> <Seroase> 2.6.1 </DERNIFRESÉE> <COPE> Compile </cope> </Dependency> <Dedency> <ProupId> com.fasterxml.jackson.core </roulid> <ArtifActid> Jackson-Databind </ Artifactid> <ArtifActid> Jackson-Databind </ Artifactid> <ArtifActid> <version> 2.6.6 </ version> </Dependance>
Étape 2: Configuration d'informations de fanfaronnade
Swaggerconfig.java
@ Configuration @ activerwebmvc @ ActivedWagger2Public classe SwaggerConfig {@bean public Docket CustomDocket () {Docket Docket = new Docket (DocumentationType.Swagger_2); docket.apiinfo (apiinfo ()); docket.select (). API (requestHandlerselectors.WithMethodannotation (apioperation.class)); docket.select (). chemins (pathSelectors.Regex ("/ api /.*")). build (); Dossier de retour; } private apiinfo apiinfo () {contact contact = new Contact ("xiao ming", "http://www.baidu.com", "[email protected]"); Return nouvel apiinfo ("API Interface", // Big Title "API Interface", // Sous-titre "0.0.1", // version "www.baidu.com", // TermesOfServiceUrl Contact, // Auteur "API Interface", // lien affichez le texte "http://ww.baidu.com" // lien de site Web); }}Remarque: Étant donné que la classe SwaggerConfig configure des annotations, cette classe doit être analysée, c'est-à-dire que la classe doit être incluse dans le contexte: composant-scan.
Étape 3: Utilisez des annotations sur les classes, les méthodes et les paramètres
@ Contrôleur @ requestmapping ("/ api / v1") @ api (description = "interface API") classe publique apicontroller {@apioperation (value = "user ligin", notes = "interface de connexion utilisateur") @APiResponses (Code = 10001, message = "Name =" Success "), @APiRESPESS IllegalArgumentException.class), @ApiResponse(code = 10002, message = "Password error") }) @RequestMapping(value = "/user/login", method = RequestMethod.POST, produces = {"application/json;charset=UTF-8;"}) @ResponseBody public String login(@ApiParam(name = "username", value = "username", required = true) @RequestParam String username, @apiparam (name = "mot de passe", value = "mot de passe", obligatoire = true) @RequestParam String Mot de passe) {return "{'username': '" + username + "', 'password': '" + mot de passe + "'}"; } @ApiimplicitParams ({@apiimplicitParam (paramtype = "header", name = "phone", dataType = "String", required = true = value = "numéro mobile"), @APIIMPLICITPARAM (paramtype = "Query", name = "surnom", dataty 666 "), @APIIMPLICtParam (paramtype =" path ", name =" plateforme ", dataType =" string ", obligé = true = value =" plateforme ", defaultValue =" pc "), @apiimplicitParam (paramtype =" body ", name = mot de passe", datatype = "string", obligatoire = value = "mot de passe")}) @reque "/ {plateforme} / user / regist", méthode = requestMethod.post, produit = {"application / json; charset = utf-8;"}) @ResponseBody Public String Regist (@RequestHeader String Phone, @requestParam String surname, @pathvariable String Platform, @requestbody String passways) {return "{'username':" + ",", ", mot de passe) {return" {'username': "+", ",", mot de passe) {retour "{'username':" + ", +", ",". 'surnom': '"+ surnom +"', 'plateforme': '"+ plateforme +"', 'mot de passe': '"+ mot de passe +"'} "; } @Requestmapping (value = "/ user / list", méthode = requestMethod.get, produmes = {"application / json; charset = utf-8;"}) @ResponseBody public String getuserList (pager Pager) {return "[{'id':" + pager.getpage () + ", 'username':: 'zhangsan "+ pager.getSize () +"'}] "; } @RequestMapping ("/ docs") @APIIGNore public String test () {return "api-docs"; }}Sacrer
classe publique Pager {@apimodelProperty (value = "Page Number", requise = true) private int page; @Apimodelproperty (valeur = "nombre de par page", obligatoire = true) private int size; public pager () {} public int getPage () {return page; } public void setPage (int page) {this.page = page; } public int getSize () {return size; } public void setSize (int size) {this.size = size; }}Annotations courantes:
Étape 4: Access / V2 / API-DOCS
Visitez http: // localhost: 8080 / nom de projet / V2 / API-docs sur le navigateur, s'il y a du contenu JSON, c'est normal
Étape 5: Télécharger Swagger-UI
Téléchargez https://github.com/swagger-api/swagger-Ui de github. Notez que vous devez sélectionner le téléchargement v2.2.10 (https://github.com/swagger-api/swagger-ui/tree/v2.2.10 (téléchargement local)). La méthode d'intégration supérieure à cette version est différente.
Méthode d'intégration: Mettez tous les fichiers dans le répertoire DIST sous V2.2.10 dans des fichiers statiques dans votre projet et utilisez le code suivant pour écraser la partie du script dans index.html
<script type = "text / javaScript"> var substanTrl = ""; $ (function () {var url = window.location.search.match (/ url = ([^ &] +) /); if (url && url.length> 1) {url = décodeuriComponent (url [1]);} else {// l'adresse API-docs décrite ci-dessus (window.swaggerTranslator) {window.swaggerTranslator.Translate ();} window.swaggerui = new swaggerui ({url: url, validatorurl: undefined, dom_id: "swagger-ui-contenant", 'support. (swagerapi, swaggerui) {if (typeof initoAuth == "function") {initoAuth ({clientId: "your-client-id", ClivityCret: "votre clinting-secret-if-require }). DocexPansion: "Aucun", JSONEditor: false, apissorter: "alpha", defaultModelRendering: 'Schema', ShowRequestHenders: false}); SwaggerClient.apikeyAuthorization (token ", token," en-tête "); </cript> Étape 6: Accédez à l'index.html modifié ci-dessus
http: // localhost: 8080 / nom de projet / statique / tiers / swagger-ui / index.html
Remarque: Parce que vous souhaitez accéder aux ressources statiques, veuillez vous assurer que les ressources statiques sont accessibles à l'aide de SpringMVC. Si vous ne pouvez pas accéder, veuillez effectuer la configuration suivante:
1. Ajouter le processeur de servlet par défaut au fichier de configuration Spring
<! - Filtre les ressources statiques -> <MVC: par défaut-service-handler />
2. Ajouter des fichiers statiques à filtrer dans web.xml
<!-- Filtering static resources--><servlet-mapping> <servlet-name>default</servlet-name> <url-pattern>*.js</url-pattern> <url-pattern>*.css</url-pattern> <url-pattern>/assets/*"</url-pattern> <url-pattern>/images/*</url-pattern></servlet-mapping>
Exemple de structure de code de projet:
L'exemple complet de la démo Adresse de téléchargement: http://xiazai.vevb.com/201804/yuanma/platform-springmvc-webapp(vevb.com).rar
autre
À propos de Spring-servlet.xml et ApplicationContext.xml
Springmvc fournit deux fichiers de configuration Spring-servlet.xml et ApplicationContext.xml
Spring-Servlet.xml est au niveau du contrôleur et son étendue d'action est la couche de contrôle. Le nom par défaut est [servlet-name] -servlet.xml
Par défaut, il est placé dans Web-Inf / Directory. Springmvc se chargera automatiquement et peut également être configuré dans web.xml.
<VerTlet> <Serplet-Name> Spring-Mvc </ Servlet-Name> <Serplet-Class> org.springframework.wisservlet.dispatcherServlet </ Servlet-Class> <Init-Param> <Am paramn-Name> ContextConfiglocation </ Param-Name> <Param-value> /web-ff /Spring-Servert.xMlL </ Param-value> </nitt-param> <onde-startup> 1 </ charge-on-startup> </ servlet>
Généralement, certaines configurations liées au contrôleur sont configurées dans Spring-servlet.xml, telles que la résolution de vue, la cartographie des fichiers de ressources statiques, l'analyse des résultats de retour, etc.
Voir l'analyse
Cartographie des ressources statiques
<MVC: Ressources location = "/ static /" mapping = "/ static / **" /> <mvc: ressources location = "/ images /" mapping = "/ static / **" /> <mvc: Resources location = "/ css /" mapping = "/ static / **" /> <mvc: Resources location = "/ js /" mApping = "/ static / **" location = "/ html /" mapping = "/ static / **" /> <mvc: ressources location = "/ upload /" mapping = "/ static / **" />
org.springframework.context.support.resourcebundleMessagesource
Analyse des résultats
3. ApplicationContext.xml est une configuration au niveau du système, et sa portée de la fonction est le contexte du système. Son initialisation doit être configurée dans Context-Param dans web.xml.
<Touxet-Param> <Am param-name> ContextConfiglocation </ Param-Name> <Amam-Value> CLASSPATH: conf / Spring / Spring - *. Xml </ Param-Value> </ Context-Param>
4. Concernant les applicationsContxt.xml, il est généralement divisé en plusieurs fichiers de configuration en fonction de la fonction, tels que:
Résumer
Ce qui précède est l'intégralité du contenu de cet article. J'espère que le contenu de cet article a une certaine valeur de référence pour l'étude ou le travail de chacun. Si vous avez des questions, vous pouvez laisser un message pour communiquer. Merci pour votre soutien à wulin.com.