Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Spring Boot Java Discussion :

Quel est l'intérêt d'utiliser @Bean plutôt que @Component


Sujet :

Spring Boot Java

  1. #1
    Membre du Club
    Quel est l'intérêt d'utiliser @Bean plutôt que @Component
    Bonjour,
    En tant que débutant dans l'environnement Spring, je cherche à comprendre les outils fournis par ce framework afin de les utiliser à bon escient. Je n'arrive toujours pas à comprendre pourquoi on utilise @Bean plutôt que @Component !
    @Component semble bien plus simple à mettre en oeuvre que @Bean !
    J'ai fait un test avec le code suivant et je ne vois pas la différence de résultat :
    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
     
    public class MyBean {
        public MyBean(){}
        public String hello(){
            return "Hello I am MyBean";
        }
    }
    @Component
    public class MyComponent {
        public MyComponent(){}
        public String hello(){
            return "Hello I am MyComponent";
        }
    }
    @Service
    public class MyService {
        @Autowired
        MyBean myBean;
        @Autowired
        MyComponent myComponent;
     
        public String helloMyComponent(){
            return myComponent.hello();
        }
     
        public String helloMyBean(){
            return myBean.hello();
        }
    }
    @Configuration
    public class MyConfiguration {
        @Bean
        public MyBean getMyBean(){
            return new MyBean();
        }
    }
    @RestController
    @RequestMapping("/test")
    public class MyController {
     
        @Autowired
        MyService myService;
     
        @GetMapping("/bean")
        public String getHelloBean(){
            return myService.helloMyBean();
        }
     
        @GetMapping("/compo")
        public String getHelloCompo(){
            return myService.helloMyComponent();
        }
    }

  2. #2
    Membre du Club
    Bonjour,

    Que ce soit @Component, @Service ou autres annotations similaires, elles sont toutes des stéréotypes de @Bean qui seront gérés par le container IOC. Mais certains de ces stéreotypes on des particularités qui évitent de combiner d'autres annotations pour le même résultat.

    En bref, c'est "juste" de la simplification mais c'est extrêmement pratique d'utiliser la bonne annotation.

  3. #3
    Membre du Club
    Bonjour,
    Merci pour la réponse, effectivement j'avais compris qu'il s'agissait d'une cascade de spécialisation, par exemple @Configuration et une spécialisation de @Component qui est une spécialisation de @Bean.
    Mais ce n'était pas tout à fait le sens de ma question qui portait plutôt sur l'opportunité d'utiliser @Bean au lieu de @Component et pour le moment j'en suis au constat suivant :
    Sur ses propres composants utiliser @Component qui permet d'utiliser @Autowired directement et sur les composants issus de bibliothèques externes qui eux n'ont pas été définis d'origine avec @Component, utiliser @Bean pour pouvoir les injecter plus tard avec @Autowired, exemple :
    Dans la classe WebSecurityConfig
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    @Configuration
    @EnableWebSecurity
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    ...
    @Bean
    public PasswordEncoder passwordEncoder() {
    	return new BCryptPasswordEncoder();
    }

    Ce qui permettra plus tard dans la classe AuthController :
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    @RestController
    @RequestMapping("/api/auth")
    public class AuthController {
    	...
    	@Autowired
    	PasswordEncoder encoder;

    Est-ce que mon raisonnement est juste ou non ?

  4. #4
    Membre du Club
    C'est un raisonnement qui me semble valable. Il semble d'ailleurs que @Bean soit utilisé la ou il y à un besoin de configuration supplémentaire alors que les autres stéréotypes sont souvent placés directement sur les classes et sont laissées à la bonne gestion du container.

    Votre exemple est donc correct.

  5. #5
    Membre du Club
    Citation Envoyé par gervais.b Voir le message
    C'est un raisonnement qui me semble valable. Il semble d'ailleurs que @Bean soit utilisé la ou il y à un besoin de configuration supplémentaire alors que les autres stéréotypes sont souvent placés directement sur les classes et sont laissées à la bonne gestion du container.

    Votre exemple est donc correct.
    Bonjour,
    Merci pour votre confirmation, elle m'est d'une grande utilité. Je continue d'avancer dans ma découverte et surtout compréhension de Spring. Je travaille actuellement sur l'authentification et plus spécifiquement sur l'utilisation de jetons dans le cadre d'un dialogue avec une application de type Angular ou Android. Il est donc possible que je pose d'autres questions ;-)
    Merci encore

  6. #6
    Membre du Club
    Avec plaisir.

    N'oubliez pas de marquer la question comme résolue si ce n'est pas déjà fait.

###raw>template_hook.ano_emploi###