Discussion :

[AlienQueen]

Bonjour,

Sur le projet sur lequel je viens d'arriver, je constate que tous les controllers Spring contiennent des champs déclarés en tant que variables d'instance et non pas en tant que variables locales de la méthode handleRequestInternal().

Ma question est : ces controllers sont-ils thread-safe ? En d'autre termes, ne risque-t-on pas de mélanger les sessions et les données ?

[julien.dubois]

http://static.springframework.org/sp...ontroller.html

Any implementation of the Controller interface should be a reusable, thread-safe class, capable of handling multiple HTTP requests throughout the lifecycle of an application. To be able to configure a Controller easily, Controller implementations are encouraged to be (and usually are) JavaBeans.

D'après ce que tu dis, ta classe n'a pas l'air d'être thread-safe du tout... Normalement tu ne dois avoir en variable d'instance que d'autres services qui sont importés (au passage, ce ne sont pas forcément tous des singletons!), et pour ce qui concerne les variables utilisées par ta requête en cours, le ModelAndView est là pour ça.

J'ai bien dit "normalement", il y a par exemple la possibilité d'utiliser le "ThrowawayController", qui lui doit avoir un scope "prototype", et qui par sa nature même n'a pas à être thread-safe.

Il faudrait que tu donnes un exemple pour mieux voir ton problème.

[AlienQueen]

Merci de ta réponse ! Je vais te donner un exemple :

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
 
 
public class A extends AbstractController {
 
    private Injected injected;
    private MyOptions myOptions;
 
    @Override
    protected ModelAndView handleRequestInternal(HttpServletRequest servletRequest, HttpServletResponse servletResponse)
            throws Exception {
 
        Map<String, Object> model = new HashMap<String, Object>();
        String backUrl;
        if (monTest) {
            backUrl = "quelquechose";
        } else {
            backUrl = "autre chose";
        }
        model.put("backUrl", backUrl);
 
        String b = "quelque chose d'autre";
        model.put("b", b);
 
        int monInt = this.myOptions.getQuelqueChose();
        model.put("monInt", monInt);
 
        return new ModelAndView("MaPage", model);
    }
 
    @Required
    public void setInjected(Injected injected) {
        this.injected = injected;
    }
 
    @Required
    public void setMyOptions(MyOptions myOptions) {
        this.myOptions = myOptions;
    }
 
}

Alors, dans ce code, ce dont je suis à peu près sûr :

- backUrl et b ne peuvent ne peuvent voir leurs valeurs "confondues" au cours des différentes requêtes puisque ce sont des variables locales

- de même le modèle qui est lui-même local.

Cependant, je m'aperçois que dans nos divers Controller, les variables d'instances sont toutes des valeurs injectées par Spring, comme myOptions et injected dans mon exemple. Et là, je me dis que Spring doit bien faire les choses puisqu'on est obligé de mettre les valeurs injectées en champ d'instance, vu qu'elles sont injectées par setter. Qu'en pense-tu ?

[julien.dubois]

Je suis d'accord avec toi sur toute la ligne! Ton code devrait être bon, à moins qu'il y ait des choses bizarres dans MyOptions par exemple.
Sinon tu peux aussi tester en mode debug, pour que tu sois sûr de ce qu'il se passe.

[AlienQueen]

Si je me mets en mode debug et qu'il y a mélange de session, que suis-je censé voir ? Dois-je tester avec deux navigateurs ?

[julien.dubois]

Oui, tu testes avec deux navigateurs en parallèle, et tu regardes le contenu de tes variables d'instance en "pas à pas". C'est un peu bourrin mais au moins tu es certain que tout fonctionne bien.
Là ton code a l'air OK, mais tu n'en as posté qu'une partie, il y a peut être un ennui ailleurs : c'est donc une manière pour toi de t'assurer.

[AlienQueen]

Hé hé merci beaucoup ! Je vais faire ça.