Spring's Annotation Type Required deprecation












1















Spring's Annotation Type Required is marked as deprecated




Deprecated.
as of 5.1, in favor of using constructor injection for required settings (or a custom InitializingBean implementation)




Same for relevant RequiredAnnotationBeanPostProcessor



But it's not clear what's the replacement, it seems that it should be unavailable.



Is this change prevent us marking method as required unless it's part of constructor method ? to prevent unexpected exceptions on class creation ?










share|improve this question





























    1















    Spring's Annotation Type Required is marked as deprecated




    Deprecated.
    as of 5.1, in favor of using constructor injection for required settings (or a custom InitializingBean implementation)




    Same for relevant RequiredAnnotationBeanPostProcessor



    But it's not clear what's the replacement, it seems that it should be unavailable.



    Is this change prevent us marking method as required unless it's part of constructor method ? to prevent unexpected exceptions on class creation ?










    share|improve this question



























      1












      1








      1


      0






      Spring's Annotation Type Required is marked as deprecated




      Deprecated.
      as of 5.1, in favor of using constructor injection for required settings (or a custom InitializingBean implementation)




      Same for relevant RequiredAnnotationBeanPostProcessor



      But it's not clear what's the replacement, it seems that it should be unavailable.



      Is this change prevent us marking method as required unless it's part of constructor method ? to prevent unexpected exceptions on class creation ?










      share|improve this question
















      Spring's Annotation Type Required is marked as deprecated




      Deprecated.
      as of 5.1, in favor of using constructor injection for required settings (or a custom InitializingBean implementation)




      Same for relevant RequiredAnnotationBeanPostProcessor



      But it's not clear what's the replacement, it seems that it should be unavailable.



      Is this change prevent us marking method as required unless it's part of constructor method ? to prevent unexpected exceptions on class creation ?







      java spring deprecated






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited Nov 18 '18 at 6:58







      user7294900

















      asked Nov 18 '18 at 6:48









      user7294900user7294900

      22.1k113258




      22.1k113258
























          1 Answer
          1






          active

          oldest

          votes


















          2














          There are three ways to inject a bean via annotation:



          Field injection



          @Autowired
          private FooService fooService;


          Setter injection



          private FooService fooService;

          @Autowired
          public void setFooService(FooService fooService) {
          this.fooService = fooService
          }


          Constructor injection (this is the mentioned replacement)



          private final FooService fooService;

          @Autowired
          public MyComponent(FooService fooService) {
          this.fooService = fooService;
          }


          As you can see, the only way to declare your Service final is by using the constructor injection, which replaces the @Required annotation because it forces the user of your class to instantiate it with the required services. The user does not have to be Spring, it could be a simple unit test as well.



          You should use constructor injection for mandatory dependencies and setter injections for optional dependencies instead of field injection.
          Some reasons why:




          • It makes it clear to everybody which dependencies are required

          • It makes testing easier

          • You can make your objects immutable


          Further reading:




          • http://olivergierke.de/2013/11/why-field-injection-is-evil/

          • https://www.vojtechruzicka.com/field-dependency-injection-considered-harmful/

          • https://spring.io/blog/2007/07/11/setter-injection-versus-constructor-injection-and-the-use-of-required/






          share|improve this answer























            Your Answer






            StackExchange.ifUsing("editor", function () {
            StackExchange.using("externalEditor", function () {
            StackExchange.using("snippets", function () {
            StackExchange.snippets.init();
            });
            });
            }, "code-snippets");

            StackExchange.ready(function() {
            var channelOptions = {
            tags: "".split(" "),
            id: "1"
            };
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function() {
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled) {
            StackExchange.using("snippets", function() {
            createEditor();
            });
            }
            else {
            createEditor();
            }
            });

            function createEditor() {
            StackExchange.prepareEditor({
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: true,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: 10,
            bindNavPrevention: true,
            postfix: "",
            imageUploader: {
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            },
            onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            });


            }
            });














            draft saved

            draft discarded


















            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53358568%2fsprings-annotation-type-required-deprecation%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            1 Answer
            1






            active

            oldest

            votes








            1 Answer
            1






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            2














            There are three ways to inject a bean via annotation:



            Field injection



            @Autowired
            private FooService fooService;


            Setter injection



            private FooService fooService;

            @Autowired
            public void setFooService(FooService fooService) {
            this.fooService = fooService
            }


            Constructor injection (this is the mentioned replacement)



            private final FooService fooService;

            @Autowired
            public MyComponent(FooService fooService) {
            this.fooService = fooService;
            }


            As you can see, the only way to declare your Service final is by using the constructor injection, which replaces the @Required annotation because it forces the user of your class to instantiate it with the required services. The user does not have to be Spring, it could be a simple unit test as well.



            You should use constructor injection for mandatory dependencies and setter injections for optional dependencies instead of field injection.
            Some reasons why:




            • It makes it clear to everybody which dependencies are required

            • It makes testing easier

            • You can make your objects immutable


            Further reading:




            • http://olivergierke.de/2013/11/why-field-injection-is-evil/

            • https://www.vojtechruzicka.com/field-dependency-injection-considered-harmful/

            • https://spring.io/blog/2007/07/11/setter-injection-versus-constructor-injection-and-the-use-of-required/






            share|improve this answer




























              2














              There are three ways to inject a bean via annotation:



              Field injection



              @Autowired
              private FooService fooService;


              Setter injection



              private FooService fooService;

              @Autowired
              public void setFooService(FooService fooService) {
              this.fooService = fooService
              }


              Constructor injection (this is the mentioned replacement)



              private final FooService fooService;

              @Autowired
              public MyComponent(FooService fooService) {
              this.fooService = fooService;
              }


              As you can see, the only way to declare your Service final is by using the constructor injection, which replaces the @Required annotation because it forces the user of your class to instantiate it with the required services. The user does not have to be Spring, it could be a simple unit test as well.



              You should use constructor injection for mandatory dependencies and setter injections for optional dependencies instead of field injection.
              Some reasons why:




              • It makes it clear to everybody which dependencies are required

              • It makes testing easier

              • You can make your objects immutable


              Further reading:




              • http://olivergierke.de/2013/11/why-field-injection-is-evil/

              • https://www.vojtechruzicka.com/field-dependency-injection-considered-harmful/

              • https://spring.io/blog/2007/07/11/setter-injection-versus-constructor-injection-and-the-use-of-required/






              share|improve this answer


























                2












                2








                2







                There are three ways to inject a bean via annotation:



                Field injection



                @Autowired
                private FooService fooService;


                Setter injection



                private FooService fooService;

                @Autowired
                public void setFooService(FooService fooService) {
                this.fooService = fooService
                }


                Constructor injection (this is the mentioned replacement)



                private final FooService fooService;

                @Autowired
                public MyComponent(FooService fooService) {
                this.fooService = fooService;
                }


                As you can see, the only way to declare your Service final is by using the constructor injection, which replaces the @Required annotation because it forces the user of your class to instantiate it with the required services. The user does not have to be Spring, it could be a simple unit test as well.



                You should use constructor injection for mandatory dependencies and setter injections for optional dependencies instead of field injection.
                Some reasons why:




                • It makes it clear to everybody which dependencies are required

                • It makes testing easier

                • You can make your objects immutable


                Further reading:




                • http://olivergierke.de/2013/11/why-field-injection-is-evil/

                • https://www.vojtechruzicka.com/field-dependency-injection-considered-harmful/

                • https://spring.io/blog/2007/07/11/setter-injection-versus-constructor-injection-and-the-use-of-required/






                share|improve this answer













                There are three ways to inject a bean via annotation:



                Field injection



                @Autowired
                private FooService fooService;


                Setter injection



                private FooService fooService;

                @Autowired
                public void setFooService(FooService fooService) {
                this.fooService = fooService
                }


                Constructor injection (this is the mentioned replacement)



                private final FooService fooService;

                @Autowired
                public MyComponent(FooService fooService) {
                this.fooService = fooService;
                }


                As you can see, the only way to declare your Service final is by using the constructor injection, which replaces the @Required annotation because it forces the user of your class to instantiate it with the required services. The user does not have to be Spring, it could be a simple unit test as well.



                You should use constructor injection for mandatory dependencies and setter injections for optional dependencies instead of field injection.
                Some reasons why:




                • It makes it clear to everybody which dependencies are required

                • It makes testing easier

                • You can make your objects immutable


                Further reading:




                • http://olivergierke.de/2013/11/why-field-injection-is-evil/

                • https://www.vojtechruzicka.com/field-dependency-injection-considered-harmful/

                • https://spring.io/blog/2007/07/11/setter-injection-versus-constructor-injection-and-the-use-of-required/







                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered Nov 18 '18 at 7:42









                quataxquatax

                11516




                11516






























                    draft saved

                    draft discarded




















































                    Thanks for contributing an answer to Stack Overflow!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid



                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.


                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function () {
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53358568%2fsprings-annotation-type-required-deprecation%23new-answer', 'question_page');
                    }
                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    這個網誌中的熱門文章

                    Xamarin.form Move up view when keyboard appear

                    Post-Redirect-Get with Spring WebFlux and Thymeleaf

                    Anylogic : not able to use stopDelay()