TOC

Spring MVC Tutorial

Spring MVC Tutorial

*1. Visão geral *

Este é um simples* tutorial do Spring MVC *que mostra como configurar um projeto do Spring MVC, tanto com uma configuração baseada em Java quanto com uma configuração XML.

As dependências do Maven para um projeto Spring MVC são descritas em detalhes no link:/spring-with-maven # mvc [dependências do Spring MVC].

===* 2. Spring MVC usando configuração Java *

Para ativar o suporte ao Spring MVC por meio de uma classe de configuração Java, tudo o que precisamos fazer é* adicionar a anotação _ @ EnableWebMvc_ *:

@EnableWebMvc
@Configuration
public class WebConfig {

   ///...
}

Isso configurará o suporte básico necessário para um projeto MVC, como registrar controladores e mapeamentos, conversores de tipo, suporte de validação, conversores de mensagens e manipulação de exceções.

*Se quisermos personalizar essa configuração, precisamos implementar a interface _WebMvcConfigurer_:*
@EnableWebMvc
@Configuration
public class WebConfig implements WebMvcConfigurer {

   @Override
   public void addViewControllers(ViewControllerRegistry registry) {
      registry.addViewController("/").setViewName("index");
   }

   @Bean
   public ViewResolver viewResolver() {
      InternalResourceViewResolver bean = new InternalResourceViewResolver();

      bean.setViewClass(JstlView.class);
      bean.setPrefix("/WEB-INF/view/");
      bean.setSuffix(".jsp");

      return bean;
   }
}

Neste exemplo, registramos um bean ViewResolver que retornará visualizações .jsp do diretório /WEB-INF/view.

Muito importante aqui é que podemos registrar os controladores de exibição que criam um mapeamento direto entre a URL e o nome da exibição usando o ViewControllerRegistry. Dessa forma, não há necessidade de qualquer Controlador entre os dois.

Se quisermos também definir e varrer classes de controladores, podemos adicionar a anotação _ @ ComponentScan_ com o pacote que contém os controladores:

@EnableWebMvc
@Configuration
@ComponentScan(basePackages = { "com..web.controller" })
public class WebConfig implements WebMvcConfigurer {
   //...
}

Para inicializar um aplicativo que carrega essa configuração, também precisamos de uma classe de inicializador:

public class MainWebAppInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(final ServletContext sc) throws ServletException {

        AnnotationConfigWebApplicationContext root =
          new AnnotationConfigWebApplicationContext();

        root.scan("com.");
        sc.addListener(new ContextLoaderListener(root));

        ServletRegistration.Dynamic appServlet =
          sc.addServlet("mvc", new DispatcherServlet(new GenericWebApplicationContext()));
        appServlet.setLoadOnStartup(1);
        appServlet.addMapping("/");
    }
}

Observe que para versões anteriores ao Spring 5, precisamos usar a classe WebMvcConfigurerAdapter em vez da interface.

*3. Spring MVC usando configuração XML *

Como alternativa à configuração Java acima, também podemos usar uma configuração puramente XML:

<context:component-scan base-package="com..web.controller"/>
<mvc:annotation-driven/>

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

    <mvc:view-controller path="/" view-name="index"/>

</beans>

Se queremos usar uma configuração puramente XML, também precisamos adicionar um arquivo web.xml para inicializar o aplicativo. Para mais detalhes sobre essa abordagem, consulte https://www..com/spring-xml-vs-java-config [nosso artigo anterior].

===* 4. Controlador e vistas *

Vamos dar uma olhada em um exemplo de um controlador básico:

@Controller
public class SampleController {
    @GetMapping("/sample")
    public String showForm() {
        return "sample";
    }

}

E o recurso jsp correspondente é o arquivo sample.jsp:

<html>
   <head></head>

   <body>
      <h1>This is the body of the sample view</h1>
   </body>
</html>

Os arquivos de visualização baseados em JSP estão localizados na pasta/WEB-INF do projeto, portanto, são acessíveis apenas à infraestrutura Spring e não pelo acesso direto à URL.

===* 5. Spring MVC com inicialização *

O Spring Boot é uma adição ao Spring Platform, que facilita muito a criação e criação de aplicativos independentes de nível de produção.* Boot não se destina a substituir o Spring, mas a tornar mais rápido e fácil o trabalho com ele. *

====* 5.1. Arrancadores de arranque com mola *

*A nova estrutura fornece dependências iniciais convenientes - que são descritores de dependência* que podem trazer toda a tecnologia necessária para uma determinada funcionalidade.

Eles têm a vantagem de não precisar mais especificar uma versão para cada dependência, mas permitir que o iniciador gerencie dependências para nós.

A maneira mais rápida de começar é adicionando o spring-boot-starter-parent _pom.xml: _

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.6.RELEASE</version>
</parent>

Isso cuidará do gerenciamento de dependências.

5.2 Ponto de entrada para inicialização com mola

Cada aplicativo criado usando Spring Boot precisa apenas definir o ponto de entrada principal. Geralmente, é uma classe Java com o método main, anotada com _ @ SpringBootApplication_:

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Esta anotação adiciona as outras anotações a seguir:

  • _ @ Configuração_ - que marca a classe como uma fonte de definições de bean

  • _ @ EnableAutoConfiguration_ - que instrui a estrutura a adicionar beans com base nas dependências do caminho de classe automaticamente *_ @ ComponentScan_ - que procura outras configurações e beans no mesmo pacote que a classe Application ou abaixo

Com o Spring Boot, podemos configurar o front-end usando o Thymeleaf ou JSP sem usar o ViewResolver, conforme definido na seção 3. Adicionando a dependência spring-boot-starter-thymeleaf ao nosso pom.xml, o Thymeleaf é ativado, e nenhuma configuração extra é necessária.

O código fonte do aplicativo Boot está, como sempre, disponível em over no GitHub.

Por fim, se você deseja iniciar o Spring Boot, dê uma olhada no nosso link:/spring-boot-start [introdução de referência aqui].

===* 6. Conclusão*

Neste exemplo, configuramos um projeto Spring MVC simples e funcional, usando a configuração Java.

A implementação deste tutorial simples do Spring MVC pode ser encontrada em o projeto GitHub.

Quando o projeto é executado localmente, o sample.jsp pode ser acessado em http://localhost: 8080/spring-mvc-basics/sample.

Related