java - Print all the Spring beans that are loaded

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Learn more about Collectives

Teams

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Learn more about Teams

Yes, get ahold of ApplicationContext and call .getBeanDefinitionNames()

You can get the context by:

implementing


    ApplicationContextAware

injecting it with


    @Inject


    @Autowired

(after 2.5)

use


    WebApplicationContextUtils.getRequiredWebApplicationContext(..)

Related: You can also detect each bean's registration by registering a BeanPostprocessor bean. It will be notified for each bean.

The reason to implement


    ApplicationContextAware

interface is because Spring framework give it the chance to access the application context. You should place it in the


    @Configuration

class for the intended application context. – smwikipedia Nov 3, 2015 at 8:52 applicationContext.getBeanDefinitionNames() does not show the beans which are registered without BeanDefinition instance. You will not be able to list singleton beans which are registered manually. ex-:) you can not list environment, systemProperties,systemEnvironment beans. However these beans are available in the container. You can autowire them using @Auwired Environment env etc. stackoverflow.com/a/54863282/1840774 – Velu Feb 25, 2019 at 10:00 public void printBeans() { System.out.println(Arrays.asList(applicationContext.getBeanDefinitionNames())); applicationContext.getBeanDefinitionNames() does not show the beans which are registered without BeanDefinition instance. You will not be able to list singleton beans which are registered manually. ex-:) you can not list environment, systemProperties,systemEnvironment beans. However these beans are available in the container. You can autowire them using @Auwired Environment env etc. stackoverflow.com/a/54863282/1840774 – Velu Feb 25, 2019 at 9:59

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
you can check the endpoint /beans
package com.javahash.spring.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class HelloWorldController {
    @Autowired
    private ApplicationContext applicationContext;
    @RequestMapping("/hello")
    public String hello(@RequestParam(value="key", required=false, defaultValue="World") String name, Model model) {
        String[] beanNames = applicationContext.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            System.out.println(beanName + " : " + applicationContext.getBean(beanName).getClass().toString());
        model.addAttribute("name", name);
        return "helloworld";
                applicationContext.getBeanDefinitionNames() does not show the beans which are registered without BeanDefinition instance. You will not be able to list singleton beans which are registered manually. ex-:) you can not list environment, systemProperties,systemEnvironment beans. However these beans are available in the container. You can autowire them using @Auwired Environment env etc. stackoverflow.com/a/54863282/1840774
– Velu
                Feb 25, 2019 at 9:56
applicationContext.getBeanDefinitionNames() does not show the beans which are registered without BeanDefinition instance.
package io.velu.core;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan
public class Core {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Core.class);
        String[] singletonNames = context.getDefaultListableBeanFactory().getSingletonNames();
        for (String singleton : singletonNames) {
            System.out.println(singleton);
Console Output
environment
systemProperties
systemEnvironment
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.ConfigurationClassPostProcessor.importRegistry
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
messageSource
applicationEventMulticaster
lifecycleProcessor
As you can see in the output, environment, systemProperties, systemEnvironment beans will not be shown using context.getBeanDefinitionNames() method.
Spring Boot
For spring boot web applications, all the beans can be listed using the below endpoint.
@RestController
@RequestMapping("/list")
class ExportController {
    @Autowired
    private ApplicationContext applicationContext;
    @GetMapping("/beans")
    @ResponseStatus(value = HttpStatus.OK)
    String[] registeredBeans() {
        return printBeans();
    private String[] printBeans() {
        AutowireCapableBeanFactory autowireCapableBeanFactory = applicationContext.getAutowireCapableBeanFactory();
        if (autowireCapableBeanFactory instanceof SingletonBeanRegistry) {
            String[] singletonNames = ((SingletonBeanRegistry) autowireCapableBeanFactory).getSingletonNames();
            for (String singleton : singletonNames) {
                System.out.println(singleton);
            return singletonNames;
        return null;
   "autoConfigurationReport",
   "springApplicationArguments",
   "springBootBanner",
   "springBootLoggingSystem",
   "environment",
   "systemProperties",
   "systemEnvironment",
   "org.springframework.context.annotation.internalConfigurationAnnotationProcessor",
   "org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory",
   "org.springframework.boot.autoconfigure.condition.BeanTypeRegistry",
   "org.springframework.context.annotation.ConfigurationClassPostProcessor.importRegistry",
   "propertySourcesPlaceholderConfigurer",
   "org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor.store",
   "preserveErrorControllerTargetClassPostProcessor",
   "org.springframework.context.annotation.internalAutowiredAnnotationProcessor",
   "org.springframework.context.annotation.internalRequiredAnnotationProcessor",
   "org.springframework.context.annotation.internalCommonAnnotationProcessor",
   "org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor",
   "org.springframework.scheduling.annotation.ProxyAsyncConfiguration",
   "org.springframework.context.annotation.internalAsyncAnnotationProcessor",
   "methodValidationPostProcessor",
   "embeddedServletContainerCustomizerBeanPostProcessor",
   "errorPageRegistrarBeanPostProcessor",
   "messageSource",
   "applicationEventMulticaster",
   "org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration$EmbeddedTomcat",
   "tomcatEmbeddedServletContainerFactory",
   "org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration$TomcatWebSocketConfiguration",
   "websocketContainerCustomizer",
   "spring.http.encoding-org.springframework.boot.autoconfigure.web.HttpEncodingProperties",
   "org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration",
   "localeCharsetMappingsCustomizer",
   "org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration",
   "serverProperties",
   "duplicateServerPropertiesDetector",
   "spring.resources-org.springframework.boot.autoconfigure.web.ResourceProperties",
   "org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration$DefaultErrorViewResolverConfiguration",
   "conventionErrorViewResolver",
   "org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration",
   "errorPageCustomizer",
   "servletContext",
   "contextParameters",
   "contextAttributes",
   "spring.mvc-org.springframework.boot.autoconfigure.web.WebMvcProperties",
   "spring.http.multipart-org.springframework.boot.autoconfigure.web.MultipartProperties",
   "org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration",
   "multipartConfigElement",
   "org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration$DispatcherServletRegistrationConfiguration",
   "org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration$DispatcherServletConfiguration",
   "dispatcherServlet",
   "dispatcherServletRegistration",
   "requestContextFilter",
   "org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration",
   "hiddenHttpMethodFilter",
   "httpPutFormContentFilter",
   "characterEncodingFilter",
   "org.springframework.context.event.internalEventListenerProcessor",
   "org.springframework.context.event.internalEventListenerFactory",
   "reportGeneratorApplication",
   "exportController",
   "exportService",
   "org.springframework.boot.autoconfigure.AutoConfigurationPackages",
   "org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration",
   "org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$Jackson2ObjectMapperBuilderCustomizerConfiguration",
   "spring.jackson-org.springframework.boot.autoconfigure.jackson.JacksonProperties",
   "standardJacksonObjectMapperBuilderCustomizer",
   "org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperBuilderConfiguration",
   "org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration",
   "jsonComponentModule",
   "jacksonObjectMapperBuilder",
   "org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperConfiguration",
   "jacksonObjectMapper",
   "org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration",
   "org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration",
   "org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration",
   "org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration",
   "defaultValidator",
   "org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration$WhitelabelErrorViewConfiguration",
   "error",
   "beanNameViewResolver",
   "errorAttributes",
   "basicErrorController",
   "org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration$EnableWebMvcConfiguration",
   "org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration$WebMvcAutoConfigurationAdapter",
   "mvcContentNegotiationManager",
   "org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration$StringHttpMessageConverterConfiguration",
   "stringHttpMessageConverter",
   "org.springframework.boot.autoconfigure.web.JacksonHttpMessageConvertersConfiguration$MappingJackson2HttpMessageConverterConfiguration",
   "mappingJackson2HttpMessageConverter",
   "org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration",
   "messageConverters",
   "mvcConversionService",
   "mvcValidator",
   "requestMappingHandlerAdapter",
   "mvcResourceUrlProvider",
   "requestMappingHandlerMapping",
   "mvcPathMatcher",
   "mvcUrlPathHelper",
   "viewControllerHandlerMapping",
   "beanNameHandlerMapping",
   "resourceHandlerMapping",
   "defaultServletHandlerMapping",
   "mvcUriComponentsContributor",
   "httpRequestHandlerAdapter",
   "simpleControllerHandlerAdapter",
   "handlerExceptionResolver",
   "mvcViewResolver",
   "org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration$WebMvcAutoConfigurationAdapter$FaviconConfiguration",
   "faviconRequestHandler",
   "faviconHandlerMapping",
   "defaultViewResolver",
   "viewResolver",
   "welcomePageHandlerMapping",
   "org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration",
   "objectNamingStrategy",
   "mbeanServer",
   "mbeanExporter",
   "org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration",
   "springApplicationAdminRegistrar",
   "org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration",
   "org.springframework.boot.autoconfigure.web.JacksonHttpMessageConvertersConfiguration",
   "spring.info-org.springframework.boot.autoconfigure.info.ProjectInfoProperties",
   "org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration",
   "multipartResolver",
   "org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration$RestTemplateConfiguration",
   "restTemplateBuilder",
   "org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration",
   "spring.devtools-org.springframework.boot.devtools.autoconfigure.DevToolsProperties",
   "org.springframework.boot.devtools.autoconfigure.LocalDevToolsAutoConfiguration$RestartConfiguration",
   "fileSystemWatcherFactory",
   "classPathRestartStrategy",
   "classPathFileSystemWatcher",
   "hateoasObjenesisCacheDisabler",
   "org.springframework.boot.devtools.autoconfigure.LocalDevToolsAutoConfiguration$LiveReloadConfiguration$LiveReloadServerConfiguration",
   "org.springframework.boot.devtools.autoconfigure.LocalDevToolsAutoConfiguration$LiveReloadConfiguration",
   "optionalLiveReloadServer",
   "org.springframework.boot.devtools.autoconfigure.LocalDevToolsAutoConfiguration",
   "lifecycleProcessor"
                To note that context is not closed in your code and should be created inside a try-with-resouces statement. try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext ())
– Navigatron
                Sep 21, 2021 at 8:46
You could try calling 
org.springframework.beans.factory.ListableBeanFactory.getBeansOfType(Object.class)
Or turn on debug logging for org.springframework. (In spring boot, that's using a parameter --logging.level.org.springframework=DEBUG)
                ListableBeanFactory is an interface. Where would one get an instance of a class extending that interface in order to execute the method getBeansOfType or any other method in the interface? I see that ApplicationContext extends it, but your example doesn't show how to acquire one of those.
– ErikE
                Jul 15, 2018 at 0:04
                You can just add a field @Autowired ListableBeanFactory listableBeanFactory and you'll get one (the implementation type shouldn't matter)
– artbristol
                Jul 15, 2018 at 18:18
                I found the bean registrations  at: org.springframework.beans.factory.support.DefaultListableBeanFactory: debug  This shows beans like this: 2021-08-23T17:30:36.547Z DEBUG 5255 --- [  restartedMain] o.s.b.f.s.DefaultListableBeanFactory     : Creating shared instance of singleton bean 'apacheHttpClientBuilder'
– Bryan Pugh
                Aug 23, 2021 at 17:31
Here is another way to print all the bean names from the spring application context:
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
/***********************************************************************************************************
 * Java File: MainApplication.java
 * Description: Main class to run the application.
 ***********************************************************************************************************/
@SpringBootApplication
public class MainApplication {
private static final Logger logger = LogManager.getLogger(MainApplication.class);
public static void main(String[] args) 
    final ConfigurableApplicationContext context = SpringApplication.run(MainApplication.class, args);
    final AtomicInteger counter = new AtomicInteger(0);
    logger.info("**************** START: Total Bean Objects: {} ******************", context.getBeanDefinitionCount());
    Arrays.asList(context.getBeanDefinitionNames())
    .forEach(beanName -> {
        logger.info("{}) Bean Name: {} ", counter.incrementAndGet(), beanName);
    logger.info("**************** END: Total Bean: {} ******************", context.getBeanDefinitionCount());
Sample Output:
2019-11-27 20:08:02.821 INFO  [main] [c.c.a.MainApplication:18] - **************** START: Total Bean Objects: 564 ****************** 
...........................
2019-11-27 20:08:02.821 INFO  [main] [c.c.a.MainApplication:22] - 460) Bean Name: mvcPathMatcher  
2019-11-27 20:08:02.821 INFO  [main] [c.c.a.MainApplication:22] - 461) Bean Name: mvcUrlPathHelper  
2019-11-27 20:08:02.821 INFO  [main] [c.c.a.MainApplication:22] - 462) Bean Name: viewControllerHandlerMapping  
2019-11-27 20:08:02.821 INFO  [main] [c.c.a.MainApplication:22] - 463) Bean Name: beanNameHandlerMapping  
2019-11-27 20:08:02.821 INFO  [main] [c.c.a.MainApplication:22] - 464) Bean Name: resourceHandlerMapping 
...........................
2019-11-27 20:08:02.821 INFO  [main] [c.c.a.MainApplication:25] - **************** END: Total Bean: 564 ****************** 
Using spring-boot-starter-actuator you can easily access all bean.
Here is the setup process:
Add dependency into gradle:
Add bellow into gradle file:
compile("org.springframework.boot:spring-boot-starter-actuator")
Enable security on application.properties:
Add management.security.enabled=false into your application.property file
call /beans endpoint: 
After that setup spring will enable some metrics related endpoints.
One of its endpoint is /beans
After calling this endpoints it will provide a json file that contains all of your bean including it's dependency and scope.
Here is an example json file:
[{"context":"application:8442","parent":null,"beans":[{"bean":"beanName","aliases":[],"scope":"singleton","type":"packageName$$4b46c703","resource":"null","dependencies":["environment","beanName1","beanName2"]},{"bean":"org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory","aliases":[],"scope":"singleton","type":"org.springframework.core.type.classreading.CachingMetadataReaderFactory","resource":"null","dependencies":[]}]
For more info visit bellow links:
Building a RESTful Web Service with Spring Boot Actuator
Spring Boot Actuator: Health check, Auditing, Metrics gathering
Spring Boot Actuator: Production-ready features
Hope this will help you. Thanks :)
        Thanks for contributing an answer to Stack Overflow!
Please be sure to answer the question. Provide details and share your research!
But avoid …
Asking for help, clarification, or responding to other answers.
Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
				Bean Names are being returned in String Format, Call methods or use variables of such bean
                See more linked questions