Partes básicas
1. Introdução ao fastjson
Fastjson é uma biblioteca Java que pode ser usada para converter objetos Java em representações JSON. Ele também pode ser usado para converter uma string json em um objeto Java equivalente. Deve ser a velocidade de conversão mais rápida e quase se tornou a configuração padrão dos projetos (o fastjson geralmente é usado em vez de Jackson quando o Ajax Solicle and Interface Development).
Github: https://github.com/alibaba/fastjson (download local)
característica:
Principais recursos:
2. Fastjson API
A classe de entrada da API Fastjson é com.alibaba.fastjson.json. As operações de serialização comuns podem ser concluídas diretamente por métodos estáticos na classe JSON.
// Parse JSON Texto como JsonObject ou JsonArray Public Static Final Object Parse (String Text); // Parse JSON Texto no JsonObject public static final jsonObject parseObject (text string); // Parse JSON Texto como Javabean Public Static Final <T> t ParseObject (texto da string, classe <T> clazz); // Parse JSON Texto no JSONArray Public Static final JsonArray Parsearray (texto da string); // analisa o texto json na coleção javabean public static final <t> list <t> parsearray (texto da string, classe <t> clazz); // serializa Javabean no texto JSON Public Static Final String tojSonstring (objeto objeto); // serializa Javabean em jSonstring formatado (objeto objeto, boolean bifurformat); // converte Javabean em JsonObject ou JsonArrayPublic Static Final Object Tojson (objeto JavaObject);
JSONArray: equivalente à listar <Becut>
JsonObject: equivalente ao mapa <string, objeto>
SerializeConfig: é uma configuração especial para alguns processos de serialização durante o processo de serialização, como a formatação de alguns campos (data, enumeração, etc.)
SerializeWriter: equivalente a StringBuffer
Propriedade do SerializerFeature:
Parte prática
1. Introduzir dependências de MVC de primavera e fastjson em 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 http://maven.apache.org/maven-v4_0_0.xsd "> <ModelVersion> 4.0.0 </modelVersion> <puperid> com.mengdee </fatchAcging> <packaging> platafortid-springmvc-webapp </artifactId> <backaging> warsing> warsing </Packaging> waring> warfactIns> </Packaging> warsing> warfaction> warsing> versão </Packagaging> </Packaging> warsing> warfaction> </Packaging> <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 </storkactid> <versão> 3.8.1 </version> <cope> test </cope> </dependency> <pendencency> <voupid> javax.servlet </friumid> <stifactId> jstl </stifactId> <versão $ {jstl.version} </versão> </sorpens> </iremntion> </irement> </irement> </irement> </irement> </irement> </irement> </irement> </sor passfactid> <version> $ {jstl.version <PuerpId> org.springframework </frugiD> <stifactId> spring-webmvc </artifactId> <versão> $ {spring.version} </versão </dependency> <pendency> </groupid> org.springframework </groupid> <TifactId> Springsion </ArtifttiM> <Depencency> <GrupID> org.springframework </frugiD> <ArtifactId> Spring-Context </ArtifactId> <Versão> $ {spring.version} </versão </dependency> <pendency> <voundid> org.springframewil <Versão> $ {spring.version} </version> </dependency> <pendency> <voundiD> org.springframework </groupiD> <TRAFACTID> spring-jdbc </artifactId> <brusteact> $ {spring.version} </version> </dependency> <Putinid> <broundId> com.alibaba <version>${fastjson.version}</version> </dependency> </dependencies> <!-- Using aliyun mirror--> <repositories> <repository> <id>aliyun</id> <name>aliyun</name> <url>http://maven.aliyun.com/nexus/content/groups/public</url> </repositório> </positório> </positório> </positório> <build> <finname> plataform-springmvc-webapp </finalName> </fuild> </project>2. Configure web.xml
<! DOCTYPE Web-App Public "-// Sun Microsystems, Inc.//dtd Web Application 2.3 // pt" "http://java.sun.com/dtd/web-app_2_3.dtd"> <web-app> <lor-name> Archetype criou o Web Application </-Dishig> <amam-value> ClassPath: conf/spring/spring-*. xml </amam-value> </xectlent-param> <lister> <cription> Spring ouvinte </cription> <lister-class> org.springframework.web.context.ContextLoaderListener </lamer-class> </auditer> <Vertlet-class> org.springframework.web.servlet.dispatcherServlet </servlet-class> <itir--param> <amam-name> contextconfigLocation </amam-name> <amam-value> /web-nf/spring-Servlet.xml </param-value> <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> <amam-name> codificação </param-name> <param-value> utf-8 </param-value> </init-param> <iit-param> <amam-name> forcencoding </amam-name> <milter-value> true </amul-value> </iot-param> </filter> <filter-mappy> caractere-lameil. </url-Pattern>/*</url-Pattern> </filtr-mappppe-Mapping> <lumber-fil-slist> <clodb Walcmante-file> /index.jsp </cle oum-Welcomefile> </clorth-file-list> <rorwerp-page> <sorl-Code> 404 </rorw-code> <lorbation>/index.jsp </location> </errror-pap>
3. Configure spring-servlet.xml
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/Context" xmlns: mvc = "http.org/schema/Context" xmlns: mvc = "http.org/schema/Context" xmlns: mvc = "http://schema/Context" Xmlns: xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-bans-4.xsd http://wwww.springfringwansweans-.2.xsd http://wwww.springfringwanswansweans-42.xsd http://wwww.springfringwanswans-42.xsd http://wwww.springfringwanswans-.2.xsd http://wwww.springfringwansweanswans-.2.xsd http://wwwwem 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.2.xsd"> <Contexto: Componente-Scan Base-Package = "com.mengdee.manage.controller"/> <bean id = "ViewResolver"> <propriedade name = "prefixo" value = "/"> </propriedade> <!-prefixo do arquivo de exibição-> <nome do nome "Name" = ".-Just> </! Use também a velocidade e outras coisas-> <propriedade name = "viewclass" value = "org.springframework.web.servlet.view.jstlview"> </propriedade> </bean> <!-Inicie a função de anotação MVC: MEGNONSTRUND MAPPING de solicitações e anotação POJOS-> <MVC: Register-Defaults = "true"> <!-Configure o fastjson para substituir o suporte original de Jackson-> <Bean> <propriedade name = "SupportedMediaTypes"> <List> <Value> text/html; charset = utf-8 </value> <Value> Application/Json </Value> </list> </propriedade> <nome da "Nome =" Citações duplas ao sair da saída de saída, padrão para true-> <Value> writeMapNullValue </value> <!-se deve produzir um campo com um valor nulo, padrão para false-> <!-<vurou> desabringCircularReferenceTeTEct </Value> <Value> WRITEDATEUSEUSTATATION <fould> "CercatallullullulSempty> <Value> WriteNullNumberasZero </value> Se o campo numérico for nulo, a saída será 0, não nula <Value> WriteNullBooleanasfalse </value> O campo booleano é nulo, a saída é falsa, não nula <Value> writeNulllistsy </value> o campo <lULL> <lULL, não é [], não é [], não é o que é nulo <] </mvc: Message-Converters> </mvc: anotação-driven> </ Beans>
4. Java
Educação: Educação (aula de enumeração)
pacote com.mengdee.manage.entity; importar java.util.hashmap; importar java.util.map;/** * educação * @author Administrator * */public Enum Education {Kindtarten ("KindlegTarn", 1), elementar ("School Elementary 3), Junior_middle (" Helldern ", 1), elementares" School ", 2), Junior_middle (" Highddle "," School "School", 2), Junior_middle ("Hellddle", "School" School ", 2), Junior_middle (" Highddle "," School "School", 2), Junior_middle " University ("University", 5), College ("College", 6); MAPO ESTÁTICO PRIVADO <Inteiro, Educação> Educação_map = New Hashmap <Inteiro, Educação> (); estático {for (educação educacional: educação.values ()) {educação_map.put (educação.getIndex (), educação); }} texto de sequência privada; índice privado int; Educação privada (texto da string, int index) {this.Text = text; this.index = index; } public string getText () {return text; } public void setText (text string) {this.text = text; } public int getIndex () {return index; } public void setIndex (int index) {this.index = index; } educação estática pública getenum (índice inteiro) {return educação_map.get (index); }}Pessoa:
pacote com.mengdee.manage.entity; importar java.util.ArrayList; importar java.util.date; importar java.util.list; importar java.util.map; importar com.alibaba.fastjson.annotation.jsonfield; nome de string privado; Gênero de byte privado; // Gênero 1: Masculino 2: Feminina Private Idade curta; // Salário longo privado da idade; // Salário de peso duplo privado; // pesando nível de char privado; // classificação adulta booleana privada; // se o aniversário de encontro privado adulto; // Educação de Educação Privada de Aniversário; // Qualificação Educacional Private String [] Hobbies; // Lista privada de Hobbies <dog> cães; // mapa privado de cão de estimação <string, objeto> endereço; // endereço // use anotações para controlar se você deseja serializar @jsonfield (serialize = false) lista privada <Object> obj = new ArrayList <> (); public Person () {} Pessoa pública (ID longa, nome da corda, gênero de byte, idade curta, salário longo, peso duplo, nível de char, adulto booleano, aniversário de data, string [] hobbies, listão <dog> cães, mapa <string, objeto> endereço) {super (); this.id = id; this.name = nome; this.gnder = gênero; this.age = idade; this.salary = salário; this.weight = peso; this.level = nível; this.adult = adulto; this.birthday = aniversário; this.hobbies = hobbies; this.dogs = cães; this.address = endereço; } public long getId () {return id; } public void setId (longo id) {this.id = id; } public string getName () {return name; } public void setName (nome da string) {this.name = name; } public byte getGender () {return gênero; } public void setgender (byte gênero) {this.gender = gênero; } public Short getage () {Age de retorno; } public void setage (idade curta) {this.age = Age; } public long getSalary () {return salary; } public void Setsalary (salário longo) {this.salary = salário; } public duplo getweight () {return weight; } public void setweight (peso duplo) {this.weight = peso; } public Char getLevel () {Return Level; } public void Setlevel (nível de char) {this.level = nível; } public boolean isadult () {return adult; } public void setadult (adulto booleano) {this.adult = adulto; } public data getBirthday () {return Birthday; } public void setbirthday (data de aniversário) {this.birthday = aniversário; } // lidera tipos de enumeração serializada, o valor padrão é serializado em string de valor enum, em vez do índice de ligação enum ou texto @jsonfield (name = "edu") public int getedu () {return educação.getIndex (); } @Jsonfield (name = "edu") public void SetedU (int index) {this.education = educação.getenum (index); } @Jsonfield (serialize = false) Educação pública Geteducation () {Return Education; } @Jsonfield (serialize = false) public void SetEducation (educação educacional) {this.education = educação; } public string [] gethobbies () {return hobbies; } public void Sethobbies (String [] hobbies) {this.hobbies = hobbies; } Lista pública <dog> getDogs () {return cães; } public void SetDogs (List <Gog> cães) {this.Dogs = cães; } mapa público <string, object> getAddress () {retornar endereço; } public void setAddress (mapa <string, objeto> endereço) {this.address = endereço; }}TestController
pacote com.mengdee.manage.controller; importar java.text.decimalformat; importar java.util.arraylist; importar java.util.date; import java.util.hashmap; org.springframework.web.bind.annotation.requestmapping; importar org.springframework.web.bind.annotation.Responsebody; importar com.alibaba.fastjson.json; import com.alibaba.fastjson.jsonarray; import.aliba.fastjson; com.alibaba.fastjson.serializer.serializeConfig; importar com.alibaba.fastjson.serializer.simpledEformatSerializer; importar com.mengdee.manage.entity.Address; import com.mengdee.anage.entity.dog; com.mengdee.manage.entity.person; @ControllerPublic Classe testController {private static serializeConfig seriizeConfig = new SerializeConfig (); estático {seriizeConfig.put (date.class, novo SimpleDateFormatSerializer ("yyyy-mm-dd hh: mm: ss")); SerializeConfig.put (Double.class, novo DoubleSerializer (novo DecimalFormat ("0,00"))); } @RequestMapping ("/index") public String Index () {return "Index"; } // javabean para objetar @RequestMapping ("/json") @ResponseBody Public Object json () {pessoa pessoa = new Person (); pessoa.setId (1L); pessoa.SetName ("Mengdee"); Person.setage ((Short) 18); // /* { "birthday": null, "weight": 0, "dogs": null, "adult": false, "hobbies": null, "education": null, "id": 1, "level": "", "address": null, "age": 18, "name": "mengdee", "gender": 0, "salary": 0 } */ Object personJson = JSON.toJSON(person); Retornar Personjson; } // javabean para string @RequestMapping ("/json2") @ResponseBody public String json2 () {Person Pessoa = new Person (); pessoa.setId (1L); pessoa.SetName ("Mengdee"); Person.setage ((Short) 18); // Se o valor do nulo for usado, ele não poderá ser testado. <Value> writeMapNullValue </value> // "{" adult ": false," idade ": 18," gênero ": 0," id ": 1," nível ":" "," nome ":" mengdee "," salário ": 0," peso ": 0.0}" string jSonstring = json.tojSonstring ": retornar JSonstring; } @RequestMapping ("/json3") @ResponseBody Public Object json3 () {Person Pessoa = new Person (); pessoa.setId (1L); pessoa.SetName ("Mengdee"); Person.setage ((Short) 18); pessoa.SetBirthday (new Date ()); Objeto PERSONJSON = JSON.TOJSON (PESSOA); // JSON.TOJSON (Pessoa) Padrões para milissegundos "Aniversário": 1495073314780, // Use o número de série SerializeConfig para configurar a formatação para as datas // "{" Birthday ":" 2017-05-18 10:19:55 "," Weight ": 0,0," adulto ": false," id ": 1," nível ":" "," idade ": 18," nome ":" mengdee "," gênero ": 0," salário ": 0}" string jSonstring = json.tojSonstring (Personjson, SerializConfig); retornar JSonstring; } @ReQuestMapping ("/json4") @ResponseBody Public Object json4 () {pessoa pessoa = new Person (); pessoa.setId (1L); pessoa.SetName ("Mengdee"); Person.setage ((Short) 18); pessoa.SetBirthday (new Date ()); pessoa.SetEducation (Education.University); // string de enumeração [] hobbies = {"Reading", "Tourism"}; Pessoa.setHobbies (hobbies); Cachorro cão1 = novo cachorro (1L, "Dog1", (curto) 1); Dog2 = novo cachorro (2L, "Dog2", (curto) 2); Lista <dog> cães = novo ArrayList <> (); Dogs.Add (Dog1); Dogs.Add (Dog2); pessoa.SetDogs (cães); Endereço do endereço1 = novo endereço (1L, "Shanghai Pudong New District"); Endereço do endereço2 = novo endereço (2L, "Distrito de Shanghai Baoshan"); Mapa <string, objeto> endereçoMAP = new Hashmap <> (); addressMap.put (endereço1.getId () + "", endereço1); addressMap.put (endereço2.getId () + "", endereço2); pessoa.setAddress (endereço); Objeto PERSONJSON = JSON.TOJSON (PESSOA); Retornar Personjson; } @RequestMapping ("/json5") @Responsebody public string json5 () {Dog1 = new Dog (1L, "Dog1", (Short) 1); Dog2 = novo cachorro (2L, "Dog2", (curto) 2); Lista <dog> cães = novo ArrayList <> (); Dogs.Add (Dog1); Dogs.Add (Dog2); // list <t> -> json string jSonstring = json.tojSonstring (cães, falso); System.out.println (JSonstring); // JSON -> LISTA <T> LISTA <DOG> Parsearray = json.parsearray (JSonstring, Dog.class); para (cachorro Dog: Parsearray) {System.out.println (cachorro); } Mapa <string, cachorro> map = novo hashmap <string, cachorro> (); map.put ("Dog1", novo cachorro (1L, "Dog1", (curto) 1)); map.put ("Dog2", novo cachorro (2L, "DOG2", (curto) 2)); map.put ("Dog3", novo cachorro (3L, "Dog3", (curto) 3)); // mapa -> json string mapjSonstring = json.tojSonstring (map, true); System.out.println (mapjSonstring); // json -> map @suppresswarnings ("desmarcado") mapa <string, cachorro> map1 = (map <string, cachorro>) json.parse (mapjSonstring); para (chave da string: map1.keySet ()) {System.out.println (Key + ":" + map1.get (key)); } // Array -> json string [] hobbies = {"a", "b", "c"}; String hobbiesstring = json.tojSonstring (hobbies, verdadeiro); System.out.println (hobbies); // json -> Array jsonArray jsonArray = json.parsearray (hobbiesstring); for (objeto o: jsonArray) {System.out.println (O); } System.out.println (jsonArray); retornar JSonstring; }}Integração de arrogância
Etapa 1: Introduzir dependências relacionadas
<Depencency> <voupiD> io.springfox </groupiD> <TROTIFACTID> springfox-swagger2 </artifactId> <versão> 2.6.1 </version> <cope> compile </scope> </dependency> <spendence> <purbract> com.fasterxml.jackson.core </Grupoid> <Versão> 2.6.6 </sisters> </dependency>
Etapa 2: Configuração de informações de arrogância
Swaggerconfig.java
@Configuration@EnableWebmvc@EnableSwagger2Public Classe SwaggerConfig {@Bean public Docket CustomDocket () {Docket Docket = new Docket (documentaçãoType.swagger_2); docket.apiinfo (apiinfo ()); docket.Select (). APIs (requestHandlerElectors.withmethodannotation (apioperation.class)); Docket.Select (). Paths (PathSelectors.Regex ("/API /.*")). Build (); retorno docket; } private apiinfo apiinfo () {contato em contato = new contact ("xiao ming", "http://www.baidu.com", "[email protected]"); Retornar novo Apiinfo ("Interface da API", // Big Title "API Interface", // Legenda "0.0.1", // versão "www.baidu.com", // termosfserviceurl Contato, // Autor "API Interface", // Link Text "http://ww.baided" }}Nota: Como a classe SwaggerConfig configura as anotações, essa classe deve ser digitalizada, ou seja, a classe deve ser incluída no contexto: Scan componente.
Etapa 3: Use anotações em classes, métodos e parâmetros
@Controlador @requestmapping ("/api/v1") @api (description = "interface da API") public class Apicontroller {@apioperation (value = "Login do usuário", notas = "interface de usuário do usuário (interface") @apiresponses ({@apiresponse (código = 0, message = "succcess"), @apiresponsensonse ({@apiresponse (code = 0, message = "succcess"), @apiresponsensOnse ({@apiresponse (code = 0, message = "succcess"), @apirespons IlegalargumentException.class), @apiresponse (code = 10002, message = "Senha Erro")}) @RequestMapping (value = "/user/login", método = requestmethod.post, produz = {"Application/json; charset = utf-8;"}) @ResponsOning public Login (Login (Login (JSON; true) @RequestParam String nome de usuário, @apiparam (name = "senha", value = "senha", requerir = true) @requestparam string senha) {return {'userName': '" + userName +"', 'senha': '" + senha +"'} ""; } @ApiImplicitParams ({@apiimplicitParam (paramtype = "cabeçalho", name = "telefone", datatype = "string", requerir = true, value = "número do celular"), @apiimplicitParam (paramtype = "query", name = "apelido", datatype = " 666"), @ApiImplicitParam(paramType = "path", name = "platform", dataType = "String", required = true, value = "platform", defaultValue = "PC"), @ApiImplicitParam(paramType = "body", name = "password", dataType = "String", required = true, value = "password") }) @RequestMapping(value = "/{Platform}/user/regist", Method = requestMethod.post, produz = {"Application/json; charset = utf-8;"}) @Responsebody public String Regist (@Requester String Phone, @RequestParam String Nickname, @Path String Platform '' '' '' '' '' @RequestBern String, @RequestParam String, @Path String 'String Platform,' '' '' 'Apelido': '" + apelido +"', 'plataforma': '" + plataforma +"', 'senha': '" + senha +"'} "; } @ReQuestMapping (value = "/user/list", método = requestMethod.get, produz = {"Application/json; charset = utf-8;"}) @ResponseBody public String getUserList (pager pager) {return "[{'id':"+Pager.getPage ()+", 'Usernker' ':' [{'id':"+Pager.getPage ()+", 'usernk 'Zhangsan "+pager.getSize ()+"'}] "; } @RequestMapping ("/docs") @apiignore public string test () {return "API-DOCs"; }}Pager
public class Pager {@apimodelProperty (value = "Número da página", requerir = true) private int página; @ApimodelProperty (value = "Número de por página", obrigatório = true) private int tamanho; public pager () {} public int getPage () {Return Page; } public void setPage (int página) {this.page = página; } public int getSize () {return size; } public void SetSize (int size) {this.size = size; }}Anotações comuns:
Etapa 4: Acesso /V2 /API-DOCS
Visite http: // localhost: 8080/nome do projeto/v2/api-docs no navegador, se houver conteúdo json, é normal
Etapa 5: Download Swagger-Ui
Faça o download https://github.com/swagger-api/swagger-ui do github. Observe que você precisa selecionar Download v2.2.10 (https://github.com/swagger-api/swagger-ui/tree/v2.2.10 (download local). O método de integração maior que esta versão é diferente.
Método de integração: Coloque todos os arquivos no diretório Dist em v2.2.10 em arquivos estáticos em seu projeto e use o seguinte código para substituir a parte do script em index.html
<script type = "text/javaScript"> var baseurl = ""; $ (function () {var url = window.location.search.match (/url = ([^&] +)/); if (url && url.length> 1) {url = decodEuricomponent (url [1]);} else {// o endereço api-docs acima do url (BASTURL + "); (window.swaggertranslator) {window.swaggertranslator.translate (); (swaggerapi, swaggerui) {if (typeof initOauth == "function") {initOauth ({clientId: "your-client-id", clientsecret: "your-client-secret-if-reeth:" if (window.swaggetranslator) {window.swaggertranslator.Translate (); JSONEDITOR: FALSO, APISSOTER: "Alpha", DefaultModelRerndering: 'Schema', ShowRequesters: false}); "Cabeçalho"); </script> Etapa 6: acesse o index.html modificado acima
http: // localhost: 8080/nome do projeto/static/terceira parte/swagger-ui/index.html
NOTA: Como você deseja acessar recursos estáticos, verifique se os recursos estáticos podem ser acessados usando o SpringMVC. Se você não pode acessar, faça a seguinte configuração:
1. Adicione o processador de servlet padrão ao arquivo de configuração de mola
<!-Filter recursos estáticos-> <mvc: padrão-servlet-Handler/>
2. Adicione arquivos estáticos para filtrar no web.xml
<!-Filtrando recursos estáticos-> <Verlet-mapping> <Verlet-name> padrão </servlet-name> <url-pattern>*.
Exemplo de estrutura do código do projeto:
O exemplo completo de download de demonstração: http://xiazai.vevb.com/201804/yuanma/platform-springmvc-webapp(vevb.com).rar
outro
Sobre Spring-Servlet.xml e ApplicationContext.xml
Springmvc fornece dois arquivos de configuração Spring-Servlet.xml e ApplicationContext.xml
Spring-Servlet.xml é o nível do controlador e seu escopo de ação é a camada de controle. O nome padrão é [servlet-name] -servlet.xml
Por padrão, ele é colocado no Web-Inf/ Diretório. O SpringMVC carregará automaticamente e também pode ser configurado no web.xml.
<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>
Geralmente, algumas configurações relacionadas ao controlador são configuradas em spring-servlet.xml, como resolução de visualização, mapeamento de arquivos de recursos estáticos, análise de resultados de retorno etc.
Ver análise
Mapeamento 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 Location = "/html/" mapping = "/static/**"/> <mvc: Recursos Location = "/Upload/" Mapping = "/static/**"/>
org.springframework.context.support.resourcebundLemessagesource
Análise de resultados
3. ApplicationContext.xml é uma configuração no nível do sistema, e seu escopo de função é o contexto do sistema. Sua inicialização precisa ser configurada no contexto-param em web.xml.
<Cexexp-Param> <amam-name> contextConfigLocation </param-name> <amam-value> ClassPath: conf/spring/spring-*. xml </param-value> </xectlent-param>
4. Em relação ao ApplicationContxt.xml, geralmente é dividido em vários arquivos de configuração de acordo com a função, como:
Resumir
O acima é o conteúdo inteiro deste artigo. Espero que o conteúdo deste artigo tenha certo valor de referência para o estudo ou trabalho de todos. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.