Créer un événement

Version imprimable

23/02/2006, 19h33
Blo0d4x3

Créer un événement

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
23/02/2006, 19h35
adiGuba

Salut,

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

a++
23/02/2006, 20h10
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"
27/02/2006, 22h33
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?

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:

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:

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:

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:

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:

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:

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:

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:

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.

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

Seulement j'ai deux ptites erreurs.
Code:

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:

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.

Bonjour,

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

Dans mon exemple :

Code:

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:

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:

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 :oops: , je n'ai pas encore pris le temps de mis mettre, c'est dur de changer ses habitudes :roll:)

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:

private List<DataBaseListener> _dbListeners;

tu imposes le type des objets de la liste.

L'instanciation de la liste devient :

Code:

_dbListeners = new ArrayList<DataBaseListener>

Et la boucle devient :
Code:

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.

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:

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); } }
Citation:

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.

ôtes moi d'un doute ?

tu as essayer ta boucle sans les lignes en commentaire :

Code:

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:

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);
      }
}

03/03/2006, 17h52
Blo0d4x3

En effet ca marche aussi