How @Autowired Works Internally

Direct Answer

@Autowired is processed by AutowiredAnnotationBeanPostProcessor — a built-in BeanPostProcessor Spring registers automatically. It uses Java reflection to scan each bean's fields, setters, and constructors for the annotation, then queries the BeanFactory to resolve matching beans by type → @Qualifier → @Primary → field name. For constructor injection, Spring resolves dependencies before instantiation. For field/setter injection, the post-processor fires in postProcessProperties after the constructor returns, which is why @Autowired fields are null inside the constructor body. The reflection call uses Field.setAccessible(true) to bypass private modifiers — the JVM's memory model leaves reflective writes to final fields undefined, which is why field injection cannot use final.

Code Example

@Autowired is not magic — it is a BeanPostProcessor (AutowiredAnnotationBeanPostProcessor) that runs reflection against each bean after instantiation and injects collaborators before @PostConstruct. This minimal reproduction shows the exact sequence.

@Component
class OrderService {
    private final UserRepository userRepo;       // constructor injection (preferred)
    @Autowired private PaymentClient payment;    // field injection (discouraged)
    private EmailService email;

    public OrderService(UserRepository userRepo) { this.userRepo = userRepo; }

    @Autowired
    public void setEmail(EmailService email) { this.email = email; }  // setter injection
}

// The processor Spring actually runs — simplified reproduction:
class MiniAutowiredProcessor implements BeanPostProcessor {
    private final BeanFactory bf;
    MiniAutowiredProcessor(BeanFactory bf) { this.bf = bf; }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String name) {
        for (Field f : bean.getClass().getDeclaredFields()) {
            if (f.isAnnotationPresent(Autowired.class)) {
                f.setAccessible(true);
                try { f.set(bean, bf.getBean(f.getType())); }    // inject by type
                catch (IllegalAccessException e) { throw new BeanCreationException(name, e); }
            }
        }
        return bean;   // return AFTER injection, BEFORE @PostConstruct
    }
}

• Spring picks the greediest satisfiable constructor for constructor injection — no annotation needed when there is only one.
• Resolution order: by type first, then by qualifier (@Qualifier("name")), then by bean name as a fallback.
• When multiple beans match, Spring throws NoUniqueBeanDefinitionException unless one is marked @Primary.
• Prefer constructor injection: fields can be final, circular dependencies fail fast at startup, and unit tests can call the constructor directly without ReflectionTestUtils.

Common Mistakes & Pitfalls

Thinking @Autowired is magic syntax; not knowing it fires after object construction, making field injection unavailable in the constructor body.