Kotlin: persistindo dados com Hibernate

Utilizando banco de dados - Apresentação

Jeni: Olá, estudante! Boas-vindas ao curso 3 da formação Kotlin! Eu sou a Jeniffer Bittencourt, mas pode me chamar de Jeni.

Audiodescrição: Jeni se descreve como uma mulher branca de cabelos ondulados na altura dos ombros, pintados de azul turquesa, sobrancelhas castanhas, e olhos castanhos. Ela usa óculos com armação redonda preta, veste uma camisa branca com uma estampa no centro, e está sentada à esquerda de uma mesa preta, em frente a um notebook e um microfone, com uma parede branca ao fundo iluminada em gradiente de azul e roxo.

Porém, não estou sozinha para te acompanhar durante os estudos neste curso.

Daniel: Olá! Eu sou o Daniel Portugal, instrutor aqui na Alura.

Audiodescrição: Daniel se descreve como um homem branco, de cabelo preto curto, barba preta curta, e olhos castanhos. Ele usa óculos de armação retangular preta, veste uma blusa preta, e está no mesmo cenário que a instrutora Jeni, mas ao lado direito da mesa, também em frente a um notebook e um microfone.

O que vamos aprender?

Jeni: O projeto com o qual vamos trabalhar durante este curso é o mesmo dos cursos anteriores: o AluGames. Mas, agora temos um foco diferente. Vamos trabalhar com a parte da administração da nossa locadora. Precisamos trazer mais segurança e eficiência com todos os itens com os quais estamos lidando.

Daniel: Exatamente, Jeni. Precisamos enfrentar um problema bastante comum nos projetos, que é a persistência de dados. Para isso, será necessário:

• Instalar o MySQL;
• Utilizar a biblioteca Hibernate, que vai facilitar o processo de comunicação com o banco de dados;
• Depois disso, vamos utilizar mais recursos de orientação a objetos, com um recurso de linguagem chamado Generics;
• E vamos conhecer padrões de projetos e aplicar boas práticas.

Temos muitas coisas interessantes para fazer!

Pré-requisitos

Jeni: Para conseguirmos aprender tudo que o Daniel mencionou, é importante que você já tenha concluído os dois cursos anteriores da formação, e tenha um bom conhecimento de orientação a objetos e também de banco de dados.

Como este é um curso focado na linguagem Kotlin, vamos utilizar o banco de dados, mas não vamos focar em ensinar conceitos específicos disso.

Além disso, você ainda terá atividades para praticar o que está aprendendo, o suporte no fórum, e a nossa comunidade no Discord, onde você pode trocar ideias conosco e com outras pessoas que estão fazendo este curso.

Daniel: Vamos começar a estudar?

Utilizando banco de dados - Utilizando banco de dados

Jeni: No curso anterior, utilizamos como base de dados do AluGames um arquivo JSON contendo todas as informações de jogo, preço e descrição. Entretanto, à medida que aumentamos a complexidade da nossa aplicação, isso começa a se complicar.

Daniel: Nossa locadora está fazendo sucesso e estamos acumulando muitos dados. Temos jogos em grande quantidade. Fazer esse trabalho de alterar preço, mexer no título, incluir novos jogos, fica inviável com o arquivo que temos. Precisamos então buscar uma solução diferente.

Jeni: A equipe não está muito satisfeita. Quem aluga os jogos está gostando, mas quem trabalha, não está contente com a grande quantidade de dados para serem alterados. Então, o que nós podemos utilizar como uma solução é a utilização de banco de dados, para começarmos a trazer essas informações de uma maneira mais simples para gerenciar.

Utilizando banco de dados

No nosso caso, utilizaremos o MySQL. Para empregar o MySQL no projeto, você precisa ter feito as etapas da atividade anterior, com a instalação do MySQL e do plugin que vamos usar.

Criando a primeira conexão

Após a instalação do MySQL e do plugin, vamos ao IntelliJ para começar a trabalhar com o banco de dados. Primeiramente, precisamos achar o acesso ao plugin no menu lateral esquerdo.

Há um ícone de lupa intitulado "DB Browser". Se ele não aparecer na sua interface, você pode clicar no ícone de reticências ao final da lista na lateral esquerda para encontrá-lo.

Clicando no ícone, temos algumas opções e a primeira, correspondente ao ícone de + em verde, serve para abrir uma nova conexão (New Connection). Precisamos criar essa nova conexão para iniciar o processo de trabalhar com o banco.

Daniel: Aprendemos anteriormente que, para acessar um arquivo, precisamos conhecer o caminho do arquivo e, com isso, conseguimos acessar os conteúdos desse arquivo.

Nesse caso, será um pouco diferente, pois temos uma camada maior de segurança. Vamos precisar colocar a senha, o nome de usuário e assim por diante.

Jeni: Dito isso, vamos criar a nova conexão em "New Connection > MySQL", que é o banco que está sendo usado. Será aberta uma janela com algumas informações padrão dessa conexão.

Não vamos mexer na questão de localização da conexão. A única coisa que vamos incluir é a parte de usuário e senha que você cadastrou no momento da instalação. Após digitar usuário e senha, clicamos em "OK" para efetuar essa primeira conexão.

Uma vez concluída a conexão, surgem algumas informações sobre ela na lateral esquerda, e na pasta de esquemas ("Schemas"), conseguiremos visualizar o banco quando ele for criado.

Se clicarmos na seta para expandir, existem alguns bancos já criados, mas queremos criar o nosso, que represente o AluGames. Para isso, clicamos duas vezes sobre "Connection", ainda na lateral esquerda, e teremos a opção de passar alguns scripts para trabalhar com o banco.

Criando o banco de dados alugames

O primeiro que vamos passar é para criar efetivamente o banco: o comando CREATE DATABASE alugames.

CREATE DATABASE alugames

Para executar este código, podemos selecioná-lo e clicar no ícone de seta verde na barra de ferramentas superior, intitulado "Execute Statement".

Daniel: "Statement" é um recurso importante que precisaremos para depois usar no nosso projeto.

Jeni: Feito isso, na parte inferior, teremos a mensagem de que o comando foi executado com sucesso. Se voltarmos ao menu lateral esquerdo e clicarmos com o botão direito sobre "Schemas", ao selecionar "Reload", visualizaremos na lista o banco de dados alugames, com o qual precisamos interagir.

Criando a tabela de jogos

O próximo passo é criar uma tabela para representar os itens existentes no AluGames. A primeira tabela com a qual vamos trabalhar será a de jogos.

Para isso, temos um script predefinido.

CREATE TABLE jogos (
            id INT AUTO_INCREMENT PRIMARY KEY,
            capa VARCHAR(255),
            descricao VARCHAR(255),
            preco DOUBLE,
            titulo VARCHAR(100))

Neste script, temos a criação da tabela jogos com as informações de id, capa, descricao, preco, e titulo, que são as informações básicas que utilizaremos.

Faremos o mesmo procedimento: selecionar todo o trecho e executar. Mas antes de executarmos, precisamos selecionar o nosso próprio banco de dados. No menu superior à esquerda, onde está escrito "mysql", podemos clicar e selecionar o banco de dados alugames. Caso contrário, criaremos uma tabela no banco padrão.

Na parte inferior, teremos a informação de que foi executado com sucesso. Agora, se atualizarmos alugames no menu esquerdo, visualizaremos a tabela jogos que criamos. Portanto, já temos uma tabela com cinco colunas: de ID, capa, descrição, preço e título.

Inserindo informações na tabela

Daniel: O próximo passo é inserir algum jogo.

Jeni: Agora que temos a tabela e o banco, precisamos incluir alguma informação. Para isso, podemos clicar com o botão direito sobre a tabela jogos e selecionar "Edit Data".

Uma tela de filtro irá aparecer, mas como não vamos fazer nenhum filtro por enquanto, vamos selecionar "No Filter" no canto inferior direito. Feito isso, uma nova aba será aberta ao lado de "Connection" com a tabela de jogos.

Daniel: É como se fosse uma planilha com uma série de colunas, mas por enquanto sem nenhuma linha, pois não incluímos nenhum registro.

Jeni: Para incluir uma informação, vamos clicar no ícone de + verde no menu superior, identificado como "Insert Record". Ele habilita a primeira linha da tabela para nós.

Não precisamos preencher o ID, pois é gerado automaticamente. Para a capa, vamos inserir a URL da imagem, que estará disponível em atividade, assim como no JSON que utilizamos no curso anterior.

A descrição será "Um RPG de ação épico com um mundo aberto, vasto e envolvente". O preço será "4.99", e por fim, o título do jogo será "The Witcher 3: Wild Hunt".

Após inserir todos os dados, o próximo passo é enviar essas informações para a nossa tabela. Apenas inserir as informações não vai salvá-las na tabela. Para isso, temos a opção do ícone de retângulo com a seta verde para baixo, identificado como "Commit". Essa opção enviará os dados para a tabela.

Consultando as informações da tabela

Daniel: Assim, inserimos o primeiro jogo na tabela. Da mesma forma que temos um comando para inserir o jogo, também possuímos um comando para consultá-lo. Vamos fazer isso?

Jeni: Vamos, sim! Primeiramente, clicaremos com o botão direito novamente sobre a tabela jogos, que está na lateral esquerda. Teremos a opção "Extract SQL Statement > SELECT Statement", a qual vamos selecionar.

Essa ação irá copiar um script pronto para fazer um SELECT com todas as informações que temos na tabela. Em seguida, vamos retornar à aba "Connection", e colar a informação copiada.

select
    j.capa,
    j.descricao,
    j.id,
    j.preco,
    j.titulo
from
    jogos j;

Após colar o SELECT que foi gerado automaticamente, selecionaremos todas as informações e acionaremos o botão "Execute Statement" novamente.

Feito isso, na parte inferior, no console de execução do plugin, teremos a informação de que há um registro na tabela, com dados referentes ao jogo "The Witcher 3" que acabamos de inserir.

Conclusão

Daniel: Começamos falando um pouco sobre não usar arquivos para fazer persistência de dados. Você observará isso na sua carreira: quando for trabalhar com persistência, utilizará a tecnologia de banco de dados.

Estamos começando a trabalhar especificamente com MySQL. Conhecemos os comandos, isto é, os statements de inserção e de consulta. Agora precisamos aplicar isso no código usando Kotlin.

Jeni: Até o próximo vídeo!

Utilizando banco de dados - Conectando com o banco de dados

Daniel: Instalamos o MySQL e, utilizando o plugin, nós criamos uma conexão, criamos a tabela jogos, inserimos dados nessa tabela, e realizamos uma consulta. Será que conseguimos fazer tudo isso usando o Kotlin?

Conectando com o banco de dados

Criando um novo pacote

Jeni: Vamos verificar a aba "Project" à esquerda no IntelliJ.

Para começar a trabalhar com dados e manter nosso projeto organizado, é possível criar um pacote para representar todos os dados que serão obtidos do banco.

Podemos clicar com o botão direito sobre o pacote geral do AluGames ("br.com.alura.alugames") e ir até "New > Package" para criar o pacote "dados", que terá todas as informações do nosso banco.

Criando a classe Banco

Dentro desse novo pacote, vamos criar um arquivo que representará a primeira informação da nossa conexão. Então, clicamos com o botão direito sobre o pacote e vamos até "New > Kotlin Class/File" para criar uma classe chamada Banco.

Banco.kt:

package br.com.alura.alugames.dados

class Banco {
}

Adicionando a dependência mysql

Antes de efetivarmos a nossa conexão com o banco, precisamos trazer essa informação do MySQL para o projeto. Antes, o plugin desempenhava essa função. Para isso, vamos adicionar uma dependência no arquivo pom.xml, arquivo do Maven que gerencia nossas dependências.

Com o arquivo pom.xml aberto, vamos até a parte inferior, onde temos a tag de fechamento que representa todas as dependências (</dependencies>). Após a última dependência, podemos colar a informação de dependência do MySQL.

pom.xml:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.28</version>
</dependency>

Depois de colar as informações do MySQL, basta atualizar o Maven para que ele possa rodar a instalação dessa dependência.

Realizando a conexão

Feito isso, podemos retornar ao arquivo Banco.kt que acabamos de criar e efetivamente fazer a conexão. Para isso, também temos um código padrão que adicionaremos no escopo da classe com os dados da conexão.

Banco.kt:

// código omitido

class Banco {
    fun obterConexao(): Connection? {
        return try {
            DriverManager.getConnection("jdbc:mysql://localhost:3306/alugames", "root", "aLxXzDcgueZu6z")
        } catch (e: SQLException) {
            e.printStackTrace()
            null
        }
    }
}

Basicamente, o método nomeado como obterConexao() tem como objetivo realizar a conexão. Nesse momento, ´precisaremos fazer algumas importações.

Primeiro, vamos importar Connection com o atalho "Alt + Enter". Precisamos ter atenção na hora de importar, para fazer a importação correta. Entre as opções que o próprio IntelliJ sugere, precisamos escolher a do java.sql. Caso contrário, teremos problemas com nossa conexão.

Além disso, precisamos importar o SQLException e o DriverManager da mesma forma.

import java.sql.Connection
import java.sql.DriverManager
import java.sql.SQLException

O código que criamos faz a conexão e também um teste. Se a conexão for válida, ou seja, se existir um banco com as informações inseridas, ou seja, com o endereço de URL do banco, com o usuário e a respectiva senha, será realizada a conexão. Caso não exista, será retornada uma conexão nula.

Portanto, este é o código necessário para fazermos a conexão.

Criando um arquivo de teste

Daniel: Agora, podemos testar a conexão no pacote principal, criando um novo arquivo de teste.

Jeni: No menu lateral esquerdo, vamos clicar com o botão direito sobre o pacote "principal" e selecionar "New > Kotlin Class/File" para criar um arquivo chamado testeBanco para que possamos testar a conexão.

Nesse arquivo, vamos chamar uma fun main(). A primeira coisa que precisamos fazer é instanciar a conexão, então podemos declarar a variável conexao e instanciar a classe Banco para chamar a conexão.

testeBanco.kt:

package br.com.alura.alugames.principal

import br.com.alura.alugames.dados.Banco

fun main() {
    val conexao = Banco()
}

Daniel: Nesse cenário, precisamos criar o objeto que representa o banco e depois pegar um objeto que representa a conexão. Como esse banco é único no sistema do nosso projeto, podemos usar um recurso na classe Banco para representar isso.

Então, vamos ao arquivo Banco.kt, onde podemos substituir class Banco por object Banco. O Kotlin tem esse recurso para dizer que conseguimos ter apenas um objeto nessa classe, no caso, Banco.

Banco.kt:

object Banco {
    fun obterConexao(): Connection? {
        return try {
            DriverManager.getConnection("jdbc:mysql://localhost:3306/alugames", "root", "aLxXzDcgueZu6z")
        } catch (e: SQLException) {
            e.printStackTrace()
            null
        }
    }
}

Jeni: Ao fazer essa troca, não precisamos mais instanciar Banco no arquivo de teste; podemos simplesmente chamar o objeto Banco, pois ele já foi instanciado pelo object, seguido do método obterConexao().

testeBanco.kt:

// código omitido

fun main() {
    val conexao = Banco()
}

Com isso, nosso processo fica mais simples.

Daniel: Como se fosse uma chamada de método estático com essa diferença.

Jeni: Agora faremos um println() de conexao para exibir e verificar se nossa conexão funciona corretamente.

fun main() {
    val conexao = Banco()
    println(conexao)
}

Daniel: Ao executar o código, se tudo estiver correto, será impresso um objeto do tipo conexao; caso contrário, será retornado nulo.

Tivemos como retorno a mensagem de que o processo foi finalizado e já temos a conexão. Vamos voltar ao arquivo Banco.kt apenas para recapitular.

Começamos o trabalho de acessar o banco usando código. Para isso, usamos três tipos específicos: Connection, DriverManager e SQLException, todos do pacote java.sql. Esse é um pacote da biblioteca JDBC (Java Database Connectivity), que vamos usar para acessar o banco de dados.

Para isso, também, precisamos instalar o driver do MySQL. Se você usar outro banco no seu trabalho, também usará outros drivers, mas neste projeto, vamos utilizar o MySQL.

Conclusão

Jeni: Demos o primeiro passo para começar a trabalhar com banco em código, trabalhando com Kotlin diretamente. No próximo vídeo, continuaremos a evolução dessa aplicação no nosso projeto. Até lá!

Sobre o curso Kotlin: persistindo dados com Hibernate

O curso Kotlin: persistindo dados com Hibernate possui 183 minutos de vídeos, em um total de 57 atividades. Gostou? Conheça nossos outros cursos de Kotlin em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Utilizando banco de dados
• Bibliotecas ORM
• Generics
• Persistindo aluguéis
• Desafio