@Lookup Annotation in Spring – 在Spring中的@Lookup注释

最后修改: 2018年 4月 13日

1. Introduction


In this quick tutorial, we’ll take a look at Spring’s method-level dependency injection support, via the @Lookup annotation.


2. Why @Lookup?


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.


@Lookup is useful for:


  • Injecting a prototype-scoped bean into a singleton bean (similar to Provider)
  • Injecting dependencies procedurally

Note also that @Lookup is the Java equivalent of the XML element lookup-method.


3. Using @Lookup


3.1. Injecting prototype-scoped Bean Into a Singleton Bean

3.1.将原型范围的Bean注入到Singleton Bean中

If we happen to decide to have a prototype Spring bean, then we are almost immediately faced with the problem of how will our singleton Spring beans access these prototype Spring beans?

如果我们碰巧决定有一个原型Spring Bean,那么我们几乎立刻就会面临这样的问题:我们的单子Spring Bean将如何访问这些原型Spring Bean?

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


First, let’s create a prototype bean that we will later inject into a singleton bean:


public class SchoolNotification {
    // ... prototype-scoped state

And if we create a singleton bean that uses @Lookup:


public class StudentServices {

    // ... member variables, etc.

    public SchoolNotification getNotification() {
        return null;

    // ... getters and setters

Using @Lookup, we can get an instance of SchoolNotification through our singleton bean:


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()); 

Note that in StudentServices, we left the getNotification method as a stub.


This is because Spring overrides the method with a call to beanFactory.getBean(StudentNotification.class), so we can leave it empty.


3.2. Injecting Dependencies Procedurally


Still more powerful, though, is that @Lookup allows us to inject a dependency procedurally, something that we cannot do with Provider.


Let’s enhance StudentNotification with some state:


public class SchoolNotification {
    @Autowired Grader grader;

    private String name;
    private Collection<Integer> marks;

    public SchoolNotification(String name) {
        // ... set fields

    // ... getters and setters

    public String addMark(Integer mark) {
        return this.grader.grade(this.marks);

Now, it is dependent on some Spring context and also additional context that we will provide procedurally.


We can then add a method to StudentServices that takes student data and persists it:


public abstract class StudentServices {
    private Map<String, SchoolNotification> notes = new HashMap<>();
    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);

At runtime, Spring will implement the method in the same way, with a couple of additional tricks.


First, note that it can call a complex constructor as well as inject other Spring beans, allowing us to treat SchoolNotification a bit more like a Spring-aware method.

首先,请注意,它可以调用复杂的构造函数以及注入其他Spring Bean,使我们可以把SchoolNotification处理得更像一个Spring感知的方法。

It does this by implementing getSchoolNotification with a call to beanFactory.getBean(SchoolNotification.class, name).

它通过调用beanFactory.getBean(SchoolNotification.class, name)来实现getSchoolNotification

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:


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));

With this setup, we can add Spring dependencies as well as method dependencies to SchoolNotification.


4. Limitations


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


  • @Lookup-annotated methods, like getNotification, must be concrete when the surrounding class, like Student, is component-scanned. This is because component scanning skips abstract beans.
  • @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.


5. Conclusion


In this quick article, we learned how and when to use Spring’s @Lookup annotation, including how to use it to inject prototype-scoped beans into singleton beans and how to use it to inject dependencies procedurally.


All the code used for this tutorial can be found over on Github.