Il Pattern DAO (Data Access Object) in Java

Il pattern DAO (Data Access Object) è un pattern architetturale che viene spesso utilizzato nelle applicazioni Java per separare la logica di accesso ai dati dal resto dell’applicazione. In questo modo, è possibile isolare la logica di accesso ai dati in una classe dedicata, chiamata DAO, che è responsabile della gestione della persistenza dei dati. In questo articolo, vedremo come implementare il pattern DAO utilizzando il linguaggio Java e come utilizzarlo per gestire la persistenza dei dati in una applicazione Java. Per implementare il pattern DAO in Java, è necessario prima di tutto definire una interfaccia DAO che definisca i metodi di accesso ai dati che devono essere implementati dalle classi DAO concrete. Questa interfaccia può essere definita come segue: Senza nome

public interface DAO<T> {
    T get(long id);
    List<T> getAll();
    void save(T t);
    void update(T t);
    void delete(T t);
}

Come si può notare, l’interfaccia DAO definisce i metodi per la lettura, la scrittura, l’aggiornamento e la cancellazione dei dati. In questo modo, qualsiasi classe DAO che implementi l’interfaccia DAO dovrà fornire un’implementazione per questi metodi.

Una volta definita l’interfaccia DAO, è possibile creare la classe DAO concreta che implementa l’interfaccia DAO. La classe DAO concreta deve essere responsabile della gestione della persistenza dei dati, utilizzando il JDBC per accedere al database.

Per implementare il pattern DAO utilizzando il JDBC, è necessario creare una classe DAO che estenda la classe JdbcDaoSupport di Spring JDBC. La classe JdbcDaoSupport semplifica l’accesso al database utilizzando il JDBC, fornendo metodi per l’esecuzione delle query e la gestione delle eccezioni.

public class ProductDAOImpl extends JdbcDaoSupport implements DAO<Product> {
    private static final String SELECT_QUERY = "SELECT * FROM products WHERE id=?";
    private static final String SELECT_ALL_QUERY = "SELECT * FROM products";
    private static final String INSERT_QUERY = "INSERT INTO products (name, price, quantity) VALUES (?, ?, ?)";
    private static final String UPDATE_QUERY = "UPDATE products SET name=?, price=?, quantity=? WHERE id=?";
    private static final String DELETE_QUERY = "DELETE FROM products WHERE id=?";

    @Override
    public Product get(long id) {
        return getJdbcTemplate().queryForObject(SELECT_QUERY, new Object[]{id}, new ProductRowMapper());
    }

    @Override
    public List<Product> getAll() {
        return getJdbcTemplate().query(SELECT_ALL_QUERY, new ProductRowMapper());
    }

    @Override
    public void save(Product product) {
        getJdbcTemplate().update(INSERT_QUERY, product.getName(), product.getPrice(), product.getQuantity());
    }

    @Override
    public void update(Product product) {
        getJdbcTemplate().update(UPDATE_QUERY, product.getName(), product.getPrice(), product.getQuantity(), product.getId());
    }

    @Override
    public void delete(Product product) {
        getJdbcTemplate().update(DELETE_QUERY, product.getId());
    }

    private static class ProductRowMapper implements RowMapper<Product> {
        @Override
        public Product mapRow(ResultSet rs, int rowNum) throws SQLException {
            Product product = new Product();
            product.setId(rs.getLong("id"));
            product.setName(rs.getString("name"));
            product.setPrice(rs.getFloat("price")); product.setQuantity(rs.getInt("quantity")); return product; 
            } 
    } 
}

Come si può notare, la classe ProductDAOImpl implementa l’interfaccia DAO e fornisce un’implementazione per i metodi get, getAll, save, update e delete. Questi metodi utilizzano il JdbcTemplate di Spring JDBC per eseguire le query SQL e mappare i risultati nel oggetto Product.

Per utilizzare la classe ProductDAOImpl, è possibile creare un’istanza della classe e chiamare i metodi dell’interfaccia DAO. Ad esempio, per ottenere un prodotto con id 1, è possibile utilizzare il seguente codice:

DAO<Product> productDAO = new ProductDAOImpl();
Product product = productDAO.get(1);

In questo modo, la classe ProductDAOImpl utilizza il JDBC per eseguire la query SQL e mappare il risultato nel oggetto Product.

In conclusione, il pattern DAO è un pattern architetturale utile per separare la logica di accesso ai dati dal resto dell’applicazione. Utilizzando il JDBC di Spring, è possibile implementare il pattern DAO in modo semplice ed efficace. L’utilizzo del pattern DAO consente di migliorare la modularità e la manutenibilità dell’applicazione Java, semplificando la gestione della persistenza dei dati.