O Spring MVC ajuda a construir aplicações web flexíveis e com baixo acoplamento. O padrão de design Modelo-visão-controlador ajuda na separação da lógica de negócio, lógica de apresentação e lógica de navegação. Os Modelos são responsáveis por encapsular os dados da aplicação. As Visões renderizam as repostas ao usuário com a ajuda do objeto modelo. Os Controladores são responsáveis por receber as requisições do usuário e executar os serviços.
A figura abaixo mostra o fluxo de uma requisição no Framework Spring MVC:
Quando uma requisição é enviada ao Framework Spring MVC a seguinte sequência de eventos acontece.
- O DispatcherServlet recebe a requisição em primeiro lugar.
- O DispatcherServlet consulta o HandlerMapping e invoca o Controller associado a requisição.
- O Controller processa a requisição através da chamada aos métodos apropriados do serviço e retorna um objeto ModeAndView para DispatcherServlet. O objeto ModeAndView contém os dados do modelo e o nome da visão.
- O DispatcherServlet envia o nome de visão para um ViewResolver para que ele encontre o View que deve ser invocado.
- Agora o DispatcherServlet passará o objeto modelo para o View para que o resultado seja renderizado.
- O View com a ajuda dos dados do modelo irá renderizar o resultado para o usuário.
Para entender o Framework Spring MVC iremos criar um exemplo simples usando o Eclipse. Nesse artigo, estaremos usando o Eclipse 3.4 com o plugin Spring IDE, Tomcat 6.0 e Spring 3.0 para demonstrar esse exemplo.
Vá para File -> New -> Dynamic Web Project, para criar um projeto web.
Informe o nome do projeto e clique no botão Finish.
Clique com o botão direito na pasta do projeto, e selecione Spring Tools -> Add Spring Project Nature, para adicionar os recursos do Spring ao projeto. Esse recursos estará disponível apenas se você instalar o Spring IDE.
Crie um novo pacote com.vaannila dentro do diretório src. A classe do controlador do Spring estende a classe org.springframework.web.servlet.mvc.AbstractController. Para criar uma nova classe de controlador clique com o botão direito no diretório src e crie um nova classe java, informe o nome da classe do controlador e o nome da super-classe e clique no botão Finish.
Copie o código abaixo dentro da classe HelloWorldController.
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
public class HelloWorldController extends AbstractController {
private String message;
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {
return new ModelAndView("welcomePage","welcomeMessage", message);
}
public void setMessage(String message) {
this.message = message;
}
}
A classe HelloWorldController tem uma propriedade message que é ajustada através de um método setter. A classe HelloWorldController deve sobrecarregar o método handleRequestInternal() para processar a requisição. Depois do processamento da requisição o método handleRequestInternal() retorna um objeto ModelAndView de volta ao DispatcherServlet.
O DispatcherSevlet, como o nome indica, é um servlet único que gerencia todo o processo de manipulação de requisições. Quando uma requisição é enviada para o DispatcherServlet ele delega o trabalho através da invocação do controlador apropriado para a requisição. Como qualquer outro servlet, o DispatcherServlet precisa ser configurado no arquivo web.xml como mostrado abaixo.
<?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" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>*.htm</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>redirect.jsp</welcome-file>
</welcome-file-list>
</web-app>
Aqui o nome do servlet é dispatcher. Por padrão o DispatcherServlet procurará por um arquivo chamado dispatcher-servlet.xml para carregar a configuração do Spring MVC. Esse nome de arquivo é formado pela concatenação do nome do servlet (“dispatcher“) com “-servlet.xml“. Aqui usamos o padrão url-pattern como “.htm” de modo a esconder a tecnologia de implementação dos usuários.
O arquivo redirect.jsp será invocado em primeiro lugar quando executamos a aplicação web Spring. Esse é o único arquivo jsp que está localizado fora do diretório WEB-INF e está nesse local para redirecionar para o DispatcherServlet. Todas as outras visões devem ser armazenadas dentro do diretório WEB-INF de modo que possam ser invocadas apenas pelo controlador.
Para criar um arquivo de configuração de bean clique com o botão direito do mouse na pasta WebContent e selecione New -> Other. A seguinte caixa de diálogo aparece:
Selecione o arquivo de configuração do Bean Spring e clique em Next.
Informe o nome do arquivo como “dispatcher-servlet.xml” e clique no botão Finish.
Agora que o arquivo de configuração do bean foi criado, precisamos configurar as classes do Controller e do ViewResolver. O código abaixo mostra como fazer isso
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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.xsd">
<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>
<bean name="/welcome.htm" class="com.vaannila.HelloWorldController" >
<property name="message" value="Hello World!" />
</bean>
</beans>
Em primeiro lugar, vamos entender como configurar o controlador
<bean name="/welcome.htm" class="com.vaannila.HelloWorldController" >
<property name="message" value="Hello World!" />
</bean>
Aqui o atributo name do elemento bean indica o padrão da URL que irá mapear a requisição. Como o atributo id não pode conter caracteres especiais como “/” , nós devemos especificar o padrão de URL usando o atributo name do elemento bean. Por padrão, o DispatcherServlet usa BeanNameUrlHandlerMapping para mapear requesições recebidas. O BeanNameUrlHandlerMapping usa o nome do bean como padrão de URL. Como BeanNameUrlHandlerMapping é usado por padrão, você não precisa criar nenhuma configuração separada para isso.
Ajustamos o atributo message da classe HelloWorldController para o método setter correspondente. A classe HelloWorldController é configurada como qualquer outra classe JavaBean no contexto da aplicação JavaBean, assim como qualquer outro JavaBean pode ter valores ajustados através da Injeção de Dependência (Dependency Injection – DI).
O arquivo redirect.jsp irá redirecionar as requisições para DispatcherServlet, que por sua vez consultará o BeanNameUrlHandlerMapping e invocará HelloWorldController. O método handleRequestInternal() da classe HelloWorldController será invocado. Aqui retornaremos a propriedade message sob o nome welcomeMessage e o nome da visão welcomePage para o DispatcherServlet. Como agora só sabemos o nome da visão, para achar a visão a ser invocada precisamos de um ViewResolver.
O ViewResolver é configurado usando o código a seguir:
<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>
Aqui InternalResourceViewResolver é usado para resolver o nome da visão na visão em si. O prefixo + nome da visão + sufixo lhe fornecerá a localização da visão. Nesse casom a localização da visão é /WEB-INF/jsp/welcomePage.jsp
Os seguintes arquivos de bibliotecas precisam ser adicionados para executar o exemplo.
antlr-runtime-3.0 commons-logging-1.0.4 org.springframework.asm-3.0.0.M3 org.springframework.beans-3.0.0.M3 org.springframework.context-3.0.0.M3 org.springframework.context.support-3.0.0.M3 org.springframework.core-3.0.0.M3 org.springframework.expression-3.0.0.M3 org.springframework.web-3.0.0.M3 org.springframework.web.servlet-3.0.0.M3
Para executar o exemplo, execute o arquivo redirect.jsp. A seguinte página será exibida.
A estrutura do diretório do exemplo é mostrada abaixo.
Você pode baixar e testar o exemplo clicando nos links abaixo.
|
Source Download -> SpringExample5
|
|
War Download -> SpringExample5.war.tar
|
Traduzido de http://www.vaannila.com/spring/spring-mvc-tutorial-1.html]]>