Spring @Autowire与getBean（className）的性能

Question

There are two variants of code:

public class MyClass {
 public void myMethod() {
  AnotherClass object = SpringContexHolder.getContext().getBean(AnotherClass.class);
  object.doSomething();
 }
}

@Component
public class MyClass {
@Autowired
AnotherClass object;     

public void myMethod() {
 object.doSomething();
}
}

Will there be any performance penalties in the first variant (by the way in the first place it's not spring bean, just simple class)? Does Autowiring do the same as getBean?

PS I think I should expand my question a little. The situation is that team I joined uses Spring injection in the project only via getBean(className). The reason I guess is that most of project classes already written are not Spring beans and using autowiring in one class means usually making dependent class bean as well and so on until most of the classes become beans...

Ok, I think I understand testability penalties and overall lacking of code-style of such an approach. But isn't there a perfomance penalty alsо? Isn't there difference between performance of ready-to-go Spring singleton that is constructed on startup with all it's fields autowired and invoking getBean(classname) (afaik several times slower then pure hashmap.get(object)) from non-spring non-singleton class (ecpecially in critical places)?

PSS I created smth like mini-benchmark (I understand that it's hard to get real info because of work of GC, JIT and so on but nevertheless...). My results are (the bigger numbers - the worse): Autowiring time - 193, GetBean time - 2161, Method in the same class - 173, Static method in another class - 206

Answer 1

IMO, you shouldn't use any of this. As some users already mentionned in comments, you shouldn't take care of performances. But for testability, use constructor based injection (and the @Autowired is implicit) :

@Component
public class MyClass {

  private final AnotherClass object;     

  public MyClass(AnotherClass object) {
    this.object = object;
  }
}

Answer 2

It's going to be inefficient to lookup a bean in the Spring context (which is often composite) every time you need to access it. You're essentially looking up an item in multiple hash tables multiple times, thrashing the CPU cache, wasting time and potentially preventing other optimization like inlining due to a more complex execution path.

Definitely use autowiring (annotation-based or constructor-based). That way the lookup is done once at application startup, and after that the class is accessed via a direct reference.

Testability is perfectly fine even with the @Autowired annotation. You simply autowire mocks instead of actual objects. Also look into Mockito and Spring-Test annotations to inject mocks and otherwise augment the Spring context for testing purposes.