Discussion :

[Blo0d4x3]

Bonjour, j'aurai besoin dans mon appli qui se connecte a une base de données mysql de créer un evenement lorsque cette connection est faite.
Comment faire pour créer cette evenement?
merci

[adiGuba]

Salut,


Ceci devrait t'aider :
FAQ : Comment créer son propre Listener ?

a++

[professeur]

Salut!

On appelle ce genre ce type de listener un TRIGGER et son implémentation dépend du de ta base de donnée et donc de ton driver.
Cherche avec google "create trigger for database"

[Blo0d4x3]

ok je voi ce que c'est un trigger, mais n'y as t'il pas moyen de faire ca juste en Java pure?

[benwit]

Puisque que tu post dans un forum java, je suppose que ton appli est écrite en java et donc que tu te connectes à ta bdd mysql par un code à peu pres :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
try
	        {
	            // Connexion à ta bdd
	            connexion = ...
	        }
	        catch(SQLException e)
	        {
	            // traitement de l'erreur
	        }
	        finally
	        {
	            // fermer proprement
	            ...
	        }

Normalement, la connexion ne met pas trois heures à s'établir, soit ça réussi, sois une exception est levée ...
Et donc tu le sais rapidement ...

Maintenant, rien ne t'empèche en effet d'essayer plusieurs fois de suite en faisant une boucle :

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
 
while (connexion == null)
{
    try
    {
        // Connexion à ta bdd
        connexion = ...
    }
    catch(SQLException e)
    {
        // traitement de l'erreur
        connexion = null;
    }
    finally
    {
        // fermer proprement
        ...
    }
}

Dans un thread, c'est mieux ...

Maintenant tu veux être avertit quand tu as la connexion :

Tu met ce bout de code (la boucle de connexion) dans la méthode d'une classe qui déclenchera ta connexion.
Appelons cette classe DataBase par exemple :

Code :

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

1
2
3
4
5
6
7
8
 
public class DataBase
{
		public connexion()
		{
			// La boucle de connexion
		}
}

Tu crée ensuite une classe DataBaseEvent qui réprésentera un évènement Base de donnée.

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
 
public class DataBaseEvent
extends      EventObject
{
		public DataBaseEvent(Object source, Connexion connexion)
		{
			 super(source)
			 this.connexion = connexion;
		}
 
		// ... d'autres truc éventuels ...
 
		// Mémoriser la connexion par ex ...
		Connexion connexion;
}

Tu crées une interface DataBaseListener qui sera un écouteur de base de données
et qui doit implémenter par exemple une méthode onConnection(DataBaseEvent e)

Code :

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

1
2
3
4
5
6
7
 
public interface DataBaseListener
{
	  public abstract onConnection(DataBaseEvent e);
 
	  // ... d'autres méthodes éventuelles ...
}

Ensuite, tu enrichis ta classe DataBase qui rappelons le est à la source de l'évènement

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
 
public class DataBase
{
		public connexion()
		{
				// La boucle de connexion
				while (connexion == null)
				{
				    try
				    {
				        // Connexion à ta bdd
				        connexion = ...
 
				        // Avertir les écouteurs enregistrés que la connexion est établi ...
				        fireOpenConnection(connexion);
				    }
				    catch(SQLException e)
				    {
				        // traitement de l'erreur
				        connexion = null;
				    }
				    finally
				    {
				        // fermer proprement
				        ...
				    }
				}
		}
 
		public addDataBaseListener(DataBaseListener listener)
		{
				// Ajout d'un écouteur
			  ...
 
			  dbListeners.add(listener);
		}
 
		public removeDataBaseListener(DataBaseListener listener)
		{
				// Retrait d'un écouteur
			  ...
 
			  dbListeners.remove(listener);
		}
 
		protected void fireOpenConnection(connexion)
		{
				DataBaseListener listener;
				for (...) // Parcourt de la liste des écouteurs
				{
					  listener = dbListeners.get(l);
 
						listener.onConnection(new DataBaseEvent(this, connexion));
				}
		}
 
		// Les écouteurs ...
		private List dbListeners;
}

Ensuite, il suffit que la classe ou tu veut être averti de la connexion implémente l'interface DataBaseListener :

Code :

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

1
2
3
4
5
6
7
8
 
public Surveillant implements DataBaseListener
{
	  public onConnection(DataBaseEvent e)
	  {
	  		// Je suis connecté !!!
	  }
}

... et soit enregistrés auprès de la classe DataBase quelque part dans ton code :

Code :

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

1
2
3
4
5
6
 
DataBase db = new DataBase();
Surveillant s = new Surveillant();
 
db.addDataBaseListener(s);
db.connection();

Voila en gros le squelette que tu adaptes ...
L'objet DataBaseEvent n'est pas obligé de dérivé de EventObject ...
Tu peux même éventuellement t'en passer si tu n'as rien de spécial à transmettre
Quand on a compris le fonctionnement, on fait ce qu'on veux ...

En espérant t'avoir aider.

[Blo0d4x3]

c'est pile ce que je cherche merci. :-D.

Seulement j'ai deux ptites erreurs.

Code :

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

1
2
3
4
5
 
public void addDataBaseListener(DataBaseListener listener)
    {       
         _dbListeners.add(listener);
    }

pour _dbListeners.add(listener); il me sort un warning:
Type safety: The method add(Object) belongs to the raw type List.
References to generic type List<E> should be parameterized

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
 
    public void removeDataBaseListener(DataBaseListener listener)
    {
         _dbListeners.remove(listener);
    } 
 
	private void FireOpenConnection(Connection connexion)
	{
		System.out.println("Fire!!!");
		DataBaseListener listener;
 
		 for (int i = 0; i < _dbListeners.size(); i++) 
         {
            listener = _dbListeners.get(i);
        	DataBaseEvent base = new DataBaseEvent(this, connexion);
 
            listener.OnConnect(base);
         } 
	}

et pour listener = _dbListeners.get(1); il me sort: Type mismatch: cannot convert from Object to DataBaseListener.

[benwit]

Bonjour,

Commençons si tu veux bien par l'erreur "Type mismatch: cannot convert from Object to DataBaseListener"

Dans mon exemple :

Code :

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

private List dbListeners;

dbListeners est une variable d'instance de type List qui contient des Object

Dans la méthode, j'ai oublié le cast (DataBaseListener) qui permet de mettre l'Object retourné par la liste dbListeners dans la variable locale listener de type DataBaseListener:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
	protected void fireOpenConnection(connexion)
	{
	    DataBaseListener listener;
	    for (...) // Parcourt de la liste des écouteurs
	    {
	         listener = (DataBaseListener) dbListeners.get(l);
 
	          listener.onConnection(new DataBaseEvent(this, connexion));
	    }
	}

Je suppose que ta _dbListeners est également une variable d'instance de type List qui contient des Object,
de déclaration :

Code :

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

private List _dbListeners;

et donc si tu rajoutes le cast (DataBaseListener) devant ton
_dbListeners.get(i); ça devrait la corrigé.



Quand au premier avertisssement pour _dbListeners.add(listener); "Type safety: The method add(Object) belongs to the raw type List. References to generic type List<E> should be parameterized",

Cela est dù probablement à deux facteurs :
- les Generics de Java 1.5 d'une part
- et l'erreur précédente d'autre part.

En effet, si tu corriges l'erreur précédente en rajoutant le cast manquant et si tu compiles en Java 1.4, normalement, ça devrait fonctionner car ça fonctionne chez moi.


Ceci étant dit, je reconnais qu'il existe une meilleure solution qui est d'utiliser les nouveautés introduites par Java 1.5 (mea culpa , je n'ai pas encore pris le temps de mis mettre, c'est dur de changer ses habitudes )

En fait, d'après ce que j'ai compris (qu'on me corrige si je me trompe), avec les generics, Java 1.5 t'évite de faire le cast en précisant le type d'objets de la liste.

En déclarant

Code :

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

private List<DataBaseListener> _dbListeners;

tu imposes le type des objets de la liste.

L'instanciation de la liste devient :

Code :

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

_dbListeners = new ArrayList<DataBaseListener>

Et la boucle devient :

Code :

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

1
2
3
4
5
for (DataBaseListener listener : _dbListeners)
{
      DataBaseEvent base = new DataBaseEvent(this, connexion);
      listener.OnConnect(base); 
}

C'est vrai que c'est cool ! (Faut que je m'y mette)

Voilà, j'espère qu'une des solutions fonctionnera de ton coté :
solution 1 : Faire le cast dans la boucle et compiler en 1.4
solution 2 : Utiliser l'emploi des generics et compiler en 1.5


Juste une petite remarque purement subjective pour finir.
J'imagine que tu préfixes la variable _dbListeners d'un _ pour répérer les variables d'instances.
Je ne saurai trop te conseiller (si tu es enclin à suivre des normes qui ne sont rappelons le que purement conventionnelles) de commencer tes méthodes onConnect et fireOpenConnection par des minucules pour mieux les distinguer des classes d'objets qui commencent par convention par une majuscule.

Bon courage pour la suite.

[Blo0d4x3]

Nikel ca marche à la perfection!

J'ai choisi d'utiliser les generics comme je suis sous 1.5, ca pete :-).
Et tu as raison, ca marche comme tu as dit!

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
 
 
_dbListeners = new ArrayList<DataBaseListener>();
....
 
private void fireOpenConnection(Connection connexion)
	{		
        int i = 0;
 
		for (DataBaseListener listener : _dbListeners)  
         {
            listener = _dbListeners.get(i);
        	DataBaseEvent base = new DataBaseEvent(this, connexion);
 
        	i++;
 
            listener.onConnect(base);
         } 
	}

Je ne saurai trop te conseiller (si tu es enclin à suivre des normes qui ne sont rappelons le que purement conventionnelles) de commencer tes méthodes onConnect et fireOpenConnection par des minucules pour mieux les distinguer des classes d'objets qui commencent par convention par une majuscule.

Oui tu as raison!

Je te remercie.

[benwit]

ôtes moi d'un doute ?

tu as essayer ta boucle sans les lignes en commentaire :

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
 
private void fireOpenConnection(Connection connexion)
{      
      // int i = 0;
 
      for (DataBaseListener listener : _dbListeners) 
      {
           // listener = _dbListeners.get(i);
           DataBaseEvent base = new DataBaseEvent(this, connexion);
 
           // i++;
 
          listener.onConnect(base);
      }
}

car l'interet des generic, c'est aussi de faciliter l'écriture des boucles !

normalement, ça devrai marcher seulement comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
 
private void fireOpenConnection(Connection connexion)
{      
      for (DataBaseListener listener : _dbListeners) 
      {
           DataBaseEvent base = new DataBaseEvent(this, connexion);
            listener.onConnect(base);
      }
}

[Blo0d4x3]

En effet ca marche aussi