Transações
Commit e rollback.
Transações é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.
O que é uma transação?
Uma transação agrupa várias operações SQL em uma única unidade: tudo ou nada.
Ou todas as instruções são executadas com sucesso e as alterações se tornam permanentes (commit), ou algo falha e todas elas são desfeitas (rollback). Isso mantém o banco de dados consistente.
ACID em um minuto
As transações oferecem as garantias ACID:
- Atomicidade — tudo ou nada.
- Consistência — move o banco de dados de um estado válido para outro.
- Isolamento — transações simultâneas não corrompem umas às outras.
- Durabilidade — depois de confirmadas, as alterações sobrevivem a uma falha.
Modo de confirmação automática
Por padrão, as conexões JDBC são executadas no modo de confirmação automática: cada instrução é sua própria transação e é confirmada imediatamente.
Isso funciona bem para instruções individuais, mas é inútil quando várias operações de escrita precisam ser bem-sucedidas em conjunto. Para controlar as transações por conta própria, desative a confirmação automática.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Main {
public static void main(String[] args) {
String url = "jdbc:postgresql://localhost:5432/bank";
try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
System.out.println("Default auto-commit: " + conn.getAutoCommit());
conn.setAutoCommit(false);
System.out.println("Now manual: " + conn.getAutoCommit());
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Commit e Rollback
Com a confirmação automática desativada, você decide os limites:
conn.commit()torna permanentes todas as alterações pendentes.conn.rollback()as descarta.
O exemplo clássico é uma transferência de dinheiro: debitar uma conta e creditar outra. As duas operações devem acontecer, ou nenhuma delas.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class Main {
public static void main(String[] args) {
String url = "jdbc:postgresql://localhost:5432/bank";
String debit = "UPDATE account SET balance = balance - ? WHERE id = ?";
String credit = "UPDATE account SET balance = balance + ? WHERE id = ?";
try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
conn.setAutoCommit(false);
try (PreparedStatement d = conn.prepareStatement(debit);
PreparedStatement c = conn.prepareStatement(credit)) {
d.setInt(1, 100); d.setInt(2, 1); d.executeUpdate();
c.setInt(1, 100); c.setInt(2, 2); c.executeUpdate();
conn.commit();
System.out.println("Transfer committed");
} catch (SQLException ex) {
conn.rollback();
System.out.println("Rolled back: " + ex.getMessage());
}
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Padrão de reversão em caso de falha
Esta é a estrutura que você deve memorizar:
- Desative a confirmação automática.
- Execute o trabalho dentro de um
tryinterno. - Em caso de sucesso, chame
commit(). - Em
catch, chamerollback()e lance novamente a exceção ou registre o erro.
Sem a reversão, uma falha poderia deixar o banco de dados parcialmente atualizado.
Simulando a atomicidade
Aqui está a ideia de tudo ou nada, modelada em Java puro para ser executada de forma independente. Aplicamos duas atualizações a um instantâneo; se qualquer uma falhar, restauramos o instantâneo.
public class Main {
public static void main(String[] args) {
int[] balances = {500, 300};
int[] backup = balances.clone();
try {
balances[0] -= 200;
if (balances[0] < 0) throw new IllegalStateException("insufficient funds");
balances[1] += 200;
System.out.println("Commit: " + balances[0] + ", " + balances[1]);
} catch (RuntimeException e) {
balances = backup;
System.out.println("Rollback: " + balances[0] + ", " + balances[1]);
}
}
}Pontos de salvamento
Um ponto de salvamento é um marcador dentro de uma transação. Você pode reverter até ele sem descartar a transação inteira.
Savepoint sp = conn.setSavepoint()conn.rollback(sp)desfaz apenas o trabalho realizado depois desse ponto.
Isso é útil para a recuperação parcial em transações longas.
Níveis de isolamento
O isolamento controla o que uma transação vê do trabalho não confirmado de outra. O JDBC define os níveis por meio de conn.setTransactionIsolation(...):
TRANSACTION_READ_COMMITTED— o padrão mais comum.TRANSACTION_REPEATABLE_READTRANSACTION_SERIALIZABLE— o mais forte e mais lento.
Um isolamento maior evita anomalias, mas reduz a simultaneidade.
Anomalias de leitura
Níveis de isolamento menores podem permitir:
- Leitura suja — visualizar uma alteração não confirmada de outra transação.
- Leitura não repetível — uma linha muda entre duas leituras.
- Leitura fantasma — novas linhas aparecem correspondendo a uma consulta anterior.
Escolha o nível mais baixo que ainda evite as anomalias que sua lógica não pode tolerar.
Restaurar a confirmação automática
Se você obteve a conexão de um conjunto de conexões, restaure o estado original dela antes de devolvê-la.
Depois de uma transação manual, chame conn.setAutoCommit(true) novamente (ou redefina o valor observado ao obter a conexão), para que o próximo usuário não seja surpreendido pelas suas configurações.
Mantenha as transações curtas
Uma transação mantém os bloqueios até ser confirmada ou revertida. Transações longas bloqueiam outro trabalho e aumentam o risco de bloqueios mútuos.
- Não faça chamadas de rede lentas nem solicite ações do usuário dentro de uma transação aberta.
- Reúna os dados primeiro; depois abra, grave e confirme rapidamente.
Transações curtas e focadas são muito mais fáceis de dimensionar.
Verificação rápida
Qual é o efeito de chamar connection.rollback()?
Recapitulação
As transações oferecem segurança de tudo ou nada:
- Desative a confirmação automática com
setAutoCommit(false). - Chame
commit()em caso de sucesso erollback()em caso de falha. - Utilize pontos de salvamento para reversões parciais.
- Ajuste os níveis de isolamento para equilibrar correção e simultaneidade.
- Restaure a confirmação automática antes de devolver uma conexão do conjunto.
Perguntas Frequentes
A aula “Transações” é grátis?
Sim — o texto completo de “Transações” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.
O que vou aprender em “Transações”?
Commit e rollback. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Transações”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.