1. Revisão do Padrão MVC

Spring MVC é um framework web robusto baseado no padrão Model-View-Controller (MVC). O padrão MVC é amplamente utilizado em sistemas cliente-servidor (b/s) para organizar o código e separar responsabilidades.

O fluxo típico em um sistema b/s sob o padrão MVC é:

1. O cliente envia uma requisição.
2. O Controller (C) recebe a requisição.
3. O Controller delega o processamento ao Model (M). O Model engloba toda a lógica de negócio, incluindo POJOs, services e DAOs.
4. Após o processamento, o Model retorna o resultado para o Controller.
5. O Controller, necessitando de uma interface visual para responder ao cliente, utiliza a View (V).
6. O Controller renderiza a View, popularndo-a com os dados do Model (geralmente armazenados no escopo da requisição).
7. A requisição processada é enviada de volta ao cliente como resposta.

Uma particularidade em sistemas b/s é que o Model não interage diretamente com a View para preencher dados; essa tarefa é responsabilidade do Controller.

2. O Framework Spring MVC

O Spring MVC implementa o padrão MVC com seus próprios componentes:

1. A requisição chega ao DispatcherServlet (Front Controller).

2. O DispatcherServlet consulta o HandlerMapping para localizar o Handler apropriado, baseado em configurações (XML ou anotações).

3. O HandlerMapping retorna o Handler para o DispatcherServlet.

4. O DispatcherServlet invoca o HandlerAdapter para executar o Handler.

5. O Handler executa sua lógica.

6. O Handler retorna um objeto ModelAndView para o HandlerAdapter. Este objeto contém tanto os dados (Model) quanto a referência à View.

7. O HandlerAdapter repassa o ModelAndView para o DispatcherServlet.

8. O DispatcherServlet solicita ao ViewResolver que interprete o nome lógico da View e a mapeie para uma View real (por exemplo, um arquivo JSP).

9. O ViewResolver retorna a View concreta para o DispatcherServlet.

10. O DispatcherServlet realiza a renderização da View, populando-a com os dados do Model provenientes do ModelAndView no escopo da requisição.

11. Finalmente, o DispatcherServlet envia a resposta renderizada ao cliente.

12. Componentes Principais do Spring MVC

• DispatcherServlet: O Front Controller central. Ele gerencia o fluxo da requisição e a coordenação entre os outros componentes, reduzindo o acoplamento. Não requer desenvolvimento direto pelo programador.
• HandlerMapping: Responsável por mapear a URL da requisição para o Handler correspondente. Não requer desenvolvimento direto pelo programador.
• HandlerAdapter: Adapta a execução do Handler aos requisitos do framework. Ele sabe como invocar diferentes tipos de Handlers. Não requer desenvolvimento direto pelo programador.
• Handler: Representa a lógica de processamento da requisição. É a parte que o programador desenvolve. É importante que o Handler siga as convenções esperadas pelo HandlerAdapter.
• ViewResolver: Converte nomes lógicos de Views em instâncias de View concretas. Não requer desenvolvimento direto pelo programador.
• View: Responsável por renderizar a resposta final. O programador geralmente desenvolve as Views (e.g., JSPs). O Spring MVC suporta diversas implementações de View.

4. Exemplo Prático de Spring MVC

4.1 Configuração do Front Controller

No arquivo web.xml:

<servlet>
   <servlet-name>springDispatcher</servlet-name>
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
   <init-param>
       <param-name>contextConfigLocation</param-name>
       <param-value>classpath*:/spring-mvc-config.xml</param-value>
   </init-param>
   <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
   <servlet-name>springDispatcher</servlet-name>
   <url-pattern>/</url-pattern>
</servlet-mapping>
   

4.2 Configuração dos Adaptadores de Handler

No arquivo de configuração do Spring (e.g., spring-mvc-config.xml):

<!-- HandlerAdapter -->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
   

4.3 Configuração dos Mapeadores de Handler

No arquivo de configuração do Spring:

<!-- HandlerMapping -->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
   

4.4 Configuração do Resolvedor de Views

No arquivo de configuração do Spring:

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

4.5 Implementação do Handler

Definindo um bean para o Handler no arquivo de configuração do Spring:

<!-- Handler -->
<bean name="/greet" class="com.example.controllers.GreetingController"/>
   

Código Java para o GreetingController:

package com.example.controllers;

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

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

public class GreetingController implements Controller {

   @Override
   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
       ModelAndView modelAndView = new ModelAndView();

       // Adiciona dados ao modelo para serem acessados na View
       modelAndView.addObject("greetingMessage", "Olá, Mundo do Spring MVC!");

       // Define o nome lógico da view a ser renderizada
       modelAndView.setViewName("greeting"); // Corresponderá a /WEB-INF/views/greeting.jsp

       return modelAndView;
   }
}
   

4.6 Implementação da View (JSP)

Crie o arquivo /WEB-INF/views/greeting.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<html>
<head>
   <meta charset="UTF-8">
   <title>Saudação</title>
</head>
<body>
   <h1>${greetingMessage}</h1>
</body>
</html>
   

4.7 Acessso à Aplicação

Acesse a aplicação através do navegador:

http://localhost:8080/seu_contexto/greet