Introdução ao MVC da primavera
O Spring MVC é uma estrutura leve da Web baseada no modelo de arquitetura MVC. O objetivo é modularizar o desenvolvimento da Web e dissipar a arquitetura geral.
MVC da primavera tem as seguintes vantagens:
Como parte da estrutura da primavera, ele tem as vantagens da primavera (COI, AOP, etc.)
Suporta mapeamento flexível de controlador de URL para página
Forneça mecanismos flexíveis de verificação, formatação e ligação de dados
Apoie o estilo repouso
Processo de solicitação MVC da primavera
O processo geral de solicitação da estrutura do MVC da primavera é o seguinte:
A figura acima envolve vários componentes funcionais do MVC da primavera:
Controlador de front-end (DispatcheServlet): Receba a solicitação do usuário e retorne o resultado da solicitação. Sua função é equivalente a um encaminhador ou processador central, que controla todo o processo de execução, agendando vários componentes e reduzindo o acoplamento entre os componentes.
Mapeamento do processador: Encontre o manipulador de processador correspondente com base no URL solicitado pelo usuário, por meio de anotação ou configuração XML.
Adaptador do processador: preencha a chamada para o método no processador com base no manipulador encontrado pelo mapeador
Manipulador: a lógica específica do processamento de solicitação, retornando dados e visualizar informações
Visualizar resolver: analisa a visualização específica e analisa o nome da visualização lógica em uma visualização real através das informações de exibição no objeto ModelAndView.
Explicação detalhada das etapas específicas do processo de solicitação:
1: O usuário inicia uma solicitação e a solicitação será interceptada pelo controlador front-end (DispatcheServlet)
2: Controlador de front-end (DispatcheserServlet) Mapper do processador (manutenção) para encontrar o manipulador
3: O mapeador do processador (Handlermapping) encontra o manipulador correspondente de acordo com a configuração (pode ser mais anotada ou configuração XML), que pode conter vários interceptores interceptores e devolvê-los ao controlador front-end.
4: O controlador front-end (DispatcheserServlet) solicita o adaptador do processador (Handleratapter) para executar o manipulador correspondente
5: O adaptador é entregue ao processador manipulador correspondente para executar
6: Depois que o processador manipulador for executado, retorne o objeto ModelAndView ao adaptador do processador
7: O adaptador do processador aceita o resultado de retorno do processador Handler e retorna o resultado ao controlador front-end (DispatcheServlet)
8: O controlador front-end (DispatcheserServlet) recebe os dados e visualiza as informações retornadas pelo adaptador do processador, solicita o analisador de visualização e analisa a visualização correspondente
9: O analisador de visualização retorna ao controlador front-end com base no resultado da visualização correspondente correspondendo às informações de exibição.
10: O controlador front-end recebe a visão específica, renderiza a visualização, preenche os dados do modelo na exibição e gera a visualização final
11: O controlador front-end retorna o resultado ao usuário
Construa demos do zero
Crie um projeto:
Crie um novo projeto dinâmico da Web sob o Eclipse
Estrutura de diretório padrão do projeto:
Adicionar dependências do pacote JAR
Importe o pacote JAR correspondente em WebContent> Web-Inf> Lib Pasta, onde o pacote Jar Core é Spring-Webmvc-5.0.0.release.jar, e os outros são principalmente para gerenciar o contexto e os pacotes de Beande, JSTL Tag Library e um pacote de logs para imprimir toras:
Configurando o controlador front-end em web.xml
O controlador front-end é equivalente ao servlet proprietário do Spring MVC, usado para interceptar todas as solicitações qualificadas e entregá-las à estrutura para o processamento subsequente.
<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id = "webapp_id" versão = "3.1"> <!-Configure o controlador front-end-DispatchServlet-> <Vertlet> <Verlet-name> springmvcnext </servlet-name> <Servlet-class> org.springframework.web.servlet.dispathervlet </class. Se o contextConfigLocation não estiver configurado, o arquivo de configuração do springmvc será padrão para: Nome da Web-Inf/Servlet+"-Servlet.xml"-> <iit-param> <amam-name> contextConfiglocation </param-name> <aver-value> ClassPathin: ApplicationArtLet.XMLOTIONCIONCIMENTO </Param-Name> <aam-Value> <ame-name> SpringmvcNext </servlet-name> <url-tattern>/</url-tattern> <!-Intercept Solicitações enviadas pelos usuários de acordo com as regras definidas pelo URL-Pattern. Todas as solicitações são interceptadas aqui, incluindo recursos estáticos-
A regra de correspondência de URL definida na tag <Vapping-mapping> está em uma forma que está em conformidade com *.Action, o servlet correspondente é chamado SpringmvcNext, e o controlador configurado por <servlet é org.springframework.web.servlet.dispatch, que é o controlador front-end da corrente Springmv. A tag <iit-param> é o parâmetro do qual o controlador atual depende. Os dois parâmetros representam os parâmetros de contexto e o caminho de carregamento de parâmetros, respectivamente.
Sobre ClassPath: representa o caminho de saída após a compilação do projeto da web
Configurar a configuração do MVC da primavera
Adicionar arquivo ApplicationContext.xml no diretório de código -fonte Java
Conteúdo específico:
<? 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/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/Security http://www.springframework.org/schema http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd http:/wwwx.springframe-mvc-4.0.xsd http:/wwwx.springframew.org/schema/schema http://wwwx.springframe-schema/schema http://wwwx.spring-mvc-4.0.XSD http://www.springframework.org/schema/context/spring-context.xsd "> <!-A etiqueta do scanner de pacotes será usada para ativar a função de varredura de anotação mvc, permitindo anotações como @Controller e @requestMapping. -> <Contexto: Componente-Scan Base-Package = "com.sl.Controller" /> <!-Driver de anotação-> <mvc: anotação-driven /> <!-Configure View Resolver-> <Bean ID = "InternalResourViewResolver"> <nome da propriedade = "prefix" " /" /" /Web-inf </ Bean> </ Beans>
Adicionar controlador e visualização
Adicione o pacote com.sl.Controller no diretório SRC e adicione o código do controlador da seguinte forma:
pacote com.sl.controller; importar org.springframework.tereotype.controller; importar org.springframework.web.bind.annotation.requestMapping; @porstrolllerg.springframework.web.servlet.modlandView; solicitações no caminho da URL começando com /índice: incluindo /index /* e /index.html public ModelAndView Helloworld () {String message = "Hello Spring MVC"; retornar new ModelAndView ("Index", "Mensagem", Mensagem); }}Adicionar visualizar o arquivo index.jsp na web-inf/visualização
<html> <head> <title> spring mvc </title> </ad Head> <body> $ {message} </body> </html>Resultados em execução:
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.