Fluxo de trabalho [SpringMVC] e caso de entrada

Enterprise 2023-09-06 02:27:44 views: null

Índice

    prefácio                                                                                            

    Revise a arquitetura MVC de três camadas                                                                               

    1. Introdução ao Spring MVC                                                                        

    1.1 Recursos do Spring MVC                                                                              

    1.2 Componentes principais do SpringMVC                                                                           

    1.3 Fluxo de trabalho Spring MVC                                                                           

    2. Caso de entrada SpringMVC                                                                 

    2.1 Adicionar dependência pom.xml 

    2.2 Crie spring-mvc.xml 

    2.3 Configurar web.xml 

    2.4 Escreva uma classe de processador 

    2.5 Escreva hello.jsp 

    2.6 Executando testes 

    2.7 Processamento de recursos estáticos 

    prefácio                                                                                            

        Spring MVC (Model-View-Controller) é uma estrutura de aplicativo da web baseada em Java que faz parte da estrutura Spring. É usado principalmente para desenvolvimento Web. Ele encapsula o Servlet e também pode ser entendido como uma versão aprimorada do Servlet.

    Revise a arquitetura MVC de três camadas                                                                               

Antes de aprender SpringMVC, vamos revisar a ideia do framework MVC customizado:

O fluxo de trabalho básico de uma estrutura MVC personalizada é o seguinte:

  1. O usuário interage com o aplicativo por meio da visualização, e a visualização passa a solicitação do usuário ao controlador.
  2. O controlador recebe a solicitação do usuário, decide qual modelo chamar para processar a solicitação de acordo com o tipo e conteúdo da solicitação e decide qual visualização precisa ser atualizada de acordo com o resultado do processamento.
  3. No processo de processamento de solicitações, o modelo pode precisar interagir com bancos de dados ou outras fontes de dados para obter os dados necessários e realizar o processamento correspondente. Quando o processamento for concluído, retorne o resultado ao controlador.
  4. Com base nos resultados do processamento do modelo, o controlador decide qual visualização atualizar para exibir os resultados ao usuário.
  5. Após receber as instruções do controlador, a visualização realiza o processamento e renderização correspondente de acordo com o conteúdo a ser exibido e, por fim, apresenta o resultado ao usuário.

 

        No MVC customizado, cada solicitação precisa escrever um Servlet, o que é obviamente inconveniente. O fluxo de trabalho do SpringMVC é semelhante a este. O controlador pode lidar com múltiplas solicitações, distribuir as solicitações e realizar diferentes operações de negócios. Ele foi aprimorado para tornar o desenvolvimento mais conveniente.

    Introdução ao Spring MVC                                                                        

        Spring MVC (Model-View-Controller) é uma estrutura de aplicativo da web baseada em Java que faz parte da estrutura Spring. Spring MVC fornece um modelo simples, flexível e poderoso para construção de aplicações web, que segue o padrão de design MVC. Esse padrão ajuda a separar a camada de apresentação, a camada de lógica de negócios e a camada de acesso a dados da aplicação, tornando o desenvolvimento mais modular e mais fácil de manter.

    Recursos do Spring MVC                                                                              

        Um princípio fundamental do Spring MVC é a separação de preocupações, separando diferentes aspectos de uma aplicação para melhor gerenciamento e manutenção de código. Isso é feito dividindo o aplicativo em três partes: Modelo, Visualização e Controlador.

  1. Modelo (Modelo): O modelo representa os dados e a lógica de negócios da aplicação. Pode ser um POJO (Plain Old Java Object) ou uma classe de entidade persistente. O modelo é responsável por ler, armazenar e validar dados, e fornecer dados à visualização para exibição.

  2. View (View): A view é responsável por exibir os dados do modelo ao usuário. Pode ser uma página JSP (JavaServer Pages), HTML ou uma página gerada por outros mecanismos de modelo. As visualizações geralmente são geradas dinamicamente com base nos dados do modelo para apresentar os dados ao usuário.

  3. Controlador (Controller): O controlador é responsável por processar as solicitações do usuário e coordenar a interação entre o modelo e a visualização. Ele recebe a solicitação do usuário, chama o modelo apropriado para processar os dados e seleciona a visualização apropriada para exibir o resultado. Os controladores também podem lidar com validação de formulário, tratamento de exceções e outras lógicas relacionadas a solicitações.

    Componentes principais do SpringMVC                                                                           

A estrutura Spring MVC fornece um conjunto de componentes principais para implementar esta arquitetura model-view-controller. Esses incluem:

  1. DispatcherServlet: É o front controller do Spring MVC e é responsável por receber todas as solicitações HTTP e despachá-las para os manipuladores apropriados.

  2. HandlerMapping: É responsável por mapear solicitações para manipuladores (controladores) apropriados.

  3. Controlador: É a interface do manipulador, responsável por tratar as solicitações do usuário e retornar modelos e visualizações apropriadas.

  4. ViewResolver: é responsável por resolver nomes de visualizações lógicas em objetos de visualização reais.

  5. View: É responsável por renderizar os dados do modelo no resultado final da resposta, que pode ser JSP, página HTML ou outros tipos de visualizações.

        Além desses componentes principais, o Spring MVC também oferece muitos outros recursos, como vinculação de dados, processamento de formulários, upload de arquivos, interceptadores, suporte à internacionalização, etc., para ajudar os desenvolvedores a construir aplicativos da web com mais facilidade.

 

    Fluxo de trabalho Spring MVC                                                                           

  1. Quando o usuário envia uma solicitação, a primeira coisa a inserir é o front controller DispatcherServlet
  2. O front controller (DispacherServlet) envia a solicitação do usuário para o mapeador do processador (HandlerMapping)
  3. O mapeador do processador encontra o controlador correspondente (Handler) de acordo com a solicitação do usuário enviada pelo controlador front-end, encapsula-o em uma cadeia de execução do processador e o retorna ao controlador front-end.
  4. Depois que o adaptador do processador recebe a cadeia de execução do controlador frontal, ele encontra o controlador específico (ou seja, seu método ou lógica correspondente) chamado pelo adaptador do processador (HandlerAdapter) correspondente à cadeia de execução.
  5. O adaptador do processador (HandlerAdaptoer) chamará o controlador específico correspondente (processando a lógica de negócios)
  6. Depois que o controlador for executado, ele retornará um objeto ModelAndView para o adaptador do processador
  7. O adaptador do processador retorna o objeto ModelAndView retornado ao front controller (todo o processamento de negócios será finalizado aqui, e a próxima etapa é responder o resultado ao usuário na forma de uma página)
  8. O front controller passa o objeto ModelAndView retornado para o resolvedor de visualização (ViewResolver), e o resolvedor de visualização resolve o objeto de página correspondente de acordo com o objeto View passado
  9. ViewResolver retornará o objeto de página encapsulado e o objeto Model para DIspatcherServlet
  10. O front controller então entrega o objeto retornado para a view (View)
  11. A visualização renderiza a página novamente de acordo com o objeto Model passado (preenche os dados do modelo na visualização) e depois retorna ao controlador frontal.
  12. O front controller responde ao navegador com o resultado concluído e então o navegador o exibe ao usuário.

 

    Caso de entrada SpringMVC                                                                 

    Adicionar dependência 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>
  <groupId>org.example</groupId>
  <artifactId>mybatis_spring</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>mybatis_spring Maven Webapp</name>
  <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.plugin.version>3.7.0</maven.compiler.plugin.version>

        <!--添加jar包依赖-->
        <!--1.spring 5.0.2.RELEASE相关-->
        <spring.version>5.0.2.RELEASE</spring.version>

        <!-- jstl+standard -->
        <jstl.version>1.2</jstl.version>
        <standard.version>1.1.2</standard.version>
        <!-- spring -->
        <spring.version>5.0.2.RELEASE</spring.version>
    </properties>


    <dependencies>
        <!--1.spring相关-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>


        <!-- spring mvc相关依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl.version}</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>${standard.version}</version>
        </dependency>
    </dependencies>

  <build>
      <finalName>mybatis_spring</finalName>
  </build>
</project>

Os dois pacotes jar sem jstl + standard reportarão java.lang.NoClassDefFoundError: javax/servlet/jsp/jstl/core/Config, isso ocorre porque org.springframework.web.servlet.view.JstlView precisa disso na análise de visualização Dois pacotes jar .

    Crie spring-mvc.xml 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--1) 扫描com.zking.zf及子子孙孙包下的控制器(扫描范围过大，耗时)-->
    <context:component-scan base-package="com.ycxw"/>

    <!--2) 此标签默认注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->
    <mvc:annotation-driven/>

    <!--3) 创建ViewResolver视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- viewClass需要在pom中引入两个包：standard.jar and jstl.jar -->
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--4) 单独处理图片、样式、js等资源 -->
    <!-- <mvc:resources location="/css/" mapping="/css/**"/>
     <mvc:resources location="/js/" mapping="/js/**"/>
     <mvc:resources location="WEB-INF/images/" mapping="/images/**"/>-->
</beans>

explicar:

Este código é um arquivo de configuração XML para um aplicativo Spring MVC. Ele é usado para definir algumas configurações básicas do Spring MVC, incluindo verificação de componentes, condução de anotações, resolvedor de visualização e manipulação de recursos estáticos. Aqui está uma explicação linha por linha deste código:

  1. <context:component-scan base-package="com.ycxw"/>: Habilite a verificação de componentes, deixe o Spring verificar automaticamente todas as classes no pacote especificado (aqui com.ycxw) e seus subpacotes, identifique e registre classes com anotações específicas (como @Controller, @Serviceetc.) como beans no contêiner Spring.

  2. <mvc:annotation-driven/>: Habilite a função orientada por anotação do Spring MVC e deixe o Spring MVC registrar automaticamente o mapeamento de processador padrão ( DefaultAnnotationHandlerMapping) e o adaptador de processador ( AnnotationMethodHandlerAdapter) para oferecer suporte a métodos de controlador baseados em anotação.

  3. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">: Defina um bean resolvedor de visualização ( InternalResourceViewResolver), que é usado para resolver o nome da visualização lógica retornado pelo controlador em um recurso de visualização real (como um arquivo JSP).

  4. <property name="viewClass" value="org.springframework.web.servlet.view.JstlView">: defina viewClassas propriedades do analisador de visualização, especificando JstlViewa classe a ser usada para processar tags JSTL.

  5. <property name="prefix" value="/WEB-INF/jsp/"/>: defina as propriedades do resolvedor de visualização prefixpara especificar o caminho do prefixo dos recursos de visualização (como arquivos JSP).

  6. <property name="suffix" value=".jsp"/>: defina suffixas propriedades do resolvedor de visualização e especifique o sufixo dos recursos de visualização (como arquivos JSP).

  7. <!--4) 单独处理图片、样式、js等资源 -->: esta é uma nota que indica que a configuração a seguir é usada para processar recursos estáticos.

  8. <!-- <mvc:resources location="/css/" mapping="/css/**"/>: esta é uma configuração comentada que, se habilitada, mapeará /css/solicitações cujo caminho de solicitação começa com /css/os recursos estáticos (como arquivos CSS) no diretório.

  9. <!-- <mvc:resources location="/js/" mapping="/js/**"/>: esta é uma configuração comentada que, se habilitada, mapeará /js/solicitações com um caminho de solicitação começando com /js/os recursos estáticos (como arquivos JavaScript) no diretório.

  10. <!-- <mvc:resources location="WEB-INF/images/" mapping="/images/**"/>: Esta é uma configuração comentada, se habilitada, mapeará solicitações começando com o /images/caminho da solicitação para WEB-INF/images/recursos estáticos (como arquivos de imagem) no diretório.

        Em resumo, este código configura um aplicativo Spring MVC básico, incluindo varredura de componentes, condução de anotações, resolvedor de visualização e manipulação de recursos estáticos.

    Configurar web.xml 

Etapas de configuração:

  1. Configure o Spring para integração com projetos da Web
  2. Configurar filtro ilegível em chinês
  3. Configurar o controlador principal SpringMVC DispatcherServlet
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
  <display-name>Archetype Created Web Application</display-name>
  <!-- Spring和web项目集成start -->
  <!-- spring上下文配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-context.xml</param-value>
  </context-param>
  <!-- 读取Spring上下文的监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- Spring和web项目集成end -->

  <!-- 中文乱码处理 -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <async-supported>true</async-supported>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- Spring MVC servlet -->
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--此参数可以不配置，默认值为：/WEB-INF/springmvc-servlet.xml-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <!--web.xml 3.0的新特性，是否支持异步-->
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

    Escreva uma classe de manipulador 

package com.ycxw.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @author 云村小威
 * @site blog.csdn.net/Justw320
 * @create 2023-09-04 20:11
 */
@Controller
public class HelloController {
    @RequestMapping(value="/hello")
    public String hello(){
        System.out.println("调用了hello方法...");
        return null;
    }
}

  1. @Controller: use @Controllera anotação para marcar esta classe como um controlador Spring MVC. Esta anotação informa ao framework Spring que esta classe manipulará solicitações HTTP.

  2. @RequestMapping(value="/hello"): Use @RequestMappinganotações para mapear um caminho de solicitação HTTP (aqui está /hello) para um método do controlador (aqui está o hello()método). O método será chamado quando o usuário visitar /helloo caminho .hello()

    Escreva olá.jsp 

O resolvedor de visualização ViewResolver foi configurado no arquivo spring-mvc.xml

    teste de corrida 

 

    Tratamento de recursos estáticos 

Todos os arquivos serão interceptados pelo arquivo de configuração spring-mvc.xml, então adicione configuração para permitir que o processador verifique o recurso

<mvc:resources location="/static/" mapping="/static/**"/>

 Como caminho:

Execute o teste: 

Acho que você gosta

Origin blog.csdn.net/Justw320/article/details/132677124
Recomendado
Clasificación
Diario
Más
2024-06-14(0)
2024-06-13(0)
2024-06-12(0)
2024-06-11(0)
2024-06-10(0)
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)

Code World

© 2018 codetd.com