Discussion :

[revever]

Salut, tout le monde, voici mon problème:

Code :

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

1
2
3
4
5
 
@Entity
class Type{
   ...
}

la table Type correspondante est en fait figée (12 records)

Code :

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

1
2
3
4
5
6
 
@Entity
class Product{
    @ManyToOne
    private Type type;
}

la table Product contient ~500K enregistrements.

Est-ce que Hibernate peut mettre la table Type en cache ou Hibernate va lire la table Type 500K fois pour télécharger tous les products?

Merci à l'avance!

[fr1man]

Tu peux utiliser le cache de niveau 2 et notamment le cache de requêtes pour que tes types ne soient chargés qu'une fois, à la première demande.

[revever]

Tu peux utiliser le cache de niveau 2 et notamment le cache de requêtes pour que tes types ne soient chargés qu'une fois, à la première demande.

Ca a l'air marcher le second-level-cache. Je vais faire des tests. Thxs!

[the last phoenix]

Salut,

Concernant tes tables tu peux preciser le type de chargement.
Par default pour toute association 'toOne' le chargement est de type 'EAGER'.
Donc toute ta table 'Type' sera chargé.
Mais en precisant 'LAZY' pour le fetchType ta table 'Type' ne sera chargé que si et seulement si tu intervient sur celle-ci.

Bon Courage.

[the last phoenix]

Re,

En y reflechissant cette nuit, annote ta classe Type avec @Embedable.

Bon courage.

[revever]

Re,

En y reflechissant cette nuit, annote ta classe Type avec @Embedable.

Bon courage.

Bonne idée! Mais y a deux soucis.

1. Selon le Hibernate doc: "components do not support shared references. In other words, two persons could have the same name, but the two person objects would contain two independent name ojects". Donc au lieu d'avoir 12 instances de Type, on aura 500K enregiestements dans la BDD et 500K instances dans la mémoire.

2. On se limite peut-être si Type est embedable. Disons un jour le Type faut s'étendre comme dessous:

Code :

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

1
2
3
4
5
6
7
 
@Entity
class Type{
      ....//primitive properties of current version 
      Set<Type> compatibleTypes;
      Set<State> supportedStates;
}

[revever]

Tu peux utiliser le cache de niveau 2 et notamment le cache de requêtes pour que tes types ne soient chargés qu'une fois, à la première demande.

ça marche superbe localement mais enfin on a abandonné cette solution. Peut-être nos raisons seront intéressantes pour quelqu'uns:

Notre system est en J2EE, Hibernate est déployé dans le serveur. Quand on teste sur le serveur, les perfomances sont largement améliorés. Mais quand on test chez les clients, l'amélioration n'est pas évidante. Sachant que: temps de reponse chez client=temps de traitement dans le serveur+ temps de transmission sur le réseau dont le temps de transmission est plus important. Malgré on a évité les multi-lectures de BDD avec second-level-cache. Mais les données sont en fait toujour transmises sur le réseau.

Notre solution actuelle:

Code :

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

1
2
3
4
5
6
7
8
9
 
@Entity
class Type{
   ...
}
@Entity
class Product{
    String typeId;
}

Coté client, on a un TypeProxy:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class TypeProxy{
    void initialize(){
         //lire tous les Type et met en cache dans un Map<id, type>
    }
 
    void findType(String typeId){
         return map.get(typeId);
    }
}

chez client, on fait toujour appèl a TypeProxy.

L'intéret est:
1. coté serveur, on a pas du tout besoin de second-level-cache (en fait, l'entité est caché coté client par TypeProxy). Une chose à mentionner ici, dans le second-level-cache d'Hibernate, il ne met pas en cache des objet. Le cache est en fait comme une copie de la BDD:

Code :

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

1
2
{ "id1", "name", "title", "desc" ...}
{ "id2", "name", "title", "desc" ...}

donc chaque fois il reconstitue un instance de Type. C'est moins rapide que map.get(typeId).

2. Il réduit le trafic sur le réseau par qu'il ne transmet que l'id de type.

J'espère c'est aidable.

[revever]

Un peu résumé:

i) si l'entité est figé durant l'application, utiliser Proxy pattern. En plus, on peut changer un peu le Proxy pour que l'utilisateur puisse mettre à jour le Proxy manuellment.

Code :

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

1
2
3
 
/**@param force  if true, re-synchronize; else if not synchronized yet, synchronize. */
void synchronize(boolean force)

ii) si l'entité change pas très frequent mais exige le mis à jour à temp-réel lors la requête chez client, utiliser second-level-cache (batch fetching optionnel).