@Lookup

scene

In the use of Spring when , This may happen ： A single example of Bean Depending on another non singleton Bean. If you simply use automatic assembly to inject dependencies , There may be some problems , As shown below ：

The singleton Class A

@Component
public class ClassA {
    
 @Autowired
 private ClassB classB;
 
 public void printClass() {
    
  System.out.println("This is Class A: " + this);
  classB.printClass();
 }
}

Not a single case Class B

@Component
@Scope(value = SCOPE_PROTOTYPE)
public class ClassB {
    
  public void printClass() {
    
    System.out.println("This is Class B: " + this);
  }
}

here Class A The default singleton is used scope, And depend on Class B, and Class B Of scope yes prototype, Therefore, it is not a single case , At this time, run a test to see the problem written like this ：

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = {
    ClassA.class, ClassB.class})
public class MyTest {
    
  @Autowired
  private ClassA classA;
 
  @Test
  public void simpleTest() {
    
    for (int i = 0; i < 3; i++) {
    
      classA.printClass();
    }
  }
}

The output is zero ：

This is Class A: ClassA@282003e1
This is Class B: ClassB@7fad8c79
This is Class A: ClassA@282003e1
This is Class B: ClassB@7fad8c79
This is Class A: ClassA@282003e1
This is Class B: ClassB@7fad8c79

You can see , Two kinds of Hash Code It's the same in all three outputs .Class A It is understandable that the value of is unchanged , Because it is singleton , however Class B Of scope yes prototype But also keep Hash Code unchanged , It seems to have become a single case ？

The reason for this is ,Class A Of scope By default singleton, therefore Context Only create Class A Of bean once , So there's only one chance to inject , The container can't give... Every time Class A Offer a new Class B.

A less good solution

To solve the above problems , It can be done to Class A Make some changes , Let it realize ApplicationContextAware.

@Component
public class ClassA implements ApplicationContextAware {
    
  private ApplicationContext applicationContext;
 
  public void printClass() {
    
    System.out.println("This is Class A: " + this);
    getClassB().printClass();
  }
 
  public ClassB getClassB() {
    
    return applicationContext.getBean(ClassB.class);
  }
 
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    
    this.applicationContext = applicationContext;
  }
}

In this way, you can get to... Every time you need it Class B Go manually when Context Find a new one in bean. Run again and get the following output ：

This is Class A: com.devhao.ClassA@4df828d7
This is Class B: com.devhao.ClassB@31206beb
This is Class A: com.devhao.ClassA@4df828d7
This is Class B: com.devhao.ClassB@3e77a1ed
This is Class A: com.devhao.ClassA@4df828d7
This is Class B: com.devhao.ClassB@3ffcd140

You can see Class A Of Hash Code Remain unchanged in three outputs , and Class B But it's different every time , It shows that the problem has been solved , Each call uses a new instance .

But this way of writing is similar to Spring Strong coupling ,Spring Provides another way to reduce invasiveness .

@Lookup

Spring A file named @Lookup Annotations , This is a comment on the method , The method marked by it will be rewritten , Then according to the type of its return value , Container call BeanFactory Of getBean() Method to return a bean.

@Component
public class ClassA {
    
  public void printClass() {
    
    System.out.println("This is Class A: " + this);
    getClassB().printClass();
  }
 
  @Lookup
  public ClassB getClassB() {
    
    return null;
  }
}

You can find a lot of simplicity , And no longer with Spring Strong coupling , Running the test again can still get the correct output .
The return value of the marked method is no longer important , Because the container will dynamically generate a subclass and then rewrite the annotated method / Realization , The final call is the subclass method .

The use of @Lookup The method needs to comply with the following signature ：
<public|protected> [abstract] theMethodName(no-arguments);

ScopedProxyMode

You can also use a proxy by specifying

@Component
@Scope(value = "prototype",proxyMode= ScopedProxyMode.TARGET_CLASS)
public class ClassB {
    
  public void printClass() {
    
    System.out.println("This is Class B: " + this);
  }
}