Criando uma Api usando o Supabase com Java Spring Boot

Olá, me chamo Felipe Fontenele, Desenvolvedor Jr. e trago aqui um guia rápido de como criar uma Api com Java Spring Boot usando o Supabase.

Como será a aplicação?

Vamos usar o modelo MVC e de forma resumida criando os pacotes: Controller, Model e Repository. Nossa API vai fornecer uma lista simples de filmes contendo id, nome e data de criação para simplificar o entendimento.

Usaremos também o protocolo HTTP e os softwares Eclipse e Postman para obter e manipular os dados da nossa API.

Estrutura do Projeto

Dependências do pom.xml:

• Spring boot Web
• Spring boot devtools
• Spring boot starter-data-jpa
• postgresql e Driver

Criação de pacotes e classes no Java com Spring Boot

Vamos começar criando uma aplicação Spring Boot usando Spring Start Project:

Botão direito do mouse no espaço vazio em Package Explorer do Eclipse > New > Spring Start Project:

Next>

Dê um nome ao seu projeto em ‘Name’, selecione o Maven em ‘Package’ o nome do seu pacote, depois, Next.

Na tela seguinte usaremos a versão 3.0.2 e adicionaremos as seguintes dependências:

• Spring boot Web
• Spring boot devtools
• Spring boot starter-data-jpa
• postgresql e Driver

Na pasta do projeto criado iremos em src/main/java > e criaremos os pacotes: Controller, Model, Repository.

Em controller teremos a classe FilmeController.java:

package com.felper.tst.controller;

import java.util.List;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

import com.felper.tst.model.Filme;
import com.felper.tst.repository.FilmeRepository;

@RestController
@RequestMapping("/filmes")
public class FilmeController {
 
 @Autowired
 private FilmeRepository filmeRepository;

 @GetMapping
 public List<Filme> listFilme() {
  return filmeRepository.findAll();
 };
 
 @GetMapping(value = "/{id}")
 public Filme getFilme(@PathVariable Long id) {
  return filmeRepository.findById(id).get();
 }
 
 @PostMapping
 @ResponseStatus(HttpStatus.CREATED)
 public Filme addFilme(@RequestBody Filme filme) {
  return filmeRepository.save(filme);
 }
 
 @PutMapping(value = "/{id}")
 public Filme updateFilme(@PathVariable Long id, @RequestBody Filme filme) {
  Filme filmeAtual = filmeRepository.findById(id).get();
  BeanUtils.copyProperties(filme, filmeAtual, "id");
  return filmeRepository.save(filmeAtual);
 }
 
 @DeleteMapping(path = "/{id}")
 public ResponseEntity<Boolean> removeFilme(@PathVariable Long id) {
  filmeRepository.deleteById(id);
  return ResponseEntity.ok(true);
 }

Em Model teremos a classe FilmeModel.java

package com.felper.tst.model;

import java.util.Date;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Filme {
 
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
 @Column(nullable = false)
 private String name;
 private Date created_at = new Date();

 public Long getId() {
  return id;
 }
 public void setId(Long id) {
  this.id = id;
 }
 public Date getCreated_at() {
  return created_at;
 }
 public void setCreated_at(Date created_at) {
  this.created_at = created_at;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }

}

E em Repository teremos a Interface FilmeRepository.java

package com.felper.tst.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.felper.tst.model.Filme;

@Repository
public interface FilmeRepository extends JpaRepository<Filme, Long> {

}

E na classe Main.java ou FilmeststApiApplication.java teremos:

package com.felper.tst;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class FilmeststApiApplication {

 public static void main(String[] args) {
  SpringApplication.run(FilmeststApiApplication.class, args);
 }


}

Toda a estrutura básica de uma API simples acaba de ser criada, vamos então ao banco de dados.

Preparando nosso Banco de Dados com Supabase

Antes de entrarmos no guia de criação de um projeto com o supabase devemos entender o que é e como ele funciona.

Em uma breve visita ao site oficial https://supabase.com/ entendemos que ele é um projeto opensource e uma alternativa ao Firebase com a difereça de que o Supabase usa Banco de Dados relacional com Postgres.

Dessa forma podemos partir para a criação simples de um projeto com apenas uma tabela e alguns campos.

Criação e configuração do projeto:

Após entrar em https://supabase.com/ e logar com sua conta crie um novo projeto em “New Project” > New Organization > Name: [Nome da sua organização] > Digite o nome do projeto e password do seu banco de dados > Seleciona a região > Next > Aguarde a criação do projeto terminar.

Cria uma nova tabela com o nome filme com os atributos criados no Model Filme:

Após a criação da tabela vá nas configurações do seu projeto para obter os dados de conexão da nossa API Spring Boot com o Supabase:

Com os dados em mãos voltamos ao projeto e abriremos o arquivo aplication.properties:

src/main/resources/application.properties

Preenchemos o arquivo com as linhas:

spring.datasource.url=jdbc:postgresql://HOSTURLSUPABASE
spring.datasource.username=postgres
spring.datasource.password=SENHADOSEUBANCO
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults=false
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

Pronto!

O Projeto deverá estar pronto para ser executado.

Executando o projeto!

 [...]
 [2m2023-01-23T16:00:13.007-03:00  INFO 8648 --- [  restartedMain] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2023-01-23T16:00:14.456-03:00  INFO 8648 --- [  restartedMain] com.zaxxer.hikari.pool.HikariPool        : HikariPool-1 - Added connection org.postgresql.jdbc.PgConnection@45a43560
2023-01-23T16:00:14.458-03:00  INFO 8648 --- [  restartedMain] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
2023-01-23T16:00:14.946-03:00  INFO 8648 --- [  restartedMain] o.h.e.t.j.p.i.JtaPlatformInitiator       : HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
2023-01-23T16:00:14.956-03:00  INFO 8648 --- [  restartedMain] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
2023-01-23T16:00:15.220-03:00  WARN 8648 --- [  restartedMain] JpaBaseConfiguration$JpaWebConfiguration : spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning
2023-01-23T16:00:15.509-03:00  INFO 8648 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2023-01-23T16:00:15.550-03:00  INFO 8648 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-01-23T16:00:15.560-03:00  INFO 8648 --- [  restartedMain] com.felper.tst.FilmeststApiApplication   : Started FilmeststApiApplication in 5.374 seconds (process running for 5.969)
2023-01-23T16:00:22.541-03:00  INFO 8648 --- [nio-8080-exec-2] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2023-01-23T16:00:22.541-03:00  INFO 8648 --- [nio-8080-exec-2] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2023-01-23T16:00:22.542-03:00  INFO 8648 --- [nio-8080-exec-2] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms

Projeto inicializado com sucesso!

Agora basta abrir o Postman e vamos aos testes:
GET:

POST:

PUT:

GET após o PUT:

DELETE:

Delete passando o id 9 como parâmetro:

GET após o DELETE:

Feito!

Dessa forma aprendemos de forma bem simples como integrar o supabase a nossa aplicação Java Spring Boot.

Lembrando que além do Supabase a configuração do nosso projeto com outros bancos deverá feito da mesma forma, alterando apenas o arquivo application.properties.