Neste artigo mostrarei como configurar o Spring MVC em um projeto usando Maven no Eclipse.
Com o Eclipse aberto. Clique no Menu File, posicione o mouse em New e clique em Maven Project conforme a figura a seguir:
Figura 1: Criando o projeto
A janela New Maven Project será exibida. Marque a opção "Create a simple project (skip archetype selection) conforme mostra a figura a seguir:
Figura 2: New Maven Project - 1ª etapa
Na segunda etapa, informe os dados do Maven necessários como Id, Group, Version e Packaging do Artifact.
Veja na figura a seguir as informações deste projeto:
Figura 3: New Maven Project - 2ª etapa
Ao clicar no botão finish, o Eclipse vai criar o projeto. Inicialmente o projeto maven vai exibir ícone de erro, veja a figura 4.
Isso acontece quando não criamos o arquivo Web.xml que é necessário em projetos Java Web.
Figura 4: Projeto criado
O maven é responsável por baixar as dependências do projeto e compilá-lo conforme informações contidas no pom.xml.
Veja como é o nosso pom completo:
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>br.eti.tiagosousa</groupId>
<artifactId>springmvc</artifactId>
<version>1.0.0</version>
<packaging>war</packaging>
<name>Spring MVC</name>
<organization>
<name>Tiago Sousa</name>
<url>tiagosousa.eti.br</url>
</organization>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<failOnMissingWebXml>false</failOnMissingWebXml>
<java.version>1.8</java.version>
<maven-compiler-pluging.version>3.2</maven-compiler-pluging.version>
<!-- Spring MVC -->
<spring-framework.version>5.0.1.RELEASE</spring-framework.version>
<!-- Servlet API -->
<servlet.version>3.1.0</servlet.version>
<!-- JSTL -->
<jstl.version>1.2</jstl.version>
</properties>
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven-compiler-pluging.version}</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
<finalName>springmvc</finalName>
</build>
<dependencies>
<!-- Spring MVC -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<!-- Servlet API -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>${servlet.version}</version>
</dependency>
<!-- JSTL -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
</dependencies>
</project>
Após alterar o pom.xml. É necessário atualizar o projeto usando o Maven.
Clique com o botão direito do mouse no nome do projeto. No Menu, selecione Maven e clique em Update Project...
Observe:
Figura 5: Atualizando o projeto usando o Maven
O Maven vai atualizar o projeto. O ícone mostrando o erro vai desaparecer. A partir desse ponto podemos codificar o projeto.
A primeira classe a ser criada é a AppInitializer que é responsável por inicializar o framework Spring. Esta classe ficará dentro do package config.init.
Clique com o botão direito do mouse no nome do projeto. No Menu, selecione Maven e clique em Update Project...
Observe:
Figura 5: Atualizando o projeto usando o Maven
O Maven vai atualizar o projeto. O ícone mostrando o erro vai desaparecer. A partir desse ponto podemos codificar o projeto.
A primeira classe a ser criada é a AppInitializer que é responsável por inicializar o framework Spring. Esta classe ficará dentro do package config.init.
package br.eti.tiagosousa.springmvc.config.init;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
protected Class<?>[] getRootConfigClasses() {
return null;
}
@Override
protected Class<?>[] getServletConfigClasses() {
return null;
}
@Override
protected String[] getServletMappings() {
return new String[] { "/" };
}
}
Neste exemplo, usei o tomcat como container para executar o projeto. Quando o tomcat for inicializado, vai exibir no console "Spring WebApplicationInitializers detected on classpath" confirmando que nossa configuração já entrou em vigor no projeto.
Observe:
Figura 6: Informações no console mostram que o Spring foi inicializado
Agora iremos criar a classe WebConfig. Ela é necessária para habilitarmos o SpringMVC e definir o ViewResolver que é responsável em encontrar os arquivos .jsp dentro da pasta templates.
Observe:
package br.eti.tiagosousa.springmvc.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
@Bean
public ViewResolver internalResourceViewResolver() {
InternalResourceViewResolver bean = new InternalResourceViewResolver();
bean.setViewClass(JstlView.class);
bean.setPrefix("/WEB-INF/templates/");
bean.setSuffix(".jsp");
return bean;
}
}
Precisamos alterar o método getServletConfigClasses da classe AppInitializer. Veja:
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class<?>[] { WebConfig.class };
}
Desta forma, ao executar o projeto. O Spring vai encontrar a classe WebConfig que habilita o MVC no nosso projeto.
Observe no console a mensagem:
Figura 7: Console mostra que a classe WebConfig foi encontrada
Até esse ponto, o Spring está sendo inicializado e está carregando, também, o MVC. Porém nosso projeto ainda não mostra nenhuma página após ser executado.
Vamos criar a classe HomeController. Adicionaremos o método exibirHome que se encarregará de encontrar o arquivo Home.jsp. Essa será a página inicial do projeto.
package br.eti.tiagosousa.springmvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HomeController {
@GetMapping(value = "/")
public ModelAndView exibirHome(){
return new ModelAndView("Home");
}
}
Precisamos criar o arquivo Home.jsp dentro da pasta WEB-INF/templates que será utilizada pelo método exibirHome.
Primeiro precisamos criar a pasta WEB-INF dentro da pasta webapp. Clique com o botão direito no projeto, selecione New e clique em Folder. Veja a figura:
Figura 8: Acessando a opção Folder
A janela New Folder será exibida conforme a figura a seguir:
Figura 9: Janela New Folder utilizada para criar a pasta WEB-INF
Repita o procedimento e crie a pasta templates.
O próximo passo é criar o arquivo Home.jsp. Clique com o botão direito no projeto, selecione New e clique em JSP File, conforme a figura a seguir:
Figura 10: Acessando a opção JSP File
A janela New JSP File contém duas etapas. A primeira etapa é onde informamos o nome do arquivo:
Figura 11: New JSP File - 1ª Etapa
Na segunda etapa precisamos selecionar o formato que a página JSP irá assumir. No nosso caso, selecionamos o template HTML.
Figura 12: Selecionando o JSP com markup HTML
Na próxima figura, veja a página Home.jsp codificada. Observe:
Figura 13: Arquivo Home.jsp criado dentro da pasta templates
Agora que a classe HomeController está codificada e já criamos o arquivo Home.jsp. O WebConfg não consegue encontrar as classes anotadas com @Controller.
Precisamos alterar a classe WebConfig. Adicione a seguinte linha antes da anotação @Configuration:
@ComponentScan(basePackageClasses = { HomeController.class })
Assim nosso projeto está configurado. Ao executar o projeto. O Spring MVC será carregado e exibirá a página Home.jsp.
Veja a figura:
Figura 14: Página Home sendo exibida.
Chegamos ao fim de mais um tutorial.
Você pode acessar o código fonte no github, clicando aqui.
Até mais.