DESENVOLVIMENTO WEB

BACK-END

Profa. Francielli Barbara Pinto

 Unidade 02

Introdução ao Padrão MVC e ao Spring Boot

Sumário
O padrão MVC.....................................................................................................................................................................3
1.1 O que é um padrão de projetos?.....................................................................................................................................3
1.2 O que é o padrão MVC?.................................................................................................................................................4
O framework Spring Boot....................................................................................................................................................5
2.1 Uma primeira aplicação Spring Boot - “Hello, World!”................................................................................................6
2.2 Spring Framework........................................................................................................................................................10
Atividade complementar.....................................................................................................................................................11
Referências.........................................................................................................................................................................13
O PADRÃO MVC

O padrão MVC é um padrão de projetos de software, mais especificamente um padrão de

arquitetura, comumente utilizado no desenvolvimento de softwares Web. Então, antes de analisar o
que é o padrão MVC, é importante entender o que é um padrão de projetos.

1.1 O que é um padrão de projetos?

É comum encontrarmos na literatura, ou em textos informais sobre o assunto, o termo

“design pattern”, que se trata do termo em inglês para “padrão de projeto”. Observe que é utilizado
o termo “design” e não “project” para se referir a “projeto”. Isso ocorre porque, em inglês, embora
design e project signifiquem “projeto”, não se tratam da mesma coisa. Software design trata-se de
uma das etapas do projeto de um software, etapa que antecede a implementação do software e em
que todas as classes e comportamentos da aplicação são “modelados”, bem como as tecnologias que
serão utilizadas são definidas – essa etapa é geralmente feita por um arquiteto de software e, na
literatura sobre padrões de projeto, é comumente utilizado o termo "projetista" para se referir ao
profissional que realizará o design de software. Já o software project trata-se de todo o processo de
desenvolvimento do software, envolve todas as etapas, como levantamento de requisitos, design,
implementação, teste, implantação, etc.
Então, design pattern está relacionado ao software design – é justamente nessa etapa do
desenvolvimento que os projetistas definem os padrões de projetos a serem utilizados no projeto e
geralmente são projetistas experimentes que definem padrões de projeto, como veremos a seguir.
O grande desafio do design de software é: seu software deve resolver um problema em
específico, porém deve ser genérico o bastante para atender a problemas e requisitos futuros –
considere, por exemplo, que uma empresa de software hoje precise desenvolver um sistema de
controle do fluxo de caixa para uma padaria e, depois de um tempo, após esse sistema ter sido
desenvolvido e implantado, surge a necessidade de desenvolver um outro sistema de controle do
fluxo de caixa, porém agora para um restaurante. Essa empresa, com certeza, reutilizará o projeto
feito para a padaria e fará modificações nele de modo a atendar à demanda do restaurante. Neste
ponto, provavelmente muitas modificações serão trabalhosas e sempre haverá um: “Nossa, se isso
tivesse feito dessa forma, poucas linhas de código precisariam ter sido alteradas para se adequar a
essa outra realidade!”
Criar um projeto de software reutilizável a primeira vez é muito difícil. Um software é
projetado, depois é reutilizado diversas vezes, sendo modificado a cada vez, até que se chegue a um
projeto genérico o bastante de modo que possa ser facilmente reutilizado. Quando uma solução para
um problema funciona, ela é então replicada diversas vezes. A principal diferença entre um
projetista experiente e um novato é: os experientes já testaram várias soluções até encontrar uma
que seja boa e então passam a fazer uso frequente destas soluções. E é assim que surgem os padrões
de projeto! Quando uma solução é boa o bastante e o projetista a descreve de maneira formal para
que a comunidade possa replicá-la em seus projetos, surge então um padrão de projetos!
Um padrão de projetos é, portanto, uma solução – que foi documentada formalmente – para
um problema específico que ocorre com frequência em um projeto de software.

1.2 O que é o padrão MVC?

O padrão MVC é um padrão de projetos de software que tem por objetivo separar lógica e
fisicamente a camada de visualização (frontend) e a camada de negócios (backend) da aplicação –
implementação das regras de negócios, comportamento, entidades do sistema, camada de dados,
etc. A ideia é que frontend e backend sejam totalmente independentes entre si, de modo que
qualquer alteração em um não impacte o outro. Esse padrão visa resolver, portanto, problemas de
manutenção e reutilização de partes da aplicação.
MVC é a sigla para Model-View-Controller e, mais especificamente, o padrão MVC propõe
que uma aplicação seja dividida em três partes, que são elas:
 Camada de modelo ou de negócios (Model) – é responsável pela implementação das
regras de negócios da aplicação, definição das entidades do sistema e seus
relacionamentos, implementa comportamento e a camada de dados;
  Camada de visualização (View) – trata-se basicamente da interface com o usuário. É
responsável pela implementação e exibição da interface;
 Camada de controle ou controlador lógico (Controller) – é responsável pelo
intermédio entre Model e View.
Em uma aplicação que segue o padrão MVC, Model e View nunca se comunicam
diretamente. Toda a troca de informações entre essas camadas é feita por meio de um controller
(controlador).
Veremos mais adiante na prática, através da utilização do framework Spring Boot, que,
quando um usuário tenta acessar, por exemplo, uma página de uma aplicação Web, uma requisição
HTTP é enviada ao servidor em que tal aplicação está em execução. O servidor então direciona essa
requisição à aplicação e toda requisição que chega à aplicação passa primeiramente por um
controller. Esse controller trata inicialmente os dados da requisição, interage com um Model, se
necessário, e prepara e envia uma resposta ao cliente, muitas vezes invocando uma View para isso.

O FRAMEWORK SPRING BOOT

Spring Boot é uma tecnologia que visa reduzir drasticamente o tempo de desenvolvimento
de aplicações Spring. Estamos falando, portanto, de aplicações que fazem uso do Spring
Framework – falaremos mais detalhadamente sobre ele mais adiante. A redução no tempo de
desenvolvimento se dá por meio da simplificação na configuração de projetos Spring.
Quando vamos desenvolver uma aplicação Web, precisamos configurar uma série de
dependências, configurar um servidor Web, etc. Quando se tratava de aplicações Spring, isso
precisava ser feito manipulando-se arquivos .xml, por exemplo. Quando se utiliza Spring Boot,
essas configurações são feitas de maneira bem mais simplificada. O Spring Boot é, portanto, uma
fina camada que opera acima do Spring Framework e de outras tecnologias Java e Spring.
Além disso, quando falamos de aplicações Web, é comum que as aplicações Web sigam o
padrão MVC. No universo Spring, uma alternativa é fazer uso do Spring MVC, que nos fornecerá
tudo aquilo que a nossa aplicação precisa ter pronto para que ela seja de fato uma aplicação MVC -
se quisermos criar um controller, por exemplo, implementaremos uma subclasse de uma classe do
Spring que implementa tudo aquilo que um controller precisa ter para operar de fato como um
controller.

2.1 Uma primeira aplicação Spring Boot - “Hello, World!”

O primeiro passo para se criar uma aplicação Spring Boot é gerar um projeto Spring Boot,
que será responsável pela implementação da aplicação. Para isso, siga os seguintes passos:
1. Acesse start.spring.io/
2. Em “Project”, selecione “Gradle - Groovy” - aqui, estamos indicando qual gerencia-
dor de dependência usaremos no nosso projeto. Como o Gradle está sendo mais utili-
zado, utilizaremos ele;
3. Mantenha selecionadas a linguagem Java e a última versão estável do Spring, que já
vem pré-selecionada.
4. Em “Project Metadata”, preencha:
a. “Group” com, por exemplo, ifsuldeminas.pas.posweb.desenvolvimentoweb.
Trata-se do pacote principal do projeto;
b. “Artifact” com helloworld - “Name” é automaticamente preenchido também
com helloworld). Trata-se do nome do projeto;
c. e “Description” com “A first Spring Boot project” (ou “Um primeiro projeto
Spring Boot”);
5. Em “Java”, selecione a versão do Java que você estiver utilizando (a versão do JDK
instalado na sua máquina);
6. Em “Dependencies”, clique em “ADD DEPENDENCIES” e selecione “Spring Web”
- selecionando “Spring Web”, o projeto será gerado com as configurações de depen-
dência para uso do Spring para Web (Spring MVC, Apache Tomcat, etc.);
7. Por último, clique em “GENERATE” e será baixado, neste caso, o arquivo hel-
loworld.zip, contendo o nosso primeiro projeto Spring Boot.
O próximo passo é importar o projeto para o IntelliJ IDEA ou outra IDE de sua preferência.
Para isso, siga os seguintes passos:
1. Em um local de sua preferência, caso não tenha ainda, crie uma pasta de nome
workspace/ - essa pasta será o seu diretório de trabalho;
2. Descompacte o arquivo helloworld.zip nesta pasta;
3. Importando o projeto para o IntelliJ IDEA:
a. Abrir o IntelliJ IDEA;
b. Clique em “Open” e selecione a pasta helloword/ no seu workspace - diretó-
rio criado anteriormente;
c. Ao abrir o projeto, o IntelliJ IDEA identificará automaticamente um projeto
Gradle, importando todas as dependências Springs do projeto – é necessário
aguardar até que esta etapa seja concluída para iniciar as alterações no proje-
to.
Antes de alterar nosso projeto para implementar nossa primeira aplicação Spring Boot, que
não poderia ser diferente de um “Hello, World!”, observemos alguns arquivos e configurações que
são gerados automaticamente para nós em nosso Spring Boot:
 Na pasta raiz do projeto, abra o arquivo build.gradle;
o Nesse arquivo, podemos analisar que é “declarada” a dependência (no bloco
dependencies) spring-boot-starter-web, que é responsável, por exemplo, por
configurar as dependências do Spring Framework e Spring MVC, além de
um servidor Tomcat;
o No mesmo bloco do mesmo arquivo, é declarada a dependência spring-boot-
starter-test, que é utilizada para implementação de testes unitários utilizando
o Spring Boot.
 Ao expandir a pasta src/, temos o diretório main/, que é onde ficará todos os arquivos
da nossa aplicação, e o diretório test/, que é onde ficarão todos os arquivos de testes
unitários;
 Em main/, temos os diretórios java/ e resources/;
 o No diretório resources/ temos o arquivo application.properties, que é onde
indicaremos todas as dependências de configuração do projeto, como, por
exemplo, informações de banco de dados;
o Expandindo a pasta java/, temos o pacote principal do projeto e, dentro dele,
temos a classe principal do projeto (no exemplo, de nome HelloworldAppli-
cation);
o Abra essa classe e observe que ela possui um método main;
o Essa classe é, portanto, o ponto inicial da execução da aplicação.
Agora, vamos de fato fazer alterações em nosso projeto para implementar um “Hello,
World!”. O comportamento que implementaremos será o seguinte: ao acessar, em um navegador, a
URL localhost:8080/hello, será exibida a mensagem “Hello, World!”. Como, em uma aplicação que
segue o padrão MVC, toda requisição é tratada inicialmente por um controller, devemos então criar
um controller – além disso, como MVC sugere a separação também física das camadas, nosso
controller estará em um pacote controller. Para isso, faça o seguinte:
1. Clique com o botão direito no pacote principal do projeto – que, lembrando, está
dentro do diretório main/java/ –, depois clique em “New” e depois em “Package”;
2. Vamos criar o pacote “controller” dentro do pacote principal;
a. Ao completar o campo que se abre com “controller”, basta apertar Enter;
b. Considerando as configurações indicadas acima para geração do projeto, fica-
rá: ifsuldeminas.pas.posweb.desenvolvimentoweb.controller.
3. Posteriormente, clique com o botão direito no pacote controller/, clique em “New” e
depois em “Java Class”;
4. Indicaremos o nome “HelloController” para a classe Java a ser criada – por padrão,
todo controller deve ter o sufixo Controller. Atente-se também às convenções Java
para nomenclaturas – nome de classe com iniciais maiúsculas;
a. Após preencher o campo com o nome da classe a ser criada, basta apertar En-
ter;
b. Um arquivo HelloController.java será criado com uma implementação inicial
para a classe HelloController.
5. Inicialmente, como não implementaremos uma interface gráfica (uma View), faremos
com que o nosso controller apenas retorne um texto a ser exibido para o usuário;
6. Dessa forma, vamos adicionar à classe HelloController, acima de sua definição, a
anotação @RestController;
a. Estamos definindo a classe HelloController como um RestController, como
uma subclasse de RestController – em Spring, isso é feito a partir de anota-
ções. RestController é um controller que segue o padrão Rest – falaremos
disso mais adiante na disciplina;
b. Para isso, é necessário importar a classe org.springframework.web.bind.an-
notation.RestController – isso é inclusive sugerido pelo próprio IntelliJ
IDEA;
c. A classe ficará:
@RestController
public classe HelloController{

}
7. Posteriormente, criaremos um método público, de nome hello, sem parâmetros, que
retorna uma String, e adicionaremos a ele o código: return “Hello, World!”;
8. Adicione a esse método, acima de sua declaração, a anotação @GetMapping("/hel-
lo")
a. Essa anotação é usada para fazer um mapeamento de URI e define que, ao
enviar uma requisição HTTP GET para, por exemplo, localhost:8080/hello,
esse método será executado;
i. Se fosse @GetMapping("/"), por exemplo, a requisição deveria ser lo-
calhost:8080/
b. Para isso é necessário importar a classe org.springframework.web.bind.anno-
tation.GetMapping
9. O método ficará:
@GetMapping(“/hello”)
 public String hello(){
return “Hello, World!”;
}
Por fim, vamos executar a aplicação e acessar a URL correspondente para que nosso método
hello seja executado e tenhamos, portanto, um “Hello, World!”. Para isso, abra um terminal de
comandos e navegue até a pasta raiz do projeto. Posteriormente, execute o seguinte comando:
- Em ambiente Windows: gradlew bootRun
- Em ambiente Linux: ./gradlew bootRun
Se estivéssemos trabalhando com um projeto Maven, deveríamos executar: mvnw spring-
boot:run (Windows) ou ./mvnw spring-boot:run (Linux). Além disso, fazemos uso do comando
gradlew e não gradle, uma vez que faremos uso de um wrapper – por isso o w. Isso é interessante,
pois as vezes a versão do Gradle que temos instalada em nossa máquina é diferente da versão do
Gradle do projeto.
Por padrão, o projeto é executado na porta 8080, como pode ser visto no terminal de
comandos após inicialização da aplicação. Para executar então nosso “Hello, World!” basta acessar,
em um navegador, a URL localhost:8080/hello e o texto “Hello, World!” aparecerá na página.
Para praticar um pouco mais e para um melhor entendimento do funcionamento básico de
uma aplicação MVC, faça as atividades complementares propostas ao término dessa seção.

2.2 Spring Framework

Quando criamos a classe HelloController e o método hello nessa classe com a anotação
@GetMapping("/"), ao enviar uma requisição para http://localhost:8080/, vimos que o método hello
é então executado. Em um projeto Java, para que um método seja executado, ele deve ser invocado
– devemos fazer uma chamada a esse método.
Como ficaria então, em Java, o código da invocação do método hello?
O método hello é um método não estático - se fosse um método estático, teria sido declarado
como public static String hello... Isso significa que se trata de um método "de objeto" (e não de
classe!!). Então, para ser invocado, a chamada a esse método deve ser feito a partir de um objeto
daquela classe (e não da classe) e, então, um objeto deve ter sido previamente instanciado, como no
exemplo a seguir:
//instanciando um objeto da classe HelloController
HelloController objeto = new HelloController();
//invocando o metodo hello
objeto.hello();
Porém, para que o método hello fosse executado, não precisamos, em nenhum lugar do
projeto, instanciar um objeto da classe HelloController e nem invocar o método hello propriamente
dito, não é mesmo? Então, onde isso é feito?? É aqui que "entra" o Spring Framework. É o Spring
Framework que se encarrega de instanciar e gerenciar os objetos para nós, em tempo de execução.
O Spring Framework implementa o padrão IoC (Inversion of Control - Inversão de
Controle) – temos uma inversão de controle justamente porque não é o programador que controla
quando e como os objetos serão instanciados e gerenciados, mas sim o Spring Framework.
Esses objetos são instanciados e gerenciados pelo container do Spring Framework. O
container é o núcleo do Spring Framework e é responsável por cuidar do ciclo de vida dos objetos.
O termo inversão de controle é utilizado, pois delegamos toda a responsabilidade de
instanciação dos objetos ao container.
As instâncias (objetos) gerenciadas pelo Spring são chamadas de spring beans – ou
simplesmente beans – e outros exemplos de beans do Spring surgirão à medida que avançarmos nos
conteúdos da disciplina.

Atividade complementar

A fim de praticar um pouco o que foi visto até o momento, faça o que se pede:

1. Na aplicação “helloworld” criada anteriormente, no pacote controller, crie o controller

(classe Java) CalendarController;
2. Defina essa classe como um RestController;
3. Nesta classe, crie os seguintes métodos, conforme as suas respectivas descrições:
a. Método today – retorna a mensagem “Hoje é <data_corrente>”, onde <data_cor-
rente> deve ser a data corrente do sistema – se necessário, pesquise como obter a
data corrente do sistema em Java;
b. Método tomorrow – retorna a mensagem “Amanhã será
<data_corrente_mais_um_dia>”, onde <data_corrente_mais_um_dia> deve ser
equivalente à data corrente do sistema acrescido um ao atributo dia (correspondente à
data de “amanhã”) – se necessário, pesquise como adicionar um dia a uma data em
Java.
4. Configure os métodos para que sejam executados conforme segue:
a. Ao acessar a URL http://localhost:8080/calendar/today, uma requisição é enviada à
aplicação, o método today do controller CalendarController é executado e é então
retornada a mensagem “Hoje é <data_corrente>”;
b. Ao acessar a URL http://localhost:8080/calendar/tomorrow, uma requisição é envia-
da à aplicação, o método tomorrow do controller CalendarController é executado e é
então retornada a mensagem “Amanhã será <data_corrente_mais_um_dia>”.
5. Por último, rode a aplicação e acesse as URLs mencionadas acima para verificar o compor-
tamento do que foi implementado.
REFERÊNCIAS

GAMMA, Erich et al. Padrões de projeto: soluções reutilizáveis de software orientado a objetos.
Porto Alegre: Bookman, 2000.

WEBB, Phillip et al. Spring boot reference guide. Spring Boot features, v. 24, 2013.

WEISSMAN, Henrique Lobo. Falando de Grails: altíssima produtividade no desenvolvimento

Web. Casa do Código, 2014.