Accueil / Enterprise / Recherche JNDI vs Injection CDI
Enterprise Intermédiaire

Recherche JNDI vs Injection CDI

Remplace les fragiles recherches JNDI par chaînes par l'injection CDI avec sécurité de types pour les ressources gérées par le conteneur.

Comparaison de Code
✕ Java EE 
public class OrderService {
    private DataSource ds;

    public void init() throws NamingException {
        InitialContext ctx = new InitialContext();
        ds = (DataSource) ctx.lookup(
            "java:comp/env/jdbc/OrderDB");
    }

    public List<Order> findAll()
            throws SQLException {
        try (Connection con = ds.getConnection()) {
            // query orders
        }
    }
}
✓ Jakarta EE 8+ 
@ApplicationScoped
public class OrderService {
    @Inject
    @Resource(name = "jdbc/OrderDB")
    DataSource ds;

    public List<Order> findAll()
            throws SQLException {
        try (Connection con = ds.getConnection()) {
            // query orders
        }
    }
}
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
🔒

Câblage avec sécurité de types

Les erreurs d'injection sont détectées au déploiement, pas à l'exécution via des recherches par chaîne.

🗑️

Sans code répétitif

Élimine la création d'InitialContext, les chaînes de noms JNDI et la gestion de NamingException.

🧪

Testable

Les dépendances sont des champs injectés, facilement remplaçables par des mocks dans les tests unitaires.

Ancienne Approche
Recherche JNDI
Approche Moderne
CDI @Inject
Depuis JDK
11
Difficulté
Intermédiaire
Support JDK
Recherche JNDI vs Injection CDI
Disponible

Disponible depuis Jakarta EE 8 / Java 11

Comment ça fonctionne

Le pattern JNDI traditionnel oblige à utiliser des noms de ressources basés sur des chaînes, à gérer NamingException et à gérer un InitialContext. L'injection CDI avec @Inject (ou @Resource pour les ressources du conteneur) permet au conteneur de connecter les dépendances automatiquement. Les fautes de frappe deviennent des erreurs à la compilation, et les classes sont plus faciles à tester car les dépendances peuvent être injectées directement.

Documentation Associée
Jakarta CDI Specification ↗ Jakarta Annotations — @Resource ↗
Patterns associés
Enterprise Intermédiaire

EJB versus CDI

Java EE
@Stateless
public class OrderEJB {
    @EJB
    private InventoryEJB inventory;

    public void placeOrder(Order order) {
        // container-managed transaction
        inventory.reserve(order.getItem());
    }
}
Jakarta EE 8+
@ApplicationScoped
public class OrderService {
    @Inject
    private InventoryService inventory;

    @Transactional
    public void placeOrder(Order order) {
        inventory.reserve(order.getItem());
    }
}
Survolez pour voir le moderne ➜
JDK 11+ →
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 Intermédiaire

Singleton EJB vs CDI @ApplicationScoped

Java EE
@Singleton
@Startup
@ConcurrencyManagement(
    ConcurrencyManagementType.CONTAINER)
public class ConfigCache {
    private Map<String, String> cache;

    @PostConstruct
    public void load() {
        cache = loadFromDatabase();
    }

    @Lock(LockType.READ)
    public String get(String key) {
        return cache.get(key);
    }

    @Lock(LockType.WRITE)
    public void refresh() {
        cache = loadFromDatabase();
    }
}
Jakarta EE 8+
@ApplicationScoped
public class ConfigCache {
    private volatile Map<String, String> cache;

    @PostConstruct
    public void load() {
        cache = loadFromDatabase();
    }

    public String get(String key) {
        return cache.get(key);
    }

    public void refresh() {
        cache = loadFromDatabase();
    }
}
Survolez pour voir le moderne ➜
JDK 11+ →
Partager 𝕏 🦋 in ⬡