générique DAO en java

Si vous pouvez vivre avec le Printemps, je vais vous suggérer les améliorations suivantes:

• Laissez Printemps faire la gestion des exceptions.
• Utilisation JdbcTemplate au lieu de créer des déclarations préparées à l'avance de vous-même.

Indépendant de l'aide de Printemps, je vous recommande les éléments suivants:

• De ne pas envoyer le nom de la table en tant que paramètre. Cela devrait être fait dans la phase d'initialisation.
• Utiliser une Chaîne sur le paramètre id, car c'est beaucoup plus générique.
• Envisager un retour un objet générique, au lieu d'une collection, car la collection doit toujours contenir qu'un seul objet.

Une amélioration de la AbstractDao avec le Printemps:

import java.util.Collection;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

public abstract class AbstractDao<T> {

    protected final RowMapper<T> rowMapper;

    protected final String findByIdSql;

    protected final JdbcTemplate jdbcTemplate;

    protected AbstractDao(RowMapper<T> rowMapper, String tableName,
            JdbcTemplate jdbcTemplate) {
        this.rowMapper = rowMapper;
        this.findByIdSql = "SELECT * FROM " + tableName + "WHERE id = ?";
        this.jdbcTemplate = jdbcTemplate;
    }

    public  Collection<T> findById(final String id) {
        Object[] params = {id};
        return jdbcTemplate.query(findByIdSql, params, rowMapper);
    }
}

Comme vous le voyez, pas de gestion de l'exception ou de piratage avec la primitive SQL classes. Ce modèles ferme le jeu de résultats pour vous, que je ne peux pas voir dans votre code.

Et la UserDao:

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

public class UserDao extends AbstractDao<User> {

    private final static String TABLE_NAME = "USERS";

    public UserDao(JdbcTemplate jdbcTemplate) {
        super(new UserRowMapper(), TABLE_NAME, jdbcTemplate);
    }

    private static class UserRowMapper implements RowMapper<User> {
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            User user = new User();
            user.setUserName(rs.getString("username"));
            user.setFirstName(rs.getString("fname"));
            user.setLastName(rs.getString("lname"));

            return user;
        }
    }
}

Mise à jour:

Lorsque vous connaissez l'id et l'id correspond à une seule ligne dans la base de données, vous devriez envisager un retour un objet générique, au lieu d'une collection.

public T findUniqueObjectById(final String id) {
    Object[] params = {id};
    return jdbcTemplate.queryForObject(findByIdSql, params, rowMapper);
}

Cela rend votre code plus lisible, puisque vous n'avez pas besoin de récupérer l'utilisateur à partir d'une liste, mais seulement:

User user = userDao.findUniqueObjectById("22");

OriginalL'auteur Espen

C'est ok, mais changer la méthode de

private List<User> convertToList(ResultSet rs)  { 
        List<User> userList= new ArrayList(); 
        User user= new User();; 
        try { 
            while (rs.next()) { 
                user.setId(rs.getInt("id")); 
                user.setUsername(rs.getString("username")); 
                user.setFname(rs.getString("fname")); 
                user.setLname(rs.getString("lname")); 
                user.setUsertype(rs.getInt("usertype")); 
                user.setPasswd(rs.getString("passwd")); 
                userList.add(user); 
            } 
        } catch (SQLException ex) { 
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex); 
        } 

        return userList; 

    } 

à

private List<User> convertToList(ResultSet rs)  { 
        List<User> userList= new ArrayList<User>(); 
        try { 
            while (rs.next()) { 
                User user= new User();
                user.setId(rs.getInt("id")); 
                user.setUsername(rs.getString("username")); 
                user.setFname(rs.getString("fname")); 
                user.setLname(rs.getString("lname")); 
                user.setUsertype(rs.getInt("usertype")); 
                user.setPasswd(rs.getString("passwd")); 
                userList.add(user); 
            } 
        } catch (SQLException ex) { 
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex); 
        } 

        return userList; 

    } 

Objet utilisateur doit être créé à l'intérieur de la boucle while.

OriginalL'auteur Ravindra Gullapalli

Vous avez besoin pour ajouter un espace avant votre clause "where"
voir ci-dessous:

pStmt = cn.prepareStatement("SELECT * FROM "+ tablename+ "WHERE id = ?");

à

 pStmt = cn.prepareStatement("SELECT * FROM "+ tablename+ " WHERE id = ?");

OriginalL'auteur Robert

Même si tout le monde suggère Printemps et son API ici, il utilise les métadonnées et c'est une mauvaise combinaison de code. Donc, n'utilisez pas de générique de DAO ou de Printemps à tous.

Code générique est lourd et ne multipliez votre charge.

OriginalL'auteur srikanth N