O Spring MVC define os seguintes componentes principais:

Figura 1 - Core Components do Spring MVC.

Qualquer que seja a requisição do cliente (URL) ele intercepta antes de passar o Objeto de Requisição para a Controller. O arquivo de configuração Web Configuration possui a definição de como o Servlet deve ser invocado para as requisições.

Segue um exemplo do arquivo web.xml para invocar o Servlet:

<?xml version='1.0' encoding='UTF-8'?>
    <web-app version='2.4'>

    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>2</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.*</url-pattern>
    </servlet-mapping>

</web-app>

Componentes que implementam a interface HandlerMapping são responsáveis por definir um mapeamento entre as requisições do cliente e os objetos handler. Esse objetos, por sua vez, redirecionam para uma controller. A interface pode ser implementada por desenvolvedores para prover estratégias de mapeamento customizadas. Alguns dos componentes definidos pelo framework, são descritos a seguir.

Figura 2 - Handler Mappings.

Esse componente permite um mapeamento direto e declarativo entre objetos bean e URLs ou entre nomes bean e URLs. Segue um exemplo de um mapeamento entre as requisições “/simpleUrlWelcome” e “/*/simpleUrlWelcome” para um bean "welcome".

@Configuration
public class SimpleUrlHandlerMappingConfig {
 
    @Bean
    public SimpleUrlHandlerMapping simpleUrlHandlerMapping() {
        SimpleUrlHandlerMapping simpleUrlHandlerMapping
          = new SimpleUrlHandlerMapping();
         
        Map<String, Object> urlMap = new HashMap<>();
        urlMap.put("/simpleUrlWelcome", welcome());
        simpleUrlHandlerMapping.setUrlMap(urlMap);
         
        return simpleUrlHandlerMapping;
    }
 
    @Bean
    public WelcomeController welcome() {
        return new WelcomeController();
    }
}

Na configuração XML:

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <value>
            /simpleUrlWelcome=welcome
            /*/simpleUrlWelcome=welcome
        </value>
    </property>
</bean>
<bean id="welcome" class="com.baeldung.WelcomeController" />

Uma alternativa relação ao XML seria:

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <prop key="/simpleUrlWelcome">welcome</prop>
            <prop key="/*/simpleUrlWelcome">welcome</prop>
        </props>
    </property>
</bean>

Esse componente é a implementação default do HandlerMapping. Ele mapeia URLs requisitadas para beans com o mesmo nome. Por exemplo, um URL "/foo" é mapeado para um bean chamado "/foo". Segue um exemplo com uma URL "/beanNameUrl":

@Configuration
public class BeanNameUrlHandlerMappingConfig {
    @Bean
    BeanNameUrlHandlerMapping beanNameUrlHandlerMapping() {
        return new BeanNameUrlHandlerMapping();
    }
 
    @Bean("/beanNameUrl")
    public WelcomeController welcome() {
        return new WelcomeController();
    }
}

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />
<bean name="/beanNameUrl" class="com.baeldung.WelcomeController" />

Controllers são componentes chamados pelo Dispatcher Servlet para executar alguma lógica de negócio. O Spring MVC provê uma variedade de componentes controllers, cada qual para um propósito específico. Todos eles implementam a interface Controller. Segue alguns exemplos de componentes controller.

Figura 3 - Controller components.

Todos os componentes do tipo controller herdam de AbstractController. O programador pode extender essa classe e implementar a sua própria controller a partir do zero. Isso pode ser feito para simplesmente retornar um recurso para o cliente, sem verificar os parâmetros da requisição.

public class ABSController extends AbstractController { 
  
 @Override
protected ModelAndView handleRequestInternal(HttpServletRequest request,
 HttpServletResponse response) throws Exception {

  String Mess = "Abstract Controller Test"; 
  ModelAndView modelAndView = new ModelAndView("abscontroller"); //buscar pela view "abscontroller"
  modelAndView.addObject("message", Mess);//adicionar o valor de Mess ao atributo "message" definido na view
  return modelAndView;
  }
}

Essa controller não requer o uso de uma classe, enviando uma requisição diretamente para uma view. Basta declarar um bean ParameterizableViewController e especificar o nome da view através da propriedade viewName.

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <prop key="/welcome.htm">welcomeController</prop>
        </props>
    </property>
</bean>

<bean name="welcomeController" class="org.springframework.web.servlet.mvc.ParameterizableViewController">
    <property name="viewName" value="WelcomePage" />
</bean>

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

O MultiActionController é usado para agrupar ações relacionadas em um único controller.

public class CustomerController extends MultiActionController{

	public ModelAndView add(HttpServletRequest request,
		HttpServletResponse response) throws Exception {

		return new ModelAndView("CustomerPage", "msg","add() method");

	}

	public ModelAndView delete(HttpServletRequest request,
		HttpServletResponse response) throws Exception {

		return new ModelAndView("CustomerPage", "msg","delete() method");

	}

	public ModelAndView update(HttpServletRequest request,
		HttpServletResponse response) throws Exception {

		return new ModelAndView("CustomerPage", "msg","update() method");

	}

	public ModelAndView list(HttpServletRequest request,
		HttpServletResponse response) throws Exception {

		return new ModelAndView("CustomerPage", "msg","list() method");

	}

}

CustomerController –> /customer/*
/customer/add.htm –> add()
/customer/delete.htm –> delete()
/customer/update.htm –> update()
/customer/list.htm –> list()

ModelAndView são objetos retornardos para o Dispatcher Servlet por uma controller. Essa classe é um container que carrega informações da View e da Model. O objeto Model representa algum pedaço de informação que pode ser usado pela View para renderizar para o usuário.

Geralmente, as controllers retornam para o DispatcherServlet dentro objeto ModelAndView uma string (Logical View) representando o objeto real da view (Physical View Logical). Esse mapeamento entre o Logical View e o Physical View Location é realizado pelos componentes do tipo ViewResolver. Isso posibilita renderizar models no browser sem amarrar a implementação a uma tecnologia de view específica. Alguns dos componentes definidos pelo framework, são explicados a seguir.

Figura 4 - View resolvers.

Esse componente adiciona as propriedades prefix e suffix à string retornada pela ModelView da controller para retonar a view real.

@Bean
public ViewResolver internalResourceViewResolver() {
    InternalResourceViewResolver bean = new InternalResourceViewResolver();
    bean.setViewClass(JstlView.class);
    bean.setPrefix("/WEB-INF/view/");
    bean.setSuffix(".jsp");
    return bean;
}

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

Por padrão, o componente ResourceBundleViewResolver carrega as view beans do arquivo views.properties localizado na raíz do classpath do projeto. Essa localização pode ser sobrescrita através da propriedade basename.

<bean class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
    <property name="basename" value="spring-views" />
</bean>

Arquivo de configuração do projeto

WelcomePage.(class)=org.springframework.web.servlet.view.JstlView
WelcomePage.url=/WEB-INF/pages/WelcomePage.jsp

spring-views.properties

Quando um view name WelcomePage é retornado pela controller, o ResourceBundleViewResolver encontra uma chave que começa com WelcomePage no arquivo spring-views.properties e retorna a URL da view correspondente para o DispatcherServlet.

O componente XMLViewResolver é usado para resolver o view name com base nas view beans no arquivo XML.

<bean class="org.springframework.web.servlet.view.XmlViewResolver">
    <property name="location">
        <value>/WEB-INF/spring-views.xml</value>
    </property>
</bean>

Arquivo de configuração do projeto

<bean id="WelcomePage" class="org.springframework.web.servlet.view.JstlView">
    <property name="url" value="/WEB-INF/pages/WelcomePage.jsp" />
</bean>

spring-views.xml

Quando um nome view WelcomePage é retornado pela controller, o XmlViewResolver irá econtrar um bean com id WelcomePage no arquivo spring-views.xml e retornar a URL da view correspondente /WEB-INF/pages/WelcomPage.jsp para o DispatcherServlet.

• http://www.roseindia.net/spring/internalresourceviewresolver.shtml
• http://javabeat.net/introduction-to-spring-mvc-web-framework-web-tier/
• http://www.baeldung.com/spring-handler-mappings
• http://www.baeldung.com/spring-mvc-view-resolver-tutorial
• http://docs.spring.io/spring/docs/
• https://www.mkyong.com/spring-mvc/spring-mvc-multiactioncontroller-example/
• https://www.mkyong.com/spring-mvc/spring-mvc-parameterizableviewcontroller-example/
• https://www.mkyong.com/spring-mvc/spring-mvc-resourcebundleviewresolver-example/