Tutorial de ejemplo completo para Spring MVC+FastJson+Integración de Swagger

Autor：Eve Cole Fecha de actualización：2025-08-12 15:00:04

Partes básicas

1. Introducción a Fastjson

Fastjson es una biblioteca Java que puede usarse para convertir los objetos Java en representaciones JSON. También se puede usar para convertir una cadena JSON en un objeto Java equivalente. Debe ser la velocidad de conversión más rápida y casi se ha convertido en la configuración estándar de los proyectos (FastJson generalmente se usa en lugar de Jackson cuando Ajax solicita y desarrollo de interfaz).

Github: https://github.com/alibaba/fastjson (descarga local)

característica:

Proporciona el mejor rendimiento en el lado del servidor y el lado del cliente de Android
Convertir objetos Java que proporcionan métodos simples de injsonstring () y parseObject () a JSON y viceversa
Permite convertir el objeto inmutable existente desde JSON
Un amplio apoyo para los genéricos de Java
Permitir objetos de representación personalizados
Admite objetos complejos arbitrarios (jerarquía de herencia profunda y uso generalizado de tipos genéricos)

Características principales:

Rápido rápido (más rápido que cualquier otro analizador y generadores basados en Java, incluido Jackson)
Potente (admite clases JDK normales que incluyen cualquier clase Java Bean, colección, mapa, fecha o enum)
Dependencia cero (sin dependencia de ninguna otra biblioteca de clase excepto JDK)
Anotaciones de apoyo

2. API de FastJson

La clase de entrada de la API de Fastjson es com.alibaba.fastjson.json. Las operaciones de serialización comunes pueden completarse directamente mediante métodos estáticos en la clase JSON.

 // PARSE JSON TEXT como JSONObject o JSONArray Public Static Final Object Parse (texto de cadena); // Pase el texto JSON en JSONObject público estático final JSONObject parseObject (texto de cadena); // El texto de JSON como Javabean Public Static Final <T> T ParseObject (texto de cadena, clase <T> clazz); // Pase el texto JSON en JSONArray Public Static final JSONArray Parsearray (texto de cadena); // analizar el texto JSON en Javabean Collection Public Static Static Final <t> List <T> Parsearray (texto de cadena, clase <t> clazz); // Serializa a Javabean en JSON Text Public static final String TojSonstring (Object Object); // Serializar a Javabean en JSonstring formateado (objeto de objeto, boolean bittleFormat); // Convertir Javabean a JSONObject o JSONArrayPublic estático Final Object Tojson (Object JavaObject);

JSONArray: equivalente a List <S Object>

JsonObject: equivalente a map <string, object>

SerializeConFig: es una configuración especial para algunos procesos de serialización durante el proceso de serialización, como el formateo de algunos campos (fecha, enumeración, etc.)

SerializeWriter: equivalente a StringBuffer

Propiedad SerializerFeature:

QuoteFieldNames Si se debe usar cotizaciones dobles al emitir la clave, el valor predeterminado es verdadero
UsseLingQuotes usa cotizaciones individuales en lugar de cotizaciones dobles, predeterminada a falso
WriteMapnullValue: el campo con un valor de nulo es falso de forma predeterminada
WriteNUMUSINGTOSTRING ENUM Nombre de salida () o original, predeterminado es falso
UseISO8601 DateFormat Date usa la salida del formato ISO8601, el valor predeterminado es falso
WriteNullListAsempty List Field Si Null es nulo, la salida es [], no nula
Campo de tipo de caracteres WriteNullStringAsempty Si Null es nulo, la salida es "" en lugar de NULL
Campo numérico de WriteNullNumberAszero Si nulo es nulo, la salida es 0, no nula
Writenullbooleanasfalse Si el campo booleano es nulo, la salida es falsa, no nula
Si Skiptransientfield es verdadero, el campo correspondiente del método GET en la clase es transitorio, y se ignorará durante la serialización. El valor predeterminado es verdadero
Sortfield se emite clasificando el nombre del campo. El valor predeterminado es falso
WriteTabassPecial Escapes /T, el valor predeterminado es falso, no recomendado
BretyFormat si el resultado está formateado, predeterminado a falso
WriteClassName Escribir información de tipo de escritura Al serializar, el valor predeterminado es falso. Se requiere deserialización
DisableCircularReFerEDEdect Elimina el problema de la referencia circular al mismo objeto, el valor predeterminado a False
WriteslashassPecial escapa de escogollos '/'
BrowserCompatible serializa el chino al formato /uxxxxx, con más bytes, pero es compatible con IE 6, y el valor predeterminado es falso
WRITEDATEUSEUDETAFORMAT Global Modificar el formato de fecha, predeterminado a FALSE. Json.deffault_date_format = "yyyy-mm-dd"; json.tojsonstring (obj, serializerFeature.WritedateDateAteFormat);
DisableCheckSpecialChar Si hay caracteres especiales como citas dobles en el atributo de cadena de un objeto, tendrá un carácter de transferencia de barra de inverso cuando se convierte a JSON. Si no hay necesidad de escapar, puede usar esta propiedad. El valor predeterminado es falso
Nowriterootclassname significado
Beantoarray convierte un objeto en una salida de matriz
WritenonstringKeyAstring
NowritedefaultValue
Seguridad en el navegador
Ignorenonfieldgetter
WriteenumusingName

Parte práctica

1. Introducir dependencias de Spring MVC y Fastjson en pom.xml

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/maven-v4_0_0.xsd "> <modelVersion> 4.0.0 </modelVersion> <MoupRupid> com.mengdee </groupid> <artifactId> Plataforma-springmvc-weBApp </afactid> <calAging> war </packaging> <versión> 0.0.1snapsapspapp <//packaging> war </packaging> <versión> 0.0.1snapsapshot> <name> Plataforma-Springmvc-Webapp Maven WebApp </name> <url> http://maven.apache.org </sl> <properties> <proyecto.build.sourceEncoding> utf-8 </project.build.sourceEncoding> <unit.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> </propiences> <epeitions> <epelpentency> <grupid> junit </groupid> <artifactid> junit </artifactid> <versión> 3.8.1 </versión> <cope> test </cope> </pendency> <pape> <proupid> javax.servlet </proupid> <artifactid> jstl </artifactid> <versión> $ {jstl.Version} </versevers> </versever> </spendency> <spendency> <spendency> <spendiny> <spendency> <pendency> <pendency> <pendency> <pendency> <SpendDeLe> <SpendDeLe> <SpendDeLe> <MoupRid> org.springframework </groupid> <artifactid> spring-webmvc </artifactid> <verserse> $ {spring.version} </versión> </pendency> <pendency> <proupID> org.springframework </groupID> <artactid> spring-coore </artifactid> <lote- Version> $ {spring.versionwork </groupid> <artifactid> Spring-Core </artifactid> <verseversion> $ {Spring. <Spendency> <MoupRupid> org.springframework </proupid> <artifactid> Spring-Context </arfactId> <PROPESPONSE> $ {Spring.version} </versión> </pendency> <Spendency> <ProupId> org.springframework </groupId> <Atifactid> Springcontext-support </artifactID>> <versión> $ {spring.version} </versión> </pendency> <epardency> <mupoupid> org.springframework </proupid> <artifactid> spring-jdbc </artifactid> <version> $ {spring.version} </versión> </dependency> <epardency> <uproupid> com.alibaba <//groupid> <artactid> <artiCid> FastiD> <RARFACDID> ARTIFID> </ArtAftid> <versión> $ {fastjson.version} </versión> </dependence> </pendencs> <!-usando Aliyun Mirror-> <Repositories> <Repository> <id> Aliyun </id> <name> Aliyun </name> <ULL> </Repository> </Repository> </ Repository> </ Repository> <S construye> <finalName> Plataforma-SpringMvc-WebApp </finalName> </build> </proyecto>

2. Configurar web.xml

 <! DocType Web-App public "-// Sun Microsystems, Inc.//dtd Aplicación web 2.3 // en" "http://java.sun.com/dtd/web-app_2_3.dtd"> <web-app> <pantsip-name> arquetype creó aplicación web </sipplave-name> <xid-param> <AmamName> <Amam-Value> classpath: conf/spring/spring-*. xml </marr-value> </cuentute-param> <searcher> <Scuidion> spring oyerer </scription> <searner-class> org.springframe.web.context.contextloaderListener </earer-class> </oyearer> <ervlet> <servlet-name-name-mvc </sidletname> <Servlet-class> org.springframework.web.servlet.dispatcherservlet </servlet-class> <it-param> <amamname> contextconfiglocation </amamname> <amam-value> /webinf/spring-servlet.xml </param-value> </ init-param> <load-startup> 1 </load oad oadp> </loadup> <servlet-mapping> <servlet-mapping> <servlet-name>spring-mvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <amamname> codificación </param-name> <amam-value> utf-8 </param-value> </init-param> <sinparam> <amamname> forceEncoding </paramname> <amam-value> true </param-value> </it-param> </filter> <filter-mapping> <filter-name> caracterescodingfilter </param-value> </param> </filter> <filter-mapping> <filter-name> caracterescodingfilter </param-value> </param> </filter> <filter-mapping> <filter-name> caracteresurencodingfilter </param-value> </param> </filter> <filter-mapping> <filter-name> caracteres-name </filter> <Url-pattern>/*</ url-pattern> </filter-mapping> <welcome-file-list> <calleado-file> /index.jsp </avey-file> </welcome-file-list> <error-page> <sor error> 404 </error-condicional> <gocional> /index.jsp </boation> </error-page> </bage-app>

3. Configurar Spring-Servlet.xml

 <? xml versión = "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/context" xmlns: mvc = "http://www.springframework.org/schema xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.2 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.4.2. <context: component-scan base-pankage = "com.mengdee.manage.controller"/> <bean id = "viewResolver"> <propiedad name = "prefix" value = "/"> </property> <!-Prefix de la vista-> <propiedad name = "sufix" value = ". jsp"> </!-sufix name = " También use Velocity y otras cosas-> <Property Name = "ViewClass" Value = "org.springframework.web.servlet.view.jstlview"> </property> </bean> <!-Iniciar función de anotación MVC para completar la asignación de las solicitudes y la anotación POJOS-> <MVC: annotation-driven> <MVC: CONCERTERS: CONCERTERS register-defaults="true"> <!-- Configure Fastjson to replace the original jackson support--> <bean> <property name="supportedMediaTypes"> <list> <value>text/html;charset=UTF-8</value> <value>application/json</value> </list> </property> <property name="features"> <list> <value>QuoteFieldNames</value> <!-- Whether to use double quotes Al emitir la clave, predeterminado a verdadero-> <valor> writeMapNullValue </value> <!-si se debe emitir un campo con un valor nulo, predeterminado a falso-> <!-<al value> DisableCircularReFerEdEdEnDect </value> <valor> WritedateSeFormat </value> <valor> WriteNullStringasEmpty </value> si el tipo de caracteres es el campo null, null, null, null, no <value>WriteNullNumberAsZero</value> If the numeric field is null, the output is 0, not null <value>WriteNullBooleanAsFalse</value> Boolean field is null, the output is false, not null <value>WriteNullListAsEmpty</value> List field is null, the output is [], not null --> </list> </property> </bean> </MVC: Message-Converters> </MVC: Annotation-Driven> </le Beans>

4. Java

Educación: Educación (clase de enumeración)

 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), Universidad ("Universidad", 5), College ("College", 6); Mapa final estático privado <Integer, Education> Education_map = new Hashmap <Integer, Education> (); static {para (Education Education: Education.Values ()) {Education_map.put (educación.getIndex (), educación); }} Texto de cadena privada; Índice de int privado; Educación privada (texto de cadena, int index) {this.text = text; this.index = index; } public String getText () {return text; } public void setText (texto de cadena) {this.text = text; } public int getIndex () {Index return; } public void setIndex (int index) {this.index = index; } Public Static Education getenum (índice entero) {return Education_map.get (índice); }}

Persona:

 paquete 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; persona de clase pública {ID privada larga; nombre de cadena privada; género de byte privado; // Género 1: Hombre 2: Femenina corta privada; // Edad salario largo privado; // salario de doble peso privado; // Peso nivel de carbón privado; // Calificación de adultos booleanos privados; // Si el cumpleaños de la cita privada para adultos; // Educación de educación privada de cumpleaños; // Calificación educativa Cadena privada [] pasatiempos; // Pasatonios Lista privada <perro> perros; // mapa privado de perro mascota <cadena, objeto> dirección; // Dirección // Use anotaciones para controlar si desea serializar @jsonfield (serialize = false) Lista privada <ject> obj = new ArrayList <> (); Persona pública () {} Persona pública (identificación larga, nombre de cadena, género de bytes, edad corta, salario largo, doble peso, nivel de char, adulto booleano, cumpleaños de cita, cadena [] pasatiempos, lista <dog> perros, mapa <cadena, objeto> dirección) {super (); this.id = id; this.name = name; this.gender = género; this.age = edad; this.salary = salario; this.weight = peso; this.level = nivel; this.adult = adulto; this.birthday = cumpleaños; this.hobbies = pasatiempos; this.dogs = perros; this.address = dirección; } public Long Long getId () {return id; } public void setid (ID long) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public byte getGender () {return gender; } public void setGender (byte gender) {this.gender = gender; } public short getAge () {return Age; } public void setAGE (edad corta) {this.age = edad; } public Long Long getSalary () {salario de retorno; } public void setSalary (salario largo) {this.salary = salario; } public Double GetPeight () {return peso; } public void setweight (doble peso) {this.weight = weight; } public char getLevel () {nivel de retorno; } public void setLevel (nivel de char) {this.level = nivel; } public boolean isadult () {return adulto; } public void setadult (adulto boolean) {this.adult = adulto; } Fecha pública GetBirthday () {regreso de cumpleaños; } public void setBirthday (cumpleaños de fecha) {this.birthday = cumpleaños; } // manejar los tipos de enumeración serializada, el valor predeterminado es la cadena de valor enum serializada, en lugar del índice de enlace enum o 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) Educación pública getEducation () {return Education; } @Jsonfield (serialize = false) public void setEducation (educación educativa) {this.education = educación; } public String [] gethobbies () {return hobbies; } public void sethobbies (string [] hobbies) {this.hobbies = hobbies; } lista pública <dog> getdogs () {return perros; } public void setDogs (list <dog> perros) {this.dogs = perros; } mapa público <string, object> getAddress () {dirección de retorno; } public void setAddress (map <string, objeto> dirección) {this.address = dirección; }}

TestController

 paquete 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; import org.springframe.stereotype. org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; import com.alibaba.fastjson.serializer.SerializeConfig; import com.alibaba.fastjson.serializer.SimpledateFormatSerializer; import com.mengdee.manage.entity.address; import Com.mengdee.manage.entity.dog; import com.mengdee.manage.entity.education; import.mengdee.manage.Entity.dog; import Com.mengdee.manage.entity.education; com.mengdee.manage.entity.person; @ControllerPublic Class testController {private static serializeConfig serializeConfig = new SerializeConFig (); static {SerializeConfig.put (date.class, nuevo SimpleDateFormatSerializer ("aaa yyyy-mm-dd hh: mm: ss")); SerializeConfig.put (doble. Clase, nuevo doblesserializer (nuevo decimalformat ("0.00"))); } @RequestMapping ("/index") public String index () {return "index"; } // javabean a object @RequestMapping ("/json") @ResponseBody Public Object json () {persona persona = nueva persona (); persona.setid (1l); persona.setName ("Mengdee"); persona.setage ((breve) 18); /// * {"cumpleaños": nulo, "peso": 0, "perros": nulo, "adulto": falso, "pasatiempos": null, "educación": null, "id": 1, "nivel": "", "dirección": null, "edad": 18, "nombre": "Mengdee", "género": 0, "salario": 0} */ personaje de objeto; Regreso Personjson; } // javabean a string @RequestMapping ("/json2") @ResponseBody public String json2 () {persona persona = nueva persona (); persona.setid (1l); persona.setName ("Mengdee"); persona.setage ((breve) 18); // Si se usa el valor de NULL, no se puede probar. <value> writeMapnullValue </value> // "{" adulto ": falso," edad ": 18," género ": 0," id ": 1," nivel ":" "," nombre ":" Mengdee "," salario ": 0," peso ": 0.0}" cadena jsonstring = json.tojsonstring (persona); regresar jsonstring; } @RequestMapping ("/json3") @ResponseBody Public Object Json3 () {Person Person = New Person (); persona.setid (1l); persona.setName ("Mengdee"); persona.setage ((breve) 18); persona.setBirthday (nueva fecha ()); Objeto personajson = json.tojson (persona); // JSON.TOJSON (PERSONA) Predeterminado a MilliseConds "Cumpleaños": 1495073314780, // Use el número de serie serializeConfig para configurar el formato para las fechas // "{" cumpleaños ":" 2017-05-18 10:19:55 "," peso ": 0.0," adulto ": falso," id ": 1," nivel ":" "," edad ": 18," nombre ":" Mengdee "," género ": 0," salario ": 0}" string jsonstring = json.tojsonstring (personajson, serializeconfig); regresar jsonstring; } @RequestMapping ("/json4") @ResponseBody Public Object json4 () {persona persona = nueva persona (); persona.setid (1l); persona.setName ("Mengdee"); persona.setage ((breve) 18); persona.setBirthday (nueva fecha ()); Person.seteducation (educación. Universidad); // String de enumeración [] Hobbies = {"Reading", "Turismo"}; persona.sethobbies (pasatiempos); Perro perro1 = nuevo perro (1L, "Dog1", (corto) 1); Perro perro2 = nuevo perro (2l, "dog2", (corto) 2); List <dog> dogs = new ArrayList <> (); perros.add (perro1); perros. Add (Dog2); Person.setDogs (perros); Dirección dirección1 = nueva dirección (1L, "Shanghai Pudong New District"); Dirección dirección2 = nueva dirección (2L, "Distrito de Shanghai Baoshan"); MAP <String, Object> DirectSmap = new HashMap <> (); directionMap.put (dirección1.getID () + "", dirección1); directionMap.put (dirección2.getid () + "", dirección2); Person.SetAddress (DirectSmap); Objeto personajson = json.tojson (persona); Regreso Personjson; } @RequestMapping ("/json5") @ResponseBody public String JSON5 () {Dog Dog1 = New Dog (1L, "Dog1", (corto) 1); Perro perro2 = nuevo perro (2l, "dog2", (corto) 2); List <dog> dogs = new ArrayList <> (); perros.add (perro1); perros. Add (Dog2); // List <T> -> JSON String JSonstring = json.tojsonstring (perros, falso); System.out.println (jsonstring); // JSON -> Lista <T> List <d dog> Parsearray = json.parsearray (jsonstring, dog.class); para (perro perro: parsearray) {System.out.println (perro); } Map <string, dog> map = new Hashmap <String, Dog> (); map.put ("dog1", nuevo perro (1l, "dog1", (corto) 1)); map.put ("dog2", nuevo perro (2l, "dog2", (corto) 2)); map.put ("dog3", nuevo perro (3l, "dog3", (corto) 3)); // map -> json string mapjSonstring = json.tojsonstring (map, true); System.out.println (MapJSonstring); // JSON -> MAP @SupPressWarnings ("sin verificar") mapa <string, dog> map1 = (map <string, dog>) json.parse (mapjSonstring); for (clave de cadena: map1.keyset ()) {system.out.println (clave + ":" + map1.get (key)); } // array -> json string [] hobbies = {"a", "b", "c"}; Cadena hobbiesString = json.tojsonstring (pasatiempos, verdadero); System.out.println (pasatiempos); // json -> array jsonarray jsonarray = json.parsearray (hobbiesstring); for (objeto o: jsonarray) {System.out.println (o); } System.out.println (JSONArray); regresar jsonstring; }}

Integración de arrogancia

Paso 1: Introducir dependencias relacionadas

 <Spendency> <MoupRoMID> io.springfox </groupid> <artifactid> springfox-swagger2 </arfactid> <verserse> 2.6.1 </versión> <cope> compilar </cope> </pendency> <pendency> <proupid> com.fasterxml.jackson.core </groupid> <artifactid> jackson-datson-databind> <Versión> 2.6.6 </versión> </pendency>

Paso 2: Configuración de información de arrogancia

Swaggerconfig.java

 @Configuration@enablewebmvc@habilswagger2public class swaggerConfig {@Bean public dockket customDocket () {Docket Docket = new Docket (documentAtType.swagger_2); Docket.apiinfo (apiinfo ()); Docket.Select (). APIS (SolicHandLerselectors.WithMethodannotation (apioperation.class)); Docket.Select (). Raths (PathSelectors.Regex ("/API /.*")). Build (); expediente de retorno; } private apiinfo apiInfo () {contact Contact = new Contact ("Xiao Ming", "http://www.baidu.com", "[email protected]"); return New APIInfo ("Interfaz API", // Big Title "API Interface", // Subtitle "0.0.1", // versión "www.baidu.com", // términosfserviceUrl contact, // autor "interfaz API", // vínculo visual de texto "http://www.baidu.com" // sitio web enlace); }}

Nota: Debido a que la clase SwaggerConfig configura las anotaciones, esta clase debe ser escaneada, es decir, la clase debe incluirse en el contexto: Component-Scan.

Paso 3: Use anotaciones en clases, métodos y parámetros

 @Controlador @requestmapping ("/api/v1") @api (descripción = "interfaz de api") public class apicOntroller {@apioperation (valor = "inicio de sesión de usuario", notas = "interfaz de inicio de sesión de usuario") @apirosponseSes ({@apiresponse (código = 0, mensaje = "éxito"), @apiressponse (código = 10001, mensaje de mensaje = "Nombre de usuario", nombre ", respuesta". 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 = "contraseña", valor = "contraseña", requerir = true) @requestparam string contraseña) {return "{'username': '" + username + "', 'contraseña': '" + contraseña + "'}"; }} @ApiimpliceTParams ({{@apiimpliceItParam (paramType = "header", name = "phone", dataType = "string", requerir = verdadero, valor = "número móvil" 666 "), @apiimpliceTparam (paramType =" path ", name =" plataforma ", dataType =" String ", requerido = verdadero, valor =" Plataforma ", defaultValue =" PC "), @ApiimpliceTParam (paramType =" Body ", name =" Password ", datatype =" String ", requerido = verdadero, value =" PASSINTY ")}) @ "/{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 + "', 'Nickname': '" + Nickname +"', 'Plataforma': '" + Plataforma +"', 'contraseña': '" + contraseña +"'} "; } @RequestMapping (valor = "/user/list", método = requestmethod.get, produce = {"aplicación/json; charset = utf-8;"}) @ResponseBody public String getUserList (Pager Pager) {return " 'Zhangsan "+Pager.getSize ()+"'}] "; } @RequestMapping ("/Docs") @apiignore public String test () {return "API-DOCS"; }}

Buscapersonas

 Public Class Pager {@apimodelproperty (valor = "número de página", requerido = true) private int página; @Apimodelproperty (value = "número de por página", requerido = true) tamaño intival privado; public Pager () {} public int getPage () {return Page; } public void setPage (int página) {this.page = page; } public int getsize () {return size; } public void setSize (int tamaño) {this.size = size; }}

Anotaciones comunes:

@Api (descripción = "Descripción de la clase de interfaz")
@Apioperation (valor = "nombre de la interfaz del método", notas = "nota descripción")
@Apiparam (name = "Nombre de parámetro", valor = "Nota Descripción", requerido = si es necesario): está marcado en el parámetro del método para describir el nombre, notas, si es necesario, etc. del parámetro.
@APIimpliceTParam (paramType = "Query", name = "Password", DataType = "String", requerido = verdadero, valor = "Password", DefaultValue = "123456") se usa para describir los parámetros del método. Está marcado en el método, al igual que la función @apiparam, pero la posición de anotación es diferente.
.ParamType: Tipo de parámetro, es decir, dónde colocar los parámetros
. Encabezado> Obtener el parámetro de solicitud: @RequestHeader, el parámetro se coloca en el encabezado de solicitud
. Consulta> Solicitar la adquisición de parámetros: @RequestParam, el parámetro agrega después de la URL
. ruta (para interfaz RESTFUL)> Obtener parámetros de solicitud: @PathVariables
. Uso del cuerpo @RequestBody para recibir la publicación de datos, y los parámetros se colocan en el cuerpo de solicitud.
.forma
.Name: nombre del parámetro
.datatype: el tipo de datos del parámetro
.Required: si el parámetro debe pasarse
. Valor: Descripción de los parámetros
.DefaultValue: el valor predeterminado del parámetro
@ApiimpliceTParams: se usa para contener múltiples @apiimpliceTparams
@Apiresponse (código = 0, mensaje = "éxito"),
.Code: código de respuesta, por ejemplo 400
.Message: información, generalmente una descripción del código
Respuesta: clase que arroja excepción
@Apimodel: Describa la información de un modelo (esto generalmente se usa al crear una publicación, utilizando @RequestBody Scenarios, y los parámetros de solicitud no se pueden describir usando @apiimpliceTparam Annotation)
.@Apimodelproperty: describa las propiedades de un modelo
. La posición permite una clasificación explícita de propiedades en el modelo.
. Nombre del parámetro de valor
. requerido si se requiere booleano
. oculto si el booleano está oculto
. permitidoValues = "rango [0, 1]" se usa generalmente para especificar el valor legal del parámetro
@Apiignore: utilizado u omitir esta interfaz, y no genere documentación para esta interfaz

Paso 4: Access /V2 /API-Docs

Visite http: // localhost: 8080/name de proyecto/v2/api-docs en el navegador, si hay contenido JSON, es normal

Paso 5: Descargar Swagger-UI

Descargue https://github.com/swagger-api/swagger-ui desde Github. Tenga en cuenta que debe seleccionar descargar v2.2.10 (https://github.com/swagger-api/swagger-ui/tree/v2.2.10 (descarga local)). El método de integración que es mayor que esta versión es diferente.

Método de integración: coloque todos los archivos en el directorio DIST en v2.2.10 en archivos estáticos en su proyecto, y use el siguiente código para sobrescribir la parte de script en index.html

 <script type = "text/javaScript"> var baseURL = ""; $ (function () {var url = window.location.search.match (/url = ([^&] +)/); if (url && url.length> 1) {url = decodeuriCoponent (url [1]);} else {// la dirección API-DOC descrita anteriormente = Baseurl + "/webapp/v2/api-docs"; (Window.swaggerTranslator) {Windows.SwaggerTranslator.Translate (); (swaggerapi, swaggerui) {if (typeOf initOauth == "function") {initOauth ({clientId: "your-client-id", clientsecret: "your-client-secret-if-requiled", reasm: "Your-Realms", appNiPniP: "Your-app-name", ScopeSeParator: "," adicionalqueryStringCarams: {}). } if (window.swaggerTranslator) {window.swaggerTranslator.translate (); "Ninguno", JSONEditor: False, Apissorter: "Alpha", DefaultModelRendering: 'Schema', ShowRequestheaders: False}); token, "encabezado"); </script>

Paso 6: Acceda al índice.html modificado anteriormente
http: // localhost: 8080/Nombre del proyecto/static/tercero/swagger-ui/index.html

Nota: Debido a que desea acceder a recursos estáticos, asegúrese de que se pueda acceder a recursos estáticos utilizando SpringMVC. Si no puede acceder, haga la siguiente configuración:

1. Agregue el procesador Servlet predeterminado al archivo de configuración de Spring

 <!-Filtrar recursos estáticos-> <MVC: predeterminado-servlet-handler/>

2. Agregue archivos estáticos para filtrar en Web.xml

Ejemplo de estructura del código del proyecto:

El ejemplo completo Dirección de descarga de la demostración: http://xiazai.vevb.com/201804/yuanma/platform-springmvc-webapp(vevb.com)

otro

Acerca de Spring-Servlet.xml y ApplicationContext.xml

SpringMVC proporciona dos archivos de configuración Spring-Servlet.xml y ApplicationContext.xml
Spring-Servlet.xml es el nivel del controlador, y su alcance de acción es la capa de control. El nombre predeterminado es [servlet-name] -servlet.xml
Por defecto, se coloca en Web-INF/ Directorio. SpringMVC se cargará automáticamente, y también se puede configurar en Web.xml.

 <Servlet> <Servlet-name> Spring-MVC </Servlet-Name> <Servlet-Class> org.springframework.web.servlet.dispatcherservlet </servlet-class> <itinparam> <amamname> contextconfiglocation </amamname> <amarr-value> /wbinf/spring-servlet.xmlmlml </param-value> </titin-param-param-valent <ar carga-on-startup> 1 </load-on-startup> </servlet>

En general, algunas configuraciones relacionadas con el controlador se configuran en Spring-Servlet.xml, como la resolución de la vista, la asignación de archivos de recursos estáticos, el análisis de los resultados de retorno, etc.

Vista de análisis

org.springframework.web.servlet.view.urlBasedViewResolver
Tiles3: org.springframework.web.servlet.view.tiles3.tilesconfigurer
Springmvc: org.springframework.web.servlet.view.internalresourceviewresolver,
shiro: org.apache.shiro.spring.security.interceptor.authorizationAttributesurceAdvisor
Cargar org.springframework.web.multipart.commons.commonsmultipartresolver,

Mapeo de recursos estáticos

 <mvc:resources location="/static/" mapping="/static/**" /><mvc:resources location="/images/" mapping="/static/**" /><mvc:resources location="/css/" mapping="/static/**" /><mvc:resources location="/js/" mapping="/static/**" /><mvc:resources ubicación = "/html/" mapping = "/static/**"/> <mvc: recursos ubicación = "/upload/" mapping = "/static/**"/>

org.springframework.context.support.resourceBundLemesSageOurce

Análisis de resultados

Fastjson: com.alibaba.fastjson.support.spring.fastjsonhttpmessageConverter

3. ApplicationContext.xml es una configuración a nivel de sistema, y su alcance de función es el contexto del sistema. Su inicialización debe configurarse en el param context en Web.xml.

 <cuentute-param> <amamname> contextConfigLocation </amamname> <amam-value> classpath: conf/spring/spring-*. xml </param-value> </context-param>

4. Con respecto a la aplicaciónContxt.xml, generalmente se divide en múltiples archivos de configuración de acuerdo con la función, como:

- ApplicationContxt-Base.xml // conceptos básicos
- ApplicationContxt-Redis.xml // Configuración relacionada con Redis
- ApplicationContxt Shiro.xml // Configuración relacionada con Shiro
- ApplicationContxt-Dao.xml // Configuración relacionada con la base de datos
- ApplicationContxt-xxx.xml // xxx

Resumir

Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.