Spring injects @Autowired fields during manual class instantiation

Question

In my project I am surprised to see that Spring (4.3) seems to attempt to autowire dependencies for classes even when they are manually instantiated.

MyClass.java (note Lombok annotations):

@NoArgsConstructor
@AllArgsConstructor
public class MyClass {
    @Autowired
    private MyClassDependency dependency;
}

MyClassDependency.java uses a factory method and no Spring annotations:

public class MyClassDependency {
    public static MyClassDependency create() { return new MyClassDependency(); }
}

Spring config resulting in NoSuchBeanDefinitionException:

@Configuration
public class SpringConfig {
    @Bean
    public MyClass myClass() {
        return new MyClass(MyClassDependency.create());
    }
}

Providing the bean makes Spring happy:

@Configuration
public class SpringConfig {
    @Bean
    public MyClass myClass() {
        return new MyClass(); // let autowire inject dependencies
    }
    @Bean
    public MyClassDependency myClassDependency() {
        return MyClassDependency.create();
    }
}

This was a big surprise to me. I'd like to have the simpler first version of the config... Where is this behavior coming from / controlled? (It's possible that I missed it or pulled it from some dependencies).

PS: To clarify, MyClass code is outside of my control but I can change Spring config. I am looking to understand how Spring intercepts the constructor call withing a bean method and whether constructor can be used instead.

Answer 1

The problem is the following:

1. You annotated a field with @Autowired - that tells Spring, that there is a dependency that needs to be injected there
2. You annotated a method with @Bean - which puts the return value into Spring's context.
3. When Spring processes the return value of the @Bean-annotated object, it starts to proces its annotations - and there is a field with an annotation, that tells Spring to inject a dependency there, even if the field already has a value assigned.
4. Spring tries to inject the dependency here, but that dependency does not exist in the Spring context, so injection fails.

So having @Bean, but manually injecting an @Autowired dependency conflicts each other, you may now understand, why - you shall not inject Autowired beans manually! Autowired is an annotation that tells he CI container to do some injection work.

Answer 2

There's a hacky way of doing that, as described in this old Stack Overflow thread.

public static <T> FactoryBean<T> preventAutowire(T bean) {
    return new FactoryBean<T>() {
        public T getObject() throws Exception {
            return bean;
        }

        public Class<?> getObjectType() {
            return bean.getClass();
        }

        public boolean isSingleton() {
            return true;
        }
    };
}

...

@Bean
static FactoryBean<MyBean> myBean() {
    return preventAutowire(new MyBean());
}