Spring - MVC Framework

A estrutura Spring Web MVC fornece arquitetura Model-View-Controller (MVC) e componentes prontos que podem ser usados ​​para desenvolver aplicativos da web flexíveis e fracamente acoplados. O padrão MVC resulta na separação dos diferentes aspectos do aplicativo (lógica de entrada, lógica de negócios e lógica de IU), enquanto fornece um acoplamento fraco entre esses elementos.

  • o Model encapsula os dados do aplicativo e, em geral, eles consistirão em POJO.

  • o View é responsável por renderizar os dados do modelo e, em geral, gera saída HTML que o navegador do cliente pode interpretar.

  • o Controller é responsável por processar as solicitações do usuário e construir um modelo apropriado e passa-o para a visualização para renderização.

O DispatcherServlet

A estrutura do Spring Web model-view-controller (MVC) é projetada em torno de um DispatcherServlet que trata todas as solicitações e respostas HTTP. O fluxo de trabalho de processamento de solicitação do Spring Web MVC DispatcherServlet é ilustrado no diagrama a seguir -

A seguir está a sequência de eventos correspondentes a uma solicitação HTTP de entrada para DispatcherServlet -

  • Depois de receber um pedido HTTP, DispatcherServlet consulta o HandlerMapping para chamar o Controlador apropriado .

  • O Controlador recebe a solicitação e chama os métodos de serviço apropriados com base no método GET ou POST usado. O método de serviço configurará os dados do modelo com base na lógica de negócios definida e retorna o nome da visualização para o DispatcherServlet .

  • O DispatcherServlet obterá ajuda de ViewResolver para selecionar a visualização definida para a solicitação.

  • Depois que a visualização é finalizada, o DispatcherServlet passa os dados do modelo para a visualização que é finalmente renderizada no navegador.

Todos os componentes mencionados acima, ou seja, HandlerMapping, Controller e ViewResolver são partes do WebApplicationContext w, que é uma extensão do ApplicationContext simples com alguns recursos extras necessários para aplicativos da web.

Configuração Requerida

Você precisa mapear as solicitações que deseja que o DispatcherServlet manipule, usando um mapeamento de URL noweb.xmlArquivo. A seguir está um exemplo para mostrar declaração e mapeamento paraHelloWeb Exemplo de DispatcherServlet -

<web-app id = "WebApp_ID" version = "2.4"
   xmlns = "http://java.sun.com/xml/ns/j2ee" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee 
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    
   <display-name>Spring MVC Application</display-name>
   
   <servlet>
      <servlet-name>HelloWeb</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>HelloWeb</servlet-name>
      <url-pattern>*.jsp</url-pattern>
   </servlet-mapping>

</web-app>

o web.xmlO arquivo será mantido no diretório WebContent / WEB-INF de seu aplicativo da web. Após a inicialização deHelloWeb DispatcherServlet, a estrutura tentará carregar o contexto do aplicativo a partir de um arquivo denominado [servlet-name]-servlet.xmllocalizado no diretório WebContent / WEB-INF do aplicativo. Neste caso, nosso arquivo seráHelloWebservlet.xml.

A seguir, a tag <servlet-mapping> indica quais URLs serão tratados por qual DispatcherServlet. Aqui, todas as solicitações HTTP que terminam com.jsp será tratado pelo HelloWeb DispatcherServlet.

Se não quiser usar o nome do arquivo padrão como [servlet-name] -servlet.xml e o local padrão como WebContent / WEB-INF , você pode personalizar o nome e o local desse arquivo adicionando o ouvinte de servlet ContextLoaderListener em seu arquivo web.xml como segue -

<web-app...>

   <!-------- DispatcherServlet definition goes here----->
   ....
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
   </context-param>

   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
   
</web-app>

Agora, vamos verificar a configuração necessária para HelloWeb-servlet.xmlarquivo, colocado no diretório WebContent / WEB-INF de seu aplicativo da web -

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans     
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint" />

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

</beans>

A seguir estão os pontos importantes sobre HelloWeb-servlet.xml arquivo -

  • O arquivo [servlet-name] -servlet.xml será usado para criar os beans definidos, substituindo as definições de quaisquer beans definidos com o mesmo nome no escopo global.

  • A tag <context: component-scan ...> será usada para ativar o recurso de varredura de anotação Spring MVC, que permite fazer uso de anotações como @Controller e @RequestMapping etc.

  • O InternalResourceViewResolver terá regras definidas para resolver os nomes das visualizações. De acordo com a regra definida acima, uma visão lógica chamadahelloé delegado a uma implementação de visualização localizada em /WEB-INF/jsp/hello.jsp .

A seção a seguir mostrará como criar seus componentes reais, ou seja, Controlador, Modelo e Visualização.

Definindo um controlador

O DispatcherServlet delega a solicitação aos controladores para executar a funcionalidade específica a ele. o@Controllera anotação indica que uma determinada classe desempenha o papel de um controlador. o@RequestMapping a anotação é usada para mapear um URL para uma classe inteira ou um método de manipulador específico.

@Controller
@RequestMapping("/hello")
public class HelloController { 
   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

o @Controllera anotação define a classe como um controlador Spring MVC. Aqui, o primeiro uso de@RequestMapping indica que todos os métodos de tratamento neste controlador são relativos ao /hellocaminho. Próxima anotação@RequestMapping(method = RequestMethod.GET)é usado para declarar o métodoprintHello () como o método de serviço padrão do controlador para lidar com a solicitação HTTP GET. Você pode definir outro método para lidar com qualquer solicitação POST no mesmo URL.

Você pode escrever o controlador acima em outro formulário onde você pode adicionar atributos adicionais em @RequestMapping da seguinte maneira -

@Controller
public class HelloController {
   @RequestMapping(value = "/hello", method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

o value atributo indica a URL para a qual o método do manipulador é mapeado e o methodatributo define o método de serviço para lidar com a solicitação HTTP GET. Os seguintes pontos importantes devem ser observados sobre o controlador definido acima -

  • Você definirá a lógica de negócios necessária dentro de um método de serviço. Você pode chamar outro método dentro deste método de acordo com o requisito.

  • Com base na lógica de negócios definida, você criará um modelo dentro deste método. Você pode usar diferentes atributos do modelo setter e esses atributos serão acessados ​​pela vista para apresentar o resultado final. Este exemplo cria um modelo com seu atributo "mensagem".

  • Um método de serviço definido pode retornar um String, que contém o nome do viewa ser usado para renderizar o modelo. Este exemplo retorna "hello" como nome de visão lógica.

Criação de visualizações JSP

Spring MVC oferece suporte a muitos tipos de visualizações para diferentes tecnologias de apresentação. Isso inclui - JSPs, HTML, PDF, planilhas do Excel, XML, modelos Velocity, feeds XSLT, JSON, Atom e RSS, JasperReports, etc. Mas, mais comumente, usamos modelos JSP escritos com JSTL.

Vamos escrever um simples hello visualizar em /WEB-INF/hello/hello.jsp -

<html>
   <head>
      <title>Hello Spring MVC</title>
   </head>
   
   <body>
      <h2>${message}</h2>
   </body>
</html>

Aqui ${message}é o atributo que configuramos dentro do Controlador. Você pode ter vários atributos a serem exibidos dentro de sua visualização.

Exemplos de framework Spring Web MVC

Com base nos conceitos acima, vamos verificar alguns exemplos importantes que o ajudarão a construir seus aplicativos da Web Spring -

Sr. Não. Exemplo e descrição
1 Exemplo Hello World do Spring MVC

Este exemplo explicará como escrever um aplicativo Spring Web Hello World simples.
2 Exemplo de manipulação de formulário Spring MVC

Este exemplo explicará como escrever um aplicativo Spring Web usando formulários HTML para enviar os dados ao controlador e exibir um resultado processado.
3 Exemplo de redirecionamento de página Spring

Aprenda a usar a funcionalidade de redirecionamento de página no Spring MVC Framework.
4 Exemplo de Spring Static Pages

Aprenda como acessar páginas estáticas junto com páginas dinâmicas no Spring MVC Framework.
5 Exemplo de manipulação de exceção de primavera

Aprenda como lidar com exceções no Spring MVC Framework.