Je connais les méthodes d'usine et abstraites, mais je veux créer un modèle d'usine DAO en Java.
J'ai vérifié ce lien mais il m'est difficile de comprendre.
Quelqu'un peut-il l'expliquer à l'aide d'un exemple?
Edit: Voici un exemple de modèle DAO tel que je l'ai compris:
public interface UserDAO {
public void insert(User user);
public void update(User user);
public void delete(int userId);
}
La mise en oeuvre:
public class UserDAOImpl implements UserDAO {
@Override
public void delete(int userId) {
// delete user from user table
}
@Override
public User[] findAll() {
// get a list of all users from user table
return null;
}
@Override
public User findByKey(int userId) {
// get a user information if we supply unique userid
return null;
}
@Override
public void insert(User user) {
// insert user into user table
}
@Override
public void update(User user) {
// update user information in user table
}
}
Usine:
public class UserDAOFactory {
public static UserDAO getUserDAO(String type) {
if (type.equalsIgnoreCase("jdbc")) {
return new UserDAOImpl();
} else {
return new UserDAOImpl();
}
}
}
Code côté client:
User user=new User();
user.setName("Jinoy P George");
user.setDesignation("Programmer");
user.setAge(35);
//get a reference to UserDAO object
UserDAO userDAO=UserDAOFactory.getUserDAO("jdbc");
//call insert method by passing user object
userDAO.insert(user);
Ce motif dao est-il correct?
Où dois-je ouvrir la connexion et la fermer?
Ce que vous ne comprenez probablement pas, c'est comment fonctionne le code? Ça semble bien.
Juste FYI:
Ce qui est défini comme UserDAOImpl peut être mieux compris si vous envisagez de le nommer UserDAOMySQLImpl et un autre nouveau en tant que UserDAOMSSQLImpl, et ainsi de suite pour chaque accès à la base de données dont vous pourriez avoir besoin.
Dans chacun de ceux-ci, vous devez gérer les connexions et ajouter d'autres choses comme des fonctions privées pour cette configuration de serveur de base de données spécifique dont il peut avoir besoin et qui ne doit pas forcément être déclarée dans l'interface (UserDAO) mais au minimum, vous devez toujours implémenter toutes les méthodes définies dans l'interface, puis dans les conditions d'usine (UserDAOFactory), vous pourriez avoir quelque chose comme ceci:
"
public class UserDAOFactory{
public static UserDAO getUserDAO(String type){
if (type.equalsIgnoreCase("mysql")){
return new UserDAOMySQLImpl();
}else{
return new UserDAOMSSQLImpl();
}
}
}
Un peu plus clair?
Ensuite, côté client au lieu d'une ligne codée en dur comme:
UserDAO userDAO=UserDAOFactory.getUserDAO("jdbc");
Vous pouvez avoir un fichier de propriétés pour pouvoir basculer entre les DAO dynamiquement, après avoir récupéré cette chaîne dans le fichier de propriétés, vous pouvez simplement faire:
UserDAO userDAO=UserDAOFactory.getUserDAO(myStringFromPropertiesFile);
myStringFromPropertiesFile contiendrait "mysql" ou "mssql" selon la définition de votre fichier de propriétés.
J'espère que cela t'aides!
DAO signifie "Data Access Object". C'est une classe basée sur une interface qui gère toutes vos opérations CRUD avec une base de données relationnelle pour un objet particulier. Voici un exemple qui utilise des génériques:
package persistence;
public interface GenericDao<K extends Serializable, T>
{
public T find(K id);
public List<T> find();
public K save(T value);
public void update(T value);
public void delete(T value);
}
Considérez une usine comme un "constructeur virtuel": sa méthode de création renvoie un type d'interface, mais vous pouvez lui demander de créer autant d'implémentations que nécessaire.