Tester la connection à une base de donnée

slaut,

comment peut on faire un test dao sans les beans

Tu peux pas etre un peu plus precis s il te plait ?

je veux ecrire des classe testant l'accé à ma base de donnée avant de réaliser les bin (hibenate)
de classe de test DAO??

C est la connexion que tu veux tester ?

Sinon quoi ?

Tu travaille avec quel support ? (Eclipse, Tomcat ...)

je travail avec eclipse ma base est sur sqlserver , j'ai realiser l'arborecense avec maven, les bin seron generer avec hibernate ,
j'ai lu qlq part quil faut realiser les classe de test dao avant la realisation du code Dao.

je commence par testNg je pense que ca marchera,

j'ai commencer par test de connexion :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TestConnection extends TestCase
{
    /**
     *@Testng 
     */
    public void init() {
	try {
	    //Chargement du pilote JDBC
	    Class.forName("com.mysql.jdbc.Driver");
	    //URL de connexion "jdbc:mysql://mabase"
	    String url = "jdbc:mysql://mabase";
	    //Connexion
	    Connection con = DriverManager.getConnection(url,user,passwd);
	    //fermeture de la connexion
	    con.close();
	}
	catch( ClassNotFoundException exp) {
 
	}
	catch(SQLException sqlexp) {
 
	}
    }
 }

est ce que ce test sufie pour tester la connection à une base de donné

Ca devrait.

sinon ajoute une fausse requete sql, et la tu seras certain.

vue que j'ai fait une classe pour être sur des connexions(librairie personnelle),
voici ce que j'ai obtenu :

Code:

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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
package jsl.nolink.db.atome;
 
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
 
import javax.swing.event.EventListenerList;
 
import jsl.nolink.db.atome.event.ConnectionEventListener;
import jsl.nolink.db.atome.event.PiloteEventListener;
import jsl.nolink.db.atome.event.RefreshEventListener;
 
 
/** Outil pour etablir la connexion à une base de données.
 * @author Johann Sorel
 *  Cet outil peut tester la connexion a interval regulier et remplacer la connexion
 *  si besoin, il se charge aussi de communiquer l'etat de la connection, et la mise
 *  a jour sur les elements qui le demande.(ConnectionEventListener)
 */
public class DBConnection implements PiloteEventListener, RefreshEventListener {
 
 
	private EventListenerList	listeners	= new EventListenerList();
 
	private Connection			connex;
	private Connection			oldconnex;
	private Statement			stmt;
 
	private DBPilote				pil;
	private Refreshor			refreshor;
	private long				testrate	= 5000;
	private boolean				DBactif		= false;
	private boolean				actif		= true;
	private boolean				errorreport	= false;
 
 
 
	/**  Outil pour etablir la connexion à une base de données.
         * @param pilote : type DBPilote
         */
	public DBConnection( DBPilote pilote ){
		pil = pilote;
		pil.addPiloteEventListener(this);
		test();
 
		refreshor = new Refreshor();
		refreshor.addRefreshEventListener(this);
		refreshor.setInterval(testrate);
		refreshor.setActif(true);
 
	}
 
 
	/**
         * forcer le test de la connexion, va entrainer la mise a jour
         * de la connexion si necessaire
         */
	public void test(){
		// test de la connection
		if( connex == null || stmt == null ){
			DBactif = false;
			restore();
		}
		else{
			try{
				if( stmt != null ){
					stmt.execute("");
					}
				}
			catch( SQLException e ){
				if( errorreport ){
					System.err.println("DBConnection : " + e);
					//e.printStackTrace();
					}
				DBactif = false;
				restore();
			}
 
		}
 
 
		// mise a jour des objets sous surveillance
		fireConnectionActive(DBactif);
 
		if( connex != null ){
			if( connex != oldconnex ){
				fireConnectionChanged(connex);
			}
		}
 
		oldconnex = connex;
 
 
	}
 
	/**
         * Forcer la mise a jour de la connection meme si celle ci est viable.
         */
	public void restore(){
		try{
			connex = pil.getConnection();
 
			if( connex != null )
				stmt = connex.createStatement();
			DBactif = true;
		}
		catch( Exception e ){
			DBactif = false;
			if( errorreport ){
				System.err.println("Fail DB Connection " + e + ", retrying in : " + testrate / 1000f + " seconds");
				}
		}
	}
 
	/** Afficher ou non les erreurs de connexion dans la console.
         * @param b : boolean
         * Il n'est pas toujours interessant d'avoir le retour, car les tests de 
         * connexion peuvent etre tres rapide et ainsi saturer la console.
         */
	public void setErrorVisible( boolean b ){
		errorreport = b;
	}
 
 
	/** retourne la connexion.
         * @return Connection
         */
	public Connection getConnection(){
		return connex;
	}
 
	/** specifier l'interval de test de la connexion.
         * @param timeinmilli
         */
	public void setTestInterval( long timeinmilli ){
		testrate = (timeinmilli < 100) ? 100 : timeinmilli;
		refreshor.setInterval(testrate);
	}
 
	/** specifier l auto rafraichissement.
         * @param b
         */
	public void setAutoRefresh(boolean b){
		actif = b;
		refreshor.setActif(actif);
	}
 
	/** Changer le pilote pour la connexion.
         * @param pilote
         * ceci entraine une mise a jour de la connexion.
         */
	public void changePilote( DBPilote pilote ){
		pil = pilote;
		restore();
		test();
	}
 
 
	public void piloteUpdated(){
		//System.out.println("pilote update");
		restore();
		//System.out.println("pilote fin eupdate");
	}
 
	public void refresh(){
		//System.out.println("test");
		test();
	}
 
 
 
	/** S ajouter a l ecoute de la connexion.
         * @param con : ConnectionEventLitener
         */
 
	public void addConnectionEventListener( ConnectionEventListener con ){
		listeners.add(ConnectionEventListener.class, con);
		con.connectionActive(DBactif);
		con.connectionUpdated(connex);
	}
 
	/** retirer un element ConnectionEventListener.
         * @param con
         */
	public void removeConnectionEventListener( ConnectionEventListener con ){
		listeners.remove(ConnectionEventListener.class, con);
	}
 
	/** retourne toutes les ConnectionEventListener.
         * @return ConnectionEventListener[]
         */
	public ConnectionEventListener[] getConnectionEventListeners(){
		return listeners.getListeners(ConnectionEventListener.class);
	}
 
	private void fireConnectionChanged( Connection con ){
 
		for( ConnectionEventListener listener : getConnectionEventListeners() ){
			listener.connectionUpdated(con);
		}
	}
 
	private void fireConnectionActive( boolean b ){
 
		for( ConnectionEventListener listener : getConnectionEventListeners() ){
			listener.connectionActive(b);
		}
	}
 
}

puisse ce que tu veux ou même récupère la librairie, j'ai développé plusieurs classe pour les connexions.
http://jsorel.developpez.com/

Salut !
Avant d'aller plus loin, juste un truc que je ne saisis pas :
tu dis "je travail avec eclipse ma base est sur sqlserver "
et ton code contient :
//Chargement du pilote JDBC
Class.forName("com.mysql.jdbc.Driver");

oui désolé je corrige ma base est sur mysql

mon but et de faire des tests DAO

Salut !

ton code contient :
Code:

1 2 3 4 String url = "jdbc:mysql://mabase"; //Connexion Connection con = DriverManager.getConnection(url,user,passwd);
mais tu ne renseignes pas les champs user et passwd
d'autre part tu dois préciser le chemin (url)
exemple :

Code:

String url="jdbc:mysql://localhost:3306/mabase";

essayes ces modifs et tu pourras tester l'accés à la base

Merci les amis.