Uploaded image for project: 'Spring Framework'
  1. Spring Framework
  2. SPR-5192

@LookupMethod annotation for use with component scanning

    Details

    • Type: New Feature
    • Status: Closed
    • Priority: Major
    • Resolution: Complete
    • Affects Version/s: None
    • Fix Version/s: 4.1 RC2
    • Component/s: Core
    • Labels:
      None
    • Last commented by a User:
      false

      Description

      I have recently started some work on an @LookupMethod annotation to be used in the following situation:

      • A prototype scoped bean needs to be used within a singleton
      • The singleton was created using component scanning

      Currently the most obvious solution would be to forgo component scanning for the singleton and define the lookup-method in the ApplicationContext XML or using spring-java-config, e.g:

      <!-- this could also be created using component scanning -->
      <bean id="myPrototype" class="sample.MyPrototype" scope="prototype"/>
       
      <bean id="mySingleton" class="sample.MySingleton">
        <lookup-method name="createMyPrototype" bean="myPrototype"/>
      </bean>
      

      However, since I've been using component scanning with 2.5, it doesn't feel right defining the wiring outside of the components, and it would be ideal if we could do something like the following:

      @Component
      public abstract class MySingleton {
         @LookupMethod(beanRef = "myPrototype")
         protected abstract MyPrototype createMyPrototype();
      }
       
      @Component
      public class MyPrototype {}
      

      It would be even better if @LookupMethod could work in conjunction with autowiring (by type), but that can be a subsequent feature request.

      I've started to implement a solution and will attach shortly.

      1. LookupMethod.java
        0.3 kB
        Casey Butterworth
      2. LookupMethod.java
        0.4 kB
        Casey Butterworth
      3. LookupMethodAnnotationBeanPostProcessor.java
        2 kB
        Casey Butterworth

        Issue Links

          Activity

          Hide
          dma_k Dmitry Katsubo added a comment -

          I would vote for @Autowired to work for such lookup methods naturally, so there is no need to introduce new annotation (@LookupMethod):

          @Autowired
          protected MyPrototype createMyPrototype() { ... }

          Show
          dma_k Dmitry Katsubo added a comment - I would vote for @Autowired to work for such lookup methods naturally, so there is no need to introduce new annotation ( @LookupMethod ): @Autowired protected MyPrototype createMyPrototype() { ... }
          Hide
          afansky Alexey Fansky added a comment -

          So are there any solutions for this?

          Show
          afansky Alexey Fansky added a comment - So are there any solutions for this?
          Hide
          pwebb Phil Webb added a comment -

          Generally the preferred solution with this type of problem is to use the javax.inject.Provider interface from JSR-330. It tends to result in clearer code and removes the need to throw the UnsupportedOperationException.

          public class MySingleton {
           
            @Autowired
            private Provider<MyPrototype> myPrototype;
           
            public void operation() {
              MyPrototype instance = myPrototype.get();
              // do something with the instance
            }
           
          }

          Show
          pwebb Phil Webb added a comment - Generally the preferred solution with this type of problem is to use the javax.inject.Provider interface from JSR-330. It tends to result in clearer code and removes the need to throw the UnsupportedOperationException. public class MySingleton {   @Autowired private Provider<MyPrototype> myPrototype;   public void operation() { MyPrototype instance = myPrototype.get(); // do something with the instance }   }
          Hide
          juergen.hoeller Juergen Hoeller added a comment - - edited

          I'm considering this for 4.1 still, following up on the work in SPR-11235 and SPR-7431. It is actually quite straightforward to implement, even nicer with a by-type lookup option if no bean name has been specified... and can easily support arguments for factory methods or constructors as well.

          Juergen

          Show
          juergen.hoeller Juergen Hoeller added a comment - - edited I'm considering this for 4.1 still, following up on the work in SPR-11235 and SPR-7431 . It is actually quite straightforward to implement, even nicer with a by-type lookup option if no bean name has been specified... and can easily support arguments for factory methods or constructors as well. Juergen
          Hide
          juergen.hoeller Juergen Hoeller added a comment -

          Finally introduced as @Lookup annotation, matching by the method's return type or by a specified bean name (if any), and supporting arguments as well.

          Juergen

          Show
          juergen.hoeller Juergen Hoeller added a comment - Finally introduced as @Lookup annotation, matching by the method's return type or by a specified bean name (if any), and supporting arguments as well. Juergen

            People

            • Assignee:
              juergen.hoeller Juergen Hoeller
              Reporter:
              casey.butterworth Casey Butterworth
              Last updater:
              St├ęphane Nicoll
            • Votes:
              37 Vote for this issue
              Watchers:
              35 Start watching this issue

              Dates

              • Created:
                Updated:
                Resolved:
                Days since last comment:
                46 weeks, 4 days ago