Tutorial do Spring MVC

O Spring MVC é um framework Java usado para construir aplicativos Web. Ele segue o padrão Model-Visualização-Padrão de design Controller. Ele implementa todas as funcionalidades básicas do framework central Spring, como injeção de dependência, inversão de controle.

O Spring MVC através DispatcherServlet Oferece uma solução elegante para usar MVC no framework Spring. Aqui, DispatcherServlet É uma classe usada para receber solicitações entrantes e mapeá-las para recursos corretos, como controladores, modelos e visualizações.

Modelo Web do Spring-Visualização-Controlador

Modelo-O modelo contém os dados do aplicativo. Os dados podem ser um único objeto ou uma coleção de objetos. Controlador-O controlador contém a lógica de negócios do aplicativo. Aqui, o anotação @Controller é usada para marcar a classe como controlador. Visualização-A visualização representa as informações fornecidas em um formato específico. Geralmente, o JSP + A JSTL é usada para criar páginas de visualização. Embora o Spring ainda suporte outras tecnologias de visualização, como Apache Velocity, Thymeleaf e FreeMarker. Controlador Frontal-No Spring Web MVC, a classe DispatcherServlet é usada como controlador frontal. Ela é responsável por gerenciar o fluxo do aplicativo Spring MVC.

Entenda o fluxo do Spring Web MVC

Como mostrado na figura, todas as solicitações entrantes são interceptadas pelo DispatcherServlet do controlador frontal. O DispatcherServlet obtém entradas de mapeamento de processadores a partir de arquivos XML e redireciona solicitações para controladores. O controlador retorna o objeto ModelAndView. O DispatcherServlet verifica a entrada do resolver de visão no arquivo XML e chama o componente de visão especificado.

Vantagens do framework Spring MVC

Vamos ver algumas vantagens do Spring MVC Framework: -

Separação de papéis-O Spring MVC separa cada papel, onde podem ser implementados objetos específicos para modelos, controladores, objetos de comando, resolvers de visão, DispatcherServlet, validadores, etc. Leve-Ele usa um contêiner servlet leve para desenvolver e deploys suas aplicações. Configuração poderosa-Ele fornece uma configuração confiável para classes do framework e do aplicativo, incluindo referências fáceis entre contextos, como de controladores da web para objetos de negócios e validadores. Desenvolvimento rápido-O Spring MVC promove o desenvolvimento rápido e paralelo. Código de negócios reutilizável-Sem a necessidade de criar novos objetos, ele nos permite usar objetos de negócios existentes. Facilidade de teste-No Spring, geralmente criamos classes JavaBeans, permitindo que você insira dados de teste usando métodos setter. Mapeamento flexível-Ele fornece anotações específicas para facilitar a redirecionamento de páginas.

Exemplo do framework Spring Web MVC

Vamos ver um exemplo simples do framework Spring Web MVC. Os passos são os seguintes:

Carregue o arquivo jar do Spring ou adicione dependência no Maven Crie a classe controladora Forneça entrada do controlador no arquivo web.xml Defina bean em arquivo XML separado Exiba a mensagem na página JSP Inicie o servidor e deploy o projeto

Estrutura de diretórios do Spring MVC

Estrutura de diretórios do Spring MVC usando Maven

arquivos jar necessários ou dependências Maven

Para executar este exemplo, você precisa carregar:

Arquivo jar do Spring Core Arquivo jar do Spring Web JSP + Arquivo jar do JSTL (se estiver usando outra tecnologia de visão, carregue o correspondente arquivo jar).

Baixe todos os arquivos jar do Spring, incluindo JSP e JSTL .

Se você estiver usando Maven, não é necessário adicionar arquivo jar. Agora, você precisa adicionar dependências Maven ao arquivo pom.xml.

1fornece informações e configurações do projeto no arquivo pom.xml.

pom.xml

<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/40.0.0 http://maven.apache.org/maven-maven.apache.org4maven
　　v4_0_0.xsd">/<modelVersion>
　　.0.0<3modelVersion>/<dependency>
　　<groupId>com.w/artifactId>
　　codebox</<artifactId>SpringMVC<
　　<packaging>war<1-packaging>/version>
　　<version>0.0./name>
　　SNAPSHOT<//<name>SpringMVC Maven Webapp</<url>http:
　　maven.apache.org<
　　　　javax.servlet
　　　　　　url>/<dependency>
　　　　　　<dependencies>/artifactId>
　　　　　　<version>3<artifactId>spring8<artifactId>spring1</version>
　　　　　　<groupId>junit</<artifactId>junit<
　　　　</dependency>
　　　　
　　　　<!--　.//.RELEASE</https:/<scope>test</spring-scope>　-->
javax.servlet
　　　　org.springframework/<dependency>
　　　　webmvc-<groupId>org.springframework</artifactId>
　　　　<version>5<artifactId>spring1<artifactId>spring1webmvc</version>
</dependency>
<!--　.//.RELEASE</https:/mvnrepository.com/mvnrepository.com-artifact　-->
javax.servlet　　
　　　　api/<dependency>　　
　　　　<groupId>javax.servlet<-<artifactId>servlet/artifactId>　　
　　　　<version>3.0-alpha-1</version>　　
</dependency>
　　</dependencies>
　　<build>
　　　　<finalName>SpringMVC</finalName>
　　</build>
</project>

2、criar classe controladora

Para criar uma classe controladora, usamos as anotações @Controller e @RequestMapping.

@Controller anotação marca a classe como Controller.

@Requestmapping anotação é usada para mapear classes com nomes de URL específicos.

HelloController.java

package com.w3codebox;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public　class　HelloController　{
@RequestMapping("/}
　　public　String　display()
　　{
　　　　return　"index";
　　}　
}

3、fornecer entrada do controlador no arquivo web.xml

Neste arquivo xml, especificamos a classe Servlet DispatcherServlet como o controlador de frente do Spring Web MVC. Todas as solicitações entrantes de arquivos html serão redirecionadas para o DispatcherServlet.

web.xml

<?xml　version="1.0"　encoding="UTF-8"?>
<web-app　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"　xmlns="http://java.sun.com/xml/ns/javaee"　xsi:schemaLocation="http://java.sun.com/xml/ns/javaee　http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"　id="WebApp_ID"　version="3.0">
　　<display-name>SpringMVC</display-name>
　　　<servlet>　　
　　　　<servlet-name>spring</servlet-name>　　
　　　　<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>　　
　　　　<load-on-startup>1</load-on-startup>　　　　
</servlet>　　
<servlet-mapping>　　
　　　　<servlet-name>spring</servlet-name>　　
　　　　<url-pattern>/</url-pattern>　　
</servlet-mapping>　　
</web-app>

4、definir bean no arquivo xml.

Este é um arquivo de configuração importante, onde deve ser especificado o componente View.

context: component-O elemento scan define o pacote básico do DispatcherServlet. Ele procurará classes de controladores.

Este arquivo xml deve estar localizado em WEB-INF diretório.

spring-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"　
　　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
　　　　　　http://www.springframework.org/schema/context/spring-context.xsd
　　　　　　http://www.springframework.org/schema/mvc
　　　　　　　　http://www.springframework.org/schema/mvc/spring-mvc.xsd">
　　<!--　Fornece suporte para o scan de componentes　-->
　　<context:component-scan base-package="com.w3codebox"　/>
　　<!--Fornece suporte para conversão, formatação e validação　-->
　　<mvc:annotation-driven/>
</beans>

5Mostrando mensagem na página JSP

Esta é uma simples página JSP, que exibe a mensagem retornada pelo Controller.

index.jsp

<html>
<body>
<p>Bem-vindo ao Tutorial de Spring MVC</p>
</body>
</html>

Saída:

Índice MVC do Spring