Java e JDBC: trabalhando com um banco de dados

Conhecendo a aplicação - Apresentação

Boas-vindas! Meu nome é João Vitor, serei seu instrutor neste curso de Java com JDBC.

João Vitor é uma pessoa de pele clara, olhos castanhos e cabelos pretos curtos. Usa bigode e cavanhaque. Veste uma camiseta azul-marinho e está sentado em uma cadeira preta. Ao fundo, há uma parede lisa com iluminação azul.

Se você quer saber como integrar sua aplicação Java com o banco de dados, você está no lugar certo! Neste curso, trabalharemos com uma aplicação Java que representa o banco virtual fictício ByteBank.

O que vamos aprender?

Ao longo de nossos estudos, construiremos métodos e funções para fazer a integração com o banco de dados, simulando operações do dia a dia da instituição bancária. Por exemplo, com esse projeto, conseguiremos realizar depósitos e saques em uma conta que existe no banco de dados.

Aprenderemos alguns padrões como Factory e DAO (Data Access Object) para deixar nossa aplicação com fácil manutenção, como esperado no mercado de trabalho. Exploraremos esses conceitos usando o Java JDBC API, isto é, a API do JAVA. A sigla JDBC significa Java Database Conectivity.

Este curso não será voltado para SQL, mas na implementação da nossa aplicação se integrando com SQL. Porém, isso não nos impedirá de trabalhar diretamente no banco de dados, fazendo consultas e usando cláusulas SQL.

Vamos estudar?

Conhecendo a aplicação - O projeto Bytebank

Vamos conhecer como funciona a nossa aplicação, chamada "BytebankApplication". Nosso intuito é realizar operações que faríamos em um banco, como cadastro e listagem de contas, bem como transferências de valores.

Com o projeto aberto no IntelliJ ou em sua IDE de preferência, podemos acessar o arquivo BytebankApplication.java e reparar que a aplicação já conta com algumas opções:

listas contas
abrir conta
encerrar conta
consultar saldo
realizar saque
realizar depósito

Na linha 50, o método exibirMenu() é responsável por mostrar um terminal em que podemos selecionar a operação desejada, pressionando o número correspondente.

Executando a aplicação

Na linha 15, temos a classe main. No canto esquerdo dessa linha, vamos clicar no ícone de play e selecionar "Run BytebankApplication.main()" para executar o projeto. Alternativamente, podemos pressionar o atalho "Ctrl + Shift + F10".

O terminal integrado do IntelliJ será aberto e teremos as opções de operações listadas há pouco:

BYTEBANK - ESCOLHA UMA OPÇÃO
1 - Listar contas abertas
2 - Abertura de conta
3 - Encerramento de conta
4 - Consultar saldo de uma conta
5 - Realizar saque em uma conta
6 Realizar depósito em uma conta
7 - Sair

Criando uma conta

Como não temos nenhuma conta cadastrada, vamos digitar "2" e pressionar a tecla "Enter "para criar uma conta. Em seguida, podemos inserir os dados solicitados, por exemplo:

Digite o número da conta: 1226
Digite o nome do cliente: João
Digite o cpf do cliente: 3648764-01
Digite o email do cliente: joao@alura.com

Finalizado o cadastro, o retorno no console é uma mensagem de operação bem-sucedida:

Conta aberta com sucesso!
Pressione qualquer tecla ou dê ENTER para voltar ao menu principal

Pressionando a tecla "Enter", voltamos ao menu com as sete opções.

Listando contas

Agora, vamos fazer a listagem de contas para conferir se ela foi realmente criada. Digitaremos "1" e pressionaremos "Enter" novamente. O retorno será o seguinte:

Contas cadastradas:
Conta{numero='1226', saldo=0, titular=Cliente{nome='João', cpf='3648764-01', email='joao@alura.com'}}
Pressione qualquer tecla ou dê ENTER para voltar ao menu principal

Vamos pressionar "Enter" para voltar ao menu e digitar "7" para encerrar a aplicação.

Na sequência, tentaremos fazer operações na conta que cadastramos. Para iniciar nossa aplicação, dessa vez, clicaremos no ícone de play no canto superior direito da IDE. Como alternativa, podemos usar o atalho "Shift + F10".

Vale ressalvar que não há diferença entre clicar neste play ou no play da linha 15, em que temos a classe main, como fizemos anteriormente. O resultado é o mesmo.

No terminal integrado do IntelliJ, temos novamente as sete opções do menu principal. Já que reiniciamos a aplicação, vamos digitar "1" para conferir as contas cadastradas. O retorno será o seguinte:

Contas cadastradas:
Pressione qualquer tecla ou dê ENTER para voltar ao menu principal

Não há contas cadastradas! O que aconteceu com a conta do João que inserimos há pouco? Voltando ao menu principal, encerraremos a aplicação. A seguir, vamos entender o que aconteceu.

Em BytebankApplication.java, a partir da linha 19, há uma estrutura switch. O case 2 corresponde à abertura de conta, em que chamamos a função abrirConta(). Vamos clicar sobre abrirConta() pressionando "Ctrl", para conferir o código dessa função (na linha 77 deste mesmo arquivo).

Após a solicitação do e-mail, chama-se o service.abrir(), passando como parâmetros as informações que digitamos no console:

service.abrir(new DadosAberturaConta(numeroDaConta, new DadosCadastroCliente(nome, cpf, email)));

Ou seja, temos uma classe de serviço que gerencia as contas e uma de suas funções chama-se abrir(). Vamos clicar em abrir(), pressionando a tecla "Ctrl" para consultá-la. Ela é definida na linha 24 do arquivo ContaService.java.

Analisando a função abrir(), reparamos que ela simplesmente adiciona a nova conta em um Set<> de contas, que consta na linha 13, apenas como um new HashSet<>().

Portanto, quando adicionamos a conta de João e fizemos a listagem, exibimos as contas em memória. Ao encerrar a aplicação e a iniciá-la novamente, limpamos a memória, por isso perdemos a conta de João.

Precisamos gravar dados de contas em um lugar permanente. O lugar permanente utilizado por muitas aplicações no mundo inteiro é o banco de dados.

Na sequência, nosso objetivo será transformar nosso cadastro de contas estático atual em um cadastro de contas em um lugar definitivo.

Conhecendo a aplicação - Configurando o conector

Atenção! Nessa aula, o instrutor configura o conector do banco de dados, usando uma string de conexão, em que passamos ao final o usuário e a senha do banco de dados.
Dessa forma, se você tem um usuário ou uma senha diferentes de ‘root’, é necessário trocar o usuário de ‘root’ pelo nome do usuário configurado e a senha de ‘root’ para a senha que você definiu para acessar seu banco.

Agora que nosso banco de dados foi criado e configurado, chegou o momento de integrar nossa aplicação com ele. Em uma ponta, temos nossa aplicação Java; na outra, temos um banco de dados. No nosso caso, trata-se de um MySQL, mas poderia ser outro, como Oracle ou PostgreSQL.

Para trafegar informações de uma ponta a outra, existem protocolos específicos e uma série de detalhes entre esses dois sistemas. Tantas particularidades podem ser confusas, mas não precisamos fazer tudo sozinhos. Desenvolvedoras e desenvolvedores de bancos de dados atuais nos fornecem bibliotecas com recursos que abstraem esses conceitos complexos. Basta adicionar a biblioteca em nossa aplicação, assim podemos focar apenas em nossa aplicação e em suas regras de negócio.

Instalando a biblioteca

No navegador, vamos acessar o site do MVN Repository. No campo de busca no topo da página, pesquisaremos por "mysql". Entre os resultados obtidos, vamos clicar em "MySQL Connector Java" para conferir a página dessa biblioteca (ou driver) de conexão com MySQL que queremos adicionar ao nosso projeto.

Descendo a página, há uma tabela com as versões. A mais recente no momento de gravação deste curso é a 8.0.31. Se houver uma versão mais recente quando você estiver estudando, você pode selecioná-la.

Clicando na versão desejada, seremos redirecionados para outra página. Descendo a página, encontraremos uma caixa com as tags da dependência que devemos inserir na nossa aplicação:

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.31</version>
</dependency>

Vamos copiar esse bloco de código. Note que a tag que envolve o código é <dependency>, ou seja, "dependência" no singular.

Nesse projeto, estamos usando o gerenciador de dependências chamado Maven. Vamos declarar as dependências externas no arquivo pom.xml e o Maven ficará responsável por fazer o download delas e colocá-las no classpath da nossa aplicação. Uma vez que esses recursos estejam no classpath, podemos usar suas classes e interfaces, que abstraem toda a complexidade dos protocolos de bancos de dados.

Na lateral esquerda da IDE, vamos clicar em "Project" para abrir a estrutura de pastas do projeto e abrir o arquivo pom.xml, no diretório raiz:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>br.com.alura</groupId>
    <artifactId>bytebank</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

Nele, temos informações como groupId e artifactId da própria aplicação, bem como propriedades, mas ainda não há nenhuma dependência.

Não podemos simplesmente colar o bloco de código nesse arquivo, pois há um nível de tag acima dele, <dependencies> Ou seja, "dependências", no plural.

Abaixo de </properties>, vamos adicionar as tags de abertura e fechamento de dependencies. Dentro dessas tags, colaremos o bloco de código que copiamos do site MVN Repository:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>br.com.alura</groupId>
    <artifactId>bytebank</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
            <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
            <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>8.0.31</version>
            </dependency>
    </dependencies>

</project>

Na lateral direita da IDE, vamos abrir a aba "Maven". No canto esquerdo superior dessa aba, clicaremos no ícone "Reload All Maven Projects". Assim, o Maven baixará as dependências declaradas em pom.xlm (se ainda não tiver baixado) e as colocará no classpath.

Fazendo a conexão

A seguir, vamos conectar com o banco de dados, que já está ativo. Nossa aplicação precisa conhecer o banco para abrir uma conexão, fazer operações e fechar a conexão.

De início, criaremos uma classe em "src > main > java > br.com.alura.bytebank". Clicaremos com o botão direito do mouse sobre o nome desse pacote e selecionaremos "New > Java Class". Daremos o nome "ConexaoDB". O resultado será o seguinte arquivo:

package br.com.alura.bytebank;

public class ConexaoDB {

}

Nessa classe, vamos desenvolver um método main() para executar a aplicação, que fará uma conexão com o banco e depois a encerrará:

package br.com.alura.bytebank;

public class ConexaoDB {

        public static void main(String... x) {

        }
}

No método main(), usaremos os recursos da nossa biblioteca para realizar o acesso ao banco de dados. Primeiramente, vamos pegar uma conexão no banco de dados para poder abri-la e conseguir interagir.

Utilizaremos a classe DriverManager do java.sql, mais especificamente o método getConnection(). Ao digitar DriverManager, a IDE automaticamente fará a importação no início do arquivo:

package br.com.alura.bytebank;

import java.sql.DriverManager;

public class ConexaoDB {

        public static void main(String... x) {

                DriverManager.getConnection();
        }
}

O código não compilará, pois é necessário passar parâmetros para o getConnection(). Precisamos informar uma URL, chamada de string de conexão. Ela tem um formato específico para identificar o tipo de conexão, o tipo de banco, o host, a porta e a database. Nossa string de conexão será assim:

"jdbc:mysql://localhost:3306/byte_bank?user=root&password=root"

Primeiramente, indicamos o tipo de conexão: jdbc. Depois, colocamos dois pontos e informamos o banco ao qual vamos nos conectar: mysql.

Adicionamos dois pontos e duas barras e indicamos o host. No nosso caso, é o host da nossa própria máquina, já que o MySQL está instalado em nosso computador. Então, digitamos localhost. Inserimos dois pontos novamente e colocamos a porta, 3306 — padrão do MySQL.

Em seguida, definimos o nome da nossa database: byte_bank. Por fim, colocamos um ponto de interrogação e passamos o usuário e a senha: user=root&password=root. Para fins de testes, não há problemas em informar usuário e senha na própria string de conexão, mas em ambientes produtivos não faremos dessa forma. Quando nos aprofundarmos nos estudos, aprenderemos mais sobre isso.

Depois de DriverManager, vamos pular uma linha para melhorar a visualização. O código ficará assim:

package br.com.alura.bytebank;

import java.sql.DriverManager;

public class ConexaoDB {

        public static void main(String... x) {

                DriverManager
                        .getConnection("jdbc:mysql://localhost:3306/byte_bank?user=root&password=root");
    }
}

Notaremos que o getConnection() não está compilando. Esse método lança uma exceção checada, do tipo SQLException. Nesses casos, temos duas alternativas. Podemos subir o nível para o main(), informando que esse método também pode lançar uma exceção checada. Assim, quem chamar a função saberá se trata a exceção checada ou não. Ou podemos inserir esse código dentro de um bloco try/catch. Vamos aplicar essa segunda opção:

package br.com.alura.bytebank;

import java.sql.DriverManager;
import java.sql.SQLException;

public class ConexaoDB {

        public static void main(String... x) {
                try {
                        DriverManager
                                        .getConnection("jdbc:mysql://localhost:3306/byte_bank?user=root&password=root");
                } catch (SQLException e) {
            System.out.println(e);
                }
        }
    }

No catch, colocamos um System.out.println(e) para imprimir o erro no console, apenas para conseguir compilar o código.

Recapitulando: na função main(), abrimos um try em que trabalhamos com a recuperação da conexão. Caso ocorra um erro e o getConnection() lance uma exceção checada, executamos um catch para imprimir a exceção no console.

Nosso objetivo no momento é fazer a conexão, imprimir uma mensagem Com System.out.println() e fechar a conexão. Ao trabalhar com esse tipo de conexão, é importante lembrar de fechar as conexões. Do contrário, a aplicação é finalizada e a conexão continua aberta. À medida que abrimos mais conexões sem fechá-las, isso se tornará oneroso para o banco de dados.

Vamos armazenar a conexão em um objeto do tipo Connection, do java.sql. Depois de recuperar a conexão, vamos imprimir a mensagem "Recuperei a conexão". Em seguida, fecharemos a conexão com connection.close():

package br.com.alura.bytebank;

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

public class ConexaoDB {

    public static void main(String... x) {
        try {
            Connection connection = DriverManager
                    .getConnection("jdbc:mysql://localhost:3306/byte_bank?user=root&password=root");

            System.out.println("Recuperei a conexão");

            connection.close();
        } catch (SQLException e) {
            System.out.println(e);
        }
    }
}

Temos nosso primeiro código para fazer a interação com banco de dados. Antes de testar, lembre-se de ativar o seu banco de dados. Finalmente, vamos executar o código, pressionando o ícone de play à esquerda do método main(), na linha 9, e selecionando "Run ConexaoDB.main()".

No terminal integrado do IntelliJ, recebemos a seguinte mensagem:

Recuperei a conexão

Recuperamos e fechamos a conexão com sucesso, mas não conseguimos conferir essa conexão funcionando, de fato. Para garantir que tudo funcionou, vamos induzir um erro. Na string de conexão, vamos remover o underline do nome da database:

"jdbc:mysql://localhost:3306/bytebank?user=root&password=root"

Vamos rodar novamente. Como nosso banco de dados não tem nenhuma database de nome bytebank (sem o underline), esperamos receber uma exceção. De fato, ao executar, temos o seguinte retorno:

java.sql.SQLSyntaxErrorException: Unknown database 'bytebank'

Ou seja, "Database bytebank desconhecida". Nosso sistema foi até o banco, não encontrou a database e lançou uma exceção. Assim, sabemos que nossa aplicação já está integrada com o banco de dados. Na sequência, conseguiremos trabalhar com o banco de dados para gravar nossas contas e fazer operações bancárias.

Sobre o curso Java e JDBC: trabalhando com um banco de dados

O curso Java e JDBC: trabalhando com um banco de dados possui 166 minutos de vídeos, em um total de 51 atividades. Gostou? Conheça nossos outros cursos de Java 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:

Conhecendo a aplicação
Cadastro de informações
Criando uma listagem
Atualização de informações
Exclusão de informações