Spring @Lookup

红太狼 2024-03-25 20:39 120阅读 0赞

A method annotated with `@Lookup` tells Spring to return an instance of the method’s return type when we invoke it. Essentially, Spring will override our annotated method and use our method’s return type and parameters as arguments to `BeanFactory#getBean(AAA.class)`.

--------------------

### How will our singleton Spring beans access prototype Spring beans? ###

`Provider is certainly one way, though @Lookup is more versatile in some respects.`

@Component
    @Scope("prototype")
    public class SchoolNotification {
        
        // ... prototype-scoped state
    }
    
    @Component
    public class StudentServices {
        
        // ... member variables, etc.
        @Lookup
        public SchoolNotification getNotification() {
        
            return null;
        }
        // ... getters and setters
    }
    
    @Test
    public void whenLookupMethodCalled_thenNewInstanceReturned() {
        
        // ... initialize context
        StudentServices first = this.context.getBean(StudentServices.class);
        StudentServices second = this.context.getBean(StudentServices.class);
           
        assertEquals(first, second); 
        assertNotEquals(first.getNotification(), second.getNotification()); 
    }

--------------------

### Injecting Dependencies Procedurally, something that we cannot do with Provider. ###

@Component
    @Scope("prototype")
    public class SchoolNotification {
        
        private String name;
        private Collection<Integer> marks;
    
        public SchoolNotification(String name) {
        
            // ... set fields
        }
    
        // ... getters and setters
    
        public String addMark(Integer mark) {
        
            this.marks.add(mark);
        }
    }
    
    public abstract class StudentServices {
        
        private Map<String, SchoolNotification> notes = new HashMap<>();
     
        @Lookup
        protected abstract SchoolNotification getNotification(String name);
    
        public String appendMark(String name, Integer mark) {
        
            SchoolNotification notification = notes.computeIfAbsent(name, exists -> getNotification(name)));
            return notification.addMark(mark);
        }
    }

First, We treat *`SchoolNotification`* a bit more like a Spring-aware method. It does this by implementing *`getSchoolNotification`* with a call to *`beanFactory.getBean(SchoolNotification.class, name)`*.

Second, we can sometimes make the *`@Lookup`* annotated method abstract, like the above example.  
Using abstract is a bit nicer-looking than a stub, but we can only use it when we don’t **`component-scan`** or **`@Bean-manage`** the surrounding bean:

@Test
    public void whenAbstractGetterMethodInjects_thenNewInstanceReturned() {
        
        // ... initialize context
    
        StudentServices services = context.getBean(StudentServices.class);    
        assertEquals("PASS", services.appendMark("Alex", 89));
        assertEquals("FAIL", services.appendMark("Bethany", 78));
        assertEquals("PASS", services.appendMark("Claire", 96));
    }

### Limitations ###

Despite @Lookup‘s versatility, there are a few notable limitations:

1、@Lookup-annotated methods, like *`getNotification`*, must be concrete when the surrounding class is ***`component-scanned`***. This is because `component scanning skips abstract beans`.  
2、@Lookup-annotated methods won’t work at all when the surrounding class is ***`@Bean-managed`***.

In those [circumstances][], if we need to inject a prototype bean into a singleton, we can look to Provider as an alternative.

--------------------

**参考：[@Lookup Annotation in Spring][Lookup Annotation in Spring]**

[circumstances]: https://dict.youdao.com/w/circumstances/#keyfrom=dict2.top
[Lookup Annotation in Spring]: https://www.baeldung.com/spring-lookup