Déconnexion de la base de données au bout de plusieurs heures

**peofofo** · 05/03/2011, 09h40

Bonjour à tous,

J'utilise le pattern DAO pour effectuer la liaison avec ma base mysql.
Tous ce passe bien. Mais si je laisse le pc tourné toute la nuit avec le programme. Le lendemain, le programme fonctionne sans erreur, sauf qu'il ne renvoi plus aucune donnée.

Base utilisée: MYSQL (WAMP SERVEUR)
Architecture de mes classes:
JdbcConnector

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.swing.JOptionPane;
 
public class JdbcConnector {
	/**
         * URL de connection
         */
	private static String url = "jdbc:mysql://localhost/bcsg";
	/**
         * Nom du user
         */
	private static String user = "root";
	/**
         * Mot de passe du user
         */
	private static String passwd = "*****";
	/**
         * Objet Connection
         */
	private static Connection connect;
 
	/**
         * Méthode qui va retourner notre instance
         * et la créer si elle n'existe pas...
         * @return
         */
	public static Connection getInstance(){
		if(connect == null){
			try {
				connect = DriverManager.getConnection(url, user, passwd);
			} catch (SQLException e) {
				JOptionPane.showMessageDialog(null, e.getMessage(), "ERREUR DE CONNEXION ! ", JOptionPane.ERROR_MESSAGE);
			}
		}		
		return connect;	
	}
}

DAOFactory

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class DAOFactory {
	protected static final Connection conn = JdbcConnector.getInstance(); 
 
	/**
     * Retourne un objet Noms interagissant avec la BDD
     * @return
     */
    public static DAO getMembresDAO(){
            return new MembresDao(conn);
    }
    public static DAO getBoissonsDAO(){
        return new BoissonsDao(conn);
    }
    public static DAO getConsommationsDAO(){
        return new ConsommationsDao(conn);
    }
    public static DAO getApprovisionnement_compte_boissonsDAO(){
        return new Approvisionnement_compte_boissonsDao(conn);
    }
    public static DAO getType_paiementDAO(){
        return new Type_paiementDao(conn);
    }
}

DAO

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
public abstract class DAO<T> {
 
    protected Connection connect = null;
 
    /**
     * Constructeur
     * @param conn
     */
    public DAO(Connection conn){
            this.connect = conn;
    }
 
    /**
     * Méthode de création
     * @param obj
     * @return
     */
    public abstract boolean create(T obj);
    /**
     * Méthode de comptage
     * @param obj
     * @return
     */
    public abstract T count();
    /**
     * Méthode pour effacer
     * @param obj
     * @return
     */
    public abstract T count(String champ, String valeur);
    /**
     * Méthode pour effacer
     * @param obj
     * @return
     */
    public abstract int id_max();
    /**
     * Méthode d'envoi de résultats
     * @return
     */
    public abstract boolean delete(int id);
    /**
     * Méthode de mise à jour
     * @param obj
     * @return
     */
    public abstract boolean update(T obj, int id);
    /**
     * Méthode de recherche des informations
     * @param id
     * @return
     */
    public abstract T find(int id);
    /**
     * Méthode d'envoi de résultats
     * @return
     */
    public abstract ArrayList<T> select();
    /**
     * Méthode d'envoi de résultats
     * @return condition champ et valeur
     */
    public abstract ArrayList<T> select(String champ, String valeur, int admin);
}

BoissonsDao (table exemples)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
public class BoissonsDao extends DAO<Boissons> {
 
    public BoissonsDao(Connection conn) {
            super(conn);
    }
 
    public boolean create(Boissons obj) {
            return false;
    }
 
    public boolean delete(int id) {
            return false;
    }
 
    public Boissons find(int id) {
 
    	Boissons noms = new Boissons();                
 
            try {
                    Statement result = this.connect.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
                    PreparedStatement prepare = this.connect.prepareStatement(
                    		"SELECT boissons.id, boissons.ordre, boissons.nom, boissons.doses, boissons.nb_doses, boissons.quantites, boissons.afficher, boissons_prix.prix, boissons_prix.prix_reel, boissons_prix.date" +
                    		" FROM boissons LEFT JOIN boissons_prix ON boissons.id=boissons_prix.id_boissons WHERE boissons.id = ? ORDER BY boissons_prix.id DESC");
                    //On paramètre notre requête préparée
        			prepare.setInt(1, id);
        			//On exécute la requête
        			ResultSet resultat = prepare.executeQuery();
 
                    if(resultat.first())
                    	noms = new Boissons(id, resultat.getInt("ordre"), resultat.getString("nom"), resultat.getInt("doses"), resultat.getInt("boissons.nb_doses"), resultat.getInt("boissons.quantites"), resultat.getInt("boissons.afficher"), resultat.getFloat("prix"), resultat.getFloat("prix_reel"), resultat.getDate("date"));
 
            } catch (SQLException e) {
                    e.printStackTrace();
            }
            return noms;
    }
 
    public ArrayList<Boissons> select() {
    	ArrayList<Boissons>  list_boissons = new ArrayList<Boissons>();// tableau multi-dimensionnel
		try {
            Statement result = this.connect.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
            PreparedStatement prepare = this.connect.prepareStatement(
            		"SELECT boissons.id, boissons.ordre, boissons.nom, boissons.doses, boissons.nb_doses, boissons.quantites, boissons.afficher, boissons_prix.prix, boissons_prix.prix_reel, boissons_prix.date" +
            		" FROM boissons LEFT JOIN boissons_prix ON boissons.id=boissons_prix.id_boissons WHERE boissons_prix.id IS NULL OR boissons_prix.id IN ( SELECT MAX(id) FROM boissons_prix GROUP BY id_boissons)");
 
			//On exécute la requête
			ResultSet resultat = prepare.executeQuery();
			int i=0;
			while(resultat.next()){
				list_boissons.add(i, new Boissons(resultat.getInt("id"), resultat.getInt("ordre"), resultat.getString("nom"), resultat.getInt("doses"), resultat.getInt("boissons.nb_doses"), resultat.getInt("boissons.quantites"), resultat.getInt("boissons.afficher"), resultat.getFloat("prix"), resultat.getFloat("prix_reel"), resultat.getDate("date")));
				i++;
			}
 
	    } catch (SQLException e) {
	            e.printStackTrace();
	    }
		return list_boissons;
    }
 
    public Boissons count() {
 
    	Boissons noms = new Boissons();                
 
            try {
                    Statement result = this.connect.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
                    PreparedStatement prepare = this.connect.prepareStatement("SELECT COUNT(*) FROM boissons");
                    //On exécute la requête
        			ResultSet resultat = prepare.executeQuery();
 
                    if(resultat.next())
                    	noms.setNombre(resultat.getInt(1));
 
            } catch (SQLException e) {
                    e.printStackTrace();
            }
       return noms;
    }
 
    public boolean update(Boissons obj, int id) {
            return false;
    }
 
    public boolean update(int id, int nouvelle_quantite, String operateur) {
    	String operateur_sql = (operateur=="consommation") ? "-" : "+";
    	try {
 		 	this.connect.createStatement();
          	PreparedStatement prepare = this.connect.prepareStatement(
          	"UPDATE boissons SET quantites=`quantites`"+operateur_sql+"? WHERE `id`=?");
          	//On paramètre notre requête préparée
          	prepare.setInt(1, nouvelle_quantite);
          	prepare.setInt(2, id);
 
 
	 		//On exécute la requête
	 		prepare.executeUpdate();
 
	 	 } catch (SQLException e) {
	          e.printStackTrace();
	 	 }
		return false;
    }
 
	@Override
	public int id_max() {
		// TODO Auto-generated method stub
		return 0;
	}
 
	@Override
	public ArrayList<Boissons> select(String champ, String valeur, int admin) {
		// TODO Auto-generated method stub
		return null;
	}
 
	@Override
	public Boissons count(String champ, String valeur) {
		// TODO Auto-generated method stub
		return null;
	}
 
}

Utilisation dans la vue du pattern MVC:
Test.java

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
DAO<Boissons> boissonsDao = DAOFactory.getBoissonsDAO();
		// On compte le nombre de boissons
		System.out.println("\tNombres de membres : "
				+ boissonsDao.count().getNombre());
		// On fait notre recherche
		noms = boissonsDao.select();
		for (int i = 1; i < boissonsDao.count().getNombre() + 1; i++) {
			list_boissons.add(i - 1, new ArrayList<String>());
			list_boissons.get(i - 1).add(0, noms.get(i - 1).getNom());
			list_boissons.get(i - 1).add(1,
					String.valueOf(noms.get(i - 1).getPrix()));
			list_boissons.get(i - 1).add(2,
					String.valueOf(noms.get(i - 1).getAfficher()));
			list_boissons.get(i - 1).add(3,
					String.valueOf(noms.get(i - 1).getOrdre()));
			list_boissons.get(i - 1).add(4,
					String.valueOf(noms.get(i - 1).getId()));
 
		System.out.println("\tBoissons N°" + noms.get(i - 1).getId()
					+ " - Ordre N°" + noms.get(i - 1).getOrdre() + " - NOM : "
					+ noms.get(i - 1).getNom() + " - Dose Ok : "
					+ noms.get(i - 1).getId_dose_ok() + " - Nb de doses : "
					+ noms.get(i - 1).getNb_dose() + " - Quantités : "
					+ noms.get(i - 1).getQuantites() + " - Affichage : "
					+ noms.get(i - 1).getAfficher() + " - Prix : "
					+ noms.get(i - 1).getPrix() + " - Prix reel : "
					+ noms.get(i - 1).getPrix_reel() + " - Date : "
					+ noms.get(i - 1).getDate());
		}

J'obtiens la liste des noms sans problème. Mais si j'attends le lendemain (le pc ce met en veille "sans arrêt de disque") au moment ou je clique sur mon bouton : il ne m'affiche plus les données de la base et ne m'indique pas d'erreur de connexion.
En gros il se connecte toujours a la bdd et ne retourne plus aucun résultat.
Est ce que ça peut venir d'un paramètre de WAMP ? avec une limite de temps.

Si vous avez des idées!
Merci.

**baxou087** · 05/03/2011, 15h39

Bonjour,

Corrige moi si je me trompe, mais a ce que je vois dans le code qui te permet de recuperer les boissons, tu pars du principe que la connexion avec la BDD est deja ouverte (en gros tu n'ouvres la connexion qu'une seule fois et la ferme qu'une seule fois (en supposant que tu la fermes effectivement et que tu ne compte pas sur l'arret du programme pour le faire a ta place)).

Si tu pars bien de ce principe, il est normal que si la connexion plante, tu ne puisse plus l'utiliser.

Une solution pour resoudre ton probleme serait d'ouvrir la connexion a chaque fois que tu as besoin d'effectuer une requete et de la fermer tout de suite apres.

Il se peut que ca te donne l'impression de perdre en performances, cependant cette methode est beaucoup plus propre.

PS : desole pour les fautes d'accentuation, mais qwerty oblige

**peofofo** · 05/03/2011, 17h42

Bonsoir Baxou087

Tu as complètement raison

J'ai corrigé toutes mes requêtes.
Je vais faire le test pour demain.

Merci pour ton aide,

Pour info j'ai ajouté:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
prepare.close();// PreparedStatement
state.close();// Statement

**baxou087** · 05/03/2011, 17h58

Je t'en prie.

Si ca marche, n'oublie pas de mettre le post en resolu, sinon n'hesite pas a exposer ton probleme.

PS : toujours en qwerty

**yotta** · 05/03/2011, 21h25

Avez-vous vérifié que la mise en veille de votre système n'entraîne pas l'arrêt de votre carte réseau ?
Elles aussi supportent aujourd'hui la notion d'économie d'énergie, et j'ai déja pu voir à plusieurs reprises des personnes se faire piéger parce que leur carte réseau se mettait tout simplement en veille. C'est surtout le cas avec l'usage de contrôleurs wifi généralement intégré dans les ordinateurs portable friands d'économie d'énergie.

**baxou087** · 05/03/2011, 23h00

Cela pourrait en effet etre le cas, mais encore faut-il que son serveur de base de donnees ne se trouve pas sur la meme machine. Et dans le cas ou le SGBD est en local la carte reseau n'a aucun impact.

De toute facon en ouvrant une connexion uniquement lorsque cela est necessaire il evitera le probleme que vous soulevez, puisque la connexion sera fermee des que le traitement sera termine.

Du coup la connexion ne pourra plus planter en cas de mise en veille de la carte reseau puisque cette meme connexion n'existera plus a ce moment la.

**peofofo** · 06/03/2011, 13h15

Merci pour vos réponses.

J'ai essayé de fermé la connexion après chaque requête.

L'application est devenu beaucoup plus lourde et lente.
Jusqu'à saturation par l'erreur "too many connections".

Je regarde comment laisser une seule connexion effective et s'il est plus valide (alors on se reconnecte).

Mais pour le moment je cherche la solution pour connaître l'état de connexion.
Je vais laisser la machine tourné, je regarderai demain.

**baxou087** · 06/03/2011, 13h33

Bonjour,

Par simple curiosite, est-ce que tu fermes la connexion apres chaque requete?

Ce que j'entends par la c'est que chaque methode qui communique avec la base doit etre sous cette forme :

1- ouverture de la connexion a la base
2- traitement de la requete et de son resultat
3- fermeture de la connexion
4- finir la methode

Si tu ne fermes pas la connexion il est pas etonnant que tu aies cette saturation au niveau des connexions ouvertes

**sinok** · 06/03/2011, 15h56

Accessoirement, pour que des statements, resultsets et connexions soient fermés proprement, il faut que ce soit fait dans la clause finally du bloc try.

cf http://java.developpez.com/faq/jdbc/...tureConnection

**yotta** · 07/03/2011, 01h12

Vous avez raison baxou087, mea culpa, je n'avais pas lu assez attentivement les premières lignes de code du poste, et effectivement, le code tourne en localhost, donc que la carte réseau se mette en veille ou pas dans ce cas n'a aucune incidence.

Par contre, j'ai remarqué que dans votre méthode getInstance vous vérifiez seulement que connect n'est pas null, ne suffirait-il pas d'ajouter un test qui vérifierait en plus qu'il est toujours connecté, et dans le cas contraire, le reconnecterait ?

**peofofo** · 17/03/2011, 09h06

Merci à tous pour vos réponses.

Désolé de ne pas avoir pu répondre plus tôt, j'étais parti en vacance.

J'ai trouvé la solution. Il m'a suffit de fermer mes requêtes. La connexion à la base je la laisse ouverte, et avec une simple condition, je réactualise la connexion grâce à connect.isClosed() : (cela évite de ré ouvrir la connexion a chaque requêtes)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static Connection getInstance(){
		try {
			if(connect == null || connect.isClosed()){
				try {
					connect = DriverManager.getConnection(url, user, passwd);
					System.out.println("Connection : "+connect);
				} catch (SQLException e) {
					JOptionPane.showMessageDialog(null, e.getMessage(), "ERREUR DE CONNEXION ! ", JOptionPane.ERROR_MESSAGE);
				}
			}
		} catch (HeadlessException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}		
		return connect;	
	}

Déconnexion de la base de données au bout de plusieurs heures

JDBC Java

Vue hybride

Discussions similaires

Partager

Partager