Atenção: esse artigo tem um vídeo complementar. Clique e assista!
Desenvolvimento prático de uma aplicação web, exemplificando um blog, passo a passo, utilizando o framework Spring MVC 3.0.
Para que serve:
Desenvolver aplicações corporativas Java EE 5 para a web de forma simples e eficiente, com uma curva de aprendizado baixa, utilizando anotações e injeção de dependências sem a necessidade de um servidor Java robusto.
Em que situação o tema é útil:
Para a construção de qualquer aplicação web que necessite de boas práticas de desenvolvimento envolvidas sobre padrões, com baixa curva de aprendizado e sem muitas configurações.
Desenvolvendo um blog com Spring MVC 3.0:
Poderoso, flexível e muito fácil de aprender, o Spring MVC é um framework open-source que usa como princípio o design MVC Model 2, em conjunto com a sua já tradicional injeção de dependências.
Na versão do Spring MVC 3.0, o framework passou a suportar novas características, sendo uma das principais o suporte completo a REST.
Com poucas linhas de código e configurações, podemos criar aplicações web facilmente utilizando o princípio de convenção sobre configuração, além de não apenas visualizar os dados no formato convencional (HTML), mas também em XML, JSON, entre outros.
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
}
