Passo a passo para desenvolver uma aplicação usando o Spring Framework MVC – Capitulo 1 – Configuração do ambiente e o fundamentos da aplicação

Depois de uma breve introdução, segue abaixo o primeiro capitulo da tradução do curso de Spring, que irá mostrar como Criar a estrutura de arquivos de nosso projeto exemplo,  os primeiros arquivos JSP, carregar nossa aplicação no Tomcat para ir checando se a aplicação está funcionando, e baixar e copiar as bibliotecas do Spring para seus locais apropriados.

1.1. Criar a estrutura de diretórios do projeto

Iremos precisar de um local para manter todo o código fonte e outros arquivosque iremos criar, assim vamos criar um diretório chamado ‘springapp’. A decisão de onde criar esse diretório cabe totalmente a você. Dentro desse diretório criaremos um sub-diretório chamado ‘src’ para guardar todos os arquivos de código fonte Java que iremos criar. Depois criaremos outros sub-diretório chamado ‘war’. Esse diretório guardará tudo o que deveria estar mo arquivo WAR que usaremos para empacotar e carregar nossa aplicação. Todos os arquivo de código fonte e outros códigos Java, como  JSp´s e arquivos de configuração, ficam no diretório ‘war’.

Abaixo você encontra uma captura de tela de como o diretório do seu projeto precisa ficcar depois das instruções acima (A tela mostra a estrutura do diretório dentro do IDE Eclipse: você não precisa usar essa IDE para completar esse tutorial, mas usando o Eclipse tornará mais fácil seguir os passos descritos aqui).


A estrutura de diretório do projeto

1.2. 'Criar o 'index.jsp'

Como estamos criando uma aplicação web, vamos comerçar criando uma página JSP simples chamada ‘index.jsp’ no diretório ‘war’. O ‘index.jsp’ é o ponto de entrada para nossa aplicação.

'springapp/war/index.jsp':

<html>
  <head><title>Example :: Spring Application</title></head>
  <body>
    <h1>Example - Spring Application</h1>
    <p>This is my test.</p>
  </body>
</html>

Para ter uma aplicação web completa, vamos criar um diretório ‘WEB-INF’ dentro do diretório ‘war’ e salvar um arquivo ‘web.xml’ nesse diretório.

'springapp/war/WEB-INF/web.xml':

<?xml version="1.0" encoding="UTF-8"?>

<web-app 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" >

  <welcome-file-list>
    <welcome-file>
      index.jsp
    </welcome-file>
  </welcome-file-list>

</web-app>

1.3. Carregar a aplicação do Tomcat

Vamos agora escrever o script de compilação do Ant que iremosmusar no decorrer desse tutorial. Esse script irá conter os alvos para a compilação e carregamento da aplicação. Um script separado será usado por alvos específicos do servidor de aplicações, como os alvos para controle da aplicação no Tomcat.

'springapp/build.xml':

<?xml version="1.0"?>

<project name="springapp" basedir="." default="usage">
    <property file="build.properties"/>

    <property name="src.dir" value="src"/>
    <property name="web.dir" value="war"/>
    <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
    <property name="name" value="springapp"/>

    <path id="master-classpath">
        <fileset dir="${web.dir}/WEB-INF/lib">
            <include name="*.jar"/>
        </fileset>
        <!-- We need the servlet API classes: -->
        <!--  * for Tomcat 5/6 use servlet-api.jar -->
        <!--  * for other app servers - check the docs -->
        <fileset dir="${appserver.lib}">
            <include name="servlet*.jar"/>
        </fileset>
        <pathelement path="${build.dir}"/>
    </path>

    <target name="usage">
        <echo message=""/>
        <echo message="${name} build file"/>
        <echo message="-----------------------------------"/>
        <echo message=""/>
        <echo message="Available targets are:"/>
        <echo message=""/>
        <echo message="build     --> Build the application"/>
        <echo message="deploy    --> Deploy application as directory"/>
        <echo message="deploywar --> Deploy application as a WAR file"/>
        <echo message="install   --> Install application in Tomcat"/>
        <echo message="reload    --> Reload application in Tomcat"/>
        <echo message="start     --> Start Tomcat application"/>
        <echo message="stop      --> Stop Tomcat application"/>
        <echo message="list      --> List Tomcat applications"/>
        <echo message=""/>
    </target>

    <target name="build" description="Compile main source tree java files">
        <mkdir dir="${build.dir}"/>
        <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
               deprecation="false" optimize="false" failonerror="true">
            <src path="${src.dir}"/>
            <classpath refid="master-classpath"/>
        </javac>
    </target>

    <target name="deploy" depends="build" description="Deploy application">
        <copy todir="${deploy.path}/${name}" preservelastmodified="true">
            <fileset dir="${web.dir}">
                <include name="**/*.*"/>
            </fileset>
        </copy>
    </target>

    <target name="deploywar" depends="build" description="Deploy application as a WAR file">
        <war destfile="${name}.war"
             webxml="${web.dir}/WEB-INF/web.xml">
            <fileset dir="${web.dir}">
                <include name="**/*.*"/>
            </fileset>
        </war>
        <copy todir="${deploy.path}" preservelastmodified="true">
            <fileset dir=".">
                <include name="*.war"/>
            </fileset>
        </copy>
    </target>

<!-- ============================================================== -->
<!-- Tomcat tasks - remove these if you don't have Tomcat installed -->
<!-- ============================================================== -->

    <path id="catalina-ant-classpath">
        <!-- We need the Catalina jars for Tomcat -->
        <!--  * for other app servers - check the docs -->
        <fileset dir="${appserver.lib}">
            <include name="catalina-ant.jar"/>
        </fileset>
    </path>

    <taskdef name="install" classname="org.apache.catalina.ant.InstallTask">
        <classpath refid="catalina-ant-classpath"/>
    </taskdef>
    <taskdef name="reload" classname="org.apache.catalina.ant.ReloadTask">
        <classpath refid="catalina-ant-classpath"/>
    </taskdef>
    <taskdef name="list" classname="org.apache.catalina.ant.ListTask">
        <classpath refid="catalina-ant-classpath"/>
    </taskdef>
    <taskdef name="start" classname="org.apache.catalina.ant.StartTask">
        <classpath refid="catalina-ant-classpath"/>
    </taskdef>
    <taskdef name="stop" classname="org.apache.catalina.ant.StopTask">
        <classpath refid="catalina-ant-classpath"/>
    </taskdef>

    <target name="install" description="Install application in Tomcat">
        <install url="${tomcat.manager.url}"
                 username="${tomcat.manager.username}"
                 password="${tomcat.manager.password}"
                 path="/${name}"
                 war="${name}"/>
    </target>

    <target name="reload" description="Reload application in Tomcat">
        <reload url="${tomcat.manager.url}"
                 username="${tomcat.manager.username}"
                 password="${tomcat.manager.password}"
                 path="/${name}"/>
    </target>

    <target name="start" description="Start Tomcat application">
        <start url="${tomcat.manager.url}"
                 username="${tomcat.manager.username}"
                 password="${tomcat.manager.password}"
                 path="/${name}"/>
    </target>

    <target name="stop" description="Stop Tomcat application">
        <stop url="${tomcat.manager.url}"
                 username="${tomcat.manager.username}"
                 password="${tomcat.manager.password}"
                 path="/${name}"/>
    </target>

    <target name="list" description="List Tomcat applications">
        <list url="${tomcat.manager.url}"
                 username="${tomcat.manager.username}"
                 password="${tomcat.manager.password}"/>
    </target>

<!-- End Tomcat tasks -->

</project>

Se você estiver usando um servidor de aplicações diferente, voce pode remover as tarefas específicas do Tomcat no final do script. Você terá que confiar no recurso de carregamento automaticaco de seu servidor, ou terá que iniciar ou parar sua aplicação manualmente.

Se estiver usando uma IDE, você pode receber algumas mensagens de erro pela IDE para o arquivo ‘build.xml’, principalmente em relação aos alvos do Tomcat. Você pode ignorar essas mensagens. A listagem acima está correta.

A listagem do script acima contém todos os alvos que iremos precisar para facilitar o nosso esforço de desenvolvimento. Não iremos aqui explicar detalhadamente esse script, desde que a grande parte dele são instruções padrão do Ant e do Tomcat. Você pode copiar o texto acima e colar em um novo arquivo ‘build.xml’ na raiz da árvore de diretório de seu desenvolvimento. Nós também precisamos do arquivo ‘build.properties’ que você precisa personalizar para ajustar como a instalação do servidor. Esse arquivo pertence ao mesmo diretório do arquivo ‘build.xml’.

'springapp/build.properties':

# Ant properties for building the springapp

appserver.home=${user.home}/apache-tomcat-6.0.14
# for Tomcat 5 use $appserver.home}/server/lib
# for Tomcat 6 use $appserver.home}/lib
appserver.lib=${appserver.home}/lib

deploy.path=${appserver.home}/webapps

tomcat.manager.url=http://localhost:8080/manager
tomcat.manager.username=tomcat
tomcat.manager.password=s3cret

Se você estiver em um sistema onde você não é o dono da instalação do Tomcat, então o administrador do Tomcat precisa lhe garantir acesso completo ao diretório ‘webapps’ ou criar um novo diretório ‘springapp’ dentro de ‘webapps’ no diretório de instalação do Tomcat, e também fornecer a você permissão para carregar essa aplicação no diretório criado. No Linux, execute o comando ‘chmod a+rwx springapp’ para fornecer a todos acesso completo a esse diretório.

Para criar um usuário Tomcat chamado ‘tomcat’ com ‘s3cret’ como senha, edite o arquivo:’appserver.home/conf/tomcat-users.xml’ e adicione a seguinte entrada.

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="manager"/>
  <user username="tomcat" password="s3cret" roles="manager"/>
</tomcat-users>

Agora execute o Ant para certicar-se de que tudo esteja ok. Você precisa estar no diretório ‘springapp’.

Abra um prompt de comando e execute ‘ant’.

$ ant
Buildfile: build.xml

usage:
     [echo]
     [echo] springapp build file
     [echo] -----------------------------------
     [echo]
     [echo] Available targets are:
     [echo]
     [echo] build     --> Build the application
     [echo] deploy    --> Deploy application as directory
     [echo] deploywar --> Deploy application as a WAR file
     [echo] install   --> Install application in Tomcat
     [echo] reload    --> Reload application in Tomcat
     [echo] start     --> Start Tomcat application
     [echo] stop      --> Stop Tomcat application
     [echo] list      --> List Tomcat applications
     [echo] 

BUILD SUCCESSFUL
Total time: 2 seconds

A última coisa que precisamos fazer aqui é compilar e carregar a aplicação. Execute o Ant especificando ‘deploy’ e ‘deploywar’ como parâmetro.

$ ant deploy
Buildfile: build.xml

build:
    [mkdir] Created dir: /Users/trisberg/Projects/springapp/war/WEB-INF/classes

deploy:
     [copy] Copying 2 files to /Users/trisberg/apache-tomcat-5.5.17/webapps/springapp

BUILD SUCCESSFUL
Total time: 4 seconds

1.4 Checar se a aplicação funciona

Vamos rapidamente iniciar o Tomcat executando o comando '${appserver.home}/bin/startup.bat'. Para nos certificarmos que podemos acessar a aplicação, execute o comando ‘list’ do seu arquivo build para ver se o Tomcat possui a sua aplicação.

$ ant list
Buildfile: build.xml

list:
     [list] OK - Listed applications for virtual host localhost
     [list] /springapp:running:0:springapp
     [list] /manager:running:0:manager
     [list] /:running:0:ROOT
     [list] /docs:running:0:docs
     [list] /examples:running:0:examples
     [list] /host-manager:running:0:host-manager

BUILD SUCCESSFUL
Total time: 3 seconds

Você pode agora abrir o navegador e acessar a página inincial de nossa aplicação pela URL seguinte: http://localhost:8080/springapp/index.jsp.

A página inicial da aplicação

1.5. Baixar o Framework do Spring

Se ainda nõa baixou o framework do Spring, agora é a hora de fazê-lo. Atualmente, esse framework pode ser baixo do site http://www.springframework.org/download. Descompacte o arquivo em algum lugar para que possamos usar diversos arquivos desse pacote várias vezes.

Esse passo completa a configuração necessária do ambiente, e agora podemos começar a desenvolver nossa aplicação usando o Spring Framework MVC.

1.6. Modificar o ‘web.xml' do diretório 'WEB-INF

Acesse o diretório ‘springapp/war/WEB-INF’. Modifique o arquivo mínimo ‘web.xml’ que nós criamos anteriormente. Definiremos um DispatcherServlet (também cinhecido como ‘Front Controller’). Ele irá controlar por onde as suas requisições serão roteadas baseado na informação que você fornecerá. Essa definição do servlet tem também uma entrada >servlet-mapping/> que mapeia o padrão da URL que estaremos usando. Decidimos deixar que qualquer URL com a extensão ‘.htm’ serão direcionadas para o servlet ‘springapp’ (o DispatcherServlet).

'springapp/war/WEB-INF/web.xml':

<?xml version="1.0" encoding="UTF-8"?>

<web-app 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" >

  <servlet>
    <servlet-name>springapp</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>springapp</servlet-name>
    <url-pattern>*.htm</url-pattern>
  </servlet-mapping>

  <welcome-file-list>
    <welcome-file>
      index.jsp
    </welcome-file>
  </welcome-file-list>

</web-app>

Agora, crire um arquivo chamado ‘stringapp-servlet.xml’ no diretório ‘springapp/war/WEB-INF’. Esse arquivo irá conter as definições de beans (objetos Java antigos) usados pelo DispatcherServlet. É o WebApplicationContext onde todos os componentes relacionados a web estão. O nome desse arquivo é determinado pelo valor do elemento <servlet-name/> do ‘web.xml’, como o sufixo ‘-servlet’ apensado a ele. Esse padrão de nomenclatura é usado pelo framework Spring MVC. Agora, adicione uma entrada chamada ‘/hello.htm’. O framework Spring MVC usa uma implementação da classe da interface chamada HandleMapping para definir o mapeamento entre a URL requisitada e o objeto que irá manipular o recursos. Diferentemente do DispatcherServlet, o HelloController é responsável por manipular as requisições para uma página em particular do website e é também conhecida como “Controlador de página’. O HandleMapping padrão que o DispatcherServlet usa é o BeanNameUrlHandlerMapping; essa classe usará o nome do bean para mapear a URL requisitada  para que o DispatcherServlet saiba que controlador precisa ser invocado para manipular diferentes URLs.

'springapp/war/WEB-INF/springapp-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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

  <!-- the application context definition for the springapp DispatcherServlet -->

  <bean name="/hello.htm"/>

</beans>

1.7. Copiando as bibliotecas para 'WEB-INF/lib'

Primeiro crie um diretório ‘lib’ dentro do ‘war/WEB-INF’. Depois, no diretório da distribuição do Spring, copie os arquivos spring.jar (de spring-framework-X.X/dist) e spring-webmvc.jar (de spring-framework-X.X/dist/modules) para o diretório que você acabou de criar. Além  desses, copie o arquivo commons-logging.jar (de spring-framework-X.X/lib/jakarta-commons) para o mesm odiretório. Esses JARs serão carregados para o servidor e serão usados durante o processo de compilação.

1.8. Crie o controlador

Crie sua classe Controller (Controlador) – nós iremos nomea-la HelloController, e definiremos ela no pacote ‘springapp.web’. Primeiro crie os diretórios do pacote e depois crie o arquivo ‘HelloController.java’ e coloque ele no diretório que acabou de criar.

'springapp/src/springapp/web/HelloController.java':

package springapp.web;

import org.springframework.web.servlet.mvc.Controller;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.IOException;

public class HelloController implements Controller {

    protected final Log logger = LogFactory.getLog(getClass());

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        logger.info("Returning hello view");

        return new ModelAndView("hello.jsp");
    }

}

Essa é uma implementação bem básica de um Controlador. Iremos explicar essa implementação mais tarde assim como nos estender sobre outras implementações de controladores fornecidos pelo Spring. No Spring Web MVC, o Controlador manipula as requisições e retorna um ModelAndView – nesse caso, um chamado ‘hello.jsp’, que é o nome do arquivo JSP que criaremos em seguida. O modelo que essa classe retorna é no momento resolvido por um ViewResolver. Já que nós explicitamente definimos um ViewResolver, iremos estar fornecendo um modelo padrão do Spring que simplesmente direciona para um URL cujo nome bate como a visão especificada. Modificaremos mais tarde isso. Nós também especificamos um logger para que possamos verificar que estamos no manipulador. Usando Tomcat, essas mensagens de log devem aparecer no arquivo ‘catalina.out’, que pode ser encontrado no diretório '${appserver.home}/log' de sua instalação do Tomcat.

Se estiver usando uma IDE, você irá querer configurar os caminhos de seu projeto adicionando os JARs do diretório ‘lib’. Você também irá querer adicionar servlet-api.jar de seu diretórios de conteinêres servlet ('${appserver.lib}'). Adicionando esses diretórios ao seu path, todas as suas sentenças import devem ser resolvidas com sucesso no arquivo ‘HelloController.java’.

1.9. Escrever um teste para o Controlador

A parte do teste é vital no desenvolvimento do software. É também uma prática crucial do desenvolvimento Agile. Provavelmente o melhor momento para fazer os testes é durante o desenvolvimento, não depois, quando o nosso controlador ainda não contém uma lógica demasiadamente complexa. Isso permitirá que nós possamos fazer mudanças a ele no futuro com confiança. Vamos criar um novo diretório dentro de ‘springapp’ chamado ‘test’. Aqui é onde todos os nossos testes irão rodas em uma estrutura de empacotamento que será um espelho da árvore de código dentro de ‘springapp/src’.

Crie um classe de teste chamada ‘HelloControllerTests’ e faça ela herdar da classe de teste do JUnit, TestCase. Essa classe é uma unidade de teste que verifica se o nome da visão retornado por handleRequest() corresponde à visão que nós esperamos: ‘hello.jsp’.

'springapp/test/springapp/web/HelloControllerTests.java':

package springapp.web;

import org.springframework.web.servlet.ModelAndView;

import springapp.web.HelloController;

import junit.framework.TestCase;

public class HelloControllerTests extends TestCase {

    public void testHandleRequestView() throws Exception{
        HelloController controller = new HelloController();
        ModelAndView modelAndView = controller.handleRequest(null, null);
        assertEquals("hello.jsp", modelAndView.getViewName());
    }
}

Para executar esse teste (e todos os que virão), precisamos adicionar um teste Ant em nosso script ‘build.xml’. Primeiro, copiamos o junit-3.8.2.jar de 'spring-framework-2.5/lib/junit' para 'war/WEB-INF/lib'. Ao invés de criar uma tarefa simples para compilar os testes e então executá-los, vamos quebrar a tarefa em duas partes distintas: ‘buildtests’ e ‘tests’ que depende de ‘buildtests’.

Se você estiver usando uma IDE, pode querer executar seus testes dentro dela. Configure o build path de seu projeto pelo acréscimo de junit-3.8.2.jar em ‘springapp/build.xml’:

    <property name="test.dir" value="test"/>

    <target name="buildtests" description="Compile test tree java files">
        <mkdir dir="${build.dir}"/>
        <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
            deprecation="false" optimize="false" failonerror="true">
            <src path="${test.dir}"/>
            <classpath refid="master-classpath"/>
        </javac>
    </target>

    <target name="tests" depends="build, buildtests" description="Run tests">
        <junit printsummary="on"
            fork="false"
            haltonfailure="false"
            failureproperty="tests.failed"
            showoutput="true">
            <classpath refid="master-classpath"/>
            <formatter type="brief" usefile="false"/>

            <batchtest>
                <fileset dir="${build.dir}">
                    <include name="**/*Tests.*"/>
                </fileset>
            </batchtest>

        </junit>

        <fail if="tests.failed">
            tests.failed=${tests.failed}
            ***********************************************************
            ***********************************************************
            ****  One or more tests failed!  Check the output ...  ****
            ***********************************************************
            ***********************************************************
        </fail>
    </target>

Now run the Ant 'tests' task and the test should pass.

$ ant tests
Buildfile: build.xml

build:

buildtests:
    [javac] Compiling 1 source file to /Users/Shared/Projects/springapp/war/WEB-INF/classes

tests:
    [junit] Running springapp.web.HelloWorldControllerTests
    [junit] Oct 30, 2007 11:31:43 PM springapp.web.HelloController handleRequest
    [junit] INFO: Returning hello view
    [junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.03 sec
    [junit] Testsuite: springapp.web.HelloWorldControllerTests
    [junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.03 sec

    [junit] ------------- Standard Error -----------------
    [junit] Oct 30, 2007 11:31:43 PM springapp.web.HelloController handleRequest
    [junit] INFO: Returning hello view
    [junit] ------------- ---------------- ---------------

BUILD SUCCESSFUL
Total time: 2 seconds

Um das outra boas práticas do desenvolvimento Agile é a Integração Continua. É uma boa idéia garantir que seus testes sejam executados a cada compilação (idealmente em uma compilação automatizada), de forma que você saiba que a lógica de sua aplicação esteja funcionando como esperado a medida que o código evolui.

1.10. Criar a Visão

Agora é o momente de criar nossa primeira visão. Como mencionado anteriormente, nós direcionaremos sistema para um página JSP chamada ‘hello.jsp’. Para começar, colocaremos o código no diretório ‘war’.

'springapp/war/hello.jsp':

<html>
  <head><title>Hello :: Spring Application</title></head>
  <body>
    <h1>Hello - Spring Application</h1>
    <p>Greetings.</p>
  </body>
</html>

1.11. Compilar e  carregar a aplicação

Rode o Ant com a opção ‘deploy’ (que invoca a opção ‘build’), e depois execute a tarefa ‘reload’ do arquivo ‘build.xml’. Isso forçar´o re-carregamento da aplicação no Tomcat. Temos que checar a sapida do Ant e os logs do Tomcat para possíveis erros de desenvolvimento – com o tipos nos archivos acima ou classes e arquivos jar ausentes.

Abaixo segue um exemplo da saída do comando Ant:

$ ant deploy reload
Buildfile: build.xml

build:
    [mkdir] Created dir: /Users/trisberg/Projects/springapp/war/WEB-INF/classes
    [javac] Compiling 1 source file to /Users/trisberg/Projects/springapp/war/WEB-INF/classes

deploy:
     [copy] Copying 7 files to /Users/trisberg/apache-tomcat-5.5.17/webapps/springapp

BUILD SUCCESSFUL
Total time: 3 seconds
$ ant reload
Buildfile: build.xml

reload:
   [reload] OK - Reloaded application at context path /springapp

BUILD SUCCESSFUL
Total time: 2 seconds

E abaixo segue um exemplo da saída do arquivo de log ‘catalina.out’:

Oct 30, 2007 11:43:09 PM org.springframework.web.servlet.FrameworkServlet initServletBean
INFO: FrameworkServlet 'springapp': initialization started
Oct 30, 2007 11:43:09 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.web.context.support.XmlWebApplicationContext@6576d5: display name
[WebApplicationContext for namespace 'springapp-servlet']; startup date [Tue Oct 30 23:43:09 GMT 2007];
...
...
Oct 30, 2007 11:43:09 PM org.springframework.web.servlet.FrameworkServlet initServletBean
INFO: FrameworkServlet 'springapp': initialization completed in 150 ms

1.12. Teste a aplicação

Vamos agora testar a aplicação.

Abra o navegador e navegue até http://localhost:8080/springapp/hello.htm.

A aplicação atualizada.

1.13. Sumário

Vamos recapitular as partes da aplicação que criamos até agora.

  1. Uma página inicial, index.jsp, a página de boas vindas de nossa aplicação. Ela é usada para testar se nossa configuração esrtá correta. Nós a mudaremos mais tarde para que forneça um link para nossa aplicação.
  2. Um DispatcherServlet (controlador frontal) com um arquivo de configuração ‘springapp-servlet.xml’ correspondente.
  3. Um controlador de página, HelloController, com funcionalidade limitada – somente retorna um ModelAndView. Nesse memento temos um modelo vazio que irá ser preenchido mais tarde.
  4. Uma unidade de teste de classe para o controlador de páginas, HelloControllerTests, para verificar se o nome da visão é o esperado.
  5. Uma visão, hello.jsp, que novamente é extremamente básica. A boa notícia é que toda a configuração funciona e estamos prontos para adicionar mais funcionalidades.

Abaixo segue uma tela de como a estrutura de diretório de nosso projeto deve ficar depois das instruções acima.