Nota: O código deste tutorial pode ser acessado via https://github.com/obrunogonzaga/Imovel
Você já pensou em criar um micro-serviço escalável e flexível? Se a resposta é sim, você está no lugar certo! Neste guia, vamos criar juntos um micro-serviço usando o poderoso ecossistema de tecnologias Spring Boot, Docker e MariaDB, tudo isso executado na nuvem da plataforma Azure. Acompanhe os passos a seguir e descubra como é fácil criar um aplicativo robusto baseado em micro-serviços.
Escopo do projeto
O objetivo deste projeto é criar o micro-serviço "Imovel" como parte do sistema "House Flipping", que gerencia as informações dos imóveis disponíveis para compra e venda. O micro-serviço, desenvolvido em Spring Boot e Java 17, se integra com um banco de dados MariaDB e permite aos usuários visualizar, buscar, salvar e criar/editar listas de imóveis para venda. Após ser desenvolvido e testado, o micro-serviço será implantado em um contêiner Docker na Azure, podendo ser integrado a outros micro-serviços e no sistema maior.
Pré-requisitos
Para seguir este tutorial e criar um micro-serviço de gerenciamento de imóveis usando Spring Boot e Java 17, configurar um banco de dados MariaDB em um contêiner Docker dentro da Azure, e implantar a aplicação em um contêiner Docker na Azure, você precisa ter conhecimentos básicos em programação em Java, desenvolvimento web e API REST, contêineres e sua utilização em desenvolvimento e implantação de aplicativos, SQL e bancos de dados relacionais como o MariaDB, além de familiaridade com o uso de um sistema de controle de versão, como o Git, para gerenciar o código-fonte da aplicação. Além disso, é necessário ter as seguintes ferramentas: Java 17, Maven, Docker, Azure CLI e MariaDB.
Objetivos
O objetivo desta parte é criar um micro-serviço chamado Imovel utilizando Spring Boot e Maven. Para isso, será necessário criar uma entidade "Imovel" com as características de um imóvel, um repositório para realizar as operações de CRUD na entidade, um serviço para implementar a lógica de negócios relacionada a imóveis e um controlador para expor os serviços REST da aplicação.
Configurando o banco de dados
Agora, vamos configurar o banco de dados MariaDB. Para isso, você pode criar um container Docker com a imagem oficial do MariaDB. Abra um terminal e execute o seguinte comando:
docker run -p 3306:3306 --name mariadb
-e MYSQL_ROOT_PASSWORD=senha -d mariadb
Esse comando irá baixar a imagem do MariaDB e criar um container com o nome "mariadb". O parâmetro "-p" indica que a porta 3306 do container será mapeada para a porta 3306 da máquina local. O parâmetro "-e" define a senha do usuário root do banco de dados.
Para verificar se o container foi criado com sucesso, execute o comando:
docker ps
Você deverá ver a linha referente ao container do MariaDB com o status "Up".
Criando um projeto Spring Boot
Para criar um projeto Spring Boot para gerenciar imóveis, vamos utilizar o Spring Initializr. Acesse o site https://start.spring.io/ e preencha as informações do projeto, como o nome, o tipo de projeto e a versão do Spring Boot. Além disso, adicione as seguintes dependências:
- Spring Web
- Spring Data JPA
- Spring Cloud Azure
Após preencher as informações do projeto, clique em "Generate" para baixar um arquivo ZIP contendo o projeto inicial.
Para gerenciar imóveis, vamos criar uma classe de Application
que inicializa a aplicação Spring Boot. Por exemplo, crie a classe ImovelApplication
no pacote br.com.houseflipping.imoveis
:
package br.com.houseflipping.imoveis;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ImovelApplication {
public static void main(String[] args) {
SpringApplication.run(ImovelApplication.class, args);
}
}
A anotação @SpringBootApplication
indica que esta é uma classe de configuração para o Spring Boot. Ela inclui as seguintes anotações:
-
@Configuration
: indica que esta classe é uma classe de configuração Spring. -
@EnableAutoConfiguration
: permite que o Spring Boot configure automaticamente a aplicação com base nas dependências adicionadas ao projeto. -
@ComponentScan
: instrui o Spring a procurar e carregar todos os componentes anotados com@Component
no pacote atual e em seus subpacotes. Note que a classeImovelApplication
é definida no pacotebr.com.houseflipping.imoveis
. Isso significa que todas as classes do projeto devem ser definidas dentro do pacotebr.com.houseflipping.imoveis
ou em subpacotes deste.
Por fim, adicione as seguintes dependências ao arquivo pom.xml para incluir as dependências do Spring Web, Spring Data JPA e Spring Cloud Azure:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.microsoft.azure</groupId>
<artifactId>spring-cloud-azure-appconfiguration-config</artifactId>
<version>2.4.1</version>
</dependency>
<dependency>
<groupId>com.microsoft.azure</groupId>
<artifactId>azure-storage</artifactId>
<version>8.6.6</version>
</dependency>
<dependency>
<groupId>org.mariadb.jdbc</groupId>
<artifactId>mariadb-java-client</artifactId>
<version>2.7.2</version>
</dependency>
</dependencies>
Com essas dependências adicionadas, você estará pronto para começar a desenvolver o seu projeto para gerenciar imóveis utilizando o Spring Boot e a Azure.
Criando a entidade Imovel
Agora, vamos criar a entidade Imovel
com os principais atributos de um imóvel. Crie uma nova classe chamada Imovel
na pasta src/main/java
com o seguinte código:
package br.com.houseflipping.entity;
import javax.persistence.*;
@Entity
@Table(name = "imoveis")
public class Imovel {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String tipo;
private String endereco;
private Integer numeroQuartos;
private Integer numeroBanheiros;
private Double area;
private Double preco;
// getters e setters
}
Essa classe representa a tabela imoveis
no banco de dados. As anotações @Entity
e @Table
definem a tabela correspondente e a anotação @Id
define o campo id
como chave primária com auto-incremento. Os demais atributos correspondem às colunas da tabela.
Os novos atributos incluem:
-
tipo
: o tipo de imóvel (casa ou apartamento, por exemplo) -
endereco
: o endereço do imóvel -
numeroQuartos
: o número de quartos do imóvel -
numeroBanheiros
: o número de banheiros do imóvel -
area
: a área do imóvel em metros quadrados -
preco
: o preço do imóvel em reais
Esses atributos representam características físicas e financeiras do imóvel e podem ser utilizados para filtrar e buscar imóveis por diferentes critérios. Vamos adicionar outros atributos, como número de vagas na garagem, área externa, piscina, etc., de acordo com as necessidades do projeto.
Criando o repositório
O repositório é responsável por manipular as entidades em um banco de dados. No Spring Boot, é possível criar um repositório facilmente utilizando a interface JpaRepository do Spring Data JPA. Essa interface define operações básicas de CRUD (Create, Read, Update, Delete) para a entidade correspondente.
Para criar um repositório para a entidade Imovel
, vamos criar uma nova interface chamada ImovelRepository
. Essa interface deve estender a interface JpaRepository e informar o tipo da entidade e o tipo da chave primária. No nosso caso, a entidade é Imovel
e a chave primária é do tipo "Long".
@Repository
public interface ImovelRepository extends JpaRepository<Imovel, Long> {
}
A anotação @Repository
indica que essa interface é um componente Spring e será gerenciada pelo contêiner. Com essa interface, já é possível utilizar as operações básicas de CRUD no banco de dados para a entidade Imovel
. Por exemplo, para salvar um novo objeto Imovel
, basta chamar o método "save" do repositório:
Imovel imovel = new Imovel();
imovel.setTipo("Casa");
imovel.setEndereco("Rua dos Bobos, 0");
imovel.setPreco(100000.0);
ImovelRepository imovelRepository = ...; // obter instância do repositório
Imovel imovelSalvo = imovelRepository.save(imovel);
O método save
retorna o objeto Imovel
salvo no banco de dados, com o ID gerado automaticamente pelo banco (se a estratégia de geração de ID for "IDENTITY" ou "SEQUENCE").
Além das operações básicas de CRUD, é possível definir outras consultas personalizadas no repositório utilizando o recurso de Query Methods do Spring Data JPA. Por exemplo, para buscar todos os objetos "Imovel" cujo tipo seja "Casa", basta definir um método na interface com o nome adequado:
@Repository
public interface ImovelRepository extends JpaRepository<Imovel, Long> {
List<Imovel> findByTipo(String tipo);
}
Esse método retorna uma lista de objetos "Imovel" cujo atributo tipo
seja igual ao parâmetro informado. Para utilizá-lo, basta chamar o método findByTipo
do repositório:
ImovelRepository imovelRepository = ...; // obter instância do repositório
List<Imovel> imoveisCasa = imovelRepository.findByTipo("Casa");
Para configurar o banco de dados MariaDB no Spring Boot, você pode adicionar as propriedades de configuração do banco de dados no arquivo application.properties. A seção de configuração do banco de dados pode ficar assim:
# Configurações do banco de dados
spring.datasource.url=jdbc:mariadb://localhost:3306/imoveis
spring.datasource.username=seu_usuario
spring.datasource.password=sua_senha
spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
# Configurações do Hibernate
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDBDialect
Criando o serviço
O serviço é a camada responsável por orquestrar as chamadas ao repositório e implementar regras de negócio específicas. No nosso caso, o serviço será responsável por manipular os objetos Imovel
e fazer a integração com o banco de dados.
Para criar o serviço, crie uma nova classe chamada ImovelService
na pasta src/main/java
com o seguinte código:
@Service
public class ImovelService {
@Autowired
private ImovelRepository imovelRepository;
public Imovel salvar(Imovel imovel) {
return imovelRepository.save(imovel);
}
public List<Imovel> listar() {
return imovelRepository.findAll();
}
public Imovel buscarPorId(Long id) {
Optional<Imovel> imovel = imovelRepository.findById(id);
if (imovel.isPresent()) {
return imovel.get();
} else {
throw new RuntimeException("Imóvel não encontrado");
}
}
public void excluir(Long id) {
imovelRepository.deleteById(id);
}
}
Nesse código, utilizamos a anotação @Service
para indicar que essa classe é um componente Spring que será gerenciado pelo contêiner. Também utilizamos a anotação @Autowired
para injetar o repositório ImovelRepository
.
O método "salvar" recebe um objeto Imovel
como parâmetro e utiliza o método save
do repositório para salvar o objeto no banco de dados. O método listar
utiliza o método findAll
do repositório para listar todos os objetos Imovel
no banco de dados.
O método buscarPorId
recebe um ID como parâmetro e utiliza o método findById
do repositório para buscar um objeto Imovel
no banco de dados. Caso o objeto não seja encontrado, lançamos uma exceção personalizada.
O método excluir
recebe um ID como parâmetro e utiliza o método deleteById
do repositório para excluir o objeto correspondente no banco de dados.
Com o serviço implementado, agora podemos utilizá-lo no controlador para expor os endpoints REST.
Criando o controlador
Um controlador é responsável por mapear as requisições HTTP para métodos Java que processam essas requisições e retornam uma resposta. No nosso caso, vamos criar um controlador para expor os serviços REST da nossa aplicação.
Para criar um controlador em Spring Boot, você pode criar uma classe Java anotada com @RestController
. Essa anotação indica que a classe é um controlador Spring que retorna objetos em formato JSON.
Além disso, você pode usar outras anotações para definir as URLs dos endpoints e os métodos HTTP suportados. Algumas anotações comuns são @RequestMapping
, @PostMapping
, @GetMapping
, @PutMapping
e @DeleteMapping
.
Vamos criar um controlador para expor os serviços REST da nossa entidade Imovel
. Abra uma nova classe chamada ImovelController
na pasta src/main/java
com o seguinte código:
@RestController
@RequestMapping("/imoveis")
public class ImovelController {
@Autowired
private ImovelService imovelService;
@PostMapping
public Imovel salvar(@RequestBody Imovel imovel) {
return imovelService.salvar(imovel);
}
@GetMapping
public List<Imovel> listar() {
return imovelService.listar();
}
@GetMapping("/{id}")
public Imovel buscarPorId(@PathVariable Long id) {
return imovelService.buscarPorId(id);
}
@DeleteMapping("/{id}")
public void excluir(@PathVariable Long id) {
imovelService.excluir(id);
}
}
Vamos entender o que esse código faz:
- A anotação
@RestController
indica que essa classe é um controlador Spring que retorna objetos em formato JSON. - A anotação
@RequestMapping
define o prefixo da URL para acessar os endpoints. - A anotação
@Autowired
injeta a dependência do serviçoImovelService
criado anteriormente. - O método
salvar
é mapeado para a URL/imoveis
com o método HTTP POST. Ele recebe um objetoImovel
no formato JSON no corpo da requisição e chama o métodosalvar
do serviçoImovelService
. - O método
listar
é mapeado para a URL/imoveis
com o método HTTP GET. Ele chama o método "listar" do serviçoImovelService
e retorna a lista de objetosImovel
no formato JSON. - O método
buscarPorId
é mapeado para a URL/imoveis/{id}
com o método HTTP GET. Ele recebe um parâmetroid
na URL e chama o métodobuscarPorId
do serviçoImovelService
para buscar o objetoImovel
correspondente. Se o objeto não for encontrado, retorna uma resposta HTTP com código 404. - O método
excluir
é mapeado para a URL/imoveis/{id}
com o método HTTP DELETE. Ele recebe um parâmetroid
na URL e chama o métodoexcluir
do serviçoImovelService
para excluir o objetoImovel
correspondente. Se o objeto não for encontrado, retorna uma resposta HTTP com código 404.
Agora, podemos testar nossa aplicação acessando os endpoints criados por esse controlador. Para isso, abra um navegador ou um cliente REST (como o Postman) e acesse as URLs:
- POST http://localhost:8080/imoveis - para salvar um novo objeto
Imovel
GET http://localhost:8080/imoveis - para listar todos os objetosImovel
GET http://localhost:8080/imoveis/{id} - para buscar um objetoImovel
por ID DELETE http://localhost:8080/imoveis/{id} - para excluir um objetoImovel
por ID Lembre-se de substituir "localhost" pelo endereço IP da máquina onde a aplicação está rodando.
Por exemplo, para salvar um novo objeto Imovel
via REST, você pode enviar um POST com o seguinte corpo:
{
"tipo": "Apartamento",
"endereco": "Rua A, 123",
"numeroQuartos": 3,
"numeroBanheiros": 2,
"area": 75.0,
"preco": 100000.0
}
E receber uma resposta no formato JSON com o objeto salvo:
{
"id": 1,
"tipo": "Apartamento",
"endereco": "Rua A, 123",
"numeroQuartos": 3,
"numeroBanheiros": 2,
"area": 75.0,
"preco": 100000.0
}
Para listar todos os objetos Imovel
, você pode enviar um GET para a URL /imoveis
e receber uma resposta no formato JSON com uma lista de objetos Imovel
.
Para buscar um objeto Imovel
por ID, você pode enviar um GET para a URL /imoveis/{id}
e receber uma resposta no formato JSON com o objeto correspondente. Se o objeto não for encontrado, você receberá uma resposta com código HTTP 404.
Para excluir um objeto Imovel
por ID, você pode enviar um DELETE para a URL /imoveis/{id}
e receber uma resposta vazia com código HTTP 204. Se o objeto não for encontrado, você receberá uma resposta com código HTTP 404.
Com esses endpoints, você pode manipular os objetos Imovel
da sua aplicação por meio de uma API RESTful simples e eficiente.
Conclusão
Neste post, vimos como criar um microserviço para gerenciar imóveis utilizando o Spring Boot e a Azure. Começamos criando um projeto Spring Boot com as dependências necessárias para a nossa aplicação. Em seguida, criamos a classe Imovel para representar um imóvel e mapeamos essa classe para o banco de dados usando o Spring Data JPA.
Depois, criamos o controlador ImovelController para lidar com as requisições HTTP e acessar o repositório ImovelRepository para realizar as operações no banco de dados. Por fim, configuramos o banco de dados MariaDB no Spring Boot e vimos como criar um repositório utilizando a interface JpaRepository do Spring Data JPA.
Com a nossa aplicação funcionando corretamente, podemos agora fazer o deploy em um container Docker na Azure e deixar nosso microserviço disponível na nuvem para acesso externo. O que iremos fazer na parte 2 desse tutorial.
Top comments (0)