Conexão com Banco de Dados no Spring Boot

Prof. Me. Danilo Bueno

Armazenamento dos dados

Como armazenar os dados em uma aplicação Web?

Até então utilizamos uma lista de objetos para armazenar os dados:

List<Product> products = new ArrayList<Product>();

Problemas com essa abordagem?

Conectando no banco de dados

Como realizar a conexão com o banco de dados em uma aplicação Spring?

Três passos principais:

1. Configurar a conexão com o banco de dados
2. Mapear as entidades
3. Criar os repositórios

Configurando a conexão BD

Para configurar a conexão, é necessário:

1. Adicionar a dependência do banco de dados
2. Configurar o arquivo application.properties

1. Adicionando a dependência:

No arquivo pom.xml, adicione as seguintes dependências:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

2. O arquivo .properties

• Caso o arquivo não exista, crie-o em src/main/resources
• Adicione as linhas ao arquivo application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/database_name
spring.datasource.username=db_username
spring.datasource.password=db_password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Para que as configurações acima funcionem parte-se do pressuposto que o serviço de banco de dados já está instalado, configurado e rodando. Além de possuir uma base de dados previamente criada.

IMPORTANTE

• Caso você esteja utilizando o MariaDB, você deve usar a dependência mariadb-java-client no lugar do mysql-connector-j

<dependency>
    <groupId>org.mariadb.jdbc</groupId>
    <artifactId>mariadb-java-client</artifactId>
    <scope>runtime</scope>
</dependency>

• E alterar a URL de conexão no arquivo .properties para: jdbc:mariadb://localhost:3306/database_name.

Analisando as propriedades

• spring.datasource.url: URL de conexão com o banco de dados e nome da base de dados
• spring.datasource.username: Usuário do banco de dados
• spring.datasource.password: Senha do usuário do BD
• spring.jpa.hibernate.ddl-auto: Estratégia de criação do banco de dados
• spring.jpa.show-sql: Exibir SQLs no console

Analisando os valores:

• create: Cria o esquema do banco toda vez que a aplicação inicia (perde todos os dados!).
• create-drop: Igual ao create, mas também apaga o esquema quando a aplicação é encerrada (uso em testes).
• update: Atualiza o esquema conforme as entidades, preservando dados existentes (cuidado em produção!).
• validate: Apenas verifica se as tabelas/colunas do banco correspondem às entidades. Não faz alterações.
• none: Desativa a gestão automática do esquema.

Qual valor utilizar?

Depende do ambiente a ser utilizado

• update: Em ambiente de desenvolvimento para prototipação rápida
• validate: Em ambiente de produção para evitar surpresas

Mas como irei alterar meu esquema do banco de dados?

O esquema do banco em produção deve ser gerenciado via migrations (ex.: Flyway, Liquibase), não pelo Hibernate.

Mapeando as entidades

• As entidades são classes que representam as tabelas do banco de dados
• Cada instância da entidade corresponde a uma linha na tabela
• Para mapear uma classe como entidade, utilizamos as seguintes anotações:
• @Entity, @Table, @Id, @GeneratedValue e @Column
• Essas anotações indicam como transformar objetos Java em dados persistidos no banco de dados.

Exemplo de entidade

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "email")
    private String email;

    @Column(name = "password")
    private String password;

Anotações usadas

Criando os repositórios

• A camada responsável pelas operações no banco de dados é conhecida como repositório.
• Isola a lógica de acesso a dados do restante da aplicação (manutenção)
• É uma classe Java anotada com @Repository que vai ter os métodos com operações do banco de dados (SELECT, INSERT, UPDATE e DELETE)
• Para acesso ao banco de dados o objeto EntityManager é utilizado

Criando o repositório

@Repository
public class UserRepository {

    @PersistenceContext
    private EntityManager em;

}

Analisando as anotações

• @Repository: Indica que a classe é um repositório
• @PersistenceContext: Injeta o EntityManager na classe.
• EntityManager: é uma classe que gerencia as entidades e realiza as operações de acesso ao banco de dados (SELECT, INSERT, UPDATE e DELETE).

O famoso CRUD

Vamos precisar criar os métodos para acessar os dados

Repositório: método save

O método save recebe um objeto User e salva no banco de dados:

@Transactional
public void save(User user) {
    String sql = "INSERT INTO user (email, password) 
        VALUES (:email, :password)";
    Query query = em.createNativeQuery(sql);
    query.setParameter("email", user.getEmail());
    query.setParameter("password", user.getPassword());
    query.executeUpdate();
}

Parâmetros Nomeados

1. Declaração na query: :email e :password são placeholders que serão substituídos pelos valores reais.

2. Vinculação de Valores

   query.setParameter("email", user.getEmail());

• Primeiro argumento: Nome do parâmetro na query
• Segundo argumento: Valor a ser inserido

Evita SQL Injection por não concatenar strings diretamente na query e valida automaticamente os tipos de dados.

Como utilizar o repositório?

Podemos usar o repositório para salvar um novo objeto no BD.

@Controller
public class UserController {

  @Autowired
  private UserRepository userRepository;

  @PostMapping("/users")
  public String saveUser() {
    userRepository.save(new User("lisa", "[email protected]"));
    return "redirect:/list";
  }
}

Explicando o código

• @PostMapping("/users"): Mapeia requisições POST para o método.

• userRepository.save(user): Chama o método save do respositório e salva o objeto no banco de dados.

• "redirect:/list": Redireciona para a rota list após salvar.

• @Autowired: é uma anotação de injeção de dependência do Spring. Sem ela, seria necessário criar o objeto manualmente com new.

Obrigado!

[email protected] · website/docs · github