Factory pattern in Spring — ApplicationContext as a factory

Direct Answer

Spring's container performs factory responsibilities: BeanFactory and ApplicationContext locate and create bean definitions, resolve dependencies, and manage lifecycle. Most application code receives beans through injection rather than calling the container as a service locator. FactoryBean<T> is Spring's explicit extension point for custom object creation; an @Bean method is another container-managed creation recipe.

Deep Dive & Architecture

Spring's IoC container separates application code from bean construction. BeanFactory is the core bean-access contract, while ApplicationContext adds broader application services. Bean definitions and configuration tell the container which type to create, how to resolve its dependencies, and which lifecycle and scope rules apply.

Application classes normally use constructor injection. Calling applicationContext.getBean(...) throughout business code turns the container into a service locator and hides dependencies.

For special construction, a FactoryBean<T> is itself a managed bean whose getObject() supplies another object. An @Bean method also acts as a configuration recipe invoked by the container. These mechanisms have factory-like roles, but not every Spring creation feature is a literal textbook GoF Factory Method implementation.

Code Example

@Configuration
class AppConfig {
    @Bean // a factory method: Spring calls it to create the bean
    PaymentProcessor paymentProcessor() { return new StripePaymentProcessor(); }

    @Bean
    NotificationService notificationService() {
        var s = new EmailNotificationService();
        s.setRetryCount(3); // factory handles complex init
        return s;
    }
}

@Service
class OrderService {
    private final PaymentProcessor processor;
    // The container (a factory) creates PaymentProcessor and injects it.
    OrderService(PaymentProcessor processor) { this.processor = processor; }
    void placeOrder(Order order) { processor.process(order.getTotal()); }
}

// The container resolves the whole graph for you:
var context = new AnnotationConfigApplicationContext(AppConfig.class);
var orderService = context.getBean(OrderService.class); // Factory in action

Common Mistakes & Pitfalls

• Not knowing BeanFactory exists. ApplicationContext extends it; BeanFactory is the actual factory interface.
• Thinking @Bean is magic. It's a factory method — Spring calls it, and you control the creation logic inside.
• Calling new inside beans. new UserRepository() bypasses the container, so Spring can't inject or manage it.
• Ignoring scope. Singleton vs prototype is the factory deciding whether to cache and reuse or create fresh.