How to Get All Spring-Managed Beans: ApplicationContext and Bean Definitions

In any non-trivial Spring Boot application, the IoC container manages hundreds or thousands of beans. From controllers and services to repositories and configuration classes, Spring wires everything together. But what happens when you need to introspect that container? Maybe you're debugging why a bean isn't being picked up, or you're building a monitoring dashboard that shows all registered components. Or perhaps you're writing a library that needs to discover beans dynamically. This article is your field guide to listing all Spring-managed beans using ApplicationContext, BeanFactory, and BeanDefinition. We'll cover the classic approaches, the gotchas that bite you in production (like proxies and lazy initialization), and real-world patterns from SaaS billing systems and payment-processing pipelines. By the end, you'll know exactly how to retrieve beans, filter them by type or annotation, and avoid the performance pitfalls that have taken down staging environments. We'll use Spring Boot 3.2 and Java 17 throughout, with code you can copy-paste into your own project.

Understanding ApplicationContext and BeanFactory

Before you can list beans, you need to understand the two core interfaces: ApplicationContext and BeanFactory. BeanFactory is the root interface for accessing the Spring IoC container. It provides basic methods like getBean() and containsBean(). ApplicationContext extends BeanFactory and adds enterprise features like event publishing, resource loading, and message i18n. In a typical Spring Boot application, you inject ApplicationContext directly. The interface you actually need for listing beans is ListableBeanFactory, which ApplicationContext inherits. ListableBeanFactory provides getBeanDefinitionNames() (returns all bean names as a String[]) and getBeansOfType(Class) (returns a Map<String, T> of beans matching a type). Here's the simplest way to get all bean names in a Spring Boot app: inject ApplicationContext into any Spring-managed component.

import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.stereotype.Service;

@Service
public class BeanListerService {

    private final ListableBeanFactory beanFactory;

    public BeanListerService(ListableBeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public void printAllBeanNames() {
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        System.out.println("Total beans: " + beanNames.length);
        for (String name : beanNames) {
            System.out.println(name);
        }
    }
}

What the Official Docs Won't Tell You

The official Spring documentation teaches you getBeanDefinitionNames() and getBeansOfType(). What it doesn't tell you is that these methods can lie to you in production. First, beans created via @Bean methods in @Configuration classes show up with the method name, not the class name. So @Bean public DataSource dataSource() registers as dataSource, not DataSource. Second, AOP proxies create a second bean with a name like userService$$EnhancerBySpringCGLIB$$.... If you list beans by type, you'll get the proxy, not the original. Third, @Lazy beans are not initialized until first access, but they still appear in getBeanDefinitionNames(). The bean definition exists, but calling getBean() on it will trigger initialization—potentially causing side effects. Fourth, @Conditional annotations (like @ConditionalOnProperty) can silently exclude beans. Your getBeansOfType() returns an empty map, and you have no idea why. The fix? Always log the bean definition source. Use BeanDefinition to inspect metadata like getResourceDescription() and getScope(). Here's how to get the full picture:

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.stereotype.Component;

@Component
public class BeanDefinitionInspector {

    private final BeanDefinitionRegistry registry;

    public BeanDefinitionInspector(BeanDefinitionRegistry registry) {
        this.registry = registry;
    }

    public void inspectBean(String beanName) {
        if (registry.containsBeanDefinition(beanName)) {
            BeanDefinition bd = registry.getBeanDefinition(beanName);
            System.out.println("Bean: " + beanName);
            System.out.println("  Scope: " + bd.getScope());
            System.out.println("  Class: " + bd.getBeanClassName());
            System.out.println("  Source: " + bd.getResourceDescription());
            System.out.println("  Lazy Init: " + bd.isLazyInit());
        }
    }
}

Filtering Beans by Type and Annotation

Listing all beans is rarely useful on its own. More often, you need to find beans of a specific type or annotated with a custom annotation. ListableBeanFactory provides getBeansOfType(Class<T> type) which returns a Map<String, T> of all beans that are assignable to the given type. This includes subclasses and proxies. For annotation-based filtering, use getBeansWithAnnotation(Class<? extends Annotation> annotationType). This is extremely powerful for finding all beans marked with @Service, @Repository, or a custom annotation like @PaymentGateway. Here's a real-world example from a payment-processing system where we discover all payment gateway implementations at runtime:

import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.stereotype.Component;
import java.util.Map;

@Component
public class PaymentGatewayRegistry {

    private final ListableBeanFactory beanFactory;

    public PaymentGatewayRegistry(ListableBeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public Map<String, PaymentGateway> getAllGateways() {
        return beanFactory.getBeansOfType(PaymentGateway.class);
    }

    public PaymentGateway getGateway(String name) {
        Map<String, PaymentGateway> gateways = getAllGateways();
        if (gateways.containsKey(name)) {
            return gateways.get(name);
        }
        // fallback to default
        return gateways.values().iterator().next();
    }
}

Using BeanFactoryPostProcessor for Early Inspection

Sometimes you need to inspect or modify bean definitions before they're instantiated. This is where BeanFactoryPostProcessor comes in. It runs during the ApplicationContext refresh lifecycle, before any singleton beans are created. You can use it to log all bean definitions, add properties, or even register new beans dynamically. This is particularly useful for frameworks that need to wire beans based on external configuration. Here's an example that logs all bean definitions at startup and adds a custom property to beans of a certain type:

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.stereotype.Component;

@Component
public class BeanDefinitionLoggerPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) throws BeansException {
        if (factory instanceof BeanDefinitionRegistry registry) {
            String[] beanNames = registry.getBeanDefinitionNames();
            System.out.println("=== Bean Definitions at Startup ===");
            for (String name : beanNames) {
                System.out.println(name);
            }
            System.out.println("Total: " + beanNames.length);
        }
    }
}

Exposing Beans via a REST Endpoint for Debugging

In production, you often need to see what beans are loaded without attaching a debugger. The cleanest approach is to create a dedicated REST endpoint that returns bean information. This is especially useful when combined with Spring Boot Actuator, but a custom endpoint gives you more control over formatting and filtering. Here's a controller that exposes all beans, with optional filtering by type:

import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/internal/debug")
public class BeanDebugController {

    private final ListableBeanFactory beanFactory;

    public BeanDebugController(ListableBeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    @GetMapping("/beans")
    public Map<String, Object> listBeans(
            @RequestParam(required = false) String type) {
        if (type != null) {
            try {
                Class<?> clazz = Class.forName(type);
                Map<String, ?> beans = beanFactory.getBeansOfType(clazz);
                return Map.of("count", beans.size(), "beans", beans.keySet());
            } catch (ClassNotFoundException e) {
                return Map.of("error", "Class not found: " + type);
            }
        }
        String[] allNames = beanFactory.getBeanDefinitionNames();
        return Map.of("count", allNames.length, "beans", List.of(allNames));
    }
}

Performance Implications and Best Practices

Calling getBeanDefinitionNames() or getBeansOfType() is not free. These methods iterate over the entire bean factory's internal registry. In a typical application with 200 beans, it's negligible (under 1ms). But in a large microservice with 2000+ beans, or if called repeatedly in a loop, it can become a bottleneck. The real danger is in hot paths: never call these methods inside a request handler that serves thousands of requests per second. The getBeansOfType() method also triggers bean initialization for any beans that are @Lazy and haven't been touched yet. This can cascade into full application initialization if you're not careful. Best practices: cache the results of bean listing if the set doesn't change at runtime (which it usually doesn't). Use @PostConstruct to capture bean references once. If you need dynamic discovery, consider using a registry pattern where beans register themselves on startup. Here's a safe pattern:

import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.stereotype.Component;
import java.util.*;

@Component
public class CachedBeanRegistry {

    private final ListableBeanFactory beanFactory;
    private Map<String, PaymentGateway> gatewayCache;

    public CachedBeanRegistry(ListableBeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    @PostConstruct
    public void init() {
        this.gatewayCache = Collections.unmodifiableMap(
            beanFactory.getBeansOfType(PaymentGateway.class));
    }

    public Map<String, PaymentGateway> getGateways() {
        return gatewayCache;
    }
}

Advanced: Programmatic Bean Registration

Sometimes listing beans isn't enough—you need to register new beans dynamically at runtime. Spring allows this via BeanDefinitionRegistry.registerBeanDefinition() or the newer GenericApplicationContext.registerBean() method. This is useful for plugin systems, feature flags, or dynamic tenant configuration. Here's an example that registers a new bean based on a runtime condition:

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class DynamicBeanRegistrar {

    private final BeanDefinitionRegistry registry;

    public DynamicBeanRegistrar(BeanDefinitionRegistry registry) {
        this.registry = registry;
    }

    public void registerPaymentGateway(String name, String className) {
        try {
            Class<?> clazz = Class.forName(className);
            BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(clazz)
                .setScope("singleton")
                .addPropertyValue("gatewayName", name);
            
            registry.registerBeanDefinition(
                name + "Gateway", 
                builder.getBeanDefinition());
            
            System.out.println("Registered bean: " + name + "Gateway");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("Class not found: " + className, e);
        }
    }
}

Comparing Approaches: When to Use What

You now have several ways to get Spring beans: ListableBeanFactory.getBeanDefinitionNames(), getBeansOfType(), getBeansWithAnnotation(), BeanDefinitionRegistry, BeanFactoryPostProcessor, and ApplicationContext.getBean(). Each has its place. Here's a comparison to help you choose: For simple listing of all bean names (debugging), use getBeanDefinitionNames(). For finding all implementations of an interface (e.g., payment gateways), use getBeansOfType(). For finding beans with a custom annotation (e.g., @Monitored), use getBeansWithAnnotation(). For inspecting properties like scope and source before instantiation, use BeanDefinitionRegistry. For modifying bean definitions at startup, use BeanFactoryPostProcessor. For accessing a single bean by name, use getBean() (but prefer injection). Never use getBean() in production code—it's a sign of poor design. The table below summarizes the trade-offs:

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class ComparisonRunner implements CommandLineRunner {

    private final BeanListerService lister;
    private final BeanDefinitionInspector inspector;
    private final PaymentGatewayRegistry registry;

    public ComparisonRunner(BeanListerService lister, 
                           BeanDefinitionInspector inspector,
                           PaymentGatewayRegistry registry) {
        this.lister = lister;
        this.inspector = inspector;
        this.registry = registry;
    }

    @Override
    public void run(String... args) {
        lister.printAllBeanNames();
        inspector.inspectBean("userService");
        System.out.println("Gateways: " + registry.getAllGateways().keySet());
    }
}