Open in app Sign up Sign in

Desenvolvendo sua
primeira API em
Spring Boot com
MySQL
Gabriel Ritter · Follow
10 min read · Jan 6, 2021

Share

Esse artigo tem como objetivo ensinar o

leitor a construir uma API simples de
cadastro de cliente. A principal ferramenta
de estudo que iremos utilizar é o Spring
Boot. Se você nunca ouviu falar em
conceitos como Spring Boot, API,
framework … Não se desespere! Durante o
artigo irei explicar tudo isso e iremos
desenvolver uma API utilizando esse
framework.

Pré-requisitos
Para acompanhar esse artigo sem
grandes dificuldades, é necessário um
certo conhecimento de lógica de
programação em Java, banco de dados
relacional e um pouco de conhecimento
em aplicações WEB. Além disso, é
necessário ter o Java (a versão 7, no
mínimo) em sua máquina e instalar os
seguintes programas:

Spring tools 4 para Eclipse: Será

nosso ambiente de desenvolvimento;

XAMPP: Inclui os principais

servidores de código aberto;

MySQL Workbench: Banco de dados

relacional;

Postman: Irá executar os testes da

nossa API.

Instalados os programas, estamos

prontos para continuar!

Conceitos importantes
Primeiramente, precisamos entender
alguns conceitos importantes:

API (Application
Programming Interface)
é uma interface de
rotinas e padrões de
programação que
diversas aplicações
podem utilizar. Um bom
exemplo de API é a do
Google Maps, que
muitas aplicações usam
para se aproveitar dessa
ferramenta poderosa
criada pelo Google. É
por meio da API que é
possível que aplicações
conversem entre si, sem
que o usuário tenha
conhecimento disso.
Sabendo o que é uma API, podemos ir
para Spring:

Spring é um framework
(conjunto de pacotes
com classes pré-
definidas para o uso)
para o desenvolvimento
de aplicações, sendo
sua estrutura baseada
na linguagem de
programação Java.
Então por que usar ele? Bom, aqui vão
alguns motivos:

Ele é modular. Isso significa que você

irá se preocupar apenas com os
pacotes e classes que de fato utilizará
no projeto;

Spring Web framework foi

desenhado para ter uma arquitetura
MVC (Model, View, Control);

Possui uma base consistente para

lançar diversas exceções;

Utiliza-se injeção de dependência

(DI). Ele pode ser considerado um
tipo de inversão de controle (Ioc).
Basicamente, a injeção de
dependência permite que as classes
possam ser os mais independentes
possíveis e que, ainda assim, estarem
unidas. Irei demonstrar isso mais
para frente.

Em geral, Spring facilita nossa vida, pois

não precisamos reinventar a roda o
tempo todo, sendo que já existe um
framework que podemos utilizar e
reutilizar em nossos projetos. Isso
permite que apliquemos nossos esforços
nas regras de negócio da aplicação.

Sabendo disso, qual é a diferença entre

Spring e Spring Boot? Não é a mesma
coisa? Não exatamente. Como já foi dito,
Spring é um framework que vem
resolver diversos problemas técnicos.
Entretanto, há diversas configurações
que devemos fazer para que o Spring
funcione perfeitamente e isso pode ser,
de certa forma, muito maçante e
complicado. O Spring Boot veio para
resolver esses problemas pois, na
criação de um projeto ele já faz as várias
configurações necessárias. Com isso,
reduz o tempo de desenvolvimento,
aumenta a produtividade e fica muito
mais simples de entender e desenvolver
suas aplicações. Em suma:

Spring boot é um
framework usado para
criar microsserviços
(arquitetura que
permite implementar e
implantar serviços de
forma independente) e
provê um ambiente
onde não é necessário
se preocupar tanto com
as configurações e sim
com a aplicação em si.
Não ficou convencido? Então lá vai
alguns pontos das funcionalidades do
Springboot:

Provê um jeito fácil de configurar as

transações entre bancos de dados e a
aplicação, entre outros tipos de
configurações importantes;

Poderoso gerenciador de endpoints

REST;

Tudo é auto-configurado;

É baseado em @anotations, fazendo

com que muita coisa seja feita “por
baixo dos panos”.

Mão na massa!
Antes de abrirmos nosso glorioso Spring
Tool Suite, temos que fazer algumas
coisinhas primeiro:

Abra o XAMPP e ligue os servidores

Apache e MySQL:

Basta clicar no Start

Agora abra o Spring Tool Suite (STS) e

crie um projeto Spring. Para isso basta ir
em File>New>Project>Spring
Boot>Spring Starter Project. Dê um
nome ao seu projeto, em type coloque
“Maven” e clique em Next:

Tela criação do projeto

Depois selecione as seguintes

dependências para seu projeto e clique
em Finish:

Dependências

Você pode estar se perguntando: O que

são essas dependências? Para que
servem? Lombok é de comer? Calma,
não se desespere! Chegaremos lá. Essas
dependências são bibliotecas externas
que adicionamos ao nosso projeto pois,
precisamos delas para o bom
funcionamento de nossa API. Vamos ver
o que é cada uma:

Spring Boot Dev Tools: Conjunto de

funcionalidades, como o Auto
Restart;

Lombok: Biblioteca focada na

redução de códigos, não sendo
necessário escrever métodos getters,
setters, equals …

Spring Data JPA: Cuida das

implementações de nossos
repositórios e da persistência de
dados;

MySQL Driver: Permite fazer a

conexão com o MySQL;

Spring Web: Possui ferramentas para

ambiente WEB.

Essas dependências ficam em um

arquivo chamado pom.xml. Além das
dependências, ele possui as principais
configurações do projeto, repositórios e
plugins.

Arquivo pom.xml na árvore do projeto

Estrutura do arquivo pom.xml

Aproveitando que você está com o

arquivo pom.xml aberto, adicione a
seguinte dependência em dependencies:

<dependency>
<groupId>org.hibernate.validato
r</groupId>
<artifactId>hibernate-
validator-cdi</artifactId>
<version>7.0.0.Final</version>
</dependency>

Ela será muito útil para importarmos

algumas classes importantes para a
validação dos dados. Muito
provavelmente você precisará
configurar o lombok (são passos
simples). Basta clicar aqui que você será
redirecionado para um pequeno tutorial.

Agora podemos criar nossos pacotes

para armazenarmos nossas classes Java.
Para criar um pacote, basta ir em
File>New>Package. Iremos separar o
projeto nos seguintes pacotes:

model: Possui as classes que

representam um modelo de uma
Entidade;

repository: Possui as interfaces que

realizam a comunicação com o
banco de dados;

controller: Possui as classes que

controlam as requisições como
POST, GET, PUT e DELETE;

config: Possui as classes de

configuração do projeto.

Depois de criar os pacotes, iremos

construir nossas classes e interfaces.
Clique com o botão direito no pacote
model>New>Class e coloque o nome da
classe como Cliente. Depois clique em
Finish.

Por padrão, a primeira letra de uma classe

é maiúscula.

Criação de uma classe

A nossa classe Cliente ficará da seguinte

maneira:

Cliente.java

Eu sei, é muita informação jogada de

uma vez só! No entanto o conceito é
simples. Vamos por partes. Antes de
tudo, definimos os atributos que o
cliente deve ter:

private Long clienteId

private String clienteNome

private String clienteEmail

private String clienteCPF

private Date clienteNascimento

Em seguida colocamos as anotações de

persistência na classe e nos atributos:

@Entity: Anotação que diz que essa

classe é uma entidade;

@Data: Anotação do Lombok. Ela

será a responsável por criar os
getters e setters da nossa classe! Isso
permite ter o código mais limpo e dá
mais agilidade na hora de
desenvolver o código;

@Id: Indica que o atributo seja a

chave identificadora do cliente;

@GeneratedValue(strategy =
GenerationType.IDENTITY): Essa
anotação irá fazer com que os
valores da chave sejam criados
automaticamente e sequenciais;

@Column(nullable = false,unique =
true): Diz para o banco que o valor
não pode ser nulo e que também
deve ser único;

@NotEmpty(message = “{}”): Indica

que o atributo clienteNome não pode
estar vazio. Caso esteja, vai lançar
uma mensagem de erro. Dentro dos
parênteses, há uma interpolação
com mensagens definidas no arquivo
mensagem.properties. Mais para
frente explicarei melhor como
funciona;

@Length(max = 100,message=”{}”):
Indica que número máximo de
caracteres deve ser 100;

@NotNull(message=”{}”): Indica que

o valor não pode ser nulo;

@Email(message =”
{campo.clienteEmail.invalido}”):
Anotação que irá verificar se o email
é válido;

@CPF(message =
“{campo.clienteCpf.invalido}”):
Anotação que irá verificar se o CPF é
válido;

@JsonFormat(pattern =
“dd/MM/yyyy”): Define o padrão de
data que o campo aceitará.

Temos uma classe chamada ApiErrors,

que irá servir para podermos mostrar
todos os erros da nossa API. Eis como ela
ficará:

public class ApiErrors {

@Getter
private List<String> errors;
public ApiErrors(List<String>
errors) {this.errors=errors;}
public ApiErrors(String
message) {this.errors =
Arrays.asList(message);}
}

Basicamente, ela irá servir para

podermos mostrar os possíveis erros na
hora das requisições. A anotação
@Getter irá gerar os getters dessa classe
de forma automática.

A anotação @Data também gera os getters

da classe. A diferença é que essa anotação
traz consigo outras como @Getter @Setter
@ToString…

Ótimo! Com nossas models prontas,

podemos seguir . Agora podemos criar a
nossa interface IClienteRepository,
pertencente ao pacote Repository.

public interface
IClienteRepository extends
JpaRepository<Cliente, Long> {}

Elá é relativamente pequena. A parte

importante aqui é que ela estende a
JpaRepository. É necessário passar a
classe modelo (Cliente) e o tipo do dado
do atributo indicado com a anotação @id
(Long) que é o clienteId. A JpaRepository
possui várias assinaturas de métodos
que iremos utilizar na nossa classe
ClienteController para podermos
acessar as informações no Banco de
dados.

Com nossa interface feita, vamos para os

nossos controllers: ClienteController e
ApplicationControllerAdvice.java :

10