Como ligar uma classe a uma base de dados em Java…

Em Java, a ligação de uma classe a uma base de dados geralmente é feita usando tecnologias de mapeamento objeto-relacional (ORM) ou JDBC.

JDBC (Java Database Connectivity)

JDBC é uma API que fornece uma forma padrão de aceder a bases de dados relacionais. Permite executar consultas SQL a partir de código Java.

Passos:

Carregar o driver da base de dados.
Estabelecer a ligação (Connection).
Criar um objeto Statement ou PreparedStatement.
Executar a consulta SQL.
Processar os resultados (ResultSet).
Fechar os recursos (Connection, Statement, ResultSet).

Exemplo de obtenção de dados:

// Exemplo de obtenção de dados da tabela "users"
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;

try {
    // Carregar o driver (depende da BD)
    Class.forName("org.postgresql.Driver"); // Exemplo para PostgreSQL

    // Estabelecer a ligação
    connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydatabase", "user", "password");

    // Criar Statement
    statement = connection.createStatement();

    // Executar a consulta
    resultSet = statement.executeQuery("SELECT id, name, email FROM users");

    // Processar os resultados
    while (resultSet.next()) {
        int id = resultSet.getInt("id");
        String name = resultSet.getString("name");
        String email = resultSet.getString("email");
        System.out.println("ID de utilizador: " + id + ", Nome: " + name + ", Email: " + email);
    }
} catch (SQLException | ClassNotFoundException e) {
    e.printStackTrace();
} finally {
    // Fechar recursos
    try {
        if (resultSet != null) resultSet.close();
        if (statement != null) statement.close();
        if (connection != null) connection.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

ORM (Mapeamento Objeto-Relacional)

Os frameworks ORM (por exemplo, Hibernate, JPA baseado em Hibernate) automatizam o processo de mapeamento de objetos Java para tabelas de bases de dados e vice-versa. Permitem trabalhar com dados como objetos Java, abstraindo do SQL.

Conceitos principais:

Entity: Classe POJO normal, marcada com anotações especiais, que corresponde a uma tabela na BD.
Anotações: São usadas para descrever as relações entre a classe e a tabela, os campos e colunas, relações entre entidades (um a um, um a muitos, etc.).
EntityManager (JPA) / Session (Hibernate): Interfaces para realizar operações com entidades (guardar, atualizar, eliminar, procurar).

Exemplo de entidade:

// Exemplo de entidade User
import javax.persistence.*;

@Entity // Indica que é uma entidade
@Table(name = "users") // Indica o nome da tabela correspondente
public class User {

    @Id // Indica a chave primária
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Estratégia de geração de ID
    private Long id;

    @Column(name = "name") // Indica o nome da coluna correspondente
    private String name;

    @Column(name = "email", unique = true)
    private String email;

    // Getters, setters, construtores
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Exemplo de guardar uma entidade usando JPA:

// Exemplo de guardar uma entidade User
import javax.persistence.*;

EntityManagerFactory emf = Persistence.createEntityManagerFactory("my_persistence_unit"); // my_persistence_unit do persistence.xml
EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();

try {
    transaction.begin();

    User newUser = new User();
    newUser.setName("John Doe");
    newUser.setEmail("john.doe@example.com");

    em.persist(newUser); // Guardar a entidade

    transaction.commit();
} catch (Exception e) {
    if (transaction != null && transaction.isActive()) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    em.close();
    emf.close();
}

Escolha entre JDBC e ORM:

Característica	JDBC	ORM (JPA/Hibernate)
Complexidade	Baixo nível de abstração, mais código.	Alto nível de abstração, menos código.
Flexibilidade	Controle total sobre SQL.	Flexibilidade limitada para trabalhar diretamente com SQL.
Desempenho	Potencialmente superior com otimizações manuais.	Pode ser menor devido à sobrecarga do ORM.
Tempo de desenvolvimento	Mais tempo em processamento manual de dados.	Menos tempo, automação de muitas tarefas.
Suporte a relações	Requer implementação manual.	Automatizado (um a um, um a muitos).

Em aplicações Java modernas, geralmente usam-se frameworks ORM para trabalhar com bases de dados devido à sua eficiência no desenvolvimento e manutenção. JDBC é usado em casos onde se requer controle total sobre SQL ou quando o ORM não é adequado por alguma razão (por exemplo, otimizações muito específicas).

Como ligar uma classe a uma base de dados em Java?