Bonsoir, 

je tente de comprendre le fonctionnement de DAO en réalisant un petit projet.

En gros je tente de mettre en place une bibliothèque en utilisant DAO ainsi que les pattern DAO et MVC dans une application java via netbeans et JDBC. 

j'essaye de faire une méthode qui permet d'ajouter des livres mais malheureusement je ne comprend pas comment résoudre mon problème.

Book:

public class Book {
    
    private int idBook;
    private int idFile;
    private String isbn;
    private String title;
    private String author;
    private String editor;
    private String genre;
    private String type;
    private double refoundPrice;
    private double scoreAverage;
    private boolean ebook;
    private String format;

    public Book() {
    }

    public Book(int idBook, int idFile, String isbn, String title, String author, String editor, String genre, String type, double refoundPrice, double scoreAverage, boolean ebook, String format) {
        this.idBook = idBook;
        this.idFile = idFile;
        this.isbn = isbn;
        this.title = title;
        this.author = author;
        this.editor = editor;
        this.genre = genre;
        this.type = type;
        this.refoundPrice = refoundPrice;
        this.scoreAverage = scoreAverage;
        this.ebook = ebook;
        this.format = format;
    }

    public int getIdBook() {
        return idBook;
    }

    public void setIdBook(int idBook) {
        this.idBook = idBook;
    }

    public int getIdFile() {
        return idFile;
    }

    public void setIdFile(int idFile) {
        this.idFile = idFile;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }


    @Override
    public String toString() {
        return "Book{" + "idBook=" + idBook + ", idFile=" + idFile + ", isbn=" + isbn + ", title=" + title + ", author=" + author + ", editor=" + editor + ", genre=" + genre + ", type=" + type + ", refoundPrice=" + refoundPrice + ", scoreAverage=" + scoreAverage + ", ebook=" + ebook + ", format=" + format + '}';
    }
    
    

    public void addBook(Book a) {
        AbstractDaoFactory factory = AbstractDaoFactory.getFactory();
        DaoBook book = factory.createBookDao();
    }

AbstractDaoFactory:

public abstract class AbstractDaoFactory {
    private static AbstractDaoFactory factory;
    
    public static AbstractDaoFactory getFactory()
    {
        return factory;
    }
    
    public static void setFactory(AbstractDaoFactory factory)
    {
        AbstractDaoFactory.factory = factory;
    }
    

    public abstract DaoBook createBookDao();
}

DaoBook (interface):

public interface DaoBook {
    
    public void addBook(Book b);
    
}

MySqlBookDAO (qui implements DaoBook):

public class MySqlBookDAO implements DaoBook{

    private static MySqlBookDAO instance;
    
    private MySqlBookDAO(){
        
    }    
    
    public static MySqlBookDAO getInstance(){
        if(instance == null)
            instance = new MySqlBookDAO();
        return instance;
    }

    @Override
    public void addBook(Book b) {
        
        
        Connection c = MySqlDaoFactory.getInstance().getConnection();
        PreparedStatement ps = null;
        
        String sql = "INSERT INTO book(idBook, idFile, isbn, title, author, editor, genre, type, refoundPrice, scoreAverage, ebook, format) VALUES (NULL,?,?,?,?,?,?,?,?,?,?,?)";
        
        try{
        ps=c.prepareStatement(sql);
        ps.setInt(1, b.getIdFile());
        ps.setString(2, b.getIsbn());
        ps.setString(3, b.getTitle());
        ps.setString(4, b.getAuthor());
        ps.setString(5, b.getEditor());
        ps.setString(6, b.getGenre());
        ps.setString(7, b.getType());
        ps.setDouble(8, b.getRefoundPrice());
        ps.setDouble(9, b.getScoreAverage());
        ps.setBoolean(10,b.isEbook());
        ps.setString(11, b.getFormat());
        ps.executeUpdate();
        
        
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        finally{
       
        MySqlDaoFactory.closeStatement(ps);
        MySqlDaoFactory.closeConnection(c);
        }
        
    }

Ma page Main:

Book a = new Book(5,3, "fghj","titreTest","auteurtest", "editest", "tst", "roman", 2.50, 0, true, "pdf");
        Book b = new Book();
        b.addBook(a);

Tous cela me renvoie un erreur "Exception in thread "main" java.lang.NullPointerException " et semble indiqué que le problème viens de la page main ou de la méthode addbook de la page Book

1°) Définis ta DAOFactory

AbstractDaoFactory.setFactory(MysqlDaoFactory.getInstance());

Tu l'as peut-être déjà fait dans une partie du code que tu n'as pas postée.

2°) La méthode addBook ne doit pas se trouver dans la classe Book.
Ce n'est pas le livre qui s'ajoute lui-même dans la base de données ; c'est toi qui demandes au DAO d'ajouter un livre.

La méthode doit donc être déclarée uniquement dans l'interface DaoBook et ses implémentations concrètes.

Tu t'en sers comme ça :

Book a = new Book(..., ...);
AbstractDaoFactory factory = AbstractDaoFactory.getFactory();
DaoBook dao = factory.createDaoBook(); // ta méthode s'appelle createBookDao(), mais si tu peux uniformiser les noms c'est mieux
dao.addBook(a);

Tout ça ne nous dit pas pourquoi tu as une NullPointerException. Avec le message d'erreur tu devrais pouvoir trouver la ligne précise qui coince.

Merci pour ta réponse j'ai appliqué tes conseils cependant il semble y avoir un problème:

 le message d'erreur indique "Incompatible type : MySqlDaoFactory cannot be converted to AbstractDaoFactory"

Comme son nom l'indique, MysqlDaoFactory doit être une classe fille de AbstractDaoFactory.
Elle propose une implémentation concrète (en l'occurrence : fournir des DAO qui travaillent avec MySQL) pour les fonctionnalités définies par AbstractDaoFactory.

En clair, il faut que tu changes la déclaration de la classe MysqlDaoFactory.

c'est fait

Par contre netbeans m'indique que je dois implémenter toutes les méthodes abstraites 

Ce que j'ai fait mais je ne comprend pas ce que je dois écrire dans le corps de la méthode:

public class MySqlDaoFactory extends AbstractDaoFactory{
    private static MySqlDaoFactory instance;
    
    private MySqlDaoFactory(){};
    
    public static MySqlDaoFactory getInstance(){
        if(instance==null)
            instance = new MySqlDaoFactory();
        return instance;
    }
    
    public Connection getConnection() {
        String url = "jdbc:mysql://localhost/projetsgbd";
        String user = "root";
        String password = "";
        Connection c = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            c = DriverManager.getConnection(url,user,password);

        } catch (ClassNotFoundException | SQLException cndfe) {
        }
        return c;
    }
    
    public static void closeResultSet(ResultSet rs){
        try{if (rs!=null)rs.close();}
        catch(SQLException e){}
    }
 
        public static void closeStatement(Statement st){
        try{if (st!=null)st.close();}
        catch(SQLException e){}
        
    }    public static void closeConnection(Connection c){
        try{if (c!=null)c.close();}
        catch(SQLException e){}
    }

    @Override
    public DaoBook createBookDao() {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

Ne gère pas les instances MySqlDaoFactory !
Ce sont aussi des instances de AbstractDaoFactory, et c'est la classe AbstractDaoFactory qui s'occupe de gérer l'instance en cours quel que soit son type (MySqlDaoFactory ou autre).

Donc toute cette partie du code doit aller à la poubelle :

private static MySqlDaoFactory instance;

public static MySqlDaoFactory getInstance(){
    if(instance==null)
        instance = new MySqlDaoFactory();
    return instance;
}

Même chose au niveau de MySqlBookDao : tu n'as pas besoin d'accéder à une instance de manière statique. Tu n'y accéderas que par le biais du DaoFactory.

Donc ça aussi va à la poubelle :

private static MySqlBookDAO instance;

public static MySqlBookDAO getInstance(){
    if(instance == null)
        instance = new MySqlBookDAO();
    return instance;
}

Le but du jeu est que ni le code principal que tu exécutes, ni le code de la classe Book ne sachent quel type de DAO ils manipulent (MySqlDao ou autre).
Ils ne les voient qu'au travers des interfaces AbstractDaoFactory (bon ok c'est une classe abstraite, mais au niveau de l'architecture ça se comporte comme une interface) et BookDao.

La méthode abstraite createBookDao doit simplement renvoyer un objet MysqlBookDao.