Accueil / Enterprise / JDBC versus jOOQ
Enterprise Intermédiaire

JDBC versus jOOQ

Remplace le SQL basé sur des chaînes de JDBC brut par le DSL SQL avec sécurité de types et fluide de jOOQ.

Comparaison de Code
✕ Raw JDBC 
String sql = "SELECT id, name, email FROM users "
           + "WHERE department = ? AND salary > ?";
try (Connection con = ds.getConnection();
     PreparedStatement ps =
             con.prepareStatement(sql)) {
    ps.setString(1, department);
    ps.setBigDecimal(2, minSalary);
    ResultSet rs = ps.executeQuery();
    List<User> result = new ArrayList<>();
    while (rs.next()) {
        result.add(new User(
            rs.getLong("id"),
            rs.getString("name"),
            rs.getString("email")));
    }
    return result;
}
✓ jOOQ 
DSLContext dsl = DSL.using(ds, SQLDialect.POSTGRES);

return dsl
    .select(USERS.ID, USERS.NAME, USERS.EMAIL)
    .from(USERS)
    .where(USERS.DEPARTMENT.eq(department)
        .and(USERS.SALARY.gt(minSalary)))
    .fetchInto(User.class);
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
🔒

Colonnes avec sécurité de types

Les noms de colonnes sont des constantes Java générées — les fautes de frappe et types incompatibles deviennent des erreurs de compilation.

📖

Fluidité SQL

Le DSL de jOOQ reflète étroitement la syntaxe SQL, donc les JOINs complexes, sous-requêtes et CTEs restent lisibles.

🛡️

Sans injection par conception

Les paramètres sont toujours liés de façon sécurisée — sans concaténation de chaînes signifie sans risque d'injection SQL.

Ancienne Approche
JDBC brut
Approche Moderne
DSL SQL de jOOQ
Depuis JDK
11
Difficulté
Intermédiaire
Support JDK
JDBC versus jOOQ
Disponible

L'édition open-source de jOOQ supporte toutes les bases de données open-source principales ; les bases de données commerciales anciennes nécessitent une licence payante

Comment ça fonctionne

jOOQ (Java Object Oriented Querying) génère du code Java à partir du schéma de votre base de données, convertissant les noms de tables et colonnes en constantes Java avec sécurité de types. Le DSL fluide reflète la syntaxe SQL pour que les requêtes soient lisibles et composables. Tous les paramètres sont liés automatiquement, éliminant le risque d'injection SQL. Contrairement à JPA/JPQL, jOOQ embrasse pleinement SQL — les fonctions de fenêtre, les CTEs, les clauses RETURNING et les extensions spécifiques aux fournisseurs sont de première classe.

Documentation Associée
jOOQ — Getting Started ↗ jOOQ — DSL API Reference ↗
Patterns associés
Enterprise Intermédiaire

JDBC versus JPA

Java EE
String sql = "SELECT * FROM users WHERE id = ?";
try (Connection con = dataSource.getConnection();
     PreparedStatement ps =
             con.prepareStatement(sql)) {
    ps.setLong(1, id);
    ResultSet rs = ps.executeQuery();
    if (rs.next()) {
        User u = new User();
        u.setId(rs.getLong("id"));
        u.setName(rs.getString("name"));
    }
}
Jakarta EE 8+
@PersistenceContext
EntityManager em;

public User findUser(Long id) {
    return em.find(User.class, id);
}

public List<User> findByName(String name) {
    return em.createQuery(
        "SELECT u FROM User u WHERE u.name = :name",
        User.class)
        .setParameter("name", name)
        .getResultList();
}
Survolez pour voir le moderne ➜
JDK 11+ →
Enterprise Avancé

JDBC ResultSet Mapping vs JPA Criteria API

Java EE
String sql = "SELECT * FROM users"
    + " WHERE status = ? AND age > ?";
try (Connection con = ds.getConnection();
     PreparedStatement ps =
             con.prepareStatement(sql)) {
    ps.setString(1, status);
    ps.setInt(2, minAge);
    ResultSet rs = ps.executeQuery();
    List<User> users = new ArrayList<>();
    while (rs.next()) {
        User u = new User();
        u.setId(rs.getLong("id"));
        u.setName(rs.getString("name"));
        u.setAge(rs.getInt("age"));
        users.add(u);
    }
}
Jakarta EE 8+
@PersistenceContext
EntityManager em;

public List<User> findActiveAboveAge(
        String status, int minAge) {
    var cb = em.getCriteriaBuilder();
    var cq =
        cb.createQuery(User.class);
    var root = cq.from(User.class);
    cq.select(root).where(
        cb.equal(root.get("status"), status),
        cb.greaterThan(root.get("age"), minAge));
    return em.createQuery(cq).getResultList();
}
Survolez pour voir le moderne ➜
JDK 11+ →
Enterprise Intermédiaire

Manual JPA Transaction vs Declarative @Transactional

Java EE
@PersistenceContext
EntityManager em;

public void transferFunds(Long from, Long to,
                          BigDecimal amount) {
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    try {
        Account src = em.find(Account.class, from);
        Account dst = em.find(Account.class, to);
        src.debit(amount);
        dst.credit(amount);
        tx.commit();
    } catch (Exception e) {
        tx.rollback();
        throw e;
    }
}
Jakarta EE 8+
@ApplicationScoped
public class AccountService {
    @PersistenceContext
    EntityManager em;

    @Transactional
    public void transferFunds(Long from, Long to,
                              BigDecimal amount) {
        var src = em.find(Account.class, from);
        var dst = em.find(Account.class, to);
        src.debit(amount);
        dst.credit(amount);
    }
}
Survolez pour voir le moderne ➜
JDK 11+ →
Partager 𝕏 🦋 in ⬡