Home / Enterprise / JDBC vs jOOQ
Enterprise Intermedio

JDBC vs jOOQ

Sostituisci il SQL basato su stringhe JDBC con il DSL SQL type-safe e fluente di jOOQ.

Confronto Codice
✕ 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);
Vedi un problema con questo codice? Faccelo sapere.
Perché vince l'approccio moderno
🔒

Colonne type-safe

I nomi delle colonne sono costanti Java generate — i typo e le mancate corrispondenze di tipo diventano errori del compilatore invece di fallimenti runtime.

📖

Fluidità SQL

Il DSL jOOQ rispecchia da vicino la sintassi SQL, così i JOIN complessi, le subquery e i CTE rimangono leggibili.

🛡️

Injection-free by design

I parametri sono sempre legati in modo sicuro — nessuna concatenazione di stringhe significa nessun rischio di SQL injection.

Approccio Vecchio
JDBC grezzo
Approccio Moderno
jOOQ SQL DSL
Dal JDK
11
Difficoltà
Intermedio
Supporto JDK
JDBC vs jOOQ
Disponibile

L'edizione open-source di jOOQ supporta tutti i principali database open-source; i database commerciali più vecchi richiedono una licenza a pagamento

Come funziona

jOOQ (Java Object Oriented Querying) genera codice Java dallo schema del database, trasformando i nomi di tabelle e colonne in costanti Java type-safe. Il DSL fluente rispecchia la sintassi SQL così le query sono leggibili e componibili. Tutti i parametri sono legati automaticamente, eliminando il rischio di SQL injection. A differenza di JPA/JPQL, jOOQ abbraccia pienamente SQL — funzioni finestra, CTE, clausole RETURNING ed estensioni specifiche del vendor sono tutte di prima classe.

Documentazione Correlata
jOOQ — Getting Started ↗ jOOQ — DSL API Reference ↗
Pattern correlati
Enterprise Intermedio

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();
}
Passa il mouse per vedere il moderno ➜
JDK 11+ →
Enterprise Avanzato

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();
}
Passa il mouse per vedere il moderno ➜
JDK 11+ →
Enterprise Intermedio

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);
    }
}
Passa il mouse per vedere il moderno ➜
JDK 11+ →
Condividi 𝕏 🦋 in ⬡