Atenção: esse artigo tem um vídeo complementar. Clique e assista!

O Spring MVC é um framework open-source que usa como princípio o padrão MVC Model 2 em conjunto com a já tradicional injeção de dependências. Em sua view, o framework possui também o suporte a outras tecnologias, como: JSP/JSTL/Tiles, XML/XSLT, Velocity e FreeMarker. A integração com JasperReports e exportação de documentos para PDF e Excel também estão inclusas.

Com suporte a anotações, introduzidas na versão 2.5, o framework Spring reduziu significativamente o uso de XML, comum em versões anteriores. Isto possibilitou a redução de códigos para a criação de aplicações web através do Spring MVC 3.0, indo de encontro ao conceito pregado por frameworks como o Ruby on Rails, de Convenção sobre Configuração (Convention over Configuration).

Neste artigo abordaremos a arquitetura do Spring MVC na versão 3.0, discutindo suas características de desenvolvimento mais significativas e construindo um simples Blog como aplicação de exemplo.

Criando e Configurando o Projeto

Para trabalhar com o Spring MVC 3.0, faça o download do framework no site http://www.springsource.org/download. Crie um projeto Web em sua IDE preferida e adicione os arquivos JARs encontrados após a descompactação do arquivo.

Para o banco de dados, vamos utilizar o MySQL (MySQL Community Server 5.1), que poderá ser baixado no site http://www.mysql.com/downloads/. Neste mesmo endereço encontramos o driver JDBC (Connector/J 5.1) que deverá ser adicionado ao projeto.

Os erros no projeto serão tratados de acordo com a especificação JSR 303 (Bean Validation). Os JARs necessários se encontram no site https://www.hibernate.org/30.html. Neste caso, teremos que baixar o Hibernate Validator. Após extrairmos, utilizaremos os JARs hibernate-validator-4.0.2.GA.jar e validation-api-1.0.0.GA.jar.

Também teremos no aplicativo a possibilidade de exportar as informações contidas no banco de dados em formato XML e JSON. Para que isso seja possível, precisaremos obter as seguintes bibliotecas: jackson-mapper-lgpl-1.0.1.jar, jackson-core-lgpl-1.0.1.jar e xstream-1.3.1.jar. Para as duas primeiras bibliotecas, acesse o site http://jackson.codehaus.org/Download. A terceira biblioteca se encontra no site http://xstream.codehaus.org/download.html.

Caso deseje preparar seu ambiente de trabalho, especificamente para desenvolver com Spring, no endereço http://www.springsource.com/products/springsource-tool-suite-download encontramos o SpringSource Tool Suite, configurado com diversos plugins, incluindo o Spring IDE, preparado para trabalhar com o framework.

Por fim, para rodar o aplicativo, um contêiner como o Apache Tomcat é o suficiente.

Spring MVC 3.0 na prática

A aplicação que desenvolveremos é um pequeno blog, onde teremos a submissão dos artigos (posts) e a possibilidade de adicionar comentários (comments).

Modelo de dados

O projeto neste artigo está baseado em duas entidades, suficientes para mostrar algumas das principais características de desenvolvimento do Spring MVC. O modelo de dados pode ser visualizado na Figura 1.

Figura 1. Modelo de dados para o blog.

Para iniciar, vamos criar o banco de dados no MySQL. A Listagem 1 mostra o script para a criação do banco de dados e as tabelas usadas no exemplo.

Listagem 1. Banco de dados e Tabelas do Blog.

  CREATE DATABASE jvmblog;
   
  CREATE TABLE posts (
    id     bigint AUTO_INCREMENT NOT NULL,
    title  varchar(255),
    body   text,
    PRIMARY KEY (id)
  ) ENGINE = InnoDB;
   
  CREATE TABLE comments (
    id      bigint AUTO_INCREMENT NOT NULL,
    post_id bigint,
    comment text,
    PRIMARY KEY (id),
    CONSTRAINT FKPOST
      FOREIGN KEY (post_id)
      REFERENCES posts(id)
  ) ENGINE = InnoDB; 

As entidades

O blog possuirá duas entidades distintas: Post e Comment. A entidade Post, baseada na tabela posts, possui três atributos, onde o atributo id será o único gerado automaticamente pela tabela, no banco de dados.

A entidade Comment possui também três atributos, onde haverá uma relação de Um-Para-Muitos em Post, através do atributo post_id. Isto significa que um post poderá ter diversos comentários. Lembrando que este artigo está focado nas características do Spring MVC 3.0 e não em um modelo de arquitetura completa.

Graças a JSR 303 (veja o quadro “A JSR 303”), chamada de Bean Validation, podemos anotar as entidades com validações. Validação de dados é uma tarefa comum e muitas vezes implementada em diferentes locais de uma aplicação. Com as anotações de Bean Validation na entidade, concentramos a validação em um único local, de forma padronizada. Além disso, também é possível tornar essas validações portáveis para outras tecnologias/frameworks além do Spring MVC.

As Listagens 2 e 3 exibem as entidades Post e Comment, respectivamente. Note que nas anotações de validação, colocamos as mensagens de erro embutidas, onde iremos capturá-las posteriormente pelo Spring MVC para exibir o problema ao usuário.

Listagem 2. Código da entidade Post.

  package br.com.integrator.domain;
   
  import java.util.Set;
  import javax.persistence.*;
  import javax.validation.constraints.Size;
   
  @Entity
  @Table(name = "posts")
  public class Post {
     @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Size(min=5, message="O título não pode ter menos que 5 caracteres!")
    private String title;
    @Size(min=10, message="O conteúdo não pode ter menos que 10 caracteres!")
    private String body;
    @OneToMany(mappedBy="post", fetch=FetchType.LAZY, cascade = CascadeType.ALL)
    private Set<Comment>  comments;
   
     //getters e setters omitidos
   
  }

Listagem 3. Código da entidade Comment.

  package br.com.integrator.domain;
   
  import javax.persistence.*;
  import javax.validation.constraints.Size;
   
  @Entity
  @Table(name = "comments")
  public class Comment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Size(min=5, message="O comentário não pode ter menos que 5 caracteres!")
    private String comment;
    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="post_id", referencedColumnName="id" )
    private Post post;
   
    //getters e setters omitidos
   
  }