Padrão DAO vs Repository

Publicidade

Se você já se perguntou qual a diferença entre DAO e Repository — ou se chegou a achar que são a mesma coisa — você está no lugar certo.

Essa dúvida é muito comum entre quem está aprendendo arquitetura de software, e hoje a gente vai resolver ela de vez.

Ambos os padrões têm a mesma missão: separar o acesso a dados da lógica de negócio — deixando o código mais organizado, mais limpo e mais fácil de testar.

Mas apesar de parecerem iguais, eles têm diferenças de intenção e contexto que fazem toda a diferença na hora de escolher qual usar no seu projeto. Vamos entender isso com calma.

🔹 1. Entendendo o DAO (Data Access Object)

O padrão DAO é, basicamente, uma camada que encapsula o acesso aos dados.

Em vez de sair colocando comandos SQL soltos no meio do código, a gente cria uma classe responsável só por isso.

Essa classe tem métodos como:

salvarAluno(Aluno aluno)
buscarPorId(int id)
removerAluno(int id)

Ou seja: operações do tipo CRUD (Create, Read, Update, Delete).

A grande vantagem é que a regra de negócio não precisa saber como os dados estão sendo armazenados. Quem se preocupa com banco de dados, driver JDBC, SQL ou qualquer coisa assim… é o DAO.

📌 Em resumo, o DAO:

  • Trabalha direto com banco de dados
  • Cuida das operações básicas de persistência
  • Deixa o restante da aplicação livre de detalhes de implementação
  • Foca mais nos dados em si do que na lógica de negócio

🔸 2. E o Repository, então?

O padrão Repository vai um passo além.

Ele também isola o acesso a dados, mas com foco no domínio da aplicação — ou seja, nos conceitos e regras que fazem sentido no seu sistema.

No Repository, a ideia não é só buscar ou salvar dados. É trabalhar com coleções de objetos do domínio, quase como se fosse uma “memória em tempo real”.

Por exemplo:

alunoRepository.buscarPorMatricula(String matricula)
alunoRepository.listarAlunosAprovados()

Repare que os métodos têm mais a ver com regras da aplicação do que com banco de dados. O Repository já traz um pouco da inteligência do domínio.

📌 Em resumo, o Repository:

  • É comum em projetos com foco em Domain-Driven Design (DDD)
  • Lida com regras mais próximas da realidade da aplicação
  • Trabalha com entidades do domínio, não só com tabelas
  • É mais semântico: reflete o que o sistema faz, não só os dados que tem

⚖️ 3. DAO vs Repository: Qual a diferença na prática?

Muita gente me pergunta:

“Professor, mas no fundo os dois fazem a mesma coisa, né?”

Sim… e não.

Os dois isolam o acesso aos dados.

Mas o DAO olha pro banco. O Repository olha pro domínio.

DAORepository
Foco no banco de dadosFoco no domínio da aplicação
Métodos CRUD genéricosMétodos mais específicos e semânticos
Independente do contextoInserido no contexto do negócio
Mais técnicoMais conceitual

🧠 Uma forma simples de lembrar:

  • DAO: “Preciso salvar esse objeto no banco.”
  • Repository: “Preciso encontrar os alunos aprovados no meu sistema.”

Ambos vão conversar com o banco, mas o Repository conversa com a lógica da aplicação de forma mais expressiva.

🔒 4. Por que separar acesso a dados da lógica de negócio?

Essa parte é muito importante.

A gente separa porque misturar dá ruim.

Quando você coloca regra de negócio junto com código de banco de dados, vira uma salada difícil de manter, testar e evoluir.

Alguns problemas que isso causa:

  • 💥 Se o banco mudar, você tem que sair caçando SQL no código todo
  • ❌ Fica mais difícil de testar, porque você depende de um banco real
  • 🤯 A lógica de negócio fica poluída com comandos que não são dela

Separando as camadas, cada parte faz o que sabe fazer.

A lógica resolve problemas.

O DAO/Repository cuida do armazenamento.

🛠️ Exemplo prático: Salvando um Aluno

Sem separação:

// Mistura lógica com persistência
if (aluno.getNotaFinal() >= 60) {
  Connection conn = DriverManager.getConnection(...);
  PreparedStatement ps = conn.prepareStatement("INSERT INTO aluno VALUES (...)");
  ...
}

Com DAO:

if (aluno.getNotaFinal() >= 60) {
  alunoDAO.salvar(aluno);
}

Com Repository:

if (aluno.estaAprovado()) {
  alunoRepository.adicionar(aluno);
}

Percebe como cada abordagem reflete um nível diferente de abstração?

🛠️ Exercício Guiado: DAO → Repository

Esse exercício te ajudará a entender na prática a diferença entre DAO e Repository, começando por uma implementação CRUD simples e evoluindo para um contexto orientado ao domínio.

🔹 Parte 1 – Criando um DAO básico

Tarefa: Criar uma classe AlunoDAO com métodos CRUD simples para um objeto Aluno.

👇 Classe base:

public class Aluno {
    private String nome;
    private int idade;

    // Construtores, getters, setters...
}

👇 DAO:

public class AlunoDAO {
    private List<Aluno> bancoFalso = new ArrayList<>();

    public void salvar(Aluno aluno) {
        bancoFalso.add(aluno);
    }

    public Aluno buscarPorNome(String nome) {
        for (Aluno aluno : bancoFalso) {
            if (aluno.getNome().equalsIgnoreCase(nome)) {
                return aluno;
            }
        }
        return null;
    }

    public void remover(Aluno aluno) {
        bancoFalso.remove(aluno);
    }

    public List<Aluno> listarTodos() {
        return bancoFalso;
    }
}

✅ Aqui, a lógica está focada apenas no acesso e manipulação dos dados. É puro CRUD.

🔸 Parte 2 – Evoluindo para Repository

Agora vamos mudar a ideia:

“Queremos um repositório que não apenas salve alunos, mas que tenha métodos orientados ao que a aplicação precisa.”

👇 Novo Repository:

import java.util.ArrayList;
import java.util.List;

public class AlunoRepository {
    private List<Aluno> alunos = new ArrayList<>();

    public void adicionar(Aluno aluno) {
        alunos.add(aluno);
    }

    public List<Aluno> listarAprovados() {
        List<Aluno> aprovados = new ArrayList<>();
        for (Aluno aluno : alunos) {
            if (aluno.getNotaFinal() >= 60) {
                aprovados.add(aluno);
            }
        }
        return aprovados;
    }

    public Aluno buscarPorMatricula(String matricula) {
        for (Aluno aluno : alunos) {
            if (aluno.getMatricula().equals(matricula)) {
                return aluno;
            }
        }
        return null;
    }
}

Percebeu?

  • DAO foca em salvar e buscar dados.
  • Repository foca em comportamentos relevantes para o domínio.

🤔 Quando usar cada um?

Use DAO quando:

  • O projeto é simples, sem muitas regras de negócio complexas
  • Você está trabalhando com acesso direto a banco via JDBC ou queries SQL
  • A prioridade é velocidade de desenvolvimento

Use Repository quando:

  • O projeto segue DDD (Domain-Driven Design)
  • As regras de negócio são complexas e precisam ser expressas com clareza
  • Você quer um código mais semântico e próximo da linguagem do negócio

Em projetos pequenos, os dois podem parecer idênticos. A diferença aparece quando o sistema cresce.

✍️ Conclusão

  • DAO e Repository não são rivais. São formas diferentes de resolver o mesmo problema com focos diferentes.
  • DAO é mais técnico, genérico, e voltado para CRUD puro.
  • Repository é mais semântico, integrado ao domínio da aplicação.
  • Em sistemas simples, usar DAO pode ser mais que suficiente.
  • Em sistemas orientados ao domínio, o Repository brilha.

Como sempre falo nas aulas:

O importante é saber o porquê das coisas. Programar é pensar, e arquitetura boa nasce de decisões conscientes, não de modinha.

Se você entender essa diferença e praticar essa separação desde cedo, seu código vai ser mais limpo, testável, fácil de manter e pronto para crescer.

Bons estudos — e continue explorando, com lógica e clareza! 💻🧠

Publicidade