Introdução ao SpringMVC

O que é MVC?

MVC significa Model View Controller (Modelo Visão Controlador), é um padrão de arquitetura de software que separa a lógica de negócios da interface do usuário. Esse padrão organiza o código separando a lógica de negócios, os dados e a apresentação visual em componentes distintos, permitindo que você melhore e personalize a interface e a interação com o usuário sem precisar reescrever a lógica de negócios, reduzindo significativamente o tempo de desenvolvimento.

Por que usar MVC?

A principal vantagem do MVC está na separação entre a implementação do Modelo e da Visão, permitindo que o mesmo programa utilize diferentes representações visuais. O exemplo mais clássico de MVC é a combinação jsp + servlet + javabean.

O que é SpringMVC?

SpringMVC é um framework MVC integrado ao Spring.

É um framework MVC que resolve problemas comuns no desenvolvimento web (recebimento de parâmetros, upload de arquivos, validação de formulários, internacionalização, etc.) e é simples de usar, com integração perfeita ao Spring. Suporta URLs no estilo RESTful.

Utiliza uma estrutura de componentes fracamente acoplados e plugáveis, sendo mais extensível e flexível do que outros frameworks MVC.

Princípio do SpringMVC

Antes de usar o SpringMVC, utilizávamos Servlets para desenvolvimento web. No entanto, o desenvolvimento com Servlets presenta complexidades relativamente maiores para接收 de parâmetros de requisição, compartilhamento de dados e navegação entre páginas. Como o Servlet é o padrão Java para desenvolvimento web, e o SpringMVC é uma abstração do Servlet, o SpringMVC é fundamentalmente um Servlet, oferecendo uma封装 mais profunda.

Fluxo de Execução do SpringMVC

O usuário envia uma requisição que é interceptada pelo controlador frontal DispatcherServlet.
O DispatcherServlet recebe a requisição e chama o HandlerMapping (mapeador de manipuladores).
O HandlerMapping encotnra o manipulador específico (buscando em configurações XML ou anotações), gera o objeto do manipulador e interceptadores (se houver), e retorna ao DispatcherServlet.
O DispatcherServlet chama o HandlerAdapter (adaptador de manipuladores).
O HandlerAdapter adapta e chama o manipulador específico (Handler/Controller).
O Controller executa e retorna o objeto ModelAndView.
O HandlerAdapter retorna o resultado ModelAndView ao DispatcherServlet.
O DispatcherServlet envia o ModelAndView ao ViewResolver (resolvedor de visualizações).
O ViewResolver analisa o ModelAndView e retorna a View (visualização) específica ao DispatcherServlet.
O DispatcherServlet renderiza a visualização (preenchendo os dados do modelo na visualização).
O DispatcherServlet responde a visualização ao usuário.
Componentes Envolvidos

DispatcherServlet (Controlador Frontal)

Não requer desenvolvimento pelo programador, é fornecido pelo framework, configurado no web.xml.

Função: Receber requisições e responder resultados, funcionando como um redistribuidor ou processador central.

HandlerMapping (Mapeador de Manipuladores)

Não requer desenvolvimento pelo programador, fornecido pelo framework.

Função: Encontrar o Handler (manipulador/Controller) com base na URL da requisição, suportando mapeamento via XML e anotações.

HandlerAdapter (Adaptador de Manipuladores)

Não requer desenvolvimento pelo programador, fornecido pelo framework.

Função: Executar os métodos do Handler seguindo regras específicas exigidas pelo HandlerAdapter.

Handler (Controller)

Requer desenvolvimento pelo programador.

Nota: O Handler deve ser编写 de acordo com os requisitos do HandlerAdapter para que o adaptador possa executá-lo corretamente.

Função: Receber informações de requisição do usuário e调用 métodos de negócio para processar a requisição, também conhecido como controlador.backend.

ViewResolver (Resolvedor de Visualizações)

Não requer desenvolvimento pelo programador, fornecido pelo framework.

Função: Analisar a visualização lógica e convertê-la em uma visualização física real.

O framework SpringMVC suporta várias tecnologias de visualização, incluindo: jstlView, freemarkerView, ThymeleafView, etc.

View (Visualização)

Requer desenvolvimento pelo engenheiro.

Função: Exibir dados ao usuário em uma página.

View é uma接口 cujas implementações suportam diferentes tecnologias de visualização (jsp, freemarker, pdf, etc.).

Desenvolvimento SpringMVC com Configuração XML

Passo 1: Adicionar dependências do SpringMVC: spring-webmvc, servlet-api, jsp-api, jstl

Passo 2: Configurar o web.xml e registrar o 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_4_0.xsd"
        version="4.0">

   <!-- 1. Registrar DispatcherServlet -->
   <servlet>
       <servlet-name>meuapp</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:applicationContext-servlet.xml</param-value>
       </init-param>
       <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
       <servlet-name>meuapp</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>
</web-app>

Passo 3: Criar arquivo de configuração do SpringMVC: applicationContext-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- Mapeador de manipuladores -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    
    <!-- Adaptador de manipuladores -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!-- ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="viewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <bean id="/saudar" class="com.exemplo.controle.SaudacaoController"/>
</beans>

Passo 4: Desenvolver o Controller

package com.exemplo.controle;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SaudacaoController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest requisicao, 
                                       HttpServletResponse resposta) throws Exception {
        
        ModelAndView resultado = new ModelAndView();
        resultado.addObject("mensagem", "Ola SpringMVC!");
        resultado.setViewName("saudacao");
        
        return resultado;
    }
}

Desenvolvimento SpringMVC com Anotações

No desenvolvimento real, geralmente se usa desenvolvimento com anotações.

Passo 1: Configurar o Maven para evitar problemas de filtragem de rceursos. Adicionar no pom.xml:

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

Passo 2: Configurar o web.xml

<?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_4_0.xsd"
        version="4.0">

   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:applicationContext-servlet.xml</param-value>
       </init-param>
       <load-on-startup>1</load-on-startup>
   </servlet>
   
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>
</web-app>

Passo 3: Criar arquivo de configuração do SpringMVC

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/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"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

   <context:component-scan base-package="com.exemplo.controle"/>
   
   <mvc:default-servlet-handler />
   
   <mvc:annotation-driven />

   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
         id="viewResolver">
       <property name="prefix" value="/WEB-INF/views/" />
       <property name="suffix" value=".jsp" />
   </bean>
</beans>

Passo 4: Desenvolver o Controller usando anotações

package com.exemplo.controle;

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

@Controller
@RequestMapping("/api")
public class SaudacaoController {

    @RequestMapping("/saudar")
    public String mensagem(Model modelo) {
        modelo.addAttribute("msg", "Ola, SpringMVC!");
        return "saudacao";
    }
}

Tags: Spring SpringMVC MVC java web-development

Publicado em 7-6 23:14

Doido Dev

Introdução ao SpringMVC

DispatcherServlet (Controlador Frontal)

HandlerMapping (Mapeador de Manipuladores)

HandlerAdapter (Adaptador de Manipuladores)

Handler (Controller)

ViewResolver (Resolvedor de Visualizações)

View (Visualização)

Tags em Destaque