Mettre en cache JDBC

**VinceSSJ** · 29/05/2012, 15h08

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 :

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
   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 :

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

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 !

**fxrobin** · 29/05/2012, 15h17

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.

**VinceSSJ** · 29/05/2012, 15h24

Voilà le CacheFactory :

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
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

**fxrobin** · 29/05/2012, 15h25

remontre CacheImpl

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

Code :

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

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.

**VinceSSJ** · 29/05/2012, 15h30

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

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
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;
        }
    }
 * */
}

**fxrobin** · 29/05/2012, 16h49

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 ?

**fxrobin** · 29/05/2012, 17h51

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

**fxrobin** · 29/05/2012, 18h01

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 :

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
 
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 :

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
 
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 :

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
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é

**VinceSSJ** · 30/05/2012, 10h39

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 !!!

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 :

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
  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

je vais essayer de cacher d'autres requêtes

en tout cas merci une nouvelle fois de ton aide

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

**fxrobin** · 30/05/2012, 12h59

et ça ressemble à quoi ce qu'il y a dans ta String "requete" ?

**VinceSSJ** · 30/05/2012, 14h12

Ç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

**fxrobin** · 30/05/2012, 17h23

tu tiens le bon bout

**VinceSSJ** · 31/05/2012, 09h50

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" ?

**fxrobin** · 31/05/2012, 10h09

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 :

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

1
2
 
String cle = Constantes.SELECT_QUERY + requete;

c'est juste une idée ;-)

(à faire avec un StringBuilder hein !

normalement)

**VinceSSJ** · 31/05/2012, 11h54

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

Code :

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

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 :

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

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

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

**fxrobin** · 31/05/2012, 13h36

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.

**VinceSSJ** · 31/05/2012, 15h43

Oui tout à fait

Si j'ai bien compris ça se passe en plusieurs temps.

J'envoie tout ça en MP

**VinceSSJ** · 31/05/2012, 16h21

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

)
Mais le problème sera toujours là, celui de trouver une bonne clé