Mettre en cache JDBC

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour,

j'essaie de mettre en cache des résultats de requêtes SQL, histoire qu'elles soient exécutées moins souvent et que les perf de l'appli soient améliorées.

Tous les accès aux BD sont faits avec JDBC, avec des preparedStatement. Aucun système de persistance est mis en place (c'est pourquoi je veux cacher).

Bref, j'essaye d'utiliser EHCache qui apparemment fait bien son boulot dans ce domaine, mais étant débutant en JEE je rencontre quelques difficultés.

Pour résumé, j'ai mes EJB dans un package dans un jar. J'ai créé un autre package dans ce même jar dans lequel j'ai mis les classes d'implémentation et d'interface de mes caches :
-Cache.java (interface)
-CacheImpl.java
-CacheFactory.java
-ehcache-config.xml

Ça plante à la récupération du cache. J'utilise mon cache comme ça :
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 public ArrayList<String> selectPart(String requete) throws Exception { PreparedStatement psSel = null; ResultSet rs = null; try { checkConnectionBDGdP(); //initialisation du cache (une seule fois) if(cacheInit==false){ CacheFactory.init(Constantes.cachePATH); sqlCachePart = CacheFactory.getCacheInstance("SqlCacheSelectPart"); cacheInit=true; } //on teste si le cache possède la liste recherchée /* if(sqlCachePart.get(requete)!=null){ return (ArrayList<String>) sqlCachePart.get(requete); } //sinon on fait le traitement else{ */ psSel = connBDGdP.prepareStatement(Constantes.SELECT_QUERY); psSel.setString(1, requete); rs = psSel.executeQuery(); ArrayList<String> parts = new ArrayList<String>(); while(rs.next()) { String partie = rs.getString(1); parts.add(partie); } //on place le nouveau couple de valeur dans le cache // sqlCachePart.put(requete, parts); return parts; // }
Mais le log de GlassFish me sort plein d'erreurs.. notamment ces lignes :
Code:

1 2 3 Caused by: net.sf.ehcache.CacheException: Another unnamed CacheManager already exists in the same VM. Please provide unique names for each CacheManager in the config or do one of following: 1. Use one of the CacheManager.create() static factory methods to reuse same CacheManager with same name or create one if necessary 2. Shutdown the earlier cacheManager before creating new one with same name.
Donc comment utiliser correctement EHCache ?
J'ai essayé d'initialiser directement le cache dans la méthode getCacheInstance mais là du coup ça me recréé autant de caches qu'il y a de requêtes..

Des idées ?

Merci !

29/05/2012, 15h17
fxrobin

la partie "init" tu devrais la faire dans la cache Factory et pas dans ta méthode.

montre la factory que je te dise où mettre cette partie.

Voilà le CacheFactory :

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
public class CacheFactory
{
    // instance du CacheManager de EHCache
    private static CacheManager cacheManager;
 
    public static void init(String pathToSetupFileOfEhCache)
    {
       cacheManager = new CacheManager(pathToSetupFileOfEhCache);
       System.out.println("|--- Using EHCache ");
       System.out.println("|--- configuration File :  ehcache-config.xml");
       System.out.println("|--- cache list :  ");
       for(String cacheName : cacheManager.getCacheNames())
       {
         System.out.println("|----- cache : "+cacheName);
       }
    }
 
    public static <K,V> Cache getCacheInstance(String cacheName)
    {
        if (cacheManager==null)
        {
          //init(Constantes.cachePATH);
          throw new RuntimeException("Cache pas initialisé. Utiliser la méthode init(String)");
        }
        else
        {
          return new CacheImpl <K,V> (cacheManager, cacheName);
        }
    }

Je voulais mettre le init là où il est en com, mais si je fais ça GF me sort des milliers de lignes "Cache créé.." qui viennent du constructeur de CacheImpl

remontre CacheImpl

sinon essaye déjà ça, qu'on optimisera plus tard :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public synchronized static <K,V> Cache getCacheInstance(String cacheName) { if (cacheManager==null) { init(Constantes.cachePATH); throw new RuntimeException("Cache pas initialisé. Utiliser la méthode init(String)"); } else { return new CacheImpl <K,V> (cacheManager, cacheName); } }
normalement tu ne dois pas appeler init ailleurs que dans cette méthode.

La voilà.
Elle je n'y ai pas touché

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
public class CacheImpl <K,V> implements cache.Cache <K,V> {
 
    net.sf.ehcache.Cache localCache = null;
    Class valueClass;
 
    public CacheImpl(CacheManager CM, String cacheName)
    {
        //URL url = getClass().getResource("ehcache.xml");
        CacheManager manager = CM;
        String name = "ImplCache_"+cacheName;        
        localCache = manager.getCache(cacheName);
        System.out.println("Cache créé : " + name);
    }
 
    public void putObject(K key, V value) {
        Element wrapperElement = new Element(key,value);
        localCache.put(wrapperElement);
        valueClass = value.getClass();
    }
 
    public V getObject(K key) {
        Element wrapperElement = localCache.get(key);
        return (V) wrapperElement.getObjectValue();
    }
 
    public String getValueClass() {
        return valueClass.getName();
    }
 
    /* méthodes imposées par l'interface Map */
 
    public int size() {
        return localCache.getSize();
    }
 
    public boolean isEmpty() {
        return localCache.getSize() == 0 ? true : false;
    }
 
    public boolean containsKey(Object key) {
        return localCache.isKeyInCache(key);
    }
 
    public boolean containsValue(Object value) {
        return localCache.isValueInCache(value);
    }
 
    public V get(Object key) {
        return this.getObject((K) key);
    }
 
    public V put(K key, V value) {
        this.putObject(key, value);
        return value;
    }
 
    public V remove(Object key) {
        V value = this.getObject((K) key);
        this.localCache.remove(key);
        return value;
    }
 
    public void putAll(Map<? extends K, ? extends V> m) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
 
    public void clear() {
        this.localCache.dispose();
    }
 
    public Set<K> keySet() {
        return new HashSet(this.localCache.getKeys());
    }
 
    public Collection<V> values() {
        List<V> list = new ArrayList<V>(this.size());
        Set<K> keys = this.keySet();
 
        for(K key : keys)
        {
            list.add(this.getObject(key));
        }
 
        return list;
    }
 
    public Set<Entry<K, V>> entrySet() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
/*
    public boolean exists(String r) {
        try{
            localCache.get(r);
            return true;
        }catch(Exception e){
            return false;
        }
    }
 * */
}

29/05/2012, 16h49
fxrobin

tu as essayé le synchronized ?

Normalement l'init ne doit se déclencher qu'une seule fois quand le cacheManager est null.

peux tu aussi montrer ton fichier de configuration EHCACHE ?
29/05/2012, 17h51
fxrobin

Bon, je crois qu'il y a qqs petits bugs dans ce que je t'ai donné et qui datait un peu.

je vais te donner ce qu'il faut ... mais là j'suis occupé, donc plus tard ;)

bon finalement c'est plus rapide que prévu, car j'ai remis la main sur la dernière version de ce que j'avais mis en place pour mon cache.

l'interface :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
package common.cache;
 
import java.util.Map;
 
/**
 *
 * @author FX
 */
public interface Cache <KeyType,ValueType> extends Map <KeyType,ValueType> {
 
    public void putObject(KeyType key, ValueType value);
    public ValueType getObject(KeyType key);
    public String getValueClass();
 
}

la factory

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
 
package common.cache;
 
import net.sf.ehcache.CacheManager;
 
/**
 * Frontal d'accès aux système de cache sous-jacent (EHCACHE)
 * @author FX
 */
public class CacheFactory
{
 
    private static CacheManager cacheManager = new CacheManager(Framework.setupEhCachePath);
 
    static
    {
        System.out.println("|--- Using EHCache ");
        System.out.println("|--- configuration File :  " + Framework.setupEhCachePath);
        System.out.println("|--- cache list :  ");
        for(String cacheName : cacheManager.getCacheNames())
        {
         System.out.println("|----- cache : "+cacheName);
        }
    }
 
    public static <K,V>  Cache getCacheInstance(String cacheName)
    {
        return new CacheImpl <K,V> (cacheName);
    }
 
    public static CacheManager getCacheManager()
    {
 
        return cacheManager;
    }
}

et enfin l'implémentation

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
 
package common.cache;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;
 
/**
 *
 * @author FX
 */
public class CacheImpl <K,V> implements common.cache.Cache <K,V> {
 
    Cache localCache = null;
    Class valueClass;
 
    public CacheImpl(String cacheName)
    {
        CacheManager cm = CacheFactory.getCacheManager();
        localCache = cm.getCache(cacheName);
    }
 
    @Override
    public void putObject(K key, V value) {
        Element wrapperElement = new Element(key,value);
        localCache.put(wrapperElement);
        valueClass = value.getClass();
    }
 
    @Override
    public V getObject(K key) {
        Element wrapperElement = localCache.get(key);
        if (wrapperElement != null) return (V) wrapperElement.getObjectValue();
        else return null;
    }
 
    @Override
    public String getValueClass() {
        return valueClass.getName();
    }
 
    /* méthodes imposées par l'interface Map */
 
    @Override
    public int size() {
        return localCache.getSize();
    }
 
    @Override
    public boolean isEmpty() {
        return localCache.getSize() == 0 ? true : false;
    }
 
    @Override
    public boolean containsKey(Object key) {
        return localCache.isKeyInCache(key);
    }
 
    @Override
    public boolean containsValue(Object value) {
        return localCache.isValueInCache(value);
    }
 
    @Override
    public V get(Object key) {
        return this.getObject((K) key);
    }
 
    @Override
    public V put(K key, V value) {
        this.putObject(key, value);
        return value;
    }
 
    @Override
    public V remove(Object key) {
        V value = this.getObject((K) key);
        this.localCache.remove(key);
        return value;
    }
 
    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
 
    @Override
    public void clear() {
        this.localCache.dispose();
    }
 
    @Override
    public Set<K> keySet() {
        return new HashSet(this.localCache.getKeys());
    }
 
    @Override
    public Collection<V> values() {
        List<V> list = new ArrayList<V>(this.size());
        Set<K> keys = this.keySet();
 
        for(K key : keys)
        {
            list.add(this.getObject(key));
        }
 
        return list;
    }
 
    @Override
    public Set<Entry<K, V>> entrySet() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
 
}

et ça devrait le faire ...
tu noteras une vraie différence de version avec ce que je t'avais un peu trop hâtivement donné ... désolé :oops:

Re !
Oui j'avais essayé avec le synchronized mais rien à faire le cache s'initiait autant de fois qu'il y avait de requêtes.
Avec ce que tu m'as donné là par contre, ça a l'air de marcher !!! :P
Le cache s'initie une seule fois donc tout va bien.

Maintenant j'essaie de cacher les bonnes requêtes mais c'est moins évident de ce que je pensais..

J'ai essayé ça :
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 public ArrayList<String> selectPart(String requete) throws Exception { PreparedStatement psSel = null; ResultSet rs = null; try { checkConnectionBDGdP(); //on récupère l'instance du cache sqlCachePart = CacheFactory.getCacheInstance("SqlCacheSelectPart"); //on teste si le cache possède la liste recherchée if(sqlCachePart.get(requete)!=null){ System.out.println("** Lecture du cache..."); return (ArrayList<String>) sqlCachePart.get(requete); } //sinon on fait le traitement else{ psSel = connBDGdP.prepareStatement(Constantes.SELECT_QUERY); psSel.setString(1, requete); rs = psSel.executeQuery(); ArrayList<String> parts = new ArrayList<String>(); while(rs.next()) { String partie = rs.getString(1); parts.add(partie); } //on place le nouveau couple de valeur dans le cache sqlCachePart.put(requete, parts); return parts;
Déjà le cache est lu des milliers de fois, alors que seules quelques valeurs sont ajoutées dedans (j'ai mis un repère dans la méthode put() de CacheImpl), et puis certaines erreurs me sont données, comme si le cache contenait une mauvais valeur par rapport à celle attendue.

Pourtant cette requête (selectPart) est une des plus appelée de l'appli donc je vais y arriver :aie:
je vais essayer de cacher d'autres requêtes

en tout cas merci une nouvelle fois de ton aide :ccool:

EDIT : en fait je viens de me rendre que selectPart appel essentiellement la requête qui permet de construire un ID donc je vais changer la cible de mon cache :aie:

30/05/2012, 12h59
fxrobin

et ça ressemble à quoi ce qu'il y a dans ta String "requete" ?
30/05/2012, 14h12
VinceSSJ

Ça renvoie le nom d'une requête, et ce nom de requête pointe sur une requête contenue dans la base.. Et la requête la plus appelée (qui correspond à la String requete) c'est REQ_CONSTRID qui est contenue dans une méthode qui a pour rôle de construire des ID à des tâches. Donc c'est cette requête que je vais essayer de cacher en fonction des ID.
Je vais essayer :aie:
30/05/2012, 17h23
fxrobin

:ccool: tu tiens le bon bout :mrgreen:
31/05/2012, 09h50
VinceSSJ

Par contre cette méthode qui construit l'ID est récursive, du coup je n'arrive pas à cacher correctement puisque même les "résultats" intermédiaires sont mis en cache..(du coup j'ai plusieurs valeurs pour la même clé ce qui me fausse évidemment tout)

Donc je me demande, est ce qu'il est préférable de cacher les résultats directement sur les méthodes "sources" ou les méthodes qui appellent justement ces méthodes "sources" ?
31/05/2012, 10h09
fxrobin
il faut de toutes façons que tu discrimines les résultats en fonction d'une clé unique dans le cache ... donc je pense que tu n'as pas le choix.

c'est pour ça que je te demandais plus haut quelle "tête" (si tu avais un exemple pour ma compréhension, ce serait plus simple) avait requete et Constantes.SELECT_QUERY.

je ne sais pas si cela va t'aider, mais par exemple la clé du cache pour être la concaténation de
Code:

1 2 String cle = Constantes.SELECT_QUERY + requete;
c'est juste une idée ;-)

(à faire avec un StringBuilder hein ! :mrgreen: normalement)

Pour selectPart voilà ce que ça me donne pour les 2 éléments :
Code:

1 2 3 4 5 6 7 8 INFO: REQUETE selectPart : REQ_CONSTRID INFO: SELECT_QUERY : Select partie From rMap Where requete = ? Order By ordre INFO: REQUETE selectPart : REQ_CONSTRID INFO: SELECT_QUERY : Select partie From rMap Where requete = ? Order By ordre INFO: REQUETE selectPart : REQ_CONSTRID INFO: SELECT_QUERY : Select partie From rMap Where requete = ? Order By ordre INFO: REQUETE selectPart : REQ_CONSTRID INFO: SELECT_QUERY : Select partie From rMap Where requete = ? Order By ordre
Sachant que REQ_CONSTRID est une requête à rallonge faite en 2 parties et qui va chercher des infos sur un serveur.

Pour la méthode de construction d'ID, voici un exemple de ce qui est entré en paramètre et ce qui est retourné :
Code:

1 2 3 4 5 6 7 8 9 10 INFO: PARAMETRE 21402076 INFO: PARAMETRE 21401112 INFO: PARAMETRE 21401110 INFO: PARAMETRE 21401099 INFO: PARAMETRE 21401098 INFO: RETURN 1- INFO: RETURN 8388609-1- INFO: RETURN 8389616-8388609-1- INFO: RETURN 8389617-8389616-8388609-1-
Et comme tu dis j'ai essayé de faire des clés concaténées :P mais comme la méthode est récursive je me retrouve quand même avec des clés identiques donc faut que je trouve un autre moyen

31/05/2012, 13h36
fxrobin

j'avoue ne pas tout saisir à l'architecture employée

Si j'ai bien compris il y a une première requête SQL qui va chercher en base quelle requête SQL faire dans un second temps. Puis cette requête est lancée avec des paramètres.

tu peux détailler un peu ?

C'est juste histoire de te guider pour savoir où placer (ou pas) la mise en cache et surtout élaborée "la clé" de cache.
31/05/2012, 15h43
VinceSSJ

Oui tout à fait :)
Si j'ai bien compris ça se passe en plusieurs temps.

J'envoie tout ça en MP :)
31/05/2012, 16h21
VinceSSJ

Pouah mais en fait je crois que je vais remonter encore d'un niveau...

Là la méthode getTachesProject est la méthode qui va chercher sur le serveur. Mais celle ci est elle même appelée par la méthode getTaches qui elle récupère juste les tâches du serveur local (et donc elle fait appel à getTachesProject :aie: )
Mais le problème sera toujours là, celui de trouver une bonne clé
31/05/2012, 16h44
fxrobin

tu as hérité d'une "belle" archi dis donc ...:aie::aie::aie:
31/05/2012, 17h00
VinceSSJ

Je sais pas trop comment je dois interpréter ton message là.. :aie::aie::aie::aie::aie::aie::aie:

Mais oui je plutôt du genre chanceux sur ce coup là :lol::aie::aie::aie::aie:

Voir 40 message(s) de cette discussion en une page