Startseite>Tutorial zur Netzwerkprogrammierung>Java-Tutorial

Vollständiges Beispiel -Tutorial für die Spring MVC+Fastjson+Swagger -Integration

Autor：Eve Cole Aktualisierungszeit：2025-08-12 15:00:04

Grundteile

1. Einführung in Fastjson

Fastjson ist eine Java -Bibliothek, mit der Java -Objekte in JSON -Darstellungen umgewandelt werden können. Es kann auch verwendet werden, um eine JSON -Zeichenfolge in ein äquivalentes Java -Objekt umzuwandeln. Es sollte die schnellste Konversionsgeschwindigkeit sein und ist fast zur Standardkonfiguration von Projekten geworden (Fastjson wird normalerweise anstelle von Jackson verwendet, wenn AJAX -Anforderung und Schnittstellenentwicklung).

Github: https://github.com/alibaba/fastjson (lokaler Download)

Merkmal:

  • Bietet die beste Leistung auf der Serverseite und auf der Android -Client -Seite
  • Konvertieren Sie Java -Objekte, die JSON und umgekehrt einfache Methoden für tojonstring () und parseobject () liefern
  • Ermöglicht das vorhandene unveränderliche Objekt von JSON
  • Umfangreiche Unterstützung für Java -Generika
  • Benutzerdefinierte Darstellungsobjekte zulassen
  • Unterstützt willkürliche komplexe Objekte (Tiefvererbungshierarchie und weit verbreitete Verwendung generischer Typen)

Hauptmerkmale:

  • Schnell (schneller als alle anderen Java-basierten Parsers und Generatoren, einschließlich Jackson)
  • Leistungsstark (unterstützt normale JDK -Klassen, einschließlich einer Java -Bohnenklasse, Sammlung, Karte, Datum oder Enum)
  • Null Abhängigkeit (keine Abhängigkeit von einer anderen Klassenbibliothek mit Ausnahme von JDK)
  • Unterstützungsanmerkungen

2. Fastjson API

Die Fastjson -API -Eintragsklasse ist com.alibaba.fastjson.json. Gemeinsame Serialisierungsvorgänge können direkt mit statischen Methoden in der JSON -Klasse abgeschlossen werden.

 // JSON -Text als JSONObject oder JsonArray öffentliches statisches endgültiges Objekt analysieren (String -Text); // JSON -Text in jsonObject Public static Final JsonObject ParseObject (String Text) analysieren; // JSON -Text als javabäische öffentliche statische endgültige <t> t ParseObject (String Text, Klasse <T> Clazz); // JSON -Text in JsonArray Public Static Final JsonArray Parsearray (String Text) analysieren; // den JSON -Text in die JavaBean Collection öffentliche statische endgültige <T> -Liste <T> Parsearray (String Text, Klasse <T> Clazz) analysieren; // javabean in json text public static Final String tojonstring (Objektobjekt); // Javabäer in formatiertem Jaucher serialisieren (Objektobjekt, boolean adformat); // Javabean in JsonObject oder jsonArrayPublic statisches endgültiges Objekt Tojson (Objekt JavaObject);

JsonArray: entspricht der Liste <Object>

JsonObject: äquivalent zu Karte <String, Objekt>

SerializeConfig: ist eine spezielle Konfiguration für einige Serialisierungsprozesse während des Serialisierungsprozesses, z. B. das Formatieren einiger Felder (Datum, Aufzählung usw.).

SerializeWriter: entspricht StringBuffer

SerializerFeature -Eigenschaft:

  • QuoteFieldNames Ob Sie bei der Ausgabe von Taste doppelte Zitate verwenden, ist Standard wahr, dass dies wahr ist
  • Verwendungslequotes verwendet einzelne Zitate anstelle von doppelten Zitaten, Standardeinstellungen zu False
  • WritemapnullValue: Das Feld mit einem Wert von Null ist standardmäßig falsch falsch
  • RecordEnuSusingToString Enum -Ausgangsname () oder Original, Standard ist falsch
  • UseSO8601DateFormat Datum verwendet ISO8601 -Formatausgabe, Standard ist falsch
  • WriteNullListasempty -Liste Wenn Null NULL ist, ist die Ausgabe [], nicht NULL
  • WriteNullStringasempty -Zeichenfeld Wenn null null ist, ist die Ausgabe "" anstelle von NULL
  • WriteNullNumberaszero numerisches Feld Wenn null null ist, ist die Ausgabe 0, nicht null
  • WriteNullbooleanasFalse Wenn das Boolesche Feld null ist, ist die Ausgabe falsch, nicht null
  • Wenn SkipTransientfield wahr ist, ist das entsprechende Feld der GET -Methode in der Klasse vorübergehend und wird während der Serialisierung ignoriert. Standard ist wahr
  • Sortfield wird ausgegeben, indem der Feldname sortiert wird. Standard ist falsch
  • WriteTaBASSPecial Escapes /T, Standard ist falsch, nicht empfohlen
  • PrettyFormat, ob das Ergebnis formatiert ist, standardmäßig falsch
  • WriteClassName schreiben Typinformationen beim Serialisieren, Standard ist falsch. Deserialisierung ist erforderlich
  • DeSableCircularReferenceTect eliminiert das Problem der kreisförmigen Verweise auf dasselbe Objekt, standardmäßig auf False
  • WritesLashAsspecial Escapes Slash '/'
  • Browsercompatible serialisiert chinesisches to /uxxxx -Format mit mehr Bytes, aber es ist mit IE 6 kompatibel, und der Standard ist falsch
  • WritedateUseUtateFormat Global ändern das Datumsformat, Standard für false. JSON.DEFFAULT_DATE_FORMAT = "YYYY-MM-DD"; JSON.TOJSONSTRING (OBJ, SerializerFeature.writedateUsedateFormat);
  • DeABLECECKKSPECIALCHAR Wenn es im String -Attribut eines Objekts Sonderzeichen wie doppelte Zitate gibt, gibt es ein Backslash -Übertragungszeichen, wenn er in JSON konvertiert wird. Wenn es nicht entkommen muss, können Sie diese Eigenschaft nutzen. Standard ist falsch
  • NichtwriterootClassname Bedeutung
  • BeantoArray wandelt ein Objekt in eine Array -Ausgabe um
  • WriteNonstringKeyAsstring
  • Nicht geschriebeneFaultValue
  • Browsersecure
  • Ignorenonfieldgetter
  • Schreibenname

Praktischer Teil

1. Einführen von Spring MVC und Fastjson -Abhängigkeiten in pom.xml

 <project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.mengdee</groupId> <artifactId>platform-springmvc-webapp</artifactId> <packaging>war</packaging> <version>0.0.1-SNAPSHOT</version> <name>platform-springmvc-webapp Maven Webapp</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <junit.version>3.8.1</junit.version> <log4j.version>2.5</log4j.version> <jstl.version>1.2</jstl.version> <spring.version>4.2.3.RELEASE</spring.version> <fastjson.version>1.2.32</fastjson.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>${jstl.version}</version> </dependency> <!-- springframework --> <dependency> <gruppeId> org.springFramework </gruppeId> <artifactId> Spring-webmvc </artifactId> <version> $ {Spring.version} </Version> </abhängig> <abhängigkeit> <gruppe org. <Depepecy> <GroupId> org.springFramework </Groupid> <artifactId> Spring-Context </artifactId> <version> $ {Spring.version} </Version> </abhängig> <Depapecing> <gruppe-org.springFramework </gruppen> <artifactid> spring-context-support-support-support-support-artifactid> <artifactid> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version> $ {fastjson.version} </Version> </abhängig> </abhängig> <!-mit Aliyun Mirror-> <Repositories> <Repository> <id> aliyun </id> <name> aliyun </name> <url> http://mavaN.aliyun.com/nexus/nexus/nexus/nexus/nexus/nexus/cont/-maven.aliyun.com/nexus/cont./kluxs/nucen.aliyun.com/nexus/cont./kluxs/nucen.aliyun.com/nexus/cont/guloups/- maven.aliyun.com/nexus/cont/grauprus/- </repository> </repository> </repository> </repository> <builds> <finalName> plattformspringmvc-webapp </ledigname> </build> </project>

2. Konfigurieren Sie web.xml

 <! DocType web-app public "-// sun microsystems, Inc.//dtd web Application 2.3 // en" "http://java.sun.com/dtd/web-app_2_3.dtd"> <web-App> <doildr. <param-value>classpath:conf/spring/spring-*.xml</param-value> </context-param> <listener> <description>Spring listener</description> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <servlet> <servlet-name>spring-mvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/spring-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <Servlet-Mapping> <Servlet-Mapping> <Servlet-Name> Spring-MVC </Servlet-Name> <URL-Pattern>/</url-mudern> </servlet-mapping> <filter> <filter-name> Zeichenschützer </Filter-Name> <Filterklasse> org.springFramework.web.filter.Charactercodingfilter </Filter-Klasse> <init-param> <param-name> codieren </param-name> <param-value> utf-8 </param-value> </init-param> <init-param> <param-name <param-value> true </param-value> </init-param> </filter> <filter-mapping> <Filter-name> Charactercodingfilter </filter-name> <url-pufter>/*</url-pufter> </filter-file-file-file> file-file> -pile>/index.-/inindex.-/index.-/index.-/index.-/index.-/index. <Fehlercode> 404 </fehlercode> <position> /Index.jsp </location> </fehlerpage> </web-App>

3. Konfigurieren Sie Spring-Service.xml

 <? xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/context" xmlns: mvc = "http 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-2.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/sschema/context/context/context/skontext/sping-context-context-context-context-context-context-contextextext/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdema/sdeme <Context: Komponent-scan-Basis-Package = "com.mengdee.Manage.Controller"/> <bean id = "viewResolver"> <Eigenschaft name = "prefix" value = "/"> </probium> <!-Präfix der Ansichtsdatei-> <Property name = "suffix" value = ". kann auch Geschwindigkeit und andere Dinge verwenden-> <Eigenschaft name = "viewClass" value = "org.springFramework.web.servlet.view.jstlview"> </property> </bean> <!-Start Spring MVC-Annotationsfunktion, um die Zuordnung von Anfragen und Annotationspojos-> <MVC: Annotation-DRiven> <mvc: Message-Converters-> <MVC: Annotation-Driven> <mvc: Message-DRiven> <mvc: Message-DRiven> <mvc: Message-DRiven: Register-Defaults = "true"> <!-Fastjson konfigurieren, um den ursprünglichen Jackson-Support zu ersetzen-> <bean> <Eigenschaft name = "SupportedMediTypes"> <list> <wert> text/html; charSet = utf-8 </value> <value> Anwendung/JSON </value> </list> </orient> <Eigenschaft> </achapiens. Zitate beim Ausgeben von Schlüssel, Standard für true-> <wert> writemapnullValue </value> <!-Ob ein Feld mit einem Nullwert ausgibt, standardmäßig zu False-> <!-<wert> deaktiviertCircularReferenceTect </value> <wert> WritedatedateFormat </value> <WriteferenceNenceTect </value> <Value> WritedateFormat </value> <WriteNlaNeNlaNence. <wert> WriteNullNumberaszero </value> Wenn das numerische Feld null ist, ist die Ausgabe 0, nicht null <wert> writeNullbooleanasfalse </value> booleanes Feld null, die Ausgabe ist falsch, nicht null <wert> writeNulllistasempty </value> List -Feld ist null, die Output ist nicht null, nicht null -> </</omite> </mvc: Nachrichtenkonverter> </mvc: Annotationsgetrieben> </beans>

4. Java

Bildung: Bildung (Aufzählungsklasse)

 package com.mengdee.manage.entity;import java.util.HashMap;import java.util.Map;/** * Education* @author Administrator * */public enum Education { KINDERGARTEN("Kindergarten", 1), ELEMENTARY("Elementary School", 2), JUNIOR_MIDDLE("Junior High School", 3), SENIOR_MIDDLE("High School", 4), Universität ("Universität", 5), College ("College", 6); private statische endgültige Karte <Integer, Education> Education_map = New HashMap <Integer, Education> (); static {für (Education Education: Education.Values ()) {Education_Map.put (Education.getIndex (), Education); }} privater String -Text; privater Int -Index; Private Education (String Text, int Index) {this.text = text; this.index = index; } public string getText () {return text; } public void setText (String text) {this.text = text; } public int getIndex () {return index; } public void setIndex (int index) {this.index = index; } public static Education Getenum (Integer -Index) {return Education_map.get (Index); }}

Person:

 Paket com.mengdee.manage.entity; import Java.util.ArrayList; Import Java.util.date; Import Java.util.List; Import java.util.map; privater Zeichenfolge Name; privates Byte -Geschlecht; // Geschlecht 1: männlich 2: weibliches privates kurzes Alter; // privates langes Gehalt; // Gehalt privates Doppelgewicht; // Gewicht privater Char Level; // Bewertung privater Booleaner Erwachsener; // ob Erwachsener Privatdatum Geburtstag; // Geburtstag privater Bildung Bildung; // Bildungsqualifikation Private String [] Hobbys; // Hobbys Private List <Dog> Hunde; // Blatthund Private Map <String, Objekt> Adresse; // Adresse // Anmerkungen verwenden, um zu steuern, ob Sie @jsonfield (serialize = false) private list <objekt> obj = new ArrayList <> () serialisieren möchten; public person () {} public person (Long ID, String -Name, Byte -Geschlecht, kurzes Alter, langes Gehalt, Doppelgewicht, Zeichenniveau, Boolean Erwachsener, Datum Geburtstag, String [] Hobbys, List <dog> Hunde, Karte <String, Objekt> Adresse) {Super (); this.id = id; this.name = name; this.Geper = Geschlecht; this.age = Alter; this.Salary = Gehalt; this.gewicht = Gewicht; this.level = Level; this.adult = Erwachsener; this.birthday = Geburtstag; this.hobbies = Hobbys; Dies.Dogs = Hunde; this.address = 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 byte getGender () {Return Gender; } public void setGender (Byte Geschlecht) {this.GENDER = Gender; } public Short getage () {Return Age; } public void Setage (kurzes Alter) {this.age = älter; } public long getSalary () {Rückgabegehalt; } public void setSalary (langes Gehalt) {this.Salary = Gehalt; } public double getWeight () {Rückgabegewicht; } public void setWeight (doppeltes Gewicht) {this.weight = Gewicht; } public char getlevel () {return Level; } public void setlevel (char Level) {this.level = Level; } public boolean isadult () {return adult; } public void setAdult (boolean Adult) {this.adult = Adult; } public date getBirthday () {Return Birthday; } public void setBirthday (Datum Geburtstag) {this.birthday = Geburtstag; } // Serialisierte Aufzählungstypen handeln, der Standardwert ist eher serialisierter Enumswert Zeichenfolge als der Enum -Bindungs -Index oder der Text @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) öffentliche Bildung geteducation () {Return Education; } @Jsonfield (serialize = false) public void setEducation (Bildungsausbildung) {this.education = Education; } public String [] Gethobbies () {Return Hobbies; } public void Sethobbies (String [] Hobbies) {this.hobbies = hobbies; } public list <dog> getDogs () {return hunde; } public void setdogs (list <hunde> hunde) {this.dogs = hunde; } public map <String, Object> getAddress () {Rückgabeadresse; } public void setAddress (map <String, Objekt> Adresse) {this.address = address; }}

TestController

 Paket com.mengdee.manage.controller; import Java.text.decimalformat; import Java.util.ArrayList; Import Java.util.date; import Java.util.hashMap; import Java.util.List; Import Java.util.map; org.springframework.web.bind.annotation.requestmapping; import org.springframework com.alibaba.fastjson.serializer.Serializeconfig; Import com.alibaba.fastjson.Serializer com.mengdee.manage.entity.person; @controllerPublic class testController {private statische SerializeConfig SerializeConfig = New SerializeConfig (); static {serializeConfig.put (Datum.Class, New SimpledateFormatSerializer ("yyyy-mm-dd HH: mm: ss"); serializeConfig.put (double.class, neuer Doppelerializer (neuer Dezimalformat ("0,00")); } @RequestMapping ("//index") public String index () {return "index"; } // javabean, um @RequestMapping ("/json") @ResponseBody Public Object json () {Person person = new Person (); Person.SetId (1L); Person.SetName ("Mengdee"); Person.Setage ((kurz) 18); /// * {"Geburtstag": null, "Gewicht": 0, "Hunde": null, "Erwachsener": Falsch, "Hobbys": null, "Bildung": null, "id": 1, "Level": "", "Adresse": null, "Alter": 18, "Name": "Mengdee", Gender ": 0, 0, 0, 0, 0/ Objekt", ". personjson zurückgeben; } // Javabean to String @RequestMapping ("/json2") @ResponseBody public String json2 () {Person Person = new Person (); Person.SetId (1L); Person.SetName ("Mengdee"); Person.Setage ((kurz) 18); // Wenn der Wert von Null verwendet wird, kann er nicht getestet werden. <Wirt> writeMapnullValue </value> // "{" adult ": falsch," Alter ": 18," Geschlecht ": 0," ID ": 1," Level ":" "," Name ":" mengdee "," Gehalt ": 0," Gewicht ": 0.0}" String JSonstring = json.tojSstring (Person); Rückgabe jSonstring; } @RequestMapping ("/json3") @ResponseBody Public Object json3 () {Person Person = new Person (); Person.SetId (1L); Person.SetName ("Mengdee"); Person.Setage ((kurz) 18); Person.SetBirthday (neues Datum ()); Object personjson = json.tojson (Person); // json.tojson (Person) standardmäßig zu Millisekunden "Geburtstag": 1495073314780, // Verwenden Sie die SerializeConfig-Seriennummer, um die Formatierung für Daten zu konfigurieren // "{" Geburtstag ":" 2017-05-18 10:19:55 "," Gewicht ": 0.0," Erwachsener ": Falsch," ID ": 1," Level ":" "," Alter ": 18," Name ":" Mengdee "," Geschlecht ": 0," Gehalt ": 0}" String jSonstring = json.tojson (Personjson, Serializeconfig); Rückgabe jSonstring; } @RequestMapping ("/json4") @ResponseBody Public Object json4 () {Person Person = new Person (); Person.SetId (1L); Person.SetName ("Mengdee"); Person.Setage ((kurz) 18); Person.SetBirthday (neues Datum ()); Person.Seteducation (Bildung.Universität); // Enumeration String [] Hobbies = {"Reading", "Tourism"}; Person.Sethobbies (Hobbys); Dog Dog1 = neuer Hund (1L, "Dog1", (kurz) 1); Dog Dog2 = neuer Hund (2L, "Dog2", (kurz) 2); Liste <hunde> hunde = new ArrayList <> (); hunde.add (hunde1); hunde.add (hunde2); Person.SetDogs (Hunde); Adresse Adresse1 = neue Adresse (1L, "Shanghai Pudong New District"); Adresse Adresse2 = neue Adresse (2L, "Shanghai Baoshan District"); Karte <String, Object> addressmap = new HashMap <> (); adressmap.put (address1.getId () + "", address1); adressmap.put (addres2.getId () + "", address2); Person.SetAddress (addressmap); Object personjson = json.tojson (Person); personjson zurückgeben; } @RequestMapping ("/json5") @ResponseBody Public String json5 () {Dog Dog1 = neuer Hund (1L, "Dog1", (kurz) 1); Dog Dog2 = neuer Hund (2L, "Dog2", (kurz) 2); Liste <hunde> hunde = new ArrayList <> (); hunde.add (hunde1); hunde.add (hunde2); // LIST <T> -> JSON STRING JSONSTRING = JSON.TOJSONSTRING (Hunde, Falsch); System.out.println (jSonstring); // JSON -> LIST <T> LIST <Dog> Parsearray = json.ParSearray (JSonstring, Dog.class); für (Hundhund: Parsearray) {System.out.println (Hund); } Map <String, Hund> map = new HashMap <String, Dog> (); map.put ("hunde1", neuer hund (1l, "hunde1", (kurz) 1)); MAP.PUT ("Dog2", neuer Hund (2L, "Dog2", (kurz) 2)); MAP.PUT ("Dog3", neuer Hund (3L, "Dog3", (kurz) 3)); // map -> json string mapjonstring = json.tojonstring (map, true); System.out.println (MapJonstring); // json -> map @SuppressWarnings ("deaktiviert") map <String, Hund> map1 = (map <String, Hund>) json.Parse (mapJonstring); für (String -Schlüssel: map1.keyset ()) {System.out.println (Schlüssel + ":" + map1.get (Schlüssel)); } // Array -> json string [] Hobbies = {"a", "b", "c"}; String hobbiessstring = json.tojonstring (Hobbys, wahr); System.out.println (Hobbys); // JSON -> Array JsonArray jsonArray = json.ParSearray (Hobbiessstring); für (Objekt O: jsonArray) {System.out.println (o); } System.out.println (jsonArray); Rückgabe jSonstring; }}

Swagger -Integration

Schritt 1: Verwandte Abhängigkeiten einführen

 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.6.1</version> <scope>compile</scope></dependency><dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version> 2.6.6 </Version> </abhängig>

Schritt 2: Swagger -Informationskonfiguration

Swaggerconfig.java

 @Configuration@enableWebmvc@enableWagger2Public Class SwaggerConfig {@Bean public docket CustomDocket () {docket docket = new docket (documentationType.swagger_2); docket.apiinfo (apiinfo ()); Docket.Select (). APIS (RequestHandLerectors.withmethodannotation (apioperation.class)); Docket.Select (). Pfade (PathSelectors.regex ("/api /.*")). Build (); Rückgabedockt; } private apiinfo apiinfo () {contact = new contact ("xiao ming", "http://www.baidu.com", "[email protected]"); RECHTEN SIE NEUE APIINFO ("API Interface", // Big Title "API Interface", // Untertitel "0.0.1", // Version "www.baidu.com", // TermsOfServiceUrl -Kontakt, // Autor "api interface", // Link Display Text " }}

Hinweis: Da die SwaggerConfig-Klasse Anmerkungen konfiguriert, muss diese Klasse gescannt werden, dh die Klasse muss in den Kontext enthalten sein: Komponenten-Scan.

Schritt 3: Verwenden Sie Anmerkungen zu Klassen, Methoden und Parametern

 @Controller@RequestMapping("/api/v1")@Api(description = "API interface")public class ApiController { @ApiOperation(value = "User login", notes = "User login interface") @ApiResponses({ @ApiResponse(code = 0, message = "success"), @ApiResponse(code = 10001, message = "User name error", response = IllegalArgumentException.class), @apiresponse (Code = 10002, Message = "Passwort-Fehler")}) @RequestMapping (value = "/user/login", method = requestMethod.post, produziert = {"Anwendung/JSON; Charset = utf-8; = true) @RequestParam String Benutzername, @APIPARAM (name = "password", value = "password", fordert = true) @RequestParam String Passwort) {return "{'Benutzername': '" + username + "', 'Passwort': '" + "Passwort +"' '} "; } @ApiImplicitParams({ @ApiImplicitParam(paramType = "header", name = "phone", dataType = "String", required = true, value = "mobile number"), @ApiImplicitParam(paramType = "query", name = "nickname", dataType = "String", required = true, value = "nickname", defaultValue = "double-click 666 "), @APIimPlicitParam (paramtype =" path ", name =" plattform ", dataType =" string ", fordert = true, value =" plattform ", defaultValue =" pc "), @apiimPlictParam (paramtype =" body ", name =" passytype "@Requestmaping =" String "," True "," True ". "/{platform}/user/regist", method = RequestMethod.POST, produces = {"application/json;charset=UTF-8;"}) @ResponseBody public String regist(@RequestHeader String phone, @RequestParam String nickname, @PathVariable String platform, @RequestBody String password){ return "{'username':'" + phone + "', 'Spitzname': '" + Spitzname +"', 'Plattform': '" + Plattform +"', 'Passwort': '" + Passwort +"'} "; } @RequestMapping (value = "/user/list", method = requestMethod.get, produziert = {"application/json; charset = utf-8;"}) @Responbody public String getUserList (Pager Pager) {return "[{'id':"+pager.getPage ()+, 'username': 'username': 'Zhangsan "+pager.getSize ()+"'}] "; } @RequestMapping ("/docs") @apiignore public String test () {return "api-docs"; }}

Pager

 public class pager {@apimodelProperty (value = "Seitenzahl", erforderlich = true) private int page; @ApimodelProperty (value = "Anzahl der pro Seite", erforderlich = true) private int -Größe; public pager () {} public int getPage () {return page; } public void setPage (int page) {this.page = page; } public int getSize () {Rückgabegröße; } public void setSize (int size) {this.size = Größe; }}

Häufige Anmerkungen:

  • @API (Beschreibung = "Beschreibung der Schnittstellenklasse")
  • @Apioperation (value = "Name der Schnittstellenmethode", Notes = "Hinweis Beschreibung")
  • @APIPARAM (name = "Parametername", value = "Anmerkung Beschreibung", erforderlich = ob es erforderlich ist): Es ist im Parameter der Methode gekennzeichnet, um den Namen zu beschreiben, Anmerkungen, ob erforderlich usw. des Parameters.
  • @ApiimPlictParam (paramtype = "query", name = "password", dataType = "String", fordert = true, value = "passwart", defaultValue = "123456") wird verwendet, um die Parameter der Methode zu beschreiben. Es ist auf der Methode markiert, genau wie die Funktion @apiparam, aber die Annotationsposition ist unterschiedlich.
    .Paramtype: Parametertyp, dh wo die Parameter platziert werden sollen
    . Header> Anforderungsparameter erhalten: @Requestheader, der Parameter wird in den Anforderungsheader platziert
    . Abfrage> Anforderungsparameter Akquisition: @RequestParam, Parameter endet nach der URL an
    . Pfad (für eine erholsame Schnittstelle)> Abrufen von Anforderungsparametern: @PathVariable
    . Body verwenden @RequestBody, um Datenposten zu empfangen, und die Parameter werden in die Anforderungsbehörde platziert.
    .bilden
    .Name: Parametername
    .Datatype: Der Datentyp des Parameters
    . Erforderne: Ob der Parameter übergeben werden muss
    .Value: Beschreibung der Parameter
    .DefaultValue: Der Standardwert des Parameters
  • @ApiimplicitParams: Wird verwendet, um mehrere @apiimplicitParams zu enthalten
  • @Apiresponse (Code = 0, Message = "Erfolg"),
    .code: Antwortcode, zum Beispiel 400
    .Message: Informationen, im Allgemeinen eine Beschreibung des Codes
    .Response: Klasse, die Ausnahme ausgelegt hat
  • @Apimodel: Beschreiben Sie die Informationen eines Modells (dies wird normalerweise beim Erstellen eines Beitrags mit @RequestBody -Szenarien verwendet, und die Anforderungsparameter können nicht mit @APIimPlictaram -Annotation beschrieben werden).
    @ApimodelProperty: Beschreiben Sie die Eigenschaften eines Modells
    . Die Position ermöglicht eine explizite Sortierung von Eigenschaften im Modell.
    . Wertparametername
    . erforderlich, ob Boolesche erforderlich ist
    . versteckt, ob Boolean versteckt ist
    . erzeugend Values = "Bereich [0, 1]" wird im Allgemeinen verwendet, um den rechtlichen Wert des Parameters anzugeben
  • @Apiignore: Wird für diese Schnittstelle verwendet oder weglassen und keine Dokumentation für diese Schnittstelle generieren

Schritt 4: Zugriff /V2 /API-Docs

Besuchen

Schritt 5: Download Swagger-UI

Laden Sie https://github.com/swagger-api/swagger-ui von github herunter. Beachten Sie, dass Sie Download v2.2.10 (https://github.com/swagger-api/swagger-ui/tree/v2.2.10 (lokaler Download)) auswählen müssen. Die Integrationsmethode, die größer als diese Version ist, ist unterschiedlich.

Integrationsmethode: Fügen Sie alle Dateien in das DIM -Verzeichnis unter v2.2.10 in statische Dateien in Ihrem Projekt ein und verwenden Sie den folgenden Code, um den Skriptteil in index.html zu überschreiben.

 <script type = "text/javaScript"> var baseUrl = ""; $ (function () {var url = window.location.search.match (/url = ([^&] +)/); if (url && url.length> 1) {url = decodeuricomponent (url [1]);} else {// die oben beschriebene API-Docs-Adresse von API-docs. (window.swaggerTranslator) {window.swaggerTranslator.translate (); (swaggerApi, swaggerUi) { if (typeof initOAuth == "function") { initOAuth({ clientId: "your-client-id", clientSecret: "your-client-secret-if-required", realm: "your-realms", appName: "your-app-name", scopeSeparator: ",", additionalQueryStringParams: {} }); } if (window.swaggertranslator) {window.swaggertranslator.translate (); "Keine", JsonEditor: False, Apissorter: "Alpha", defaultModelrendering: 'Schema', Showrequestheaders: False}); Token, "Header"); </script>

Schritt 6: Zugriff auf den oben geänderten Index.html
http: // localhost: 8080/Projektname/static/Drittanbieter/Swagger-UI/index.html

Hinweis: Da Sie auf statische Ressourcen zugreifen möchten, stellen Sie bitte sicher, dass auf statische Ressourcen mit SpringMVC zugegriffen werden können. Wenn Sie nicht zugreifen können, stellen Sie bitte die folgende Konfiguration vor:

1. Fügen Sie den Standard -Servlet -Prozessor zur Federkonfigurationsdatei hinzu

 <!-Filter statische Ressourcen-> <MVC: Standard-Service-Handler/>

2. Fügen Sie statische Dateien hinzu, um in web.xml zu filtern

 <!-Filterung statische Ressourcen-> <Servlet-Mapping> <Servlet-Name> Standard </Servlet-Name> <URL-Muster>*. Js </url-pufter> <URL-Muster>*. <URL-Muster>/Bilder/*</url-muster> </servlet-Mapping>

Beispielprojektcode -Struktur:

Das vollständige Beispiel Demo-Download-Adresse: http://xiazai.vevb.com/201804/yuanma/platform-springmvc-webapp(vevb.com).rar

andere

Über Spring-servlet.xml und ApplicationContext.xml

SpringMVC bietet zwei Konfigurationsdateien Spring-servlet.xml und applicationContext.xml
Spring-servlet.xml ist eine Controller-Ebene, und sein Aktionsumfang ist die Steuerungsschicht. Der Standardname ist [Servlet-name] -servlet.xml
Standardmäßig wird es im Web-Inf/ Verzeichnis platziert. SpringMVC lädt automatisch und kann auch in web.xml konfiguriert werden.

 <servlet> <Servlet-name> Spring-MVC </Servlet-name> <servlet-classe> org.springFramework.web.servlet.DispatcherServlet </Servlet-Class> <init-param> <param-name> contextconFigLocation </param-value> /webinf/sping-Seilt.xml < </init-param> <load-on-startup> 1 </load-on-startup> </servlet>

Im Allgemeinen sind einige Controller-bezogene Konfigurationen in Spring-servlet.xml konfiguriert, z.

Analyseanalyse

  • org.springframework.web.servlet.view.urlbasedViewresolver
  • TILES3: org.springframework.web.servlet.view.tiles3.tilesconfiger
  • SpringMVC: org.springframework.web.servlet.view.internalresourceViewresolver,
  • shiro: org.apache.shiro.spring.security.interceptor.authorizationAttributesourceadvisor
  • Hochladen org.springframework.web.multipart.commons.commonsmultipartresolver,

Statische Ressourcenzuordnung

 <MVC: Ressourcen location = "/static/" maping = "/static/**"/> <mvc: Ressourcen locum = "/bilder/" maping = "/static/**"/> <mvc: Ressourcen locum = "/css/" maping = "/static/**"/> <mvc: ressourcen loces = "/js/" maping location = "/html/" maping = "/static/**"/> <mvc: ressourcen location = "/upload/" maping = "/static/**"/>

org.springframework.context.support.resourcebundLemessageSource

Ergebnisanalyse

  • FASTJSON: Com.alibaba.fastjson.Support.spring.fastjsonhttpMessageConverter

A ApplicationContext.xml ist eine Konfiguration auf Systemebene, und der Funktionsumfang ist der Systemkontext. Die Initialisierung muss in Context-Param in web.xml konfiguriert werden.

 <Context-Param> <param-name> contextconfigLocation </param-name> <param-value> classPath: conf/fing/fing-*. xml </param-value> </context-param>

V.

  • - ApplicationContxt-Base.xml // Grundlagen
  • - applicationContxt-redis.xml // redisbezogene Konfiguration
  • - applicationContxt-shiro.xml // Shiro-bezogene Konfiguration
  • - applicationContxt-dao.xml // Datenbankbezogene Konfiguration
  • - ApplicationContxt-xxx.xml // xxx

Zusammenfassen

Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Referenzwert für das Studium oder die Arbeit eines jeden hat. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen. Vielen Dank für Ihre Unterstützung bei Wulin.com.

Ähnliche Artikel